Fixed forwarding of sending-complete information.
[lcr.git] / apppbx.cpp
1 /*****************************************************************************\
2 **                                                                           **
3 ** Linux Call Router                                                         **
4 **                                                                           **
5 **---------------------------------------------------------------------------**
6 ** Copyright: Andreas Eversberg                                              **
7 **                                                                           **
8 ** The EndpointAppPBX implements PBX4Linux                                   **
9 **                                                                           **
10 \*****************************************************************************/ 
11
12
13 #include "main.h"
14
15 class EndpointAppPBX *apppbx_first = NULL;
16
17 int action_timeout(struct lcr_timer *timer, void *instance, int index);
18 int match_timeout(struct lcr_timer *timer, void *instance, int index);
19 int redial_timeout(struct lcr_timer *timer, void *instance, int index);
20 int powerdial_timeout(struct lcr_timer *timer, void *instance, int index);
21 int cfnr_timeout(struct lcr_timer *timer, void *instance, int index);
22 int cfnr_call_timeout(struct lcr_timer *timer, void *instance, int index);
23 int password_timeout(struct lcr_timer *timer, void *instance, int index);
24 int callback_timeout(struct lcr_timer *timer, void *instance, int index);
25
26 /*
27  * EndpointAppPBX constructor
28  */
29 EndpointAppPBX::EndpointAppPBX(class Endpoint *epoint, int origin) : EndpointApp(epoint, origin)
30 {
31         class EndpointAppPBX **apppointer;
32
33         memset(&e_crypt_handler, 0, sizeof(e_crypt_handler));
34         add_timer(&e_crypt_handler, crypt_handler, this, 0);
35         memset(&e_vbox_refresh, 0, sizeof(e_vbox_refresh));
36         add_timer(&e_vbox_refresh, vbox_refresh, this, 0);
37         memset(&e_action_timeout, 0, sizeof(e_action_timeout));
38         add_timer(&e_action_timeout, action_timeout, this, 0);
39         memset(&e_match_timeout, 0, sizeof(e_match_timeout));
40         add_timer(&e_match_timeout, match_timeout, this, 0);
41         memset(&e_redial_timeout, 0, sizeof(e_redial_timeout));
42         add_timer(&e_redial_timeout, redial_timeout, this, 0);
43         memset(&e_powerdial_timeout, 0, sizeof(e_powerdial_timeout));
44         add_timer(&e_powerdial_timeout, powerdial_timeout, this, 0);
45         memset(&e_cfnr_timeout, 0, sizeof(e_cfnr_timeout));
46         add_timer(&e_cfnr_timeout, cfnr_timeout, this, 0);
47         memset(&e_cfnr_call_timeout, 0, sizeof(e_cfnr_call_timeout));
48         add_timer(&e_cfnr_call_timeout, cfnr_call_timeout, this, 0);
49         memset(&e_callback_timeout, 0, sizeof(e_callback_timeout));
50         add_timer(&e_callback_timeout, callback_timeout, this, 0);
51         memset(&e_password_timeout, 0, sizeof(e_password_timeout));
52         add_timer(&e_password_timeout, password_timeout, this, 0);
53         e_powerdial_on = 0;
54
55         /* add application to chain */
56         next = NULL;
57         apppointer = &apppbx_first;
58         while(*apppointer)
59                 apppointer = &((*apppointer)->next);
60         *apppointer = this;
61
62         /* initialize */
63         memset(&e_ext, 0, sizeof(struct extension));
64         // *************** NOTE: also change value in read_extension() **************
65         e_ext.rights = 4; /* international */
66         e_ext.rx_gain = e_ext.tx_gain = 0;
67         e_state = EPOINT_STATE_IDLE;
68         e_ext.number[0] = '\0';
69         e_extension_interface[0] = '\0';
70         memset(&e_callerinfo, 0, sizeof(struct caller_info));
71         memset(&e_dialinginfo, 0, sizeof(struct dialing_info));
72         memset(&e_connectinfo, 0, sizeof(struct connect_info));
73         memset(&e_redirinfo, 0, sizeof(struct redir_info));
74         memset(&e_capainfo, 0, sizeof(struct capa_info));
75         e_start = e_stop = 0;
76         e_origin = origin;
77         e_ruleset = ruleset_main;
78         if (e_ruleset)
79                 e_rule = e_ruleset->rule_first;
80         e_rule_nesting = 0;
81         e_action = NULL;
82         e_match_to_action = NULL;
83         e_select = 0;
84         e_extdialing = e_dialinginfo.id;
85 //        e_knocking = 0;
86 //        e_knocktime = 0;
87         e_hold = 0;
88 //        e_join_tone[0] = e_hold_tone[0] = '\0';
89         e_join_pattern /*= e_hold_pattern*/ = 0;
90         e_tone[0] = '\0';
91         e_adminid = 0; // will be set, if call was initiated via admin socket
92         e_powerdelay = 0;
93         e_powerlimit = 0;
94         e_cbdialing[0] = '\0';
95         e_cbcaller[0] = '\0';
96         e_cbto[0] = '\0';
97         memset(&e_callbackinfo, 0, sizeof(struct caller_info));
98         e_connectedmode = 0;
99         e_dtmf = 0;
100         e_dtmf_time = 0;
101         e_dtmf_last = 0;
102         e_enablekeypad = 0;
103         e_multipoint_cause = 0;
104         e_multipoint_location = 0;
105         e_dialing_queue[0] = '\0';
106         e_crypt = CRYPT_OFF;
107         e_crypt_state = CM_ST_NULL;
108         e_crypt_keyengine_busy = 0;
109         e_crypt_info[0] = '\0'; 
110         e_overlap = 0;
111         e_vbox[0] = '\0';
112         e_tx_state = NOTIFY_STATE_ACTIVE;
113         e_rx_state = NOTIFY_STATE_ACTIVE;
114         e_join_cause = e_join_location = 0;
115 /*********************************
116  *********************************
117  ********* ATTENTION *************
118  *********************************
119  *********************************/
120 /* if you add new values, that must be initialized, also check if they must
121  * be initialized when doing callback
122  */
123
124 }
125
126 /*
127  * EpointAppPBX destructor
128  */
129 EndpointAppPBX::~EndpointAppPBX(void)
130 {
131         class EndpointAppPBX *temp, **tempp;
132
133         del_timer(&e_crypt_handler);
134         del_timer(&e_vbox_refresh);
135         del_timer(&e_action_timeout);
136         del_timer(&e_match_timeout);
137         del_timer(&e_redial_timeout);
138         del_timer(&e_powerdial_timeout);
139         del_timer(&e_cfnr_timeout);
140         del_timer(&e_cfnr_call_timeout);
141         del_timer(&e_callback_timeout);
142         del_timer(&e_password_timeout);
143
144         /* detach */
145         temp =apppbx_first;
146         tempp = &apppbx_first;
147         while(temp) {
148                 if (temp == this)
149                         break;
150
151                 tempp = &temp->next;
152                 temp = temp->next;
153         }
154         if (temp == 0)
155                 FATAL("Endpoint not in endpoint's list.\n");
156         *tempp = next;
157
158 }
159
160
161 /*
162  * trace header for application
163  */
164 void EndpointAppPBX::trace_header(const char *name, int direction)
165 {
166         struct trace _trace;
167
168         char msgtext[sizeof(_trace.name)];
169
170         SCPY(msgtext, name);
171
172         /* init trace with given values */
173         start_trace(-1,
174                     NULL,
175                     numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype, options.national, options.international),
176                     e_dialinginfo.id,
177                     direction,
178                     CATEGORY_EP,
179                     ea_endpoint->ep_serial,
180                     msgtext);
181 }
182
183
184 EPOINT_STATE_NAMES
185
186 /* set new endpoint state
187  */
188 void EndpointAppPBX::new_state(int state)
189 {
190 #if 0
191         if (e_state != state) {
192                 trace_header("NEW STATE", DIRECTION_NONE);
193                 add_trace("state", "old", "%s", state_name[e_state]);
194                 add_trace("state", "new", "%s", state_name[state]);
195                 end_trace();
196         }
197 #endif
198         e_state = state;
199 }
200
201
202 /* release join and port (as specified)
203  */
204 void EndpointAppPBX::release(int release, int joinlocation, int joincause, int portlocation, int portcause, int force)
205 {
206         struct port_list *portlist;
207         struct lcr_msg *message;
208         char cause[16];
209
210         /* message to test call */
211         admin_call_response(e_adminid, ADMIN_CALL_RELEASE, "", joincause, joinlocation, 0);
212
213         /* if a release is pending */
214         if (release==RELEASE_JOIN || release==RELEASE_ALL || release==RELEASE_PORT_JOINONLY) {
215                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): do pending release (joincause %d location %d)\n", ea_endpoint->ep_serial, joincause, joinlocation);
216                 if (ea_endpoint->ep_join_id) {
217                         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_RELEASE);
218                         message->param.disconnectinfo.cause = joincause;
219                         message->param.disconnectinfo.location = joinlocation;
220                         message_put(message);
221                         ea_endpoint->ep_join_id = 0;
222                 }
223                 e_join_pattern = 0;
224 #if 0
225                 if (release != RELEASE_PORT_JOINONLY) {
226                         if (e_hold_id)
227                                 join_release(e_hold_id, ea_endpoint->ep_serial, 1, joinlocation, joincause);
228                         e_hold_id = 0;
229                 }
230 #endif
231         }
232         if (release==RELEASE_ALL || release==RELEASE_PORT_JOINONLY) {
233                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) do pending release (portcause %d portlocation)\n", ea_endpoint->ep_serial, portcause, portlocation);
234                 while((portlist = ea_endpoint->ep_portlist)) {
235                         if (portlist->port_id) {
236                                 SPRINT(cause, "cause_%02x", portcause);
237                                 set_tone(portlist, cause);
238                                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_RELEASE);
239                                 message->param.disconnectinfo.cause = portcause;
240                                 message->param.disconnectinfo.location = portlocation;
241                                 message->param.disconnectinfo.force = force; // set, if port should release imediately
242                                 message_put(message);
243                                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
244                         }
245                         ea_endpoint->free_portlist(portlist);
246                 }
247
248                 /* if callback is enabled, call back with the given caller id */
249                 if (e_callback_timeout.active) {
250                         /* reset some stuff */
251                         new_state(EPOINT_STATE_IDLE);
252                         memset(&e_connectinfo, 0, sizeof(struct connect_info));
253                         memset(&e_redirinfo, 0, sizeof(struct redir_info));
254                         e_start = e_stop = 0;
255                         e_ruleset = ruleset_main;
256                         if (e_ruleset)
257                                 e_rule = e_ruleset->rule_first;
258                         e_action = NULL;
259                         unsched_timer(&e_action_timeout);
260                         unsched_timer(&e_match_timeout);
261                         unsched_timer(&e_cfnr_timeout);
262                         unsched_timer(&e_cfnr_call_timeout);
263                         e_match_to_action = NULL;
264                         //e_select = 0;
265                         e_extdialing = e_dialinginfo.id;
266                         e_connectedmode = 0;
267                         e_dtmf = 0;
268                         e_dtmf_time = 0;
269                         e_dtmf_last = 0;
270                         e_enablekeypad = 0;
271                         e_multipoint_cause = 0;
272                         e_multipoint_location = 0;
273                         e_dialing_queue[0] = '\0';
274                         e_crypt = 0;
275                         e_crypt_state = CM_ST_NULL;
276                         e_crypt_keyengine_busy = 0;
277                         e_crypt_info[0] = '\0'; 
278                         e_tone[0] = '\0';
279                         e_overlap = 0;
280                         e_vbox[0] = '\0';
281                         e_tx_state = NOTIFY_STATE_ACTIVE;
282                         e_rx_state = NOTIFY_STATE_ACTIVE;
283                         e_join_cause = e_join_location = 0;
284                         e_rule_nesting = 0;
285                         /* the caller info of the callback user */
286                         memcpy(&e_callbackinfo, &e_callerinfo, sizeof(e_callbackinfo));
287                         memset(&e_dialinginfo, 0, sizeof(e_dialinginfo));
288                         /* create dialing by callerinfo */
289                         if (e_ext.number[0] && e_extension_interface[0]) {
290                                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) preparing callback to internal: %s interface %s\n", ea_endpoint->ep_serial, e_ext.number, e_extension_interface);
291                                 /* create callback to the current terminal */
292                                 SCPY(e_dialinginfo.id, e_ext.number);
293                                 SCPY(e_dialinginfo.interfaces, e_extension_interface);
294                                 e_dialinginfo.itype = INFO_ITYPE_ISDN_EXTENSION;
295                                 e_dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
296                         } else {
297                                 if (e_cbto[0]) {
298                                         SCPY(e_dialinginfo.id, e_cbto);
299                                 } else {
300                                         /* numberrize caller id and use it to dial to the callback */
301                                         SCPY(e_dialinginfo.id, numberrize_callerinfo(e_callerinfo.id,e_callerinfo.ntype, options.national, options.international));
302                                 }
303                                 e_dialinginfo.itype = INFO_ITYPE_ISDN;
304                                 e_dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
305                                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) preparing callback to external: %s\n", ea_endpoint->ep_serial, e_dialinginfo.id);
306                         }
307                         return;
308                 }
309
310                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) do pending release of epoint itself.\n", ea_endpoint->ep_serial);
311                 if (--ea_endpoint->ep_use <= 0) /* when e_lock is 0, the endpoint will be deleted */
312                         trigger_work(&ea_endpoint->ep_delete);
313                 return;
314         }
315 }
316
317
318 /* cancel callerid if restricted, unless anon-ignore is enabled at extension or port is of type external (so called police gets caller id :)*/
319 void apply_callerid_restriction(struct extension *ext, char *id, int *ntype, int *present, int *screen, char *extension, char *name)
320 {
321         PDEBUG(DEBUG_EPOINT, "id='%s' ntype=%d present=%d screen=%d extension='%s' name='%s'\n", (id)?id:"NULL", (ntype)?*ntype:-1, (present)?*present:-1, (screen)?*screen:-1, (extension)?extension:"NULL", (name)?name:"NULL");
322
323         /* caller id is not restricted, so we do nothing */
324         if (*present != INFO_PRESENT_RESTRICTED)
325                 return;
326
327         /* only extensions are restricted */
328         if (!ext->number[0])
329                 return;
330
331         /* if we enabled anonymouse ignore */
332         if (ext->anon_ignore)
333                 return;
334
335         /* else we remove the caller id */
336         if (id)
337                 id[0] = '\0';
338         if (ntype)
339                 *ntype = INFO_NTYPE_UNKNOWN;
340 //      if (screen)
341 //              *screen = INFO_SCREEN_USER;
342 // maybe we should not make voip address anonymous
343 //      if (voip)
344 //              voip[0] = '\0';
345 // maybe it's no fraud to present extension id
346 //      if (extension)
347 //              extension[0] = '\0';
348         if (name)
349                 name[0] = '\0';
350 }
351
352 /* used display message to display callerid as available */
353 char *EndpointAppPBX::apply_callerid_display(const char *id, int itype, int ntype, int present, int screen, const char *extension, const char *name)
354 {
355         static char display[81];
356
357         display[0] = '\0';
358         const char *cid = numberrize_callerinfo(id, ntype, options.national, options.international);
359
360         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) id='%s' itype=%d ntype=%d present=%d screen=%d extension='%s' name='%s'\n", ea_endpoint->ep_serial, (id)?id:"NULL", itype, ntype, present, screen, (extension)?extension:"NULL", (name)?name:"NULL");
361
362         if (!id)
363                 id = "";
364         if (!extension)
365                 extension = "";
366         if (!name)
367                 name = "";
368
369         /* NOTE: is caller is is not available for this extesion, it has been removed by apply_callerid_restriction already */
370
371         /* internal extension's caller id */
372         if (extension[0] && e_ext.display_int) {
373                 if (!display[0])
374                         SCAT(display, extension);
375                 if (display[0])
376                         SCAT(display, " ");
377                 if (itype == INFO_ITYPE_VBOX)
378                         SCAT(display, "(vbox)");
379                 else
380                         SCAT(display, "(int)");
381         }
382
383         /* external caller id */
384         if (!extension[0] && e_ext.display_ext) {
385                 if (!display[0]) {
386                         if (!cid[0]) {
387                                 if (present == INFO_PRESENT_RESTRICTED)
388                                         SCAT(display, "anonymous");
389                                 else
390                                         SCAT(display, "unknown");
391                         }
392                         else
393                                 SCAT(display, cid);
394                 }
395         }
396
397         /* display if callerid is anonymouse but available due anon-ignore */
398         if (e_ext.display_anon && present==INFO_PRESENT_RESTRICTED) {
399                 if (!cid[0])
400                         SCAT(display, "unknown");
401                 else 
402                         SCAT(display, cid);
403                 SCAT(display, " anon");
404         }
405
406         /* display if callerid is anonymouse but available due anon-ignore */
407         if (e_ext.display_fake && screen==INFO_SCREEN_USER && ntype!=INFO_NTYPE_NOTPRESENT) {
408                 if (!display[0]) {
409                         if (!id[0]) {
410                                 if (present == INFO_PRESENT_RESTRICTED)
411                                         SCAT(display, "anonymous");
412                                 else
413                                         SCAT(display, "unknown");
414                         }
415                         else
416                                 SCAT(display, cid);
417                 }
418                 SCAT(display, " fake");
419         }
420
421         /* caller name */
422         if (name[0] && e_ext.display_name) {
423                 if (!display[0] && cid[0])
424                                 SCAT(display, cid);
425                 if (display[0])
426                                 SCAT(display, " ");
427                 SCAT(display, name);
428         }
429
430         return(display);
431 }
432
433 /*
434  * uses the current state to notify activity
435  */
436 void EndpointAppPBX::notify_active(void)
437 {
438         struct port_list *portlist = ea_endpoint->ep_portlist;
439         struct lcr_msg *message;
440         int notify = 0;
441
442         switch(e_tx_state) {
443                 case NOTIFY_STATE_ACTIVE:
444                 /* we are already active, so we don't do anything */
445                 break;
446
447                 case NOTIFY_STATE_SUSPEND:
448                 notify = INFO_NOTIFY_USER_RESUMED;
449                 while(portlist) {
450                         set_tone(portlist, NULL);
451                         portlist = portlist->next;
452                 }
453                 portlist = ea_endpoint->ep_portlist;
454                 break;
455
456                 case NOTIFY_STATE_HOLD:
457                 notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
458                 while(portlist) {
459                         set_tone(portlist, NULL);
460                         portlist = portlist->next;
461                 }
462                 portlist = ea_endpoint->ep_portlist;
463                 break;
464
465                 case NOTIFY_STATE_CONFERENCE:
466                 notify = INFO_NOTIFY_CONFERENCE_DISCONNECTED;
467                 while(portlist) {
468                         set_tone(portlist, NULL);
469                         portlist = portlist->next;
470                 }
471                 portlist = ea_endpoint->ep_portlist;
472                 break;
473
474                 default:
475                 PERROR("unknown e_tx_state = %d\n", e_tx_state);
476         }
477
478         if (notify)
479         while(portlist) {
480                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
481                 message->param.notifyinfo.notify = notify;
482                 message_put(message);
483                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
484                 portlist = portlist->next;
485         }
486 }
487
488
489 /*
490  * keypad functions during call. one example to use this is to put a call on hold or start a conference
491  */
492 void EndpointAppPBX::keypad_function(char digit)
493 {
494
495         /* we must be in a call, in order to send messages to the call */
496         if (e_ext.number[0] == '\0') {
497                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) IGNORING keypad received not from extension.\n", ea_endpoint->ep_serial);
498                 return;
499         }
500
501         switch(digit) {
502                 /* join conference */
503                 case '3':
504                 if (ea_endpoint->ep_join_id == 0) {
505                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) keypad received during connect but not during a call.\n", ea_endpoint->ep_serial);
506                         break;
507                 }
508                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) join call with call on hold\n", ea_endpoint->ep_serial);
509                 join_join();
510                 break;
511
512                 /* crypt shared */
513                 case '7':
514                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) shared key encryption selected.\n", ea_endpoint->ep_serial);
515                 encrypt_shared();
516                 break;
517
518                 /* crypt key-exchange */
519                 case '8':
520                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) key exchange encryption selected.\n", ea_endpoint->ep_serial);
521                 encrypt_keyex();
522                 break;
523
524                 /* crypt off */
525                 case '9':
526                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) encryption off selected.\n", ea_endpoint->ep_serial);
527                 encrypt_off();
528                 break;
529
530                 default:        
531                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) unsupported keypad digit '%c'.\n", ea_endpoint->ep_serial, digit);
532         }
533 }
534
535
536 /* set tone pattern for port */
537 void EndpointAppPBX::set_tone(struct port_list *portlist, const char *tone)
538 {
539         struct lcr_msg *message;
540
541         if (!tone)
542                 tone = "";
543
544         /* store for suspended processes */
545         SCPY(e_tone, tone);
546
547
548         if (e_join_pattern /* pattern are provided */
549          && !(e_ext.own_setup && e_state == EPOINT_STATE_IN_SETUP)
550          && !(e_ext.own_setup && e_state == EPOINT_STATE_IN_OVERLAP)
551          && !(e_ext.own_proceeding && e_state == EPOINT_STATE_IN_PROCEEDING)
552          && !(e_ext.own_alerting && e_state == EPOINT_STATE_IN_ALERTING)
553          && !(e_ext.own_cause && e_state == EPOINT_STATE_IN_DISCONNECT)
554          && !(e_ext.own_setup && e_state == EPOINT_STATE_OUT_SETUP)
555          && !(e_ext.own_setup && e_state == EPOINT_STATE_OUT_OVERLAP)
556          && !(e_ext.own_proceeding && e_state == EPOINT_STATE_OUT_PROCEEDING)
557          && !(e_ext.own_alerting && e_state == EPOINT_STATE_OUT_ALERTING)
558          && !(e_ext.own_cause && e_state == EPOINT_STATE_OUT_DISCONNECT)
559          && tone[0] && !!strncmp(tone,"crypt_*",6)) {
560                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) tone not provided since patterns are available\n", ea_endpoint->ep_serial);
561                 tone = "";
562         }
563
564         if (portlist) {
565                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_TONE);
566                 SCPY(message->param.tone.dir, e_ext.tones_dir);
567                 SCPY(message->param.tone.name, tone);
568                 message_put(message);
569                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
570         } else {
571                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) no port to notify tone.\n", ea_endpoint->ep_serial);
572                 return;
573         }
574 }
575
576
577 /*
578  * hunts an mISDNport that is available for an outgoing call
579  * if no ifname was given, any interface that is not an extension
580  * will be searched.
581  */
582 struct mISDNport *EndpointAppPBX::hunt_port(char *ifname, int *channel)
583 {
584         struct interface *interface;
585         struct interface_port *ifport, *ifport_start;
586         struct select_channel *selchannel; 
587         struct mISDNport *mISDNport;
588         int index, i;
589         int there_is_an_external = 0;
590
591         interface = interface_first;
592
593         /* first find the given interface or, if not given, one with no extension */
594         checknext:
595         if (!interface) {
596                 if (!there_is_an_external && !(ifname && ifname[0])) {
597                         trace_header("CHANNEL SELECTION (no external interface specified)", DIRECTION_NONE);
598                         add_trace("info", NULL, "Add 'extern' parameter to interface.conf.");
599                         end_trace();
600                 }
601                 return(NULL);
602         }
603
604         /* check for given interface */
605         if (ifname && ifname[0]) {
606                 if (!strcasecmp(interface->name, ifname)) {
607                         /* found explicit interface */
608                         trace_header("CHANNEL SELECTION (found given interface)", DIRECTION_NONE);
609                         add_trace("interface", NULL, "%s", ifname);
610                         end_trace();
611                         goto foundif;
612                 }
613
614         } else {
615                 if (interface->external) {
616                         there_is_an_external = 1;
617                         /* found non extension */
618                         trace_header("CHANNEL SELECTION (found external interface)", DIRECTION_NONE);
619                         add_trace("interface", NULL, "%s", interface->name);
620                         end_trace();
621                         goto foundif;
622                 }
623         }
624
625         interface = interface->next;
626         goto checknext;
627 foundif:
628
629         /* see if interface has ports */
630         if (!interface->ifport) {
631                 /* no ports */
632                 trace_header("CHANNEL SELECTION (active ports, skipping)", DIRECTION_NONE);
633                 add_trace("interface", NULL, "%s", interface->name);
634                 end_trace();
635                 interface = interface->next;
636                 goto checknext;
637         }
638
639         /* select port by algorithm */
640         ifport_start = interface->ifport;
641         index = 0;
642         if (interface->hunt == HUNT_ROUNDROBIN) {
643                 while(ifport_start->next && index<interface->hunt_next) {
644                         ifport_start = ifport_start->next;
645                         index++;
646                 }
647                 trace_header("CHANNEL SELECTION (starting round-robin)", DIRECTION_NONE);
648                 add_trace("port", NULL, "%d", ifport_start->portnum);
649                 add_trace("position", NULL, "%d", index);
650                 end_trace();
651         }
652
653         /* loop ports */
654         ifport = ifport_start;
655         nextport:
656
657         /* see if port is available */
658         if (!ifport->mISDNport) {
659                 trace_header("CHANNEL SELECTION (port not available, skipping)", DIRECTION_NONE);
660                 add_trace("port", NULL, "%d", ifport->portnum);
661                 add_trace("position", NULL, "%d", index);
662                 end_trace();
663                 goto portbusy;
664         }
665         mISDNport = ifport->mISDNport;
666
667         /* see if port is administratively blocked */
668         if (ifport->block) {
669                 trace_header("CHANNEL SELECTION (port blocked by admin, skipping)", DIRECTION_NONE);
670                 add_trace("port", NULL, "%d", ifport->portnum);
671                 add_trace("position", NULL, "%d", index);
672                 end_trace();
673                 goto portbusy;
674         }
675
676         /* see if link is up on PTP*/
677         if (mISDNport->l2hold && mISDNport->l2link<1) {
678                 trace_header("CHANNEL SELECTION (port's layer 2 is down, skipping)", DIRECTION_NONE);
679                 add_trace("port", NULL, "%d", ifport->portnum);
680                 add_trace("position", NULL, "%d", index);
681                 end_trace();
682                 goto portbusy;
683         }
684
685         /* check for channel form selection list */
686         *channel = 0;
687 #ifdef WITH_SS5
688         if (mISDNport->ss5) {
689                 class Pss5 *port;
690                 port = ss5_hunt_line(mISDNport);
691                 if (port) {
692                         *channel = port->p_m_b_channel;
693                         trace_header("CHANNEL SELECTION (selecting SS5 channel)", DIRECTION_NONE);
694                         add_trace("port", NULL, "%d", ifport->portnum);
695                         add_trace("position", NULL, "%d", index);
696                         add_trace("channel", NULL, "%d", *channel);
697                         end_trace();
698                 }
699         } else
700 #endif
701         {
702                 selchannel = ifport->out_channel;
703                 while(selchannel) {
704                         switch(selchannel->channel) {
705                                 case CHANNEL_FREE: /* free channel */
706                                 if (mISDNport->b_reserved >= mISDNport->b_num)
707                                         break; /* all channel in use or reserverd */
708                                 /* find channel */
709                                 i = 0;
710                                 while(i < mISDNport->b_num) {
711                                         if (mISDNport->b_port[i] == NULL) {
712                                                 *channel = i+1+(i>=15);
713                                                 trace_header("CHANNEL SELECTION (selecting free channel)", DIRECTION_NONE);
714                                                 add_trace("port", NULL, "%d", ifport->portnum);
715                                                 add_trace("position", NULL, "%d", index);
716                                                 add_trace("channel", NULL, "%d", *channel);
717                                                 end_trace();
718                                                 break;
719                                         }
720                                         i++;
721                                 }
722                                 if (*channel)
723                                         break;
724                                 trace_header("CHANNEL SELECTION (no channel is 'free')", DIRECTION_NONE);
725                                 add_trace("port", NULL, "%d", ifport->portnum);
726                                 add_trace("position", NULL, "%d", index);
727                                 end_trace();
728                                 break;
729
730                                 case CHANNEL_ANY: /* don't ask for channel */
731                                 if (mISDNport->b_reserved >= mISDNport->b_num) {
732                                         trace_header("CHANNEL SELECTION (cannot ask for 'any' channel, all reserved)", DIRECTION_NONE);
733                                         add_trace("port", NULL, "%d", ifport->portnum);
734                                         add_trace("position", NULL, "%d", index);
735                                         add_trace("total", NULL, "%d", mISDNport->b_num);
736                                         add_trace("reserved", NULL, "%d", mISDNport->b_reserved);
737                                         end_trace();
738                                         break; /* all channel in use or reserverd */
739                                 }
740                                 trace_header("CHANNEL SELECTION (using 'any' channel)", DIRECTION_NONE);
741                                 add_trace("port", NULL, "%d", ifport->portnum);
742                                 add_trace("position", NULL, "%d", index);
743                                 end_trace();
744                                 *channel = CHANNEL_ANY;
745                                 break;
746
747                                 case CHANNEL_NO: /* call waiting */
748                                 trace_header("CHANNEL SELECTION (using 'no' channel, call-waiting)", DIRECTION_NONE);
749                                 add_trace("port", NULL, "%d", ifport->portnum);
750                                 add_trace("position", NULL, "%d", index);
751                                 end_trace();
752                                 *channel = CHANNEL_NO;
753                                 break;
754
755                                 default:
756                                 if (selchannel->channel<1 || selchannel->channel==16) {
757                                         trace_header("CHANNEL SELECTION (channel out of range)", DIRECTION_NONE);
758                                         add_trace("port", NULL, "%d", ifport->portnum);
759                                         add_trace("position", NULL, "%d", index);
760                                         add_trace("channel", NULL, "%d", selchannel->channel);
761                                         end_trace();
762                                         break; /* invalid channels */
763                                 }
764                                 i = selchannel->channel-1-(selchannel->channel>=17);
765                                 if (i >= mISDNport->b_num) {
766                                         trace_header("CHANNEL SELECTION (channel out of range)", DIRECTION_NONE);
767                                         add_trace("port", NULL, "%d", ifport->portnum);
768                                         add_trace("position", NULL, "%d", index);
769                                         add_trace("channel", NULL, "%d", selchannel->channel);
770                                         add_trace("channels", NULL, "%d", mISDNport->b_num);
771                                         end_trace();
772                                         break; /* channel not in port */
773                                 }
774                                 if (mISDNport->b_port[i] == NULL) {
775                                         *channel = selchannel->channel;
776                                         trace_header("CHANNEL SELECTION (selecting given channel)", DIRECTION_NONE);
777                                         add_trace("port", NULL, "%d", ifport->portnum);
778                                         add_trace("position", NULL, "%d", index);
779                                         add_trace("channel", NULL, "%d", *channel);
780                                         end_trace();
781                                         break;
782                                 }
783                                 break;
784                         }
785                         if (*channel)
786                                 break; /* found channel */
787                         selchannel = selchannel->next;
788                 }
789         }
790
791         /* if channel was found, return mISDNport and channel */
792         if (*channel) {
793                 /* setting next port to start next time */
794                 if (interface->hunt == HUNT_ROUNDROBIN) {
795                         index++;
796                         if (!ifport->next)
797                                 index = 0;
798                         interface->hunt_next = index;
799                 }
800                 
801                 return(mISDNport);
802         }
803
804         trace_header("CHANNEL SELECTION (skipping, no channel found)", DIRECTION_NONE);
805         add_trace("port", NULL, "%d", ifport->portnum);
806         add_trace("position", NULL, "%d", index);
807         end_trace();
808
809         portbusy:
810         /* go next port, until all ports are checked */
811         index++;
812         ifport = ifport->next;
813         if (!ifport) {
814                 index = 0;
815                 ifport = interface->ifport;
816         }
817         if (ifport != ifport_start)
818                 goto nextport;
819
820         if (!ifname) {
821                 interface = interface->next;
822                 goto checknext;
823         }
824
825         return(NULL); /* no port found */
826 }
827
828 /* outgoing setup to port(s)
829  * ports will be created and a setup is sent if everything is ok. otherwhise
830  * the endpoint is destroyed.
831  */
832 void EndpointAppPBX::out_setup(void)
833 {
834         struct dialing_info     dialinginfo;
835         class Port              *port;
836         struct port_list        *portlist;
837         struct lcr_msg          *message;
838         int                     anycall = 0;
839         int                     cause = CAUSE_RESSOURCEUNAVAIL;
840         const char              *p;
841         char                    cfp[64];
842         struct mISDNport        *mISDNport;
843         char                    portname[32];
844         char                    *dirname;
845         class EndpointAppPBX    *atemp;
846 //      char                    allowed_ports[256];
847 //      char                    exten[256];
848         char                    ifname[sizeof(e_ext.interfaces)],
849                                 number[256];
850         struct port_settings    port_settings;
851         int                     channel = 0;
852         int                     earlyb;
853         int                     mode = B_MODE_TRANSPARENT;
854
855         /* set bchannel mode */
856         mode = e_capainfo.source_mode;
857
858         /* create settings for creating port */
859         memset(&port_settings, 0, sizeof(port_settings));
860         if (e_ext.tones_dir)
861                 SCPY(port_settings.tones_dir, e_ext.tones_dir);
862         else
863                 SCPY(port_settings.tones_dir, options.tones_dir);
864         port_settings.no_seconds = e_ext.no_seconds;
865         
866         /* NOTE: currently the try_card feature is not supported. it should be used later to try another card, if the outgoing call fails on one port */
867
868         /* check what dialinginfo.itype we got */
869         switch(e_dialinginfo.itype) {
870                 /* *********************** call to extension or vbox */
871                 case INFO_ITYPE_ISDN_EXTENSION:
872                 /* check if we deny incoming calls when we use an extension */
873                 if (e_ext.noknocking) {
874                         atemp = apppbx_first;
875                         while(atemp) {
876                                 if (atemp != this)
877                                 if (!strcmp(atemp->e_ext.number, e_ext.number))
878                                         break;
879                                 atemp = atemp->next;
880                         }
881                         if (atemp) {
882                                 PERROR("EPOINT(%d) noknocking and currently a call\n", ea_endpoint->ep_serial);
883                                 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_BUSY, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0); /* RELEASE_TYSPE_ join, port */
884                                 return; /* must exit here */
885                         }
886                 }
887                 /* FALL THROUGH !!!! */
888                 case INFO_ITYPE_VBOX:
889                 /* get dialed extension's info */
890 //              SCPY(exten, e_dialinginfo.id);
891 //              if (strchr(exten, ','))
892 //                      *strchr(exten, ',') = '\0';
893 //              if (!read_extension(&e_ext, exten))
894                 if (!read_extension(&e_ext, e_dialinginfo.id)) {
895                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) extension %s not configured\n", ea_endpoint->ep_serial, e_dialinginfo.id);
896                         release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_OUTOFORDER, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0); /* RELEASE_TYPE, join, port */
897                         return; /* must exit here */
898                 }
899                 e_dialinginfo.sending_complete = 1;
900
901                 if (e_dialinginfo.itype == INFO_ITYPE_VBOX) {
902                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dialing directly to VBOX\n", ea_endpoint->ep_serial);
903                         p = "vbox";
904                         goto vbox_only;
905                 }
906
907                 /* string from unconditional call forward (cfu) */
908                 p = e_ext.cfu;
909                 if (*p) {
910                         /* present to forwarded party */
911                         if (e_ext.anon_ignore && e_callerinfo.id[0]) {
912                                 e_callerinfo.present = INFO_PRESENT_ALLOWED;
913                         }
914                         if (!!strcmp(p, "vbox") || (e_capainfo.bearer_capa==INFO_BC_AUDIO) || (e_capainfo.bearer_capa==INFO_BC_SPEECH))
915                                 goto cfu_only;
916                 }
917
918                 /* string from busy call forward (cfb) */
919                 p = e_ext.cfb;
920                 if (*p) {
921                         class EndpointAppPBX *checkapp = apppbx_first;
922                         while(checkapp) {
923                                 if (checkapp != this) { /* any other endpoint except our own */
924                                         if (!strcmp(checkapp->e_ext.number, e_ext.number)) {
925                                                 /* present to forwarded party */
926                                                 if (e_ext.anon_ignore && e_callerinfo.id[0]) {
927                                                         e_callerinfo.present = INFO_PRESENT_ALLOWED;
928                                                 }
929                                                 if (!!strcmp(p, "vbox") || (e_capainfo.bearer_capa==INFO_BC_AUDIO) || (e_capainfo.bearer_capa==INFO_BC_SPEECH))
930                                                         goto cfb_only;
931                                         }
932                                 }
933                                 checkapp = checkapp->next;
934                         }
935                 }
936
937                 /* string from no-response call forward (cfnr) */
938                 p = e_ext.cfnr;
939                 if (*p) {
940                         /* when cfnr is done, out_setup() will setup the call */
941                         if (e_cfnr_call_timeout.active) {
942                                 /* present to forwarded party */
943                                 if (e_ext.anon_ignore && e_callerinfo.id[0]) {
944                                         e_callerinfo.present = INFO_PRESENT_ALLOWED;
945                                 }
946                                 goto cfnr_only;
947                         }
948                         if (!!strcmp(p, "vbox") || (e_capainfo.bearer_capa==INFO_BC_AUDIO) || (e_capainfo.bearer_capa==INFO_BC_SPEECH)) {
949                                 schedule_timer(&e_cfnr_timeout, e_ext.cfnr_delay, 0);
950                                 schedule_timer(&e_cfnr_call_timeout, e_ext.cfnr_delay + 1, 0); /* call one second after release */
951                                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) setting time for call-forward-busy to %s with delay %ld.\n", ea_endpoint->ep_serial, e_ext.cfnr, e_ext.cfnr_delay);
952                         }
953                 }
954
955                 /* call to all internal interfaces */
956                 p = e_ext.interfaces;
957                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) generating multiple joins for extension %s to interfaces %s\n", ea_endpoint->ep_serial, e_dialinginfo.id, p);
958                 while(*p) {
959                         ifname[0] = '\0';
960                         while(*p!=',' && *p!='\0')
961                                 if (*p > ' ')
962                                         SCCAT(ifname, *p++);
963                         if (*p == ',')
964                                 p++;
965                         /* found interface */
966                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) calling to interface %s\n", ea_endpoint->ep_serial, ifname);
967                         /* hunt for mISDNport and create Port */
968                         mISDNport = hunt_port(ifname, &channel);
969                         if (!mISDNport) {
970                                 trace_header("INTERFACE (not found or busy)", DIRECTION_NONE);
971                                 add_trace("interface", NULL, "%s", ifname);
972                                 end_trace();
973                                 continue;
974                         }
975                         /* creating INTERNAL port */
976                         SPRINT(portname, "%s-%d-out", mISDNport->ifport->interface->name, mISDNport->portnum);
977 #ifdef WITH_SS5
978                         if (mISDNport->ss5)
979                                 port = ss5_hunt_line(mISDNport);
980                         else
981 #endif
982                         if (!mISDNport->gsm)
983                                 port = new Pdss1((mISDNport->ntmode)?PORT_TYPE_DSS1_NT_OUT:PORT_TYPE_DSS1_TE_OUT, mISDNport, portname, &port_settings, channel, mISDNport->ifport->channel_force, mode);
984                         else
985 #ifdef WITH_GSM
986                                 port = new Pgsm(PORT_TYPE_GSM_OUT, mISDNport, portname, &port_settings, channel, mISDNport->ifport->channel_force, mode);
987 #else
988                                 port = NULL;
989 #endif
990                         if (!port)
991                                 FATAL("No memory for Port instance\n");
992                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) got port %s\n", ea_endpoint->ep_serial, port->p_name);
993                         memset(&dialinginfo, 0, sizeof(dialinginfo));
994                         SCPY(dialinginfo.id, e_dialinginfo.id);
995                         dialinginfo.itype = INFO_ITYPE_ISDN_EXTENSION;
996                         dialinginfo.ntype = e_dialinginfo.ntype;
997                         /* create port_list relation */
998                         portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, mISDNport->earlyb);
999                         if (!portlist) {
1000                                 PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
1001                                 delete port;
1002                                 goto check_anycall_intern;
1003                         }
1004                         /* directory.list */
1005                         if (e_callerinfo.id[0] && e_ext.display_name) {
1006                                 dirname = parse_directory(e_callerinfo.id, e_callerinfo.ntype);
1007                                 if (dirname)
1008                                         SCPY(e_callerinfo.name, dirname);
1009                         }
1010 //                      dss1 = (class Pdss1 *)port;
1011                         /* message */
1012 //printf("INTERNAL caller=%s,id=%s,dial=%s\n", param.setup.networkid, param.setup.callerinfo.id, param.setup.dialinginfo.id);
1013                         message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_SETUP);
1014                         memcpy(&message->param.setup.dialinginfo, &dialinginfo, sizeof(struct dialing_info));
1015                         memcpy(&message->param.setup.redirinfo, &e_redirinfo, sizeof(struct redir_info));
1016                         memcpy(&message->param.setup.callerinfo, &e_callerinfo, sizeof(struct caller_info));
1017                         memcpy(&message->param.setup.capainfo, &e_capainfo, sizeof(struct capa_info));
1018 //terminal                      SCPY(message->param.setup.from_terminal, e_ext.number);
1019 //terminal                      if (e_dialinginfo.id)
1020 //terminal                              SCPY(message->param.setup.to_terminal, e_dialinginfo.id);
1021                         /* handle restricted caller ids */
1022                         apply_callerid_restriction(&e_ext, message->param.setup.callerinfo.id, &message->param.setup.callerinfo.ntype, &message->param.setup.callerinfo.present, &message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name);
1023                         apply_callerid_restriction(&e_ext, message->param.setup.callerinfo.id2, &message->param.setup.callerinfo.ntype2, &message->param.setup.callerinfo.present2, &message->param.setup.callerinfo.screen2, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name);
1024                         apply_callerid_restriction(&e_ext, message->param.setup.redirinfo.id, &message->param.setup.redirinfo.ntype, &message->param.setup.redirinfo.present, 0, message->param.setup.redirinfo.extension, NULL);
1025                         /* display callerid if desired for extension */
1026                         SCPY(message->param.setup.callerinfo.display, apply_callerid_display(message->param.setup.callerinfo.id, message->param.setup.callerinfo.itype, message->param.setup.callerinfo.ntype, message->param.setup.callerinfo.present, message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name));
1027 //printf("\n\ndisplay = %s\n\n\n",message->param.setup.callerinfo.display);
1028                         /* use cnip, if enabld */
1029         //              if (!e_ext.centrex)
1030         //                      message->param.setup.callerinfo.name[0] = '\0';
1031                         /* screen clip if prefix is required */
1032                         if (message->param.setup.callerinfo.id[0] && e_ext.clip_prefix[0]) {
1033                                 SCPY(message->param.setup.callerinfo.id, e_ext.clip_prefix);
1034                                 SCAT(message->param.setup.callerinfo.id, numberrize_callerinfo(e_callerinfo.id,e_callerinfo.ntype, options.national, options.international));
1035                                 message->param.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
1036                         }
1037                         if (message->param.setup.callerinfo.id2[0] && e_ext.clip_prefix[0]) {
1038                                 SCPY(message->param.setup.callerinfo.id2, e_ext.clip_prefix);
1039                                 SCAT(message->param.setup.callerinfo.id2, numberrize_callerinfo(e_callerinfo.id2,e_callerinfo.ntype2, options.national, options.international));
1040                                 message->param.setup.callerinfo.ntype2 = INFO_NTYPE_UNKNOWN;
1041                         }
1042                         /* use internal caller id */
1043                         if (e_callerinfo.extension[0] && (message->param.setup.callerinfo.present!=INFO_PRESENT_RESTRICTED || e_ext.anon_ignore)) {
1044                                 SCPY(message->param.setup.callerinfo.id, e_callerinfo.extension);
1045                                 message->param.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
1046                                 message->param.setup.callerinfo.ntype2 = INFO_NTYPE_NOTPRESENT;
1047                         }
1048                         message_put(message);
1049                         logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1050                         anycall = 1;
1051                 }
1052
1053                 /* string from parallel call forward (cfp) */
1054                 p = e_ext.cfp;
1055                 if (*p) {
1056                         if (e_ext.anon_ignore && e_callerinfo.id[0]) {
1057                                 e_callerinfo.present = INFO_PRESENT_ALLOWED;
1058                                 e_callerinfo.present2 = INFO_PRESENT_ALLOWED;
1059                         }
1060                 }
1061
1062                 vbox_only: /* entry point for answering machine only */
1063                 cfu_only: /* entry point for cfu */
1064                 cfb_only: /* entry point for cfb */
1065                 cfnr_only: /* entry point for cfnr */
1066                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call extension %s for external destiantion(s) '%s'\n", ea_endpoint->ep_serial, e_dialinginfo.id, p);
1067 //              i=0;
1068                 while(*p) {
1069                         earlyb = 0;
1070                         /* only if vbox should be dialed, and terminal is given */
1071                         if (!strcmp(p, "vbox") && e_ext.number[0]) {
1072                                 /* go to the end of p */
1073                                 p += strlen(p);
1074
1075                                 /* answering vbox call */
1076                                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) answering machine\n", ea_endpoint->ep_serial);
1077                                 /* alloc port */
1078                                 if (!(port = new VBoxPort(PORT_TYPE_VBOX_OUT, &port_settings)))
1079                                         FATAL("No memory for VBOX Port instance\n");
1080                                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) allocated port %s\n", ea_endpoint->ep_serial, port->p_name);
1081                                 UCPY(cfp, e_ext.number); /* cfp or any other direct forward/vbox */
1082                         } else {
1083                                 cfp[0] = '\0';
1084                                 while(*p!=',' && *p!='\0')
1085                                         SCCAT(cfp, *p++);
1086                                 if (*p == ',')
1087                                         p++;
1088                                 /* external call */
1089                                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cfp external %s\n", ea_endpoint->ep_serial, cfp);
1090                                 /* hunt for mISDNport and create Port */
1091                                 mISDNport = hunt_port(e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:NULL, &channel);
1092                                 if (mISDNport) {
1093                                         /* creating EXTERNAL port*/
1094                                         SPRINT(portname, "%s-%d-out", mISDNport->ifport->interface->name, mISDNport->portnum);
1095 #ifdef WITH_SS5
1096                                         if (mISDNport->ss5)
1097                                                 port = ss5_hunt_line(mISDNport);
1098                                         else
1099 #endif
1100                                                 port = new Pdss1((mISDNport->ntmode)?PORT_TYPE_DSS1_NT_OUT:PORT_TYPE_DSS1_TE_OUT, mISDNport, portname, &port_settings, channel, mISDNport->ifport->channel_force, mode);
1101                                         if (!port)
1102                                                 FATAL("No memory for Port instance\n");
1103                                         earlyb = mISDNport->earlyb;
1104                                 } else {
1105                                         port = NULL;
1106                                         trace_header("INTERFACE (too busy)", DIRECTION_NONE);
1107                                         add_trace("interface", NULL, "%s", e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:"any interface");
1108                                         end_trace();
1109                                 }
1110                         }
1111                         if (!port) {
1112                                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) no port found or created, which is idle.\n", ea_endpoint->ep_serial);
1113                                 goto check_anycall_intern;
1114                         }
1115                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) found or created port %s\n", ea_endpoint->ep_serial, port->p_name);
1116                         memset(&dialinginfo, 0, sizeof(dialinginfo));
1117                         SCPY(dialinginfo.id, cfp);
1118                         dialinginfo.itype = INFO_ITYPE_ISDN;
1119                         dialinginfo.ntype = e_dialinginfo.ntype;
1120                         portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, earlyb);
1121                         if (!portlist) {
1122                                 PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
1123                                 delete port;
1124                                 goto check_anycall_intern;
1125                         }
1126 //printf("EXTERNAL caller=%s,id=%s,dial=%s\n", param.setup.networkid, param.setup.callerinfo.id, param.setup.dialinginfo.id);
1127                         message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_SETUP);
1128                         memcpy(&message->param.setup.dialinginfo, &dialinginfo, sizeof(struct dialing_info));
1129                         memcpy(&message->param.setup.redirinfo, &e_redirinfo, sizeof(struct redir_info));
1130                         memcpy(&message->param.setup.callerinfo, &e_callerinfo, sizeof(struct caller_info));
1131                         /* if clip is hidden */
1132                         if (e_ext.clip==CLIP_HIDE && port->p_type!=PORT_TYPE_VBOX_OUT) {
1133                                 SCPY(message->param.setup.callerinfo.id, e_ext.callerid);
1134                                 SCPY(message->param.setup.callerinfo.extension, e_ext.number);
1135                                 message->param.setup.callerinfo.ntype = e_ext.callerid_type;
1136                                 message->param.setup.callerinfo.present = e_ext.callerid_present;
1137                                 message->param.setup.callerinfo.ntype = INFO_NTYPE_NOTPRESENT;
1138                         }
1139                         memcpy(&message->param.setup.capainfo, &e_capainfo, sizeof(struct capa_info));
1140 //terminal                      SCPY(message->param.setup.from_terminal, e_ext.number);
1141 //terminal                      if (e_dialinginfo.id)
1142 //terminal                              SCPY(message->param.setup.to_terminal, e_dialinginfo.id);
1143                                 /* handle restricted caller ids */
1144                         apply_callerid_restriction(&e_ext, message->param.setup.callerinfo.id, &message->param.setup.callerinfo.ntype, &message->param.setup.callerinfo.present, &message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name);
1145                         apply_callerid_restriction(&e_ext, message->param.setup.callerinfo.id2, &message->param.setup.callerinfo.ntype2, &message->param.setup.callerinfo.present2, &message->param.setup.callerinfo.screen2, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name);
1146                         apply_callerid_restriction(&e_ext, message->param.setup.redirinfo.id, &message->param.setup.redirinfo.ntype, &message->param.setup.redirinfo.present, 0, message->param.setup.redirinfo.extension, NULL);
1147                         /* display callerid if desired for extension */
1148                         SCPY(message->param.setup.callerinfo.display, apply_callerid_display(message->param.setup.callerinfo.id, message->param.setup.callerinfo.itype, message->param.setup.callerinfo.ntype, message->param.setup.callerinfo.present, message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name));
1149                         message_put(message);
1150                         logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1151                         anycall = 1;
1152                 }
1153
1154                 check_anycall_intern:
1155                 /* now we have all ports created */
1156                 if (!anycall) {
1157                         trace_header("INTERFACE (no extension's interface)", DIRECTION_NONE);
1158                         end_trace();
1159                         if (!ea_endpoint->ep_join_id)
1160                                 break;
1161                         release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, cause, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0); /* RELEASE_TYPE, join, port */
1162                         return; /* must exit here */
1163                 }
1164                 break;
1165
1166                 /* *********************** external call */
1167                 default:
1168                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dialing external: called='%s' keypad='%s'\n", ea_endpoint->ep_serial, e_dialinginfo.id, e_dialinginfo.keypad);
1169                 /* call to extenal interfaces */
1170                 if (e_dialinginfo.keypad[0])
1171                         p = e_dialinginfo.keypad;
1172                 else
1173                         p = e_dialinginfo.id;
1174                 do {
1175                         number[0] = '\0';
1176                         while(*p!=',' && *p!='\0')
1177                                 SCCAT(number, *p++);
1178                         if (*p == ',')
1179                                 p++;
1180                         /* found number */
1181                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) calling to number '%s' interface '%s'\n", ea_endpoint->ep_serial, number, e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:"any interface");
1182                         /* hunt for mISDNport and create Port */
1183                         /* hunt for mISDNport and create Port */
1184                         mISDNport = hunt_port(e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:NULL, &channel);
1185                         if (!mISDNport) {
1186                                 trace_header("INTERFACE (too busy)", DIRECTION_NONE);
1187                                 add_trace("interface", NULL, "%s", e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:"any interface");
1188                                 end_trace();
1189                                 goto check_anycall_extern;
1190                         }
1191                         /* creating EXTERNAL port*/
1192                         SPRINT(portname, "%s-%d-out", mISDNport->ifport->interface->name, mISDNport->portnum);
1193 #ifdef WITH_SS5
1194                         if (mISDNport->ss5)
1195                                 port = ss5_hunt_line(mISDNport);
1196                         else
1197 #endif
1198                         if (!mISDNport->gsm)
1199                                 port = new Pdss1((mISDNport->ntmode)?PORT_TYPE_DSS1_NT_OUT:PORT_TYPE_DSS1_TE_OUT, mISDNport, portname, &port_settings, channel, mISDNport->ifport->channel_force, mode);
1200                         else
1201 #ifdef WITH_GSM
1202                                 port = new Pgsm(PORT_TYPE_GSM_OUT, mISDNport, portname, &port_settings, channel, mISDNport->ifport->channel_force, mode);
1203 #else
1204                                 port = NULL;
1205 #endif
1206                         if (!port)
1207                                 FATAL("No memory for Port instance\n");
1208                         earlyb = mISDNport->earlyb;
1209                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) created port %s\n", ea_endpoint->ep_serial, port->p_name);
1210                         memset(&dialinginfo, 0, sizeof(dialinginfo));
1211                         if (e_dialinginfo.keypad[0])
1212                                 SCPY(dialinginfo.keypad, number);
1213                         else
1214                                 SCPY(dialinginfo.id, number);
1215                         dialinginfo.itype = INFO_ITYPE_ISDN;
1216                         dialinginfo.ntype = e_dialinginfo.ntype;
1217                         dialinginfo.sending_complete = e_dialinginfo.sending_complete;
1218                         portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, mISDNport->earlyb);
1219                         if (!portlist) {
1220                                 PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
1221                                 delete port;
1222                                 goto check_anycall_extern;
1223                         }
1224 //printf("EXTERNAL caller=%s,id=%s,dial=%s\n", param.setup.networkid, param.setup.callerinfo.id, param.setup.dialinginfo.id);
1225                         message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_SETUP);
1226                         memcpy(&message->param.setup.dialinginfo, &dialinginfo, sizeof(struct dialing_info));
1227                         memcpy(&message->param.setup.redirinfo, &e_redirinfo, sizeof(struct redir_info));
1228                         memcpy(&message->param.setup.callerinfo, &e_callerinfo, sizeof(struct caller_info));
1229                         memcpy(&message->param.setup.capainfo, &e_capainfo, sizeof(struct capa_info));
1230 //terminal                      SCPY(message->param.setup.from_terminal, e_ext.number);
1231 //terminal                      if (e_dialinginfo.id)
1232 //terminal                              SCPY(message->param.setup.to_terminal, e_dialinginfo.id);
1233                                 /* handle restricted caller ids */
1234                         apply_callerid_restriction(&e_ext, message->param.setup.callerinfo.id, &message->param.setup.callerinfo.ntype, &message->param.setup.callerinfo.present, &message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name);
1235                         apply_callerid_restriction(&e_ext, message->param.setup.callerinfo.id2, &message->param.setup.callerinfo.ntype2, &message->param.setup.callerinfo.present2, &message->param.setup.callerinfo.screen2, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name);
1236                         apply_callerid_restriction(&e_ext, message->param.setup.redirinfo.id, &message->param.setup.redirinfo.ntype, &message->param.setup.redirinfo.present, 0, message->param.setup.redirinfo.extension, NULL);
1237                         /* display callerid if desired for extension */
1238                         SCPY(message->param.setup.callerinfo.display, apply_callerid_display(message->param.setup.callerinfo.id, message->param.setup.callerinfo.itype, message->param.setup.callerinfo.ntype, message->param.setup.callerinfo.present, message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name));
1239                         message_put(message);
1240                         logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1241                         anycall = 1;
1242                 } while(*p);
1243
1244                 check_anycall_extern:
1245                 /* now we have all ports created */
1246                 if (!anycall) {
1247                         trace_header("INTERFACE (no free ports found)", DIRECTION_NONE);
1248                         end_trace();
1249                         if (!ea_endpoint->ep_join_id)
1250                                 break;
1251                         release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NOCHANNEL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0); /* RELEASE_TYPE, join, port */
1252                         return; /* must exit here */
1253                 }
1254                 break;
1255         }
1256
1257 }
1258
1259 int action_timeout(struct lcr_timer *timer, void *instance, int index)
1260 {
1261         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1262
1263         if (!ea->e_action || ea->e_state == EPOINT_STATE_CONNECT)
1264                 return 0;
1265
1266         unsched_timer(&ea->e_redial_timeout);
1267         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) current action timed out.\n", ea->ea_endpoint->ep_serial);
1268         ea->e_multipoint_cause = 0;
1269         ea->e_multipoint_location = 0;
1270         ea->new_state(EPOINT_STATE_IN_OVERLAP);
1271         ea->e_join_pattern = 0;
1272         ea->process_dialing(1);
1273         /* we must exit, because our endpoint might be gone */
1274
1275         return 0;
1276 }
1277
1278 int match_timeout(struct lcr_timer *timer, void *instance, int index)
1279 {
1280         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1281
1282         if (!ea->e_action) {
1283                 unsched_timer(&ea->e_redial_timeout);
1284                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we got a match timeout.\n", ea->ea_endpoint->ep_serial);
1285                 ea->process_dialing(0);
1286                 /* we must exit, because our endpoint might be gone */
1287         }
1288
1289         return 0;
1290 }
1291
1292 int redial_timeout(struct lcr_timer *timer, void *instance, int index)
1293 {
1294         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1295
1296         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) starting redial.\n", ea->ea_endpoint->ep_serial);
1297
1298         ea->new_state(EPOINT_STATE_OUT_SETUP);
1299         /* call special setup routine */
1300         ea->out_setup();
1301
1302         return 0;
1303 }
1304
1305 int powerdial_timeout(struct lcr_timer *timer, void *instance, int index)
1306 {
1307         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1308
1309         /* leave power dialing on */
1310         ea->e_powerdial_on = 1;
1311         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) starting redial of powerdial.\n", ea->ea_endpoint->ep_serial);
1312
1313         /* redial */
1314         ea->e_ruleset = ruleset_main;
1315         if (ea->e_ruleset)
1316                 ea->e_rule = ea->e_ruleset->rule_first;
1317         ea->e_action = NULL;
1318         ea->new_state(EPOINT_STATE_IN_OVERLAP);
1319         ea->process_dialing(0);
1320
1321         return 0;
1322 }
1323
1324 int cfnr_timeout(struct lcr_timer *timer, void *instance, int index)
1325 {
1326         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1327         struct port_list *portlist;
1328         struct lcr_msg *message;
1329
1330         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call-forward-no-response time has expired, hanging up.\n", ea->ea_endpoint->ep_serial);
1331
1332         /* release all ports */
1333         while((portlist = ea->ea_endpoint->ep_portlist)) {
1334                 message = message_create(ea->ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_RELEASE);
1335                 message->param.disconnectinfo.cause = CAUSE_NORMAL; /* normal clearing */
1336                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1337                 message_put(message);
1338                 ea->logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1339                 ea->ea_endpoint->free_portlist(portlist);
1340         }
1341         /* put on hold */
1342         message = message_create(ea->ea_endpoint->ep_serial, ea->ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
1343         message->param.audiopath = 0;
1344         message_put(message);
1345         /* indicate no patterns */
1346         message = message_create(ea->ea_endpoint->ep_serial, ea->ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
1347         message_put(message);
1348         /* set setup state, since we have no response from the new join */
1349         ea->new_state(EPOINT_STATE_OUT_SETUP);
1350
1351         return 0;
1352 }
1353
1354 int cfnr_call_timeout(struct lcr_timer *timer, void *instance, int index)
1355 {
1356         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1357
1358         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call-forward-busy time has expired, calling the forwarded number: %s.\n", ea->ea_endpoint->ep_serial, ea->e_ext.cfnr);
1359         ea->out_setup();
1360
1361         return 0;
1362 }
1363
1364 int callback_timeout(struct lcr_timer *timer, void *instance, int index)
1365 {
1366         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1367
1368         if (ea->e_state == EPOINT_STATE_IDLE) {
1369                 /* epoint is idle, check callback */
1370                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) starting callback.\n", ea->ea_endpoint->ep_serial);
1371                 ea->new_state(EPOINT_STATE_OUT_SETUP);
1372                 ea->out_setup();
1373         }
1374
1375         return 0;
1376 }
1377
1378 int password_timeout(struct lcr_timer *timer, void *instance, int index)
1379 {
1380         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1381
1382         if (ea->e_action->index==ACTION_PASSWORD || ea->e_action->index==ACTION_PASSWORD_WRITE) {
1383                 struct port_list *portlist;
1384
1385                 ea->e_ruleset = ruleset_main;
1386                 if (ea->e_ruleset)
1387                         ea->e_rule = ea->e_ruleset->rule_first;
1388                 ea->e_action = NULL;
1389                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) password timeout %s\n", ea->ea_endpoint->ep_serial, ea->e_extdialing);
1390                 ea->trace_header("PASSWORD timeout", DIRECTION_NONE);
1391                 end_trace();
1392                 ea->e_connectedmode = 0;
1393                 ea->e_dtmf = 0;
1394                 ea->new_state(EPOINT_STATE_OUT_DISCONNECT);
1395                 portlist = ea->ea_endpoint->ep_portlist;
1396                 if (portlist) {
1397                         ea->message_disconnect_port(portlist, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, "");
1398                         ea->set_tone(portlist, "cause_10");
1399                 }
1400         }
1401
1402         return 0;
1403 }
1404
1405 /* doing a hookflash */
1406 void EndpointAppPBX::hookflash(void)
1407 {
1408         class Port *port;
1409         time_t now;
1410
1411         /* be sure that we are active */
1412         notify_active();
1413         e_tx_state = NOTIFY_STATE_ACTIVE;
1414
1415         trace_header("HOOKFLASH DTMF", DIRECTION_NONE);
1416         end_trace();
1417         if (ea_endpoint->ep_use > 1) {
1418                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot hooflash while child process is running.\n", ea_endpoint->ep_serial);
1419                 return;
1420         }
1421         /* dialtone after pressing the hash key */
1422         process_hangup(e_join_cause, e_join_location);
1423         e_multipoint_cause = 0;
1424         e_multipoint_location = 0;
1425         port = find_port_id(ea_endpoint->ep_portlist->port_id);
1426         if (port) {
1427                 port->set_echotest(0);
1428         }
1429         if (ea_endpoint->ep_join_id) {
1430                 release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0); /* RELEASE_TYPE, join, port */
1431         }
1432         e_ruleset = ruleset_main;
1433         if (e_ruleset)
1434                 e_rule = e_ruleset->rule_first;
1435         e_action = NULL;
1436         new_state(EPOINT_STATE_IN_OVERLAP);
1437         e_connectedmode = 1;
1438         SCPY(e_dialinginfo.id, e_ext.prefix);
1439         e_extdialing = e_dialinginfo.id;
1440         e_join_pattern = 0;
1441         if (e_dialinginfo.id[0]) {
1442                 set_tone(ea_endpoint->ep_portlist, "dialing");
1443                 process_dialing(0);
1444         } else {
1445                 set_tone(ea_endpoint->ep_portlist, "dialpbx");
1446         }
1447         time(&now);
1448         e_dtmf_time = now;
1449         e_dtmf_last = '\0';
1450 }
1451
1452
1453 /* messages from port
1454  */
1455 /* port MESSAGE_SETUP */
1456 void EndpointAppPBX::port_setup(struct port_list *portlist, int message_type, union parameter *param)
1457 {
1458         struct lcr_msg          *message;
1459         char                    buffer[256];
1460         int                     writeext;               /* flags need to write extension after modification */
1461         class Port              *port;
1462         struct interface        *interface;
1463
1464         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
1465         
1466         portlist->port_type = param->setup.port_type;
1467         memcpy(&e_callerinfo, &param->setup.callerinfo, sizeof(e_callerinfo));
1468         memcpy(&e_dialinginfo, &param->setup.dialinginfo, sizeof(e_dialinginfo));
1469         memcpy(&e_redirinfo, &param->setup.redirinfo, sizeof(e_redirinfo));
1470         memcpy(&e_capainfo, &param->setup.capainfo, sizeof(e_capainfo));
1471
1472         /* convert (inter-)national number type */
1473         SCPY(e_dialinginfo.id, numberrize_callerinfo(e_dialinginfo.id, e_dialinginfo.ntype, options.national, options.international));
1474         e_dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
1475
1476 //      e_dtmf = param->setup.dtmf;
1477         /* screen incoming caller id */
1478         interface = interface_first;
1479         while(interface) {
1480                 if (!strcmp(e_callerinfo.interface, interface->name)) {
1481                         break;
1482                 }
1483                 interface = interface->next;
1484         }
1485         if (interface) {
1486                 do_screen(0, e_callerinfo.id, sizeof(e_callerinfo.id), &e_callerinfo.ntype, &e_callerinfo.present, interface);
1487                 do_screen(0, e_callerinfo.id2, sizeof(e_callerinfo.id2), &e_callerinfo.ntype2, &e_callerinfo.present2, interface);
1488         }
1489
1490         /* process extension */
1491         if (e_callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION) {
1492                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming call is extension\n", ea_endpoint->ep_serial);
1493                 /* port makes call from extension */
1494                 SCPY(e_callerinfo.extension, e_callerinfo.id);
1495                 SCPY(e_ext.number, e_callerinfo.extension);
1496                 SCPY(e_extension_interface, e_callerinfo.interface);
1497         } else {
1498                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming call is external or voip\n", ea_endpoint->ep_serial);
1499         }
1500
1501         if (e_callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION) {
1502                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call from extension '%s'\n", ea_endpoint->ep_serial, e_ext.number);
1503
1504                 /* get extension's info about caller */
1505                 if (!read_extension(&e_ext, e_ext.number)) {
1506                         /* extension doesn't exist */
1507                         trace_header("EXTENSION (not created)", DIRECTION_IN);
1508                         add_trace("extension", NULL, "%s", e_ext.number);
1509                         end_trace();
1510                         message_disconnect_port(portlist, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, "");
1511                         new_state(EPOINT_STATE_OUT_DISCONNECT);
1512                         set_tone(portlist, "cause_80"); /* pbx cause: extension not authorized */
1513                         e_ext.number[0] = '\0'; /* no terminal */
1514                         return;
1515                 }
1516                 writeext = 0;
1517
1518                 /* put prefix (next) in front of e_dialinginfo.id */
1519                 if (e_ext.next[0]) {
1520                         SPRINT(buffer, "%s%s", e_ext.next, e_dialinginfo.id);
1521                         SCPY(e_dialinginfo.id, buffer);
1522                         e_ext.next[0] = '\0';
1523                         writeext = 1;
1524                 } else if (e_ext.prefix[0]) {
1525                         SPRINT(buffer, "%s%s", e_ext.prefix, e_dialinginfo.id);
1526                         SCPY(e_dialinginfo.id, buffer);
1527                 }
1528
1529                 /* screen caller id by extension's config */
1530                 e_callerinfo.screen = INFO_SCREEN_NETWORK;
1531                 if (e_ext.name[0])
1532                         SCPY(e_callerinfo.name, e_ext.name);
1533                 /* use caller id (or if exist: id_next_call) for this call */
1534                 if (e_ext.id_next_call_present >= 0) {
1535                         SCPY(e_callerinfo.id, e_ext.id_next_call);
1536                         /* if we restrict the pesentation */
1537                         if (e_ext.id_next_call_present==INFO_PRESENT_ALLOWED && e_callerinfo.present==INFO_PRESENT_RESTRICTED)
1538                                 e_callerinfo.present = INFO_PRESENT_RESTRICTED;
1539                         else    e_callerinfo.present = e_ext.id_next_call_present;
1540                         e_callerinfo.ntype = e_ext.id_next_call_type;
1541                         e_ext.id_next_call_present = -1;
1542                         writeext = 1;
1543                 } else {
1544                         SCPY(e_callerinfo.id, e_ext.callerid);
1545                         /* if we restrict the pesentation */
1546                         if (e_ext.callerid_present==INFO_PRESENT_ALLOWED && e_callerinfo.present==INFO_PRESENT_RESTRICTED)
1547                                 e_callerinfo.present = INFO_PRESENT_RESTRICTED;
1548                         else    e_callerinfo.present = e_ext.callerid_present;
1549                         e_callerinfo.ntype = e_ext.callerid_type;
1550                 }
1551                 e_callerinfo.ntype2 = INFO_NTYPE_NOTPRESENT;
1552
1553                 /* extension is written */
1554                 if (writeext)
1555                         write_extension(&e_ext, e_ext.number);
1556
1557                 /* set volume of rx and tx */
1558                 if (param->setup.callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION)
1559                 if (e_ext.tx_gain!=0 || e_ext.rx_gain!=0) {
1560                         message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_mISDNSIGNAL);
1561                         message->param.mISDNsignal.message = mISDNSIGNAL_VOLUME;
1562                         message->param.mISDNsignal.rx_gain = e_ext.tx_gain;
1563                         message->param.mISDNsignal.tx_gain = e_ext.rx_gain;
1564                         message_put(message);
1565                 }
1566
1567                 /* start recording if enabled */
1568                 if (e_ext.record!=CODEC_OFF && (e_capainfo.bearer_capa==INFO_BC_SPEECH || e_capainfo.bearer_capa==INFO_BC_AUDIO)) {
1569                         /* check if we are a terminal */
1570                         if (e_ext.number[0] == '\0')
1571                                 PERROR("Port(%d) cannot record because we are not a terminal\n", ea_endpoint->ep_serial);
1572                         else {
1573                                 port = find_port_id(portlist->port_id);
1574                                 if (port)
1575                                         port->open_record(e_ext.record, 0, 0, e_ext.number, e_ext.anon_ignore, "", 0);
1576                         }
1577                 }
1578         } else {
1579                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call from external port\n", ea_endpoint->ep_serial);
1580                 /* no terminal identification */
1581                 e_ext.number[0] = '\0';
1582                 e_extension_interface[0] = '\0';
1583                 memset(&e_ext, 0, sizeof(e_ext));
1584                 e_ext.rights = 4; /* right to dial internat */
1585         }
1586
1587         /* incoming call */
1588         e_ruleset = ruleset_main;
1589         if (e_ruleset)
1590                 e_rule = e_ruleset->rule_first;
1591         e_action = NULL;
1592         e_extdialing = e_dialinginfo.id;
1593         new_state(EPOINT_STATE_IN_SETUP);
1594         if (e_dialinginfo.id[0]) {
1595                 set_tone(portlist, "dialing");
1596         } else {
1597                 if (e_ext.number[0])
1598                         set_tone(portlist, "dialpbx");
1599                 else
1600                         set_tone(portlist, "dialtone");
1601         }
1602         process_dialing(0);
1603         if (e_state == EPOINT_STATE_IN_SETUP) {
1604                 /* request MORE info, if not already at higher state */
1605                 new_state(EPOINT_STATE_IN_OVERLAP);
1606                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_OVERLAP);
1607                 message_put(message);
1608                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1609         }
1610 }
1611
1612 /* port MESSAGE_INFORMATION */
1613 void EndpointAppPBX::port_information(struct port_list *portlist, int message_type, union parameter *param)
1614 {
1615         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
1616
1617         /* ignore information message without digit information */
1618         if (!param->information.id[0])
1619                 return;
1620
1621         e_overlap = 1;
1622
1623         /* turn off dtmf detection, in case dtmf is sent with keypad information */
1624         if (e_dtmf) {
1625                 trace_header("DTMF (disabling due to keypad)", DIRECTION_IN);
1626                 end_trace();
1627                 e_dtmf = 0;
1628         }
1629
1630         /* if vbox_play is done, the information are just used as they come */
1631         if (e_action)
1632         if (e_action->index == ACTION_VBOX_PLAY) {
1633                 /* concat dialing string */
1634                 SCAT(e_dialinginfo.id, param->information.id);
1635                 process_dialing(0);
1636                 return;
1637         }
1638
1639         /* keypad when disconnect but in connected mode */
1640         if (e_state==EPOINT_STATE_OUT_DISCONNECT && e_connectedmode) {
1641                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) keypad information received after disconnect: %s.\n", ea_endpoint->ep_serial, param->information.id);
1642                 /* processing keypad function */
1643                 if (param->information.id[0] == '0') {
1644                         hookflash();
1645                 }
1646                 return;
1647         }
1648
1649         /* keypad when connected */
1650         if (e_state == EPOINT_STATE_CONNECT || e_state == EPOINT_STATE_IN_ALERTING) {
1651                 if (e_ext.keypad || e_enablekeypad) {
1652                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) keypad information received during connect: %s.\n", ea_endpoint->ep_serial, param->information.id);
1653                         /* processing keypad function */
1654                         if (param->information.id[0] == '0') {
1655                                 hookflash();
1656                         }
1657                         if (param->information.id[0])
1658                                 keypad_function(param->information.id[0]);
1659                 } else {
1660                         if (e_ext.number[0])
1661                                 trace_header("KEYPAD (not enabled by extension's settings)", DIRECTION_IN);
1662                         else
1663                                 trace_header("KEYPAD (not enabled for external interfaces)", DIRECTION_IN);
1664                         end_trace();
1665                 }
1666                 return;
1667         }
1668         if (e_state != EPOINT_STATE_IN_OVERLAP) {
1669                 if (e_ext.number[0])
1670                         trace_header("KEYPAD (ignored, not connected and not dialing)", DIRECTION_IN);
1671                 else
1672                         trace_header("KEYPAD (not enabled for external interfaces)", DIRECTION_IN);
1673                 end_trace();
1674                 return;
1675         }
1676         if (!param->information.id[0])
1677                 return;
1678         if (e_dialinginfo.id[0]=='\0' && !e_action) {
1679                 set_tone(portlist, "dialing");
1680         }
1681         if (e_action)
1682         if (e_action->index==ACTION_OUTDIAL
1683          || e_action->index==ACTION_EXTERNAL
1684          || e_action->index==ACTION_REMOTE) {
1685                 if (!e_extdialing)
1686                         set_tone(portlist, "dialing");
1687                 else if (!e_extdialing[0])
1688                         set_tone(portlist, "dialing");
1689         }
1690         /* concat dialing string */
1691         SCAT(e_dialinginfo.id, param->information.id);
1692         process_dialing(0);
1693 }
1694
1695 /* port MESSAGE_DTMF */
1696 void EndpointAppPBX::port_dtmf(struct port_list *portlist, int message_type, union parameter *param)
1697 {
1698         time_t now;
1699
1700         time(&now);
1701
1702         /* only if dtmf detection is enabled */
1703         if (!e_dtmf) {
1704                 trace_header("DTMF (disabled)", DIRECTION_IN);
1705                 end_trace();
1706                 return;
1707         }
1708         trace_header("DTMF", DIRECTION_IN);
1709         add_trace("digit", NULL, "%c", param->dtmf);
1710         end_trace();
1711
1712 #if 0
1713 NOTE: vbox is now handled due to overlap state
1714         /* if vbox_play is done, the dtmf digits are just used as they come */
1715         if (e_action)
1716         if (e_action->index == ACTION_VBOX_PLAY) {
1717                 /* concat dialing string */
1718                 if (strlen(e_dialinginfo.id)+1 < sizeof(e_dialinginfo.id)) {
1719                         e_dialinginfo.id[strlen(e_dialinginfo.id)+1] = '\0';
1720                         e_dialinginfo.id[strlen(e_dialinginfo.id)] = param->dtmf;
1721                         process_dialing(0);
1722                 }
1723                 /* continue to process *X# sequences */
1724         }
1725 #endif
1726
1727         /* check for *X# sequence */
1728         if (e_state == EPOINT_STATE_CONNECT || e_state == EPOINT_STATE_IN_ALERTING) {
1729                 if (e_dtmf_time+3 < now) {
1730                         /* the last digit was too far in the past to be a sequence */
1731                         if (param->dtmf == '*')
1732                                 /* only start is allowed in the sequence */
1733                                 e_dtmf_last = '*';
1734                         else
1735                                 e_dtmf_last = '\0';
1736                 } else {
1737                         /* we have a sequence of digits, see what we got */
1738                         if (param->dtmf == '*')
1739                                 e_dtmf_last = '*';
1740                         else if (param->dtmf>='0' && param->dtmf<='9') {
1741                                 /* we need to have a star before we receive the digit of the sequence */
1742                                 if (e_dtmf_last == '*')
1743                                         e_dtmf_last = param->dtmf;
1744                         } else if (param->dtmf == '#') {
1745                                 /* the hash key */
1746                                 if (e_dtmf_last>='0' && e_dtmf_last<='9') {
1747                                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dtmf sequence *%c# detected.\n", ea_endpoint->ep_serial, e_dtmf_last);
1748                                         if (e_dtmf_last == '0') {
1749                                                 hookflash();
1750                                                 return;
1751                                         }
1752                                         /* processing keypad function */
1753                                         if (param->dtmf)
1754                                                 keypad_function(e_dtmf_last);
1755                                         e_dtmf_last = '\0';
1756                                 }
1757                         }
1758                 }
1759
1760                 /* set last time of dtmf */
1761                 e_dtmf_time = now;
1762                 return;
1763         }
1764
1765         /* check for ## hookflash during dialing */
1766         if (e_action)
1767         if (e_action->index==ACTION_PASSWORD
1768          || e_action->index==ACTION_PASSWORD_WRITE)
1769                 goto password;
1770         if (param->dtmf=='#') { /* current digit is '#' */
1771                 if (e_state==EPOINT_STATE_IN_DISCONNECT
1772                  || (e_state!=EPOINT_STATE_CONNECT && e_dtmf_time+3>=now && e_dtmf_last=='#')) { /* when disconnected, just #. when dialing, ##. */
1773                         hookflash();
1774                         return;
1775                 } else {
1776                         e_dtmf_time = now;
1777                         e_dtmf_last = '#';
1778                 }
1779         } else {
1780                 password:
1781                 e_dtmf_time = now;
1782                 e_dtmf_last = '\0';
1783         }
1784         
1785
1786         /* dialing using dtmf digit */
1787         if (e_state==EPOINT_STATE_IN_OVERLAP){ // && e_state==e_connectedmode)
1788                 if (e_dialinginfo.id[0]=='\0' && !e_action) {
1789                         set_tone(portlist, "dialing");
1790                 }
1791                 /* concat dialing string */
1792                 if (strlen(e_dialinginfo.id)+1 < sizeof(e_dialinginfo.id)) {
1793                         e_dialinginfo.id[strlen(e_dialinginfo.id)+1] = '\0';
1794                         e_dialinginfo.id[strlen(e_dialinginfo.id)] = param->dtmf;
1795                         process_dialing(0);
1796                 }
1797         }
1798 }
1799
1800 /* port MESSAGE_CRYPT */
1801 void EndpointAppPBX::port_crypt(struct port_list *portlist, int message_type, union parameter *param)
1802 {
1803         /* send crypt response to cryptman */
1804         if (param->crypt.type == CR_MESSAGE_IND)
1805                 cryptman_msg2man(param->crypt.data, param->crypt.len);
1806         else
1807                 cryptman_message(param->crypt.type, param->crypt.data, param->crypt.len);
1808 }
1809
1810 /* port MESSAGE_OVERLAP */
1811 void EndpointAppPBX::port_overlap(struct port_list *portlist, int message_type, union parameter *param)
1812 {
1813         struct lcr_msg *message;
1814
1815         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
1816
1817         /* signal to call tool */
1818         admin_call_response(e_adminid, ADMIN_CALL_SETUP_ACK, "", 0, 0, 0);
1819
1820         if (e_dialing_queue[0] && portlist) {
1821                 /* send what we have not dialed yet, because we had no setup complete */
1822                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dialing pending digits: '%s'\n", ea_endpoint->ep_serial, e_dialing_queue);
1823                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_INFORMATION);
1824                 SCPY(message->param.information.id, e_dialing_queue);
1825                 message->param.information.ntype = INFO_NTYPE_UNKNOWN;
1826                 message_put(message);
1827                 logmessage(message->type, &message->param, ea_endpoint->ep_portlist->port_id, DIRECTION_OUT);
1828                 e_dialing_queue[0] = '\0';
1829         }
1830         /* check if pattern is available */
1831         if (!ea_endpoint->ep_portlist->next && portlist->early_b) { /* one port_list relation and tones available */
1832                 /* indicate patterns */
1833                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
1834                 message_put(message);
1835
1836                 /* connect audio, if not already */
1837                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
1838                 message->param.audiopath = 1;
1839                 message_put(message);
1840         } else {
1841                 /* indicate no patterns */
1842                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
1843                 message_put(message);
1844
1845                 /* disconnect audio, if not already */
1846                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
1847                 message->param.audiopath = 0;
1848                 message_put(message);
1849         }
1850         new_state(EPOINT_STATE_OUT_OVERLAP);
1851         /* if we are in a join */
1852         if (ea_endpoint->ep_join_id) { 
1853                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
1854                 memcpy(&message->param, param, sizeof(union parameter));
1855                 message_put(message);
1856         }
1857 }
1858
1859 /* port MESSAGE_PROCEEDING */
1860 void EndpointAppPBX::port_proceeding(struct port_list *portlist, int message_type, union parameter *param)
1861 {
1862         struct lcr_msg *message;
1863
1864         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
1865
1866         /* signal to call tool */
1867         admin_call_response(e_adminid, ADMIN_CALL_PROCEEDING, "", 0, 0, 0);
1868
1869         e_state = EPOINT_STATE_OUT_PROCEEDING;
1870         /* check if pattern is availatle */
1871         if (!ea_endpoint->ep_portlist->next && (portlist->early_b || portlist->port_type==PORT_TYPE_VBOX_OUT)) { /* one port_list relation and tones available */
1872                 /* indicate patterns */
1873                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
1874                 message_put(message);
1875
1876                 /* connect audio, if not already */
1877                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
1878                 message->param.audiopath = 1;
1879                 message_put(message);
1880         } else {
1881                 /* indicate no patterns */
1882                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
1883                 message_put(message);
1884
1885                 /* disconnect audio, if not already */
1886                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
1887                 message->param.audiopath = 0;
1888                 message_put(message);
1889         }
1890         /* if we are in a call */
1891         if (ea_endpoint->ep_join_id) { 
1892                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
1893                 memcpy(&message->param, param, sizeof(union parameter));
1894                 message_put(message);
1895         }
1896 }
1897
1898 /* port MESSAGE_ALERTING */
1899 void EndpointAppPBX::port_alerting(struct port_list *portlist, int message_type, union parameter *param)
1900 {
1901         struct lcr_msg *message;
1902
1903         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
1904
1905         /* signal to call tool */
1906         admin_call_response(e_adminid, ADMIN_CALL_ALERTING, "", 0, 0, 0);
1907 //#warning hack!!
1908 //      if (e_adminid)
1909 //              set_tone(portlist, "hold");
1910
1911         new_state(EPOINT_STATE_OUT_ALERTING);
1912         /* check if pattern is available */
1913         if (!ea_endpoint->ep_portlist->next && (portlist->early_b || portlist->port_type==PORT_TYPE_VBOX_OUT)) { /* one port_list relation and tones available */
1914                 /* indicate patterns */
1915                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
1916                 message_put(message);
1917
1918                 /* connect audio, if not already */
1919                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
1920                 message->param.audiopath = 1;
1921                 message_put(message);
1922         } else {
1923                 /* indicate no patterns */
1924                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
1925                 message_put(message);
1926
1927                 /* disconnect audio, if not already */
1928                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
1929                 message->param.audiopath = 0;
1930                 message_put(message);
1931         }
1932         /* if we are in a call */
1933         if (ea_endpoint->ep_join_id) { 
1934                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
1935                 memcpy(&message->param, param, sizeof(union parameter));
1936                 message_put(message);
1937         }
1938 }
1939
1940 /* port MESSAGE_CONNECT */
1941 void EndpointAppPBX::port_connect(struct port_list *portlist, int message_type, union parameter *param)
1942 {
1943         struct lcr_msg *message;
1944         char buffer[256];
1945         unsigned int port_id = portlist->port_id;
1946         struct port_list *tportlist;
1947         class Port *port;
1948         struct interface        *interface;
1949         time_t now;
1950
1951         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
1952
1953         /* signal to call tool */
1954         admin_call_response(e_adminid, ADMIN_CALL_CONNECT, numberrize_callerinfo(param->connectinfo.id,param->connectinfo.ntype, options.national, options.international), 0, 0, 0);
1955
1956         memcpy(&e_connectinfo, &param->connectinfo, sizeof(e_connectinfo));
1957         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) removing all other ports (start)\n", ea_endpoint->ep_serial);
1958         while(ea_endpoint->ep_portlist->next) { /* as long as we have at least two ports */
1959                 tportlist = ea_endpoint->ep_portlist;
1960                 if (tportlist->port_id == port_id) /* if the first portlist is the calling one, the second must be a different one */
1961                         tportlist = tportlist->next;
1962                 if (tportlist->port_id == port_id)
1963                         FATAL("EPOINT(%d) this should not happen since the portlist list must not have two links to the same port - exitting.\n");
1964                 message = message_create(ea_endpoint->ep_serial, tportlist->port_id, EPOINT_TO_PORT, MESSAGE_RELEASE);
1965                 message->param.disconnectinfo.cause = CAUSE_NONSELECTED; /* non selected user clearing */
1966                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1967                 message_put(message);
1968                 logmessage(message->type, &message->param, tportlist->port_id, DIRECTION_OUT);
1969                 ea_endpoint->free_portlist(tportlist);
1970         }
1971         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) removing all other ports (end)\n", ea_endpoint->ep_serial);
1972
1973         time(&now);
1974         e_start = now;
1975
1976         /* screen incoming connected id */
1977         interface = interface_first;
1978         while(interface) {
1979                 if (!strcmp(e_connectinfo.interface, interface->name)) {
1980                         break;
1981                 }
1982                 interface = interface->next;
1983         }
1984         if (interface)
1985                 do_screen(0, e_connectinfo.id, sizeof(e_connectinfo.id), &e_connectinfo.ntype, &e_connectinfo.present, interface);
1986
1987         /* screen connected name */
1988         if (e_ext.name[0])
1989                 SCPY(e_connectinfo.name, e_ext.name);
1990
1991         /* add internal id to colp */
1992         SCPY(e_connectinfo.extension, e_ext.number);
1993
1994         /* we store the connected port number */
1995         SCPY(e_extension_interface, e_connectinfo.interface);
1996
1997         /* for internal and am calls, we get the extension's id */
1998         if (portlist->port_type==PORT_TYPE_VBOX_OUT || e_ext.colp==COLP_HIDE) {
1999                 SCPY(e_connectinfo.id, e_ext.callerid);
2000                 SCPY(e_connectinfo.extension, e_ext.number);
2001                 e_connectinfo.itype = INFO_ITYPE_ISDN_EXTENSION;
2002                 e_connectinfo.ntype = e_ext.callerid_type;
2003                 e_connectinfo.present = e_ext.callerid_present;
2004         }
2005         if (portlist->port_type==PORT_TYPE_VBOX_OUT) {
2006                 e_connectinfo.itype = INFO_ITYPE_VBOX;
2007                 e_connectinfo.ntype = INFO_NTYPE_UNKNOWN;
2008         }
2009
2010         new_state(EPOINT_STATE_CONNECT);
2011
2012         /* set volume of rx and tx */
2013         if (e_ext.tx_gain!=0 || e_ext.rx_gain!=0) {
2014                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_mISDNSIGNAL);
2015                 message->param.mISDNsignal.message = mISDNSIGNAL_VOLUME;
2016                 message->param.mISDNsignal.rx_gain = e_ext.tx_gain;
2017                 message->param.mISDNsignal.tx_gain = e_ext.rx_gain;
2018                 message_put(message);
2019         }
2020
2021         unsched_timer(&e_cfnr_timeout);
2022         unsched_timer(&e_cfnr_call_timeout);
2023         if (e_ext.number[0])
2024                 e_dtmf = 1; /* allow dtmf */
2025
2026         /* modify colp */
2027         /* other calls with no caller id (or not available for the extension) and force colp */
2028         if ((e_connectinfo.id[0]=='\0' || (e_connectinfo.present==INFO_PRESENT_RESTRICTED && !e_ext.anon_ignore))&& e_ext.colp==COLP_FORCE) {
2029                 e_connectinfo.ntype = INFO_NTYPE_NOTPRESENT;
2030                 if (portlist->port_type==PORT_TYPE_DSS1_TE_OUT || portlist->port_type==PORT_TYPE_DSS1_NT_OUT || portlist->port_type==PORT_TYPE_GSM_OUT) { /* external extension answered */
2031                         port = find_port_id(portlist->port_id);
2032                         if (port) {
2033                                 SCPY(e_connectinfo.id, nationalize_callerinfo(port->p_dialinginfo.id, &e_connectinfo.ntype, options.national, options.international));
2034                                 e_connectinfo.present = INFO_PRESENT_ALLOWED;
2035                         }
2036                 }
2037         }
2038
2039         /* send connect to join */
2040         if (ea_endpoint->ep_join_id) {
2041                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
2042                 memcpy(&message->param.connectinfo, &e_connectinfo, sizeof(struct connect_info));
2043                 message_put(message);
2044
2045                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2046                 message->param.audiopath = 1;
2047                 message_put(message);
2048         } else if (!e_adminid) {
2049                 /* callback */
2050                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we have a callback, so we create a call with cbcaller: \"%s\".\n", ea_endpoint->ep_serial, e_cbcaller);
2051                 SCPY(e_ext.number, e_cbcaller);
2052                 new_state(EPOINT_STATE_IN_OVERLAP);
2053                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) callback from extension '%s'\n", ea_endpoint->ep_serial, e_ext.number);
2054
2055                 /* get extension's info about terminal */
2056                 if (!read_extension(&e_ext, e_ext.number)) {
2057                         /* extension doesn't exist */
2058                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) rejecting callback from not existing extension: '%s'\n", ea_endpoint->ep_serial, e_ext.number);
2059                         message_disconnect_port(portlist, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, "");
2060                         new_state(EPOINT_STATE_OUT_DISCONNECT);
2061                         set_tone(portlist, "cause_80"); /* pbx cause: extension not authorized */
2062                         return;
2063                 }
2064
2065                 /* put prefix in front of e_cbdialing */
2066                 SPRINT(buffer, "%s%s", e_ext.prefix, e_cbdialing);
2067                 SCPY(e_dialinginfo.id, buffer);
2068                 e_dialinginfo.itype = INFO_ITYPE_ISDN;
2069                 e_dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
2070
2071                 /* use caller id (or if exist: id_next_call) for this call */
2072                 e_callerinfo.screen = INFO_SCREEN_NETWORK;
2073                 SCPY(e_callerinfo.extension, e_ext.number);
2074                 if (e_ext.id_next_call_present >= 0) {
2075                         SCPY(e_callerinfo.id, e_ext.id_next_call);
2076                         e_callerinfo.present = e_ext.id_next_call_present;
2077                         e_callerinfo.ntype = e_ext.id_next_call_type;
2078                         e_ext.id_next_call_present = -1;
2079                         /* extension is written */
2080                         write_extension(&e_ext, e_ext.number);
2081                 } else {
2082                         SCPY(e_callerinfo.id, e_ext.callerid);
2083                         e_callerinfo.present = e_ext.callerid_present;
2084                         e_callerinfo.ntype = e_ext.callerid_type;
2085                 }
2086                 e_callerinfo.ntype2 = INFO_NTYPE_NOTPRESENT;
2087
2088                 e_connectedmode = 1; /* dtmf-hangup & disconnect prevention */
2089                 e_dtmf = 1;
2090
2091                 /* check if caller id is NOT authenticated */
2092                 if (!parse_callbackauth(e_ext.number, &e_callbackinfo)) {
2093                         /* make call state to enter password */
2094                         new_state(EPOINT_STATE_IN_OVERLAP);
2095                         e_action = &action_password_write;
2096                         unsched_timer(&e_match_timeout);
2097                         e_match_to_action = NULL;
2098                         e_dialinginfo.id[0] = '\0';
2099                         e_extdialing = strchr(e_dialinginfo.id, '\0');
2100                         schedule_timer(&e_password_timeout, 20, 0);
2101                         process_dialing(0);
2102                 } else {
2103                         /* incoming call (callback) */
2104                         e_ruleset = ruleset_main;
2105                         if (e_ruleset)
2106                                 e_rule = e_ruleset->rule_first;
2107                         e_action = NULL;
2108                         e_extdialing = e_dialinginfo.id;
2109                         if (e_dialinginfo.id[0]) {
2110                                 set_tone(portlist, "dialing");
2111                                 process_dialing(0);
2112                         } else {
2113                                 set_tone(portlist, "dialpbx");
2114                         }
2115                 }
2116         } else { /* testcall */
2117                 set_tone(portlist, "hold");
2118         }
2119
2120         /* start recording if enabled, not when answering machine answers */
2121         if (param->connectinfo.itype!=INFO_ITYPE_VBOX && e_ext.number[0] && e_ext.record!=CODEC_OFF && (e_capainfo.bearer_capa==INFO_BC_SPEECH || e_capainfo.bearer_capa==INFO_BC_AUDIO)) {
2122                 /* check if we are a terminal */
2123                 if (e_ext.number[0] == '\0')
2124                         PERROR("Port(%d) cannot record because we are not a terminal\n", ea_endpoint->ep_serial);
2125                 else {
2126                         port = find_port_id(portlist->port_id);
2127                         if (port)
2128                                 port->open_record(e_ext.record, 0, 0, e_ext.number, e_ext.anon_ignore, "", 0);
2129                 }
2130         }
2131 }
2132
2133 /* port MESSAGE_DISCONNECT MESSAGE_RELEASE */
2134 void EndpointAppPBX::port_disconnect_release(struct port_list *portlist, int message_type, union parameter *param)
2135 {
2136         struct lcr_msg  *message;
2137         char            buffer[256];
2138         unsigned int    port_id = portlist->port_id;
2139         int             cause,
2140                         location;
2141
2142         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
2143
2144         /* signal to call tool */
2145         admin_call_response(e_adminid, (message_type==MESSAGE_DISCONNECT)?ADMIN_CALL_DISCONNECT:ADMIN_CALL_RELEASE, "", param->disconnectinfo.cause, param->disconnectinfo.location, 0);
2146
2147 //#warning does this work? only disconnect when incoming port hat not already disconnected yet?
2148         if (e_state==EPOINT_STATE_IN_DISCONNECT && message_type!=MESSAGE_RELEASE){ // || e_state==EPOINT_STATE_OUT_DISCONNECT || e_state==EPOINT_STATE_IDLE)
2149                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are already disconnected.\n", ea_endpoint->ep_serial);
2150                 return;
2151         }
2152
2153         /* collect cause */
2154         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) current multipoint cause %d location %d, received cause %d location %d.\n", ea_endpoint->ep_serial, e_multipoint_cause, e_multipoint_location, param->disconnectinfo.cause, param->disconnectinfo.location);
2155         collect_cause(&e_multipoint_cause, &e_multipoint_location, param->disconnectinfo.cause, param->disconnectinfo.location);
2156         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) new multipoint cause %d location %d.\n", ea_endpoint->ep_serial, e_multipoint_cause, e_multipoint_location);
2157
2158         /* check if we have more than one portlist relation and we just ignore the disconnect */
2159         if (ea_endpoint->ep_portlist) if (ea_endpoint->ep_portlist->next) {
2160                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) the disconnect was from a multipoint call. we just release that relation.\n", ea_endpoint->ep_serial);
2161                 portlist = ea_endpoint->ep_portlist;
2162                 while(portlist) {
2163                         if (portlist->port_id == port_id)
2164                                 break;
2165                         portlist = portlist->next;
2166                 }
2167                 if (!portlist)
2168                         FATAL("EPOINT(%d) no portlist related to the calling port.\n", ea_endpoint->ep_serial);
2169                 if (message_type != MESSAGE_RELEASE) {
2170                         message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_RELEASE);
2171                         message->param.disconnectinfo.cause = CAUSE_NORMAL; /* normal clearing */
2172                         message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2173                         message_put(message);
2174                         logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2175                 }
2176                 ea_endpoint->free_portlist(portlist);
2177                 return; /* one relation removed */ 
2178         }
2179         if (e_state == EPOINT_STATE_CONNECT) {
2180                 /* use cause from port after connect */
2181                 cause = param->disconnectinfo.cause;
2182                 location = param->disconnectinfo.location;
2183         } else {
2184                 /* use multipoint cause if no connect yet */
2185                 if (e_multipoint_cause) {
2186                         cause = e_multipoint_cause;
2187                         location = e_multipoint_location;
2188                 } else {
2189                         cause = CAUSE_NOUSER;
2190                         location = LOCATION_PRIVATE_LOCAL;
2191                 }
2192         }
2193
2194         unsched_timer(&e_cfnr_timeout);
2195         unsched_timer(&e_cfnr_call_timeout);
2196
2197         /* process hangup */
2198         process_hangup(e_join_cause, e_join_location);
2199         e_multipoint_cause = 0;
2200         e_multipoint_location = 0;
2201
2202         if (message_type == MESSAGE_DISCONNECT) {
2203                 /* tone to disconnected end */
2204                 SPRINT(buffer, "cause_%02x", cause);
2205                 if (ea_endpoint->ep_portlist)
2206                         set_tone(ea_endpoint->ep_portlist, buffer);
2207
2208                 new_state(EPOINT_STATE_IN_DISCONNECT);
2209         }
2210
2211         if (ea_endpoint->ep_join_id) {
2212                 int haspatterns = 0;
2213                 /* check if pattern is available */
2214                 if (ea_endpoint->ep_portlist)
2215                 if (!ea_endpoint->ep_portlist->next && ea_endpoint->ep_portlist->early_b)
2216                 if (joinpbx_countrelations(ea_endpoint->ep_join_id)==2 // we must count relations, in order not to disturb the conference ; NOTE: asterisk always counts two, since it is a point to point call 
2217                  && message_type != MESSAGE_RELEASE) // if we release, we are done
2218                         haspatterns = 1;
2219                 if (haspatterns) {
2220                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) the port has patterns.\n", ea_endpoint->ep_serial);
2221                         /* indicate patterns */
2222                         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
2223                         message_put(message);
2224                         /* connect audio, if not already */
2225                         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2226                         message->param.audiopath = 1;
2227                         message_put(message);
2228                         /* send disconnect */
2229                         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
2230                         memcpy(&message->param, param, sizeof(union parameter));
2231                         message_put(message);
2232                         /* disable encryption if disconnected */
2233 //PERROR("REMOVE ME: state =%d, %d\n", e_crypt_state, e_crypt);
2234                         if (e_crypt_state)
2235                                 cryptman_message(CI_DISCONNECT_IND, NULL, 0);
2236                         return;
2237                 } else {
2238                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) the port has no patterns.\n", ea_endpoint->ep_serial);
2239                 }
2240         }
2241         if (message_type == MESSAGE_RELEASE)
2242                 ea_endpoint->free_portlist(portlist);
2243         release(RELEASE_ALL, location, cause, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0); /* RELEASE_TYPE, callcause, portcause */
2244         return; /* must exit here */
2245 }
2246
2247 /* port MESSAGE_TIMEOUT */
2248 void EndpointAppPBX::port_timeout(struct port_list *portlist, int message_type, union parameter *param)
2249 {
2250         char cause[16];
2251
2252         trace_header("TIMEOUT", DIRECTION_IN);
2253         message_type = MESSAGE_DISCONNECT;
2254         switch (param->state) {
2255                 case PORT_STATE_OUT_SETUP:
2256                 case PORT_STATE_OUT_OVERLAP:
2257                 add_trace("state", NULL, "outgoing setup/dialing");
2258                 end_trace();
2259                 /* no user responding */
2260                 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NOUSER, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0);
2261                 return; /* must exit here */
2262
2263                 case PORT_STATE_IN_SETUP:
2264                 case PORT_STATE_IN_OVERLAP:
2265                 add_trace("state", NULL, "incoming setup/dialing");
2266                 param->disconnectinfo.cause = CAUSE_INVALID; /* number incomplete */
2267                 param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2268                 break;
2269
2270                 case PORT_STATE_OUT_PROCEEDING:
2271                 add_trace("state", NULL, "outgoing proceeding");
2272                 end_trace();
2273                 param->disconnectinfo.cause = CAUSE_NOUSER; /* no user responding */
2274                 param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2275                 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NOUSER, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0);
2276                 return; /* must exit here */
2277
2278                 case PORT_STATE_IN_PROCEEDING:
2279                 add_trace("state", NULL, "incoming proceeding");
2280                 param->disconnectinfo.cause = CAUSE_NOUSER;
2281                 param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL; /* no user responding */
2282                 break;
2283
2284                 case PORT_STATE_OUT_ALERTING:
2285                 add_trace("state", NULL, "outgoing alerting");
2286                 end_trace();
2287                 param->disconnectinfo.cause = CAUSE_NOANSWER; /* no answer */
2288                 param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2289                 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NOANSWER, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0);
2290                 return; /* must exit here */
2291
2292                 case PORT_STATE_CONNECT:
2293                 add_trace("state", NULL, "connect");
2294                 end_trace();
2295                 param->disconnectinfo.cause = CAUSE_NORMAL; /* normal */
2296                 param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2297                 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0);
2298                 return; /* must exit here */
2299
2300                 case PORT_STATE_IN_ALERTING:
2301                 add_trace("state", NULL, "incoming alerting");
2302                 param->disconnectinfo.cause = CAUSE_NOANSWER;
2303                 param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2304                 break;
2305
2306                 case PORT_STATE_IN_DISCONNECT:
2307                 case PORT_STATE_OUT_DISCONNECT:
2308                 add_trace("state", NULL, "disconnect");
2309                 end_trace();
2310                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) in this special case, we release due to disconnect timeout.\n", ea_endpoint->ep_serial);
2311                 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0);
2312                 return; /* must exit here */
2313
2314                 default:
2315                 param->disconnectinfo.cause = 31; /* normal unspecified */
2316                 param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2317         }
2318         end_trace();
2319         /* release call, disconnect isdn */
2320         e_join_pattern = 0;
2321         new_state(EPOINT_STATE_OUT_DISCONNECT);
2322         SPRINT(cause, "cause_%02x", param->disconnectinfo.cause);
2323         SCPY(e_tone, cause);
2324         while(portlist) {
2325                 set_tone(portlist, cause);
2326                 message_disconnect_port(portlist, param->disconnectinfo.cause, param->disconnectinfo.location, "");
2327                 portlist = portlist->next;
2328         }
2329         release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0); /* RELEASE_TYPE, join, port */
2330 }
2331
2332 /* port MESSAGE_NOTIFY */
2333 void EndpointAppPBX::port_notify(struct port_list *portlist, int message_type, union parameter *param)
2334 {
2335         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
2336
2337         struct lcr_msg *message;
2338         const char *logtext = "";
2339         char buffer[64];
2340
2341         /* signal to call tool */
2342         admin_call_response(e_adminid, ADMIN_CALL_NOTIFY, numberrize_callerinfo(param->notifyinfo.id,param->notifyinfo.ntype, options.national, options.international), 0, 0, param->notifyinfo.notify);
2343         if (param->notifyinfo.notify) {
2344                 e_rx_state = track_notify(e_rx_state, param->notifyinfo.notify);
2345         }
2346
2347         /* if we get notification from stack, local shows if we disabled/enabled audio stream */
2348         if (param->notifyinfo.local) switch(param->notifyinfo.notify) {
2349                 case INFO_NOTIFY_REMOTE_HOLD:
2350                 case INFO_NOTIFY_USER_SUSPENDED:
2351                 /* tell call about it */
2352                 if (ea_endpoint->ep_join_id) {
2353                         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2354                         message->param.audiopath = 0;
2355                         message_put(message);
2356                 }
2357                 break;
2358
2359                 case INFO_NOTIFY_REMOTE_RETRIEVAL:
2360                 case INFO_NOTIFY_USER_RESUMED:
2361                 /* set volume of rx and tx */
2362                 if (param->setup.callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION)
2363                 if (e_ext.tx_gain!=0 || e_ext.rx_gain!=0)
2364                 if (portlist) {
2365                         message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_mISDNSIGNAL);
2366                         message->param.mISDNsignal.message = mISDNSIGNAL_VOLUME;
2367                         message->param.mISDNsignal.rx_gain = e_ext.tx_gain;
2368                         message->param.mISDNsignal.tx_gain = e_ext.rx_gain;
2369                         message_put(message);
2370                 }
2371                 /* set current tone */
2372                 if (portlist)
2373                         set_tone(portlist, e_tone);
2374                 /* tell call about it */
2375                 if (ea_endpoint->ep_join_id) {
2376                         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2377                         message->param.audiopath = 1;
2378                         message_put(message);
2379                 }
2380                 break;
2381         }
2382
2383         /* get name of notify */
2384         switch(param->notifyinfo.notify) {
2385                 case 0x00:
2386                 logtext = "NULL";
2387                 break;
2388                 case 0x80:
2389                 logtext = "USER_SUSPENDED";
2390                 break;
2391                 case 0x82:
2392                 logtext = "BEARER_SERVICE_CHANGED";
2393                 break;
2394                 case 0x81:
2395                 logtext = "USER_RESUMED";
2396                 break;
2397                 case 0xc2:
2398                 logtext = "CONFERENCE_ESTABLISHED";
2399                 break;
2400                 case 0xc3:
2401                 logtext = "CONFERENCE_DISCONNECTED";
2402                 break;
2403                 case 0xc4:
2404                 logtext = "OTHER_PARTY_ADDED";
2405                 break;
2406                 case 0xc5:
2407                 logtext = "ISOLATED";
2408                 break;
2409                 case 0xc6:
2410                 logtext = "REATTACHED";
2411                 break;
2412                 case 0xc7:
2413                 logtext = "OTHER_PARTY_ISOLATED";
2414                 break;
2415                 case 0xc8:
2416                 logtext = "OTHER_PARTY_REATTACHED";
2417                 break;
2418                 case 0xc9:
2419                 logtext = "OTHER_PARTY_SPLIT";
2420                 break;
2421                 case 0xca:
2422                 logtext = "OTHER_PARTY_DISCONNECTED";
2423                 break;
2424                 case 0xcb:
2425                 logtext = "CONFERENCE_FLOATING";
2426                 break;
2427                 case 0xcc:
2428                 logtext = "CONFERENCE_DISCONNECTED_PREEMTED";
2429                 break;
2430                 case 0xcf:
2431                 logtext = "CONFERENCE_FLOATING_SERVED_USER_PREEMTED";
2432                 break;
2433                 case 0xe0:
2434                 logtext = "CALL_IS_A_WAITING_CALL";
2435                 break;
2436                 case 0xe8:
2437                 logtext = "DIVERSION_ACTIVATED";
2438                 break;
2439                 case 0xe9:
2440                 logtext = "RESERVED_CT_1";
2441                 break;
2442                 case 0xea:
2443                 logtext = "RESERVED_CT_2";
2444                 break;
2445                 case 0xee:
2446                 logtext = "REVERSE_CHARGING";
2447                 break;
2448                 case 0xf9:
2449                 logtext = "REMOTE_HOLD";
2450                 break;
2451                 case 0xfa:
2452                 logtext = "REMOTE_RETRIEVAL";
2453                 break;
2454                 case 0xfb:
2455                 logtext = "CALL_IS_DIVERTING";
2456                 break;
2457                 default:
2458                 SPRINT(buffer, "%d", param->notifyinfo.notify - 0x80);
2459                 logtext = buffer;
2460
2461         }
2462
2463         /* notify call if available */
2464         if (ea_endpoint->ep_join_id) {
2465                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOTIFY);
2466                 memcpy(&message->param.notifyinfo, &param->notifyinfo, sizeof(struct notify_info));
2467                 message_put(message);
2468         }
2469
2470 }
2471
2472 /* port MESSAGE_FACILITY */
2473 void EndpointAppPBX::port_facility(struct port_list *portlist, int message_type, union parameter *param)
2474 {
2475         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
2476
2477         struct lcr_msg *message;
2478
2479         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_FACILITY);
2480         memcpy(&message->param.facilityinfo, &param->facilityinfo, sizeof(struct facility_info));
2481         message_put(message);
2482 }
2483
2484 /* port MESSAGE_SUSPEND */
2485 /* NOTE: before supending, the inactive-notification must be done in order to set call mixer */
2486 void EndpointAppPBX::port_suspend(struct port_list *portlist, int message_type, union parameter *param)
2487 {
2488         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
2489
2490         /* epoint is now parked */
2491         ea_endpoint->ep_park = 1;
2492         memcpy(ea_endpoint->ep_park_callid, param->parkinfo.callid, sizeof(ea_endpoint->ep_park_callid));
2493         ea_endpoint->ep_park_len = (param->parkinfo.len>8)?8:param->parkinfo.len;
2494
2495         /* remove port relation */
2496         ea_endpoint->free_portlist(portlist);
2497 }
2498
2499 /* port MESSAGE_RESUME */
2500 /* NOTE: before resume, the active-notification must be done in order to set call mixer */
2501 void EndpointAppPBX::port_resume(struct port_list *portlist, int message_type, union parameter *param)
2502 {
2503         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
2504
2505         /* epoint is now resumed */
2506         ea_endpoint->ep_park = 0;
2507
2508 }
2509
2510
2511 /* port sends message to the endpoint
2512  */
2513 void EndpointAppPBX::ea_message_port(unsigned int port_id, int message_type, union parameter *param)
2514 {
2515         struct port_list *portlist;
2516
2517         portlist = ea_endpoint->ep_portlist;
2518         while(portlist) {
2519                 if (port_id == portlist->port_id)
2520                         break;
2521                 portlist = portlist->next;
2522         }
2523         if (!portlist) {
2524                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) warning: port is not related to this endpoint. This may happen, if port has been released after the message was created.\n", ea_endpoint->ep_serial);
2525                 return;
2526         }
2527
2528 //      PDEBUG(DEBUG_EPOINT, "received message %d (terminal %s, caller id %s)\n", message, e_ext.number, e_callerinfo.id);
2529         switch(message_type) {
2530                 case MESSAGE_DATA: /* data from port */
2531                 /* check if there is a call */
2532                 if (!ea_endpoint->ep_join_id)
2533                         break;
2534                 /* continue if only one portlist */
2535                 if (ea_endpoint->ep_portlist->next != NULL)
2536                         break;
2537                 /* forward message */
2538                 message_forward(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, param);  
2539                 break;
2540
2541                 case MESSAGE_TONE_EOF: /* tone is end of file */
2542                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) current tone is now end of file.\n", ea_endpoint->ep_serial);
2543                 if (e_action) {
2544                         if (e_action->index == ACTION_VBOX_PLAY) {
2545                                 vbox_message_eof();
2546                         }
2547                         if (e_action->index == ACTION_EFI) {
2548                                 efi_message_eof();
2549                         }
2550                 }
2551                 break;
2552
2553                 case MESSAGE_TONE_COUNTER: /* counter info received */
2554                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) received counter information: %d / %d seconds after start of tone.\n", ea_endpoint->ep_serial, param->counter.current, param->counter.max);
2555                 if (e_action)
2556                 if (e_action->index == ACTION_VBOX_PLAY) {
2557                         e_vbox_counter = param->counter.current;
2558                         if (param->counter.max >= 0)
2559                                 e_vbox_counter_max = param->counter.max;
2560                 }
2561                 break;
2562
2563                 /* PORT sends SETUP message */
2564                 case MESSAGE_SETUP:
2565                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming call from callerid=%s, dialing=%s\n", ea_endpoint->ep_serial, param->setup.callerinfo.id, param->setup.dialinginfo.id);
2566                 if (e_state!=EPOINT_STATE_IDLE) {
2567                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in idle state.\n", ea_endpoint->ep_serial);
2568                         break;
2569                 }
2570                 port_setup(portlist, message_type, param);
2571                 break;
2572
2573                 /* PORT sends INFORMATION message */
2574                 case MESSAGE_INFORMATION: /* additional digits received */
2575                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming call dialing more=%s (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, param->information.id, e_ext.number, e_callerinfo.id);
2576                 port_information(portlist, message_type, param);
2577                 break;
2578
2579                 /* PORT sends FACILITY message */
2580                 case MESSAGE_FACILITY:
2581                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming facility (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
2582                 port_facility(portlist, message_type, param);
2583                 break;
2584
2585                 /* PORT sends DTMF message */
2586                 case MESSAGE_DTMF: /* dtmf digits received */
2587                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dtmf digit=%c (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, param->dtmf, e_ext.number, e_callerinfo.id);
2588                 port_dtmf(portlist, message_type, param);
2589                 break;
2590
2591                 /* PORT sends CRYPT message */
2592                 case MESSAGE_CRYPT: /* crypt response received */
2593                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) crypt response=%d\n", ea_endpoint->ep_serial, param->crypt.type);
2594                 port_crypt(portlist, message_type, param);
2595                 break;
2596
2597                 /* PORT sends MORE message */
2598                 case MESSAGE_OVERLAP:
2599                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call is accepted [overlap dialing] (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
2600                 if (e_state != EPOINT_STATE_OUT_SETUP) {
2601                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup state (for port_list: another portlist might have changed the state already).\n", ea_endpoint->ep_serial);
2602                         break;
2603                 }
2604                 port_overlap(portlist, message_type, param);
2605                 break;
2606
2607                 /* PORT sends PROCEEDING message */
2608                 case MESSAGE_PROCEEDING: /* port is proceeding */
2609                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call is proceeding (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
2610                 if (e_state!=EPOINT_STATE_OUT_SETUP
2611                  && e_state!=EPOINT_STATE_OUT_OVERLAP) {
2612                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in overlap state (for port_list: another portlist might have changed the state already).\n", ea_endpoint->ep_serial);
2613                         break;
2614                 }
2615                 port_proceeding(portlist, message_type, param);
2616                 break;
2617
2618                 /* PORT sends ALERTING message */
2619                 case MESSAGE_ALERTING:
2620                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call is ringing (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
2621                 if (e_state!=EPOINT_STATE_OUT_SETUP
2622                  && e_state!=EPOINT_STATE_OUT_OVERLAP
2623                  && e_state!=EPOINT_STATE_OUT_PROCEEDING) {
2624                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup or proceeding state (for port_list: another portlist might have changed the state already).\n", ea_endpoint->ep_serial);
2625                         break;
2626                 }
2627                 port_alerting(portlist, message_type, param);
2628                 break;
2629
2630                 /* PORT sends CONNECT message */
2631                 case MESSAGE_CONNECT:
2632                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call connected to %s (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_connectinfo.id, e_ext.number, e_callerinfo.id);
2633                 if (e_state!=EPOINT_STATE_OUT_SETUP
2634                  && e_state!=EPOINT_STATE_OUT_OVERLAP
2635                  && e_state!=EPOINT_STATE_OUT_PROCEEDING
2636                  && e_state!=EPOINT_STATE_OUT_ALERTING) {
2637                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup, proceeding or alerting state.\n", ea_endpoint->ep_serial);
2638                         break;
2639                 }
2640                 port_connect(portlist, message_type, param);
2641                 break;
2642
2643                 /* PORT sends DISCONNECT message */
2644                 case MESSAGE_DISCONNECT: /* port is disconnected */
2645                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call disconnect with cause=%d location=%d (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, param->disconnectinfo.cause, param->disconnectinfo.location, e_ext.number, e_callerinfo.id);
2646                 port_disconnect_release(portlist, message_type, param);
2647                 break;
2648
2649                 /* PORT sends a RELEASE message */
2650                 case MESSAGE_RELEASE: /* port releases */
2651                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) release with cause=%d location=%d (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, param->disconnectinfo.cause, param->disconnectinfo.location, e_ext.number, e_callerinfo.id);
2652                 /* portlist is release at port_disconnect_release, thanx Paul */
2653                 port_disconnect_release(portlist, message_type, param);
2654                 break;
2655
2656                 /* PORT sends a TIMEOUT message */
2657                 case MESSAGE_TIMEOUT:
2658                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received timeout (state=%d).\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, param->state);
2659                 port_timeout(portlist, message_type, param);
2660                 break; /* release */
2661
2662                 /* PORT sends a NOTIFY message */
2663                 case MESSAGE_NOTIFY:
2664                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received notify.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
2665                 port_notify(portlist, message_type, param);
2666                 break;
2667
2668                 /* PORT sends a SUSPEND message */
2669                 case MESSAGE_SUSPEND:
2670                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received suspend.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
2671                 port_suspend(portlist, message_type, param);
2672                 break; /* suspend */
2673
2674                 /* PORT sends a RESUME message */
2675                 case MESSAGE_RESUME:
2676                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received resume.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
2677                 port_resume(portlist, message_type, param);
2678                 break;
2679
2680 #if 0
2681                 kann nach dem test gelöscht werden, da eine direkte funktion im join und im mISDN zum austausch der message existiert
2682                 /* port assigns bchannel */
2683                 case MESSAGE_BCHANNEL: /* bchannel assignment messafe */
2684                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received bchannel message %d from port.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, param->bchannel.type);
2685                 /* only one port is expected to be connected to bchannel */
2686                 message = message_forward(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, param);
2687                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_IN);
2688                 break;
2689 #endif
2690
2691
2692                 default:
2693                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received a wrong message: %d\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, message_type);
2694         }
2695
2696         /* Note: this endpoint may be destroyed, so we MUST return */
2697 }
2698
2699
2700 /* messages from join
2701  */
2702 /* join MESSAGE_CRYPT */
2703 void EndpointAppPBX::join_crypt(struct port_list *portlist, int message_type, union parameter *param)
2704 {
2705         switch(param->crypt.type) {
2706                 /* message from remote port to "crypt manager" */
2707                 case CU_ACTK_REQ:           /* activate key-exchange */
2708                 case CU_ACTS_REQ:            /* activate shared key */
2709                 case CU_DACT_REQ:          /* deactivate */
2710                 case CU_INFO_REQ:         /* request last info message */
2711                 cryptman_message(param->crypt.type, param->crypt.data, param->crypt.len);
2712                 break;
2713
2714                 /* message from "crypt manager" to user */
2715                 case CU_ACTK_CONF:          /* key-echange done */
2716                 case CU_ACTS_CONF:          /* shared key done */
2717                 case CU_DACT_CONF:           /* deactivated */
2718                 case CU_DACT_IND:           /* deactivated */
2719                 case CU_ERROR_IND:         /* receive error message */
2720                 case CU_INFO_IND:         /* receive info message */
2721                 case CU_INFO_CONF:         /* receive info message */
2722                 encrypt_result(param->crypt.type, (char *)param->crypt.data);
2723                 break;
2724
2725                 default:
2726                 PERROR("EPOINT(%d) epoint with terminal '%s' (caller id '%s') unknown crypt message: '%d'\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, param->crypt.type);
2727         }
2728 }
2729
2730 /* join MESSAGE_INFORMATION */
2731 void EndpointAppPBX::join_information(struct port_list *portlist, int message_type, union parameter *param)
2732 {
2733         struct lcr_msg *message;
2734
2735         e_overlap = 1;
2736
2737         while(portlist) {
2738                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_INFORMATION);
2739                 memcpy(&message->param.information, &param->information, sizeof(struct dialing_info));
2740                 message_put(message);
2741                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2742                 portlist = portlist->next;
2743         }
2744 }
2745
2746 /* join MESSAGE_FACILITY */
2747 void EndpointAppPBX::join_facility(struct port_list *portlist, int message_type, union parameter *param)
2748 {
2749         struct lcr_msg *message;
2750
2751         if (!e_ext.facility && e_ext.number[0]) {
2752                 return;
2753         }
2754
2755         while(portlist) {
2756                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_FACILITY);
2757                 memcpy(&message->param.facilityinfo, &param->facilityinfo, sizeof(struct facility_info));
2758                 message_put(message);
2759                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2760                 portlist = portlist->next;
2761         }
2762 }
2763
2764 /* join MESSAGE_MORE */
2765 void EndpointAppPBX::join_overlap(struct port_list *portlist, int message_type, union parameter *param)
2766 {
2767         struct lcr_msg *message;
2768
2769         new_state(EPOINT_STATE_IN_OVERLAP);
2770         
2771         /* own dialtone */
2772         if (e_join_pattern && e_ext.own_setup) {
2773                 /* disconnect audio */
2774                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2775                 message->param.audiopath = 0;
2776                 message_put(message);
2777         }
2778         if (e_action) if (e_action->index == ACTION_OUTDIAL || e_action->index == ACTION_EXTERNAL) {
2779                         if (e_dialinginfo.id[0])
2780                                 set_tone(portlist, "dialing");
2781                         else
2782                                 set_tone(portlist, "dialtone");
2783                         return;
2784         }
2785         if (e_dialinginfo.id[0]) {
2786                 set_tone(portlist, "dialing");
2787         } else {
2788                 if (e_ext.number[0])
2789                         set_tone(portlist, "dialpbx");
2790                 else
2791                         set_tone(portlist, "dialtone");
2792         }
2793 }
2794
2795 /* join MESSAGE_PROCEEDING */
2796 void EndpointAppPBX::join_proceeding(struct port_list *portlist, int message_type, union parameter *param)
2797 {
2798         struct lcr_msg *message;
2799
2800         new_state(EPOINT_STATE_IN_PROCEEDING);
2801
2802         /* own proceeding tone */
2803         if (e_join_pattern) {
2804                 /* connect / disconnect audio */
2805                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2806                 if (e_ext.own_proceeding)
2807                         message->param.audiopath = 0;
2808                 else
2809                         message->param.audiopath = 1;
2810                 message_put(message);
2811         }
2812 //                      UCPY(e_join_tone, "proceeding");
2813         if (portlist) {
2814                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
2815                 message_put(message);
2816                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2817         }
2818         set_tone(portlist, "proceeding");
2819 }
2820
2821 /* join MESSAGE_ALERTING */
2822 void EndpointAppPBX::join_alerting(struct port_list *portlist, int message_type, union parameter *param)
2823 {
2824         struct lcr_msg *message;
2825
2826         new_state(EPOINT_STATE_IN_ALERTING);
2827
2828         /* own alerting tone */
2829         if (e_join_pattern) {
2830                 /* connect / disconnect audio */
2831                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2832                 if (e_ext.own_alerting)
2833                         message->param.audiopath = 0;
2834                 else
2835                         message->param.audiopath = 1;
2836                 message_put(message);
2837         }
2838         if (portlist) {
2839                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_ALERTING);
2840                 message_put(message);
2841                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2842         }
2843         if (e_action) if (e_action->index == ACTION_OUTDIAL || e_action->index == ACTION_EXTERNAL) {
2844                 set_tone(portlist, "ringing");
2845                 return;
2846         }
2847         if (e_ext.number[0])
2848                 set_tone(portlist, "ringpbx");
2849         else
2850                 set_tone(portlist, "ringing");
2851
2852         if (e_ext.number[0])
2853                 e_dtmf = 1; /* allow dtmf */
2854 }
2855
2856 /* join MESSAGE_CONNECT */
2857 void EndpointAppPBX::join_connect(struct port_list *portlist, int message_type, union parameter *param)
2858 {
2859         struct lcr_msg *message;
2860         time_t now;
2861
2862         new_state(EPOINT_STATE_CONNECT);
2863 //                      UCPY(e_join_tone, "");
2864 //                      
2865         if (e_ext.number[0])
2866                 e_dtmf = 1; /* allow dtmf */
2867
2868         e_powerdial_on = 0;
2869         unsched_timer(&e_powerdial_timeout);
2870         memcpy(&e_connectinfo, &param->connectinfo, sizeof(e_callerinfo));
2871         if(portlist) {
2872                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
2873                 memcpy(&message->param, param, sizeof(union parameter));
2874
2875                 /* screen clip if prefix is required */
2876                 if (e_ext.number[0] && message->param.connectinfo.id[0] && e_ext.clip_prefix[0]) {
2877                         SCPY(message->param.connectinfo.id, e_ext.clip_prefix);
2878                         SCAT(message->param.connectinfo.id, numberrize_callerinfo(e_connectinfo.id,e_connectinfo.ntype, options.national, options.international));
2879                         message->param.connectinfo.ntype = INFO_NTYPE_UNKNOWN;
2880                 }
2881
2882                 /* use internal caller id */
2883                 if (e_ext.number[0] && e_connectinfo.extension[0] && (message->param.connectinfo.present!=INFO_PRESENT_RESTRICTED || e_ext.anon_ignore)) {
2884                         SCPY(message->param.connectinfo.id, e_connectinfo.extension);
2885                         message->param.connectinfo.ntype = INFO_NTYPE_UNKNOWN;
2886                 }
2887
2888                 /* handle restricted caller ids */
2889                 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);
2890                 /* display callerid if desired for extension */
2891                 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));
2892
2893                 /* use conp, if enabld */
2894 //              if (!e_ext.centrex)
2895 //                      message->param.connectinfo.name[0] = '\0';
2896
2897                 /* send connect */
2898                 message_put(message);
2899                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2900         }
2901         set_tone(portlist, NULL);
2902         e_join_pattern = 0;
2903         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2904         message->param.audiopath = 1;
2905         message_put(message);
2906         time(&now);
2907         e_start = now;
2908 }
2909
2910 /* join MESSAGE_DISCONNECT MESSAGE_RELEASE */
2911 void EndpointAppPBX::join_disconnect_release(int message_type, union parameter *param)
2912 {
2913         char cause[16];
2914         struct lcr_msg *message;
2915         struct port_list *portlist = NULL;
2916         time_t now;
2917
2918
2919         /* be sure that we are active */
2920         notify_active();
2921         e_tx_state = NOTIFY_STATE_ACTIVE;
2922
2923         /* we are powerdialing, if e_powerdial_on is set and limit is not exceeded if given */
2924         if (e_powerdial_on && ((e_powercount+1)<e_powerlimit || e_powerlimit<1)) {
2925                 release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL,0 ); /* RELEASE_TYPE, join, port */
2926
2927                 /* set time for power dialing */
2928                 schedule_timer(&e_powerdial_timeout, (int)e_powerdelay, 0); /* set redial in the future */
2929                 e_powercount++;
2930
2931                 /* set redial tone */
2932                 if (ea_endpoint->ep_portlist) {
2933                         e_join_pattern = 0;
2934                 }
2935                 set_tone(ea_endpoint->ep_portlist, "redial");
2936                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') redialing in %d seconds\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, (int)e_powerdelay);
2937                 /* send proceeding when powerdialing and still setup (avoid dialing timeout) */
2938                 if (e_state==EPOINT_STATE_IN_OVERLAP) {
2939                         new_state(EPOINT_STATE_IN_PROCEEDING);
2940                         if (ea_endpoint->ep_portlist) {
2941                                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
2942                                 message_put(message);
2943                                 logmessage(message->type, &message->param, ea_endpoint->ep_portlist->port_id, DIRECTION_OUT);
2944                         }
2945 /* caused the error, that the first knock sound was not there */
2946 /*                                      set_tone(portlist, "proceeding"); */
2947                 }
2948                 /* send display of powerdialing */
2949                 if (e_ext.display_dialing) {
2950                         portlist = ea_endpoint->ep_portlist;
2951                         while (portlist) {
2952                                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
2953                                 if (e_powerlimit)
2954                                         SPRINT(message->param.notifyinfo.display, "Retry %d of %d", e_powercount, e_powerlimit);
2955                                 else
2956                                         SPRINT(message->param.notifyinfo.display, "Retry %d", e_powercount);
2957                                 message_put(message);
2958                                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2959                                 portlist = portlist->next;
2960                         }
2961                 }
2962                 return;
2963         }
2964
2965         /* set stop time */
2966         time(&now);
2967         e_stop = now;
2968
2969         if ((e_state!=EPOINT_STATE_CONNECT
2970           && e_state!=EPOINT_STATE_OUT_DISCONNECT
2971           && e_state!=EPOINT_STATE_IN_OVERLAP
2972           && e_state!=EPOINT_STATE_IN_PROCEEDING
2973           && e_state!=EPOINT_STATE_IN_ALERTING)
2974          || !ea_endpoint->ep_portlist) { /* or no port */
2975                 process_hangup(param->disconnectinfo.cause, param->disconnectinfo.location);
2976                 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, param->disconnectinfo.cause, 0); /* RELEASE_TYPE, join, port */
2977                 return; /* must exit here */
2978         }
2979         /* save cause */
2980         if (!e_join_cause) {
2981                 e_join_cause = param->disconnectinfo.cause;
2982                 e_join_location = param->disconnectinfo.location;
2983         }
2984
2985         /* on release we need the audio again! */
2986         if (message_type == MESSAGE_RELEASE) {
2987                 e_join_pattern = 0;
2988                 ea_endpoint->ep_join_id = 0;
2989         }
2990         /* disconnect and select tone */
2991         new_state(EPOINT_STATE_OUT_DISCONNECT);
2992         SPRINT(cause, "cause_%02x", param->disconnectinfo.cause);
2993         /* if own_cause, we must release the join */
2994         if (e_ext.own_cause /* own cause */
2995          || !e_join_pattern) { /* no patterns */
2996                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we have own cause or we have no patterns. (own_cause=%d pattern=%d)\n", ea_endpoint->ep_serial, e_ext.own_cause, e_join_pattern);
2997                 if (message_type != MESSAGE_RELEASE)
2998                         release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0); /* RELEASE_TYPE, join, port */
2999                 e_join_pattern = 0;
3000         } else { /* else we enable audio */
3001                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
3002                 message->param.audiopath = 1;
3003                 message_put(message);
3004         }
3005         /* send disconnect message */
3006         SCPY(e_tone, cause);
3007         portlist = ea_endpoint->ep_portlist;
3008         while(portlist) {
3009                 set_tone(portlist, cause);
3010                 message_disconnect_port(portlist, param->disconnectinfo.cause, param->disconnectinfo.location, "");
3011                 portlist = portlist->next;
3012         }
3013 }
3014
3015 /* join MESSAGE_SETUP */
3016 void EndpointAppPBX::join_setup(struct port_list *portlist, int message_type, union parameter *param)
3017 {
3018         struct lcr_msg *message;
3019 //      struct interface        *interface;
3020
3021         /* if we already in setup state, we just update the dialing with new digits */
3022         if (e_state == EPOINT_STATE_OUT_SETUP
3023          || e_state == EPOINT_STATE_OUT_OVERLAP) {
3024                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we are in setup state, so we do overlap dialing.\n", ea_endpoint->ep_serial);
3025                 /* if digits changed, what we have already dialed */
3026                 if (!!strncmp(e_dialinginfo.id,param->setup.dialinginfo.id,strlen(e_dialinginfo.id))) {
3027                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we have dialed digits which have been changed or we have a new multidial, so we must redial.\n", ea_endpoint->ep_serial);
3028                         /* release all ports */
3029                         while((portlist = ea_endpoint->ep_portlist)) {
3030                                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_RELEASE);
3031                                 message->param.disconnectinfo.cause = CAUSE_NORMAL; /* normal clearing */
3032                                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
3033                                 message_put(message);
3034                                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
3035                                 ea_endpoint->free_portlist(portlist);
3036                         }
3037
3038                         /* disconnect audio */
3039                         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
3040                         message->param.audiopath = 0;
3041                         message_put(message);
3042
3043                         /* get dialing info */
3044                         memcpy(&e_callerinfo, &param->setup.callerinfo, sizeof(e_callerinfo));
3045                         memcpy(&e_dialinginfo, &param->setup.dialinginfo, sizeof(e_dialinginfo));
3046                         memcpy(&e_redirinfo, &param->setup.redirinfo, sizeof(e_redirinfo));
3047                         memcpy(&e_capainfo, &param->setup.capainfo, sizeof(e_capainfo));
3048                         new_state(EPOINT_STATE_OUT_OVERLAP);
3049
3050                         /* get time */
3051                         schedule_timer(&e_redial_timeout, 1, 0);
3052                         return;
3053                 }
3054                 /* if we have a pending redial, so we just adjust the dialing number */
3055                 if (e_redial_timeout.active) {
3056                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) redial in progress, so we update the dialing number to %s.\n", ea_endpoint->ep_serial, param->setup.dialinginfo.id);
3057                         memcpy(&e_dialinginfo, &param->setup.dialinginfo, sizeof(e_dialinginfo));
3058                         return;
3059                 }
3060                 if (!ea_endpoint->ep_portlist) {
3061                         PERROR("ERROR: overlap dialing to a NULL port relation\n");
3062                 }
3063                 if (ea_endpoint->ep_portlist->next) {
3064                         PERROR("ERROR: overlap dialing to a port_list port relation\n");
3065                 }
3066                 if (e_state == EPOINT_STATE_OUT_SETUP) {
3067                         /* queue digits */
3068                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) digits '%s' are queued because we didn't receive a setup acknowledge.\n", ea_endpoint->ep_serial, param->setup.dialinginfo.id);
3069                         SCAT(e_dialing_queue, param->setup.dialinginfo.id + strlen(e_dialinginfo.id));