Merge branch 'master' of ssh://jolly@www.misdn.org/var/git/lcr
[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(int cfnr)
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 (cfnr) {
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 #ifdef WITH_GSM_BS
983                         if (mISDNport->gsm_bs)
984                                 port = new Pgsm_bs(PORT_TYPE_GSM_BS_OUT, mISDNport, portname, &port_settings, channel, mISDNport->ifport->channel_force, mode);
985                         else
986 #endif
987 #ifdef WITH_GSM_MS
988                         if (mISDNport->gsm_ms)
989                                 port = new Pgsm_ms(PORT_TYPE_GSM_MS_OUT, mISDNport, portname, &port_settings, channel, mISDNport->ifport->channel_force, mode);
990                         else
991 #endif
992                                 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);
993                         if (!port)
994                                 FATAL("Failed to create Port instance\n");
995                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) got port %s\n", ea_endpoint->ep_serial, port->p_name);
996                         memset(&dialinginfo, 0, sizeof(dialinginfo));
997                         SCPY(dialinginfo.id, e_dialinginfo.id);
998                         dialinginfo.itype = INFO_ITYPE_ISDN_EXTENSION;
999                         dialinginfo.ntype = e_dialinginfo.ntype;
1000                         /* create port_list relation */
1001                         portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, mISDNport->earlyb);
1002                         if (!portlist) {
1003                                 PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
1004                                 delete port;
1005                                 goto check_anycall_intern;
1006                         }
1007                         /* directory.list */
1008                         if (e_callerinfo.id[0] && e_ext.display_name) {
1009                                 dirname = parse_directory(e_callerinfo.id, e_callerinfo.ntype);
1010                                 if (dirname)
1011                                         SCPY(e_callerinfo.name, dirname);
1012                         }
1013 //                      dss1 = (class Pdss1 *)port;
1014                         /* message */
1015 //printf("INTERNAL caller=%s,id=%s,dial=%s\n", param.setup.networkid, param.setup.callerinfo.id, param.setup.dialinginfo.id);
1016                         message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_SETUP);
1017                         memcpy(&message->param.setup.dialinginfo, &dialinginfo, sizeof(struct dialing_info));
1018                         memcpy(&message->param.setup.redirinfo, &e_redirinfo, sizeof(struct redir_info));
1019                         memcpy(&message->param.setup.callerinfo, &e_callerinfo, sizeof(struct caller_info));
1020                         memcpy(&message->param.setup.capainfo, &e_capainfo, sizeof(struct capa_info));
1021 //terminal                      SCPY(message->param.setup.from_terminal, e_ext.number);
1022 //terminal                      if (e_dialinginfo.id)
1023 //terminal                              SCPY(message->param.setup.to_terminal, e_dialinginfo.id);
1024                         /* handle restricted caller ids */
1025                         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);
1026                         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);
1027                         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);
1028                         /* display callerid if desired for extension */
1029                         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));
1030 //printf("\n\ndisplay = %s\n\n\n",message->param.setup.callerinfo.display);
1031                         /* use cnip, if enabld */
1032         //              if (!e_ext.centrex)
1033         //                      message->param.setup.callerinfo.name[0] = '\0';
1034                         /* screen clip if prefix is required */
1035                         if (message->param.setup.callerinfo.id[0] && e_ext.clip_prefix[0]) {
1036                                 SCPY(message->param.setup.callerinfo.id, e_ext.clip_prefix);
1037                                 SCAT(message->param.setup.callerinfo.id, numberrize_callerinfo(e_callerinfo.id,e_callerinfo.ntype, options.national, options.international));
1038                                 message->param.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
1039                         }
1040                         if (message->param.setup.callerinfo.id2[0] && e_ext.clip_prefix[0]) {
1041                                 SCPY(message->param.setup.callerinfo.id2, e_ext.clip_prefix);
1042                                 SCAT(message->param.setup.callerinfo.id2, numberrize_callerinfo(e_callerinfo.id2,e_callerinfo.ntype2, options.national, options.international));
1043                                 message->param.setup.callerinfo.ntype2 = INFO_NTYPE_UNKNOWN;
1044                         }
1045                         /* use internal caller id */
1046                         if (e_callerinfo.extension[0] && (message->param.setup.callerinfo.present!=INFO_PRESENT_RESTRICTED || e_ext.anon_ignore)) {
1047                                 SCPY(message->param.setup.callerinfo.id, e_callerinfo.extension);
1048                                 message->param.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
1049                                 message->param.setup.callerinfo.ntype2 = INFO_NTYPE_NOTPRESENT;
1050                         }
1051                         message_put(message);
1052                         logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1053                         anycall = 1;
1054                 }
1055
1056                 /* string from parallel call forward (cfp) */
1057                 p = e_ext.cfp;
1058                 if (*p) {
1059                         if (e_ext.anon_ignore && e_callerinfo.id[0]) {
1060                                 e_callerinfo.present = INFO_PRESENT_ALLOWED;
1061                                 e_callerinfo.present2 = INFO_PRESENT_ALLOWED;
1062                         }
1063                 }
1064
1065                 vbox_only: /* entry point for answering machine only */
1066                 cfu_only: /* entry point for cfu */
1067                 cfb_only: /* entry point for cfb */
1068                 cfnr_only: /* entry point for cfnr */
1069                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call extension %s for external destiantion(s) '%s'\n", ea_endpoint->ep_serial, e_dialinginfo.id, p);
1070 //              i=0;
1071                 while(*p) {
1072                         earlyb = 0;
1073                         /* only if vbox should be dialed, and terminal is given */
1074                         if (!strcmp(p, "vbox") && e_ext.number[0]) {
1075                                 /* go to the end of p */
1076                                 p += strlen(p);
1077
1078                                 /* answering vbox call */
1079                                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) answering machine\n", ea_endpoint->ep_serial);
1080                                 /* alloc port */
1081                                 if (!(port = new VBoxPort(PORT_TYPE_VBOX_OUT, &port_settings)))
1082                                         FATAL("No memory for VBOX Port instance\n");
1083                                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) allocated port %s\n", ea_endpoint->ep_serial, port->p_name);
1084                                 UCPY(cfp, e_ext.number); /* cfp or any other direct forward/vbox */
1085                         } else {
1086                                 cfp[0] = '\0';
1087                                 while(*p!=',' && *p!='\0')
1088                                         SCCAT(cfp, *p++);
1089                                 if (*p == ',')
1090                                         p++;
1091                                 /* external call */
1092                                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cfp external %s\n", ea_endpoint->ep_serial, cfp);
1093                                 /* hunt for mISDNport and create Port */
1094                                 mISDNport = hunt_port(e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:NULL, &channel);
1095                                 if (mISDNport) {
1096                                         /* creating EXTERNAL port*/
1097                                         SPRINT(portname, "%s-%d-out", mISDNport->ifport->interface->name, mISDNport->portnum);
1098 #ifdef WITH_SS5
1099                                         if (mISDNport->ss5)
1100                                                 port = ss5_hunt_line(mISDNport);
1101                                         else
1102 #endif
1103                                                 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);
1104                                         if (!port)
1105                                                 FATAL("No memory for Port instance\n");
1106                                         earlyb = mISDNport->earlyb;
1107                                 } else {
1108                                         port = NULL;
1109                                         trace_header("INTERFACE (too busy)", DIRECTION_NONE);
1110                                         add_trace("interface", NULL, "%s", e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:"any interface");
1111                                         end_trace();
1112                                 }
1113                         }
1114                         if (!port) {
1115                                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) no port found or created, which is idle.\n", ea_endpoint->ep_serial);
1116                                 goto check_anycall_intern;
1117                         }
1118                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) found or created port %s\n", ea_endpoint->ep_serial, port->p_name);
1119                         memset(&dialinginfo, 0, sizeof(dialinginfo));
1120                         SCPY(dialinginfo.id, cfp);
1121                         dialinginfo.itype = INFO_ITYPE_ISDN;
1122                         dialinginfo.ntype = e_dialinginfo.ntype;
1123                         portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, earlyb);
1124                         if (!portlist) {
1125                                 PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
1126                                 delete port;
1127                                 goto check_anycall_intern;
1128                         }
1129 //printf("EXTERNAL caller=%s,id=%s,dial=%s\n", param.setup.networkid, param.setup.callerinfo.id, param.setup.dialinginfo.id);
1130                         message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_SETUP);
1131                         memcpy(&message->param.setup.dialinginfo, &dialinginfo, sizeof(struct dialing_info));
1132                         memcpy(&message->param.setup.redirinfo, &e_redirinfo, sizeof(struct redir_info));
1133                         memcpy(&message->param.setup.callerinfo, &e_callerinfo, sizeof(struct caller_info));
1134                         /* if clip is hidden */
1135                         if (e_ext.clip==CLIP_HIDE && port->p_type!=PORT_TYPE_VBOX_OUT) {
1136                                 SCPY(message->param.setup.callerinfo.id, e_ext.callerid);
1137                                 SCPY(message->param.setup.callerinfo.extension, e_ext.number);
1138                                 message->param.setup.callerinfo.ntype = e_ext.callerid_type;
1139                                 message->param.setup.callerinfo.present = e_ext.callerid_present;
1140                                 message->param.setup.callerinfo.ntype = INFO_NTYPE_NOTPRESENT;
1141                         }
1142                         memcpy(&message->param.setup.capainfo, &e_capainfo, sizeof(struct capa_info));
1143 //terminal                      SCPY(message->param.setup.from_terminal, e_ext.number);
1144 //terminal                      if (e_dialinginfo.id)
1145 //terminal                              SCPY(message->param.setup.to_terminal, e_dialinginfo.id);
1146                                 /* handle restricted caller ids */
1147                         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);
1148                         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);
1149                         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);
1150                         /* display callerid if desired for extension */
1151                         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));
1152                         message_put(message);
1153                         logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1154                         anycall = 1;
1155                 }
1156
1157                 check_anycall_intern:
1158                 /* now we have all ports created */
1159                 if (!anycall) {
1160                         trace_header("INTERFACE (no extension's interface)", DIRECTION_NONE);
1161                         end_trace();
1162                         if (!ea_endpoint->ep_join_id)
1163                                 break;
1164                         release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, cause, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0); /* RELEASE_TYPE, join, port */
1165                         return; /* must exit here */
1166                 }
1167                 break;
1168
1169                 /* *********************** external call */
1170                 default:
1171                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dialing external: called='%s' keypad='%s'\n", ea_endpoint->ep_serial, e_dialinginfo.id, e_dialinginfo.keypad);
1172                 /* call to extenal interfaces */
1173                 if (e_dialinginfo.keypad[0])
1174                         p = e_dialinginfo.keypad;
1175                 else
1176                         p = e_dialinginfo.id;
1177                 do {
1178                         number[0] = '\0';
1179                         while(*p!=',' && *p!='\0')
1180                                 SCCAT(number, *p++);
1181                         if (*p == ',')
1182                                 p++;
1183                         /* found number */
1184                         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");
1185                         /* hunt for mISDNport and create Port */
1186                         /* hunt for mISDNport and create Port */
1187                         mISDNport = hunt_port(e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:NULL, &channel);
1188                         if (!mISDNport) {
1189                                 trace_header("INTERFACE (too busy)", DIRECTION_NONE);
1190                                 add_trace("interface", NULL, "%s", e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:"any interface");
1191                                 end_trace();
1192                                 goto check_anycall_extern;
1193                         }
1194                         /* creating EXTERNAL port*/
1195                         SPRINT(portname, "%s-%d-out", mISDNport->ifport->interface->name, mISDNport->portnum);
1196 #ifdef WITH_SS5
1197                         if (mISDNport->ss5)
1198                                 port = ss5_hunt_line(mISDNport);
1199                         else
1200 #endif
1201 #ifdef WITH_GSM_BS
1202                         if (mISDNport->gsm_bs)
1203                                 port = new Pgsm_bs(PORT_TYPE_GSM_BS_OUT, mISDNport, portname, &port_settings, channel, mISDNport->ifport->channel_force, mode);
1204                         else
1205 #endif
1206 #ifdef WITH_GSM_MS
1207                         if (mISDNport->gsm_ms)
1208                                 port = new Pgsm_ms(PORT_TYPE_GSM_MS_OUT, mISDNport, portname, &port_settings, channel, mISDNport->ifport->channel_force, mode);
1209                         else
1210 #endif
1211                                 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);
1212                         if (!port)
1213                                 FATAL("No memory for Port instance\n");
1214                         earlyb = mISDNport->earlyb;
1215                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) created port %s\n", ea_endpoint->ep_serial, port->p_name);
1216                         memset(&dialinginfo, 0, sizeof(dialinginfo));
1217                         if (e_dialinginfo.keypad[0])
1218                                 SCPY(dialinginfo.keypad, number);
1219                         else
1220                                 SCPY(dialinginfo.id, number);
1221                         dialinginfo.itype = INFO_ITYPE_ISDN;
1222                         dialinginfo.ntype = e_dialinginfo.ntype;
1223                         dialinginfo.sending_complete = e_dialinginfo.sending_complete;
1224                         portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, mISDNport->earlyb);
1225                         if (!portlist) {
1226                                 PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
1227                                 delete port;
1228                                 goto check_anycall_extern;
1229                         }
1230 //printf("EXTERNAL caller=%s,id=%s,dial=%s\n", param.setup.networkid, param.setup.callerinfo.id, param.setup.dialinginfo.id);
1231                         message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_SETUP);
1232                         memcpy(&message->param.setup.dialinginfo, &dialinginfo, sizeof(struct dialing_info));
1233                         memcpy(&message->param.setup.redirinfo, &e_redirinfo, sizeof(struct redir_info));
1234                         memcpy(&message->param.setup.callerinfo, &e_callerinfo, sizeof(struct caller_info));
1235                         memcpy(&message->param.setup.capainfo, &e_capainfo, sizeof(struct capa_info));
1236 //terminal                      SCPY(message->param.setup.from_terminal, e_ext.number);
1237 //terminal                      if (e_dialinginfo.id)
1238 //terminal                              SCPY(message->param.setup.to_terminal, e_dialinginfo.id);
1239                                 /* handle restricted caller ids */
1240                         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);
1241                         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);
1242                         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);
1243                         /* display callerid if desired for extension */
1244                         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));
1245                         message_put(message);
1246                         logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1247                         anycall = 1;
1248                 } while(*p);
1249
1250                 check_anycall_extern:
1251                 /* now we have all ports created */
1252                 if (!anycall) {
1253                         trace_header("INTERFACE (no free ports found)", DIRECTION_NONE);
1254                         end_trace();
1255                         if (!ea_endpoint->ep_join_id)
1256                                 break;
1257                         release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NOCHANNEL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0); /* RELEASE_TYPE, join, port */
1258                         return; /* must exit here */
1259                 }
1260                 break;
1261         }
1262
1263 }
1264
1265 int action_timeout(struct lcr_timer *timer, void *instance, int index)
1266 {
1267         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1268
1269         if (!ea->e_action || ea->e_state == EPOINT_STATE_CONNECT)
1270                 return 0;
1271
1272         unsched_timer(&ea->e_redial_timeout);
1273         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) current action timed out.\n", ea->ea_endpoint->ep_serial);
1274         ea->e_multipoint_cause = 0;
1275         ea->e_multipoint_location = 0;
1276         ea->new_state(EPOINT_STATE_IN_OVERLAP);
1277         ea->e_join_pattern = 0;
1278         ea->process_dialing(1);
1279         /* we must exit, because our endpoint might be gone */
1280
1281         return 0;
1282 }
1283
1284 int match_timeout(struct lcr_timer *timer, void *instance, int index)
1285 {
1286         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1287
1288         if (!ea->e_action) {
1289                 unsched_timer(&ea->e_redial_timeout);
1290                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we got a match timeout.\n", ea->ea_endpoint->ep_serial);
1291                 ea->process_dialing(0);
1292                 /* we must exit, because our endpoint might be gone */
1293         }
1294
1295         return 0;
1296 }
1297
1298 int redial_timeout(struct lcr_timer *timer, void *instance, int index)
1299 {
1300         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1301
1302         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) starting redial.\n", ea->ea_endpoint->ep_serial);
1303
1304         ea->new_state(EPOINT_STATE_OUT_SETUP);
1305         /* call special setup routine */
1306         ea->out_setup(0);
1307
1308         return 0;
1309 }
1310
1311 int powerdial_timeout(struct lcr_timer *timer, void *instance, int index)
1312 {
1313         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1314
1315         /* leave power dialing on */
1316         ea->e_powerdial_on = 1;
1317         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) starting redial of powerdial.\n", ea->ea_endpoint->ep_serial);
1318
1319         /* redial */
1320         ea->e_ruleset = ruleset_main;
1321         if (ea->e_ruleset)
1322                 ea->e_rule = ea->e_ruleset->rule_first;
1323         ea->e_action = NULL;
1324         ea->new_state(EPOINT_STATE_IN_OVERLAP);
1325         ea->process_dialing(0);
1326
1327         return 0;
1328 }
1329
1330 int cfnr_timeout(struct lcr_timer *timer, void *instance, int index)
1331 {
1332         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1333         struct port_list *portlist;
1334         struct lcr_msg *message;
1335
1336         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call-forward-no-response time has expired, hanging up.\n", ea->ea_endpoint->ep_serial);
1337
1338         /* release all ports */
1339         while((portlist = ea->ea_endpoint->ep_portlist)) {
1340                 message = message_create(ea->ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_RELEASE);
1341                 message->param.disconnectinfo.cause = CAUSE_NORMAL; /* normal clearing */
1342                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1343                 message_put(message);
1344                 ea->logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1345                 ea->ea_endpoint->free_portlist(portlist);
1346         }
1347         /* put on hold */
1348         message = message_create(ea->ea_endpoint->ep_serial, ea->ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
1349         message->param.audiopath = 0;
1350         message_put(message);
1351         /* indicate no patterns */
1352         message = message_create(ea->ea_endpoint->ep_serial, ea->ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
1353         message_put(message);
1354         /* set setup state, since we have no response from the new join */
1355         ea->new_state(EPOINT_STATE_OUT_SETUP);
1356
1357         return 0;
1358 }
1359
1360 int cfnr_call_timeout(struct lcr_timer *timer, void *instance, int index)
1361 {
1362         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1363
1364         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);
1365         ea->out_setup(1);
1366
1367         return 0;
1368 }
1369
1370 int callback_timeout(struct lcr_timer *timer, void *instance, int index)
1371 {
1372         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1373
1374         if (ea->e_state == EPOINT_STATE_IDLE) {
1375                 /* epoint is idle, check callback */
1376                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) starting callback.\n", ea->ea_endpoint->ep_serial);
1377                 ea->new_state(EPOINT_STATE_OUT_SETUP);
1378                 ea->out_setup(0);
1379         }
1380
1381         return 0;
1382 }
1383
1384 int password_timeout(struct lcr_timer *timer, void *instance, int index)
1385 {
1386         class EndpointAppPBX *ea = (class EndpointAppPBX *)instance;
1387
1388         if (ea->e_action->index==ACTION_PASSWORD || ea->e_action->index==ACTION_PASSWORD_WRITE) {
1389                 struct port_list *portlist;
1390
1391                 ea->e_ruleset = ruleset_main;
1392                 if (ea->e_ruleset)
1393                         ea->e_rule = ea->e_ruleset->rule_first;
1394                 ea->e_action = NULL;
1395                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) password timeout %s\n", ea->ea_endpoint->ep_serial, ea->e_extdialing);
1396                 ea->trace_header("PASSWORD timeout", DIRECTION_NONE);
1397                 end_trace();
1398                 ea->e_connectedmode = 0;
1399                 ea->e_dtmf = 0;
1400                 ea->new_state(EPOINT_STATE_OUT_DISCONNECT);
1401                 portlist = ea->ea_endpoint->ep_portlist;
1402                 if (portlist) {
1403                         ea->message_disconnect_port(portlist, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, "");
1404                         ea->set_tone(portlist, "cause_10");
1405                 }
1406         }
1407
1408         return 0;
1409 }
1410
1411 /* doing a hookflash */
1412 void EndpointAppPBX::hookflash(void)
1413 {
1414         class Port *port;
1415         time_t now;
1416
1417         /* be sure that we are active */
1418         notify_active();
1419         e_tx_state = NOTIFY_STATE_ACTIVE;
1420
1421         trace_header("HOOKFLASH DTMF", DIRECTION_NONE);
1422         end_trace();
1423         if (ea_endpoint->ep_use > 1) {
1424                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot hooflash while child process is running.\n", ea_endpoint->ep_serial);
1425                 return;
1426         }
1427         /* dialtone after pressing the hash key */
1428         process_hangup(e_join_cause, e_join_location);
1429         e_multipoint_cause = 0;
1430         e_multipoint_location = 0;
1431         port = find_port_id(ea_endpoint->ep_portlist->port_id);
1432         if (port) {
1433                 port->set_echotest(0);
1434         }
1435         if (ea_endpoint->ep_join_id) {
1436                 release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0); /* RELEASE_TYPE, join, port */
1437         }
1438         e_ruleset = ruleset_main;
1439         if (e_ruleset)
1440                 e_rule = e_ruleset->rule_first;
1441         e_action = NULL;
1442         new_state(EPOINT_STATE_IN_OVERLAP);
1443         e_connectedmode = 1;
1444         SCPY(e_dialinginfo.id, e_ext.prefix);
1445         e_extdialing = e_dialinginfo.id;
1446         e_join_pattern = 0;
1447         if (e_dialinginfo.id[0]) {
1448                 set_tone(ea_endpoint->ep_portlist, "dialing");
1449                 process_dialing(0);
1450         } else {
1451                 set_tone(ea_endpoint->ep_portlist, "dialpbx");
1452         }
1453         time(&now);
1454         e_dtmf_time = now;
1455         e_dtmf_last = '\0';
1456 }
1457
1458
1459 /* messages from port
1460  */
1461 /* port MESSAGE_SETUP */
1462 void EndpointAppPBX::port_setup(struct port_list *portlist, int message_type, union parameter *param)
1463 {
1464         struct lcr_msg          *message;
1465         char                    buffer[256];
1466         int                     writeext;               /* flags need to write extension after modification */
1467         class Port              *port;
1468         struct interface        *interface;
1469
1470         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
1471         
1472         portlist->port_type = param->setup.port_type;
1473         memcpy(&e_callerinfo, &param->setup.callerinfo, sizeof(e_callerinfo));
1474         memcpy(&e_dialinginfo, &param->setup.dialinginfo, sizeof(e_dialinginfo));
1475         memcpy(&e_redirinfo, &param->setup.redirinfo, sizeof(e_redirinfo));
1476         memcpy(&e_capainfo, &param->setup.capainfo, sizeof(e_capainfo));
1477
1478         /* convert (inter-)national number type */
1479         SCPY(e_dialinginfo.id, numberrize_callerinfo(e_dialinginfo.id, e_dialinginfo.ntype, options.national, options.international));
1480         e_dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
1481
1482 //      e_dtmf = param->setup.dtmf;
1483         /* screen incoming caller id */
1484         interface = interface_first;
1485         while(interface) {
1486                 if (!strcmp(e_callerinfo.interface, interface->name)) {
1487                         break;
1488                 }
1489                 interface = interface->next;
1490         }
1491         if (interface) {
1492                 do_screen(0, e_callerinfo.id, sizeof(e_callerinfo.id), &e_callerinfo.ntype, &e_callerinfo.present, interface);
1493                 do_screen(0, e_callerinfo.id2, sizeof(e_callerinfo.id2), &e_callerinfo.ntype2, &e_callerinfo.present2, interface);
1494         }
1495
1496         /* process extension */
1497         if (e_callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION) {
1498                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming call is extension\n", ea_endpoint->ep_serial);
1499                 /* port makes call from extension */
1500                 SCPY(e_callerinfo.extension, e_callerinfo.id);
1501                 SCPY(e_ext.number, e_callerinfo.extension);
1502                 SCPY(e_extension_interface, e_callerinfo.interface);
1503         } else {
1504                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming call is external or voip\n", ea_endpoint->ep_serial);
1505         }
1506
1507         if (e_callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION) {
1508                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call from extension '%s'\n", ea_endpoint->ep_serial, e_ext.number);
1509
1510                 /* get extension's info about caller */
1511                 if (!read_extension(&e_ext, e_ext.number)) {
1512                         /* extension doesn't exist */
1513                         trace_header("EXTENSION (not created)", DIRECTION_IN);
1514                         add_trace("extension", NULL, "%s", e_ext.number);
1515                         end_trace();
1516                         message_disconnect_port(portlist, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, "");
1517                         new_state(EPOINT_STATE_OUT_DISCONNECT);
1518                         set_tone(portlist, "cause_80"); /* pbx cause: extension not authorized */
1519                         e_ext.number[0] = '\0'; /* no terminal */
1520                         return;
1521                 }
1522                 writeext = 0;
1523
1524                 /* put prefix (next) in front of e_dialinginfo.id */
1525                 if (e_ext.next[0]) {
1526                         SPRINT(buffer, "%s%s", e_ext.next, e_dialinginfo.id);
1527                         SCPY(e_dialinginfo.id, buffer);
1528                         e_ext.next[0] = '\0';
1529                         writeext = 1;
1530                 } else if (e_ext.prefix[0]) {
1531                         SPRINT(buffer, "%s%s", e_ext.prefix, e_dialinginfo.id);
1532                         SCPY(e_dialinginfo.id, buffer);
1533                 }
1534
1535                 /* screen caller id by extension's config */
1536                 e_callerinfo.screen = INFO_SCREEN_NETWORK;
1537                 if (e_ext.name[0])
1538                         SCPY(e_callerinfo.name, e_ext.name);
1539                 /* use caller id (or if exist: id_next_call) for this call */
1540                 if (e_ext.id_next_call_present >= 0) {
1541                         SCPY(e_callerinfo.id, e_ext.id_next_call);
1542                         /* if we restrict the pesentation */
1543                         if (e_ext.id_next_call_present==INFO_PRESENT_ALLOWED && e_callerinfo.present==INFO_PRESENT_RESTRICTED)
1544                                 e_callerinfo.present = INFO_PRESENT_RESTRICTED;
1545                         else    e_callerinfo.present = e_ext.id_next_call_present;
1546                         e_callerinfo.ntype = e_ext.id_next_call_type;
1547                         e_ext.id_next_call_present = -1;
1548                         writeext = 1;
1549                 } else {
1550                         SCPY(e_callerinfo.id, e_ext.callerid);
1551                         /* if we restrict the pesentation */
1552                         if (e_ext.callerid_present==INFO_PRESENT_ALLOWED && e_callerinfo.present==INFO_PRESENT_RESTRICTED)
1553                                 e_callerinfo.present = INFO_PRESENT_RESTRICTED;
1554                         else    e_callerinfo.present = e_ext.callerid_present;
1555                         e_callerinfo.ntype = e_ext.callerid_type;
1556                 }
1557                 e_callerinfo.ntype2 = INFO_NTYPE_NOTPRESENT;
1558
1559                 /* extension is written */
1560                 if (writeext)
1561                         write_extension(&e_ext, e_ext.number);
1562
1563                 /* set volume of rx and tx */
1564                 if (param->setup.callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION)
1565                 if (e_ext.tx_gain!=0 || e_ext.rx_gain!=0) {
1566                         message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_mISDNSIGNAL);
1567                         message->param.mISDNsignal.message = mISDNSIGNAL_VOLUME;
1568                         message->param.mISDNsignal.rx_gain = e_ext.tx_gain;
1569                         message->param.mISDNsignal.tx_gain = e_ext.rx_gain;
1570                         message_put(message);
1571                 }
1572
1573                 /* start recording if enabled */
1574                 if (e_ext.record!=CODEC_OFF && (e_capainfo.bearer_capa==INFO_BC_SPEECH || e_capainfo.bearer_capa==INFO_BC_AUDIO)) {
1575                         /* check if we are a terminal */
1576                         if (e_ext.number[0] == '\0')
1577                                 PERROR("Port(%d) cannot record because we are not a terminal\n", ea_endpoint->ep_serial);
1578                         else {
1579                                 port = find_port_id(portlist->port_id);
1580                                 if (port)
1581                                         port->open_record(e_ext.record, 0, 0, e_ext.number, e_ext.anon_ignore, "", 0);
1582                         }
1583                 }
1584         } else {
1585                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call from external port\n", ea_endpoint->ep_serial);
1586                 /* no terminal identification */
1587                 e_ext.number[0] = '\0';
1588                 e_extension_interface[0] = '\0';
1589                 memset(&e_ext, 0, sizeof(e_ext));
1590                 e_ext.rights = 4; /* right to dial internat */
1591         }
1592
1593         /* incoming call */
1594         e_ruleset = ruleset_main;
1595         if (e_ruleset)
1596                 e_rule = e_ruleset->rule_first;
1597         e_action = NULL;
1598         e_extdialing = e_dialinginfo.id;
1599         new_state(EPOINT_STATE_IN_SETUP);
1600         if (e_dialinginfo.id[0]) {
1601                 set_tone(portlist, "dialing");
1602         } else {
1603                 if (e_ext.number[0])
1604                         set_tone(portlist, "dialpbx");
1605                 else
1606                         set_tone(portlist, "dialtone");
1607         }
1608         process_dialing(0);
1609         if (e_state == EPOINT_STATE_IN_SETUP) {
1610                 /* request MORE info, if not already at higher state */
1611                 new_state(EPOINT_STATE_IN_OVERLAP);
1612                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_OVERLAP);
1613                 message_put(message);
1614                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1615         }
1616 }
1617
1618 /* port MESSAGE_INFORMATION */
1619 void EndpointAppPBX::port_information(struct port_list *portlist, int message_type, union parameter *param)
1620 {
1621         struct lcr_msg          *message;
1622
1623         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
1624
1625         /* ignore information message without digit information */
1626         if (!param->information.id[0])
1627                 return;
1628
1629         e_overlap = 1;
1630
1631         /* turn off dtmf detection, in case dtmf is sent with keypad information */
1632         if (e_dtmf) {
1633                 trace_header("DTMF (disabling due to keypad)", DIRECTION_IN);
1634                 end_trace();
1635                 e_dtmf = 0;
1636         }
1637
1638         /* if vbox_play is done, the information are just used as they come */
1639         if (e_action)
1640         if (e_action->index == ACTION_VBOX_PLAY) {
1641                 /* concat dialing string */
1642                 SCAT(e_dialinginfo.id, param->information.id);
1643                 process_dialing(0);
1644                 return;
1645         }
1646
1647         /* keypad when disconnect but in connected mode */
1648         if (e_state==EPOINT_STATE_OUT_DISCONNECT && e_connectedmode) {
1649                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) keypad information received after disconnect: %s.\n", ea_endpoint->ep_serial, param->information.id);
1650                 /* processing keypad function */
1651                 if (param->information.id[0] == '0') {
1652                         hookflash();
1653                 }
1654                 return;
1655         }
1656
1657         /* keypad when connected */
1658         if (e_state == EPOINT_STATE_CONNECT || e_state == EPOINT_STATE_IN_ALERTING) {
1659                 if (e_enablekeypad) {
1660                         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
1661                         memcpy(&message->param, param, sizeof(union parameter));
1662                         message_put(message);
1663                         return;
1664                 }
1665                 if (e_ext.keypad) {
1666                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) keypad information received during connect: %s.\n", ea_endpoint->ep_serial, param->information.id);
1667                         /* processing keypad function */
1668                         if (param->information.id[0] == '0') {
1669                                 hookflash();
1670                         }
1671                         if (param->information.id[0])
1672                                 keypad_function(param->information.id[0]);
1673                 } else {
1674                         if (e_ext.number[0])
1675                                 trace_header("KEYPAD (not enabled by extension's settings)", DIRECTION_IN);
1676                         else
1677                                 trace_header("KEYPAD (not enabled for external interfaces)", DIRECTION_IN);
1678                         end_trace();
1679                 }
1680                 return;
1681         }
1682         if (e_state != EPOINT_STATE_IN_OVERLAP) {
1683                 if (e_ext.number[0])
1684                         trace_header("KEYPAD (ignored, not connected and not dialing)", DIRECTION_IN);
1685                 else
1686                         trace_header("KEYPAD (not enabled for external interfaces)", DIRECTION_IN);
1687                 end_trace();
1688                 return;
1689         }
1690         if (!param->information.id[0])
1691                 return;
1692         if (e_dialinginfo.id[0]=='\0' && !e_action) {
1693                 set_tone(portlist, "dialing");
1694         }
1695         if (e_action)
1696         if (e_action->index==ACTION_OUTDIAL
1697          || e_action->index==ACTION_EXTERNAL
1698          || e_action->index==ACTION_REMOTE) {
1699                 if (!e_extdialing)
1700                         set_tone(portlist, "dialing");
1701                 else if (!e_extdialing[0])
1702                         set_tone(portlist, "dialing");
1703         }
1704         /* concat dialing string */
1705         SCAT(e_dialinginfo.id, param->information.id);
1706         process_dialing(0);
1707 }
1708
1709 /* port MESSAGE_DTMF */
1710 void EndpointAppPBX::port_dtmf(struct port_list *portlist, int message_type, union parameter *param)
1711 {
1712         time_t now;
1713         struct lcr_msg          *message;
1714
1715         time(&now);
1716
1717         /* only if dtmf detection is enabled */
1718         if (!e_dtmf) {
1719                 trace_header("DTMF (disabled)", DIRECTION_IN);
1720                 end_trace();
1721                 return;
1722         }
1723         trace_header("DTMF", DIRECTION_IN);
1724         add_trace("digit", NULL, "%c", param->dtmf);
1725         end_trace();
1726
1727 #if 0
1728 NOTE: vbox is now handled due to overlap state
1729         /* if vbox_play is done, the dtmf digits are just used as they come */
1730         if (e_action)
1731         if (e_action->index == ACTION_VBOX_PLAY) {
1732                 /* concat dialing string */
1733                 if (strlen(e_dialinginfo.id)+1 < sizeof(e_dialinginfo.id)) {
1734                         e_dialinginfo.id[strlen(e_dialinginfo.id)+1] = '\0';
1735                         e_dialinginfo.id[strlen(e_dialinginfo.id)] = param->dtmf;
1736                         process_dialing(0);
1737                 }
1738                 /* continue to process *X# sequences */
1739         }
1740 #endif
1741
1742         /* check for *X# sequence */
1743         if (e_state == EPOINT_STATE_CONNECT || e_state == EPOINT_STATE_IN_ALERTING) {
1744                 if (e_enablekeypad) {
1745                         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
1746                         memcpy(&message->param, param, sizeof(union parameter));
1747                         message_put(message);
1748                         return;
1749                 }
1750                 if (e_dtmf_time+3 < now) {
1751                         /* the last digit was too far in the past to be a sequence */
1752                         if (param->dtmf == '*')
1753                                 /* only start is allowed in the sequence */
1754                                 e_dtmf_last = '*';
1755                         else
1756                                 e_dtmf_last = '\0';
1757                 } else {
1758                         /* we have a sequence of digits, see what we got */
1759                         if (param->dtmf == '*')
1760                                 e_dtmf_last = '*';
1761                         else if (param->dtmf>='0' && param->dtmf<='9') {
1762                                 /* we need to have a star before we receive the digit of the sequence */
1763                                 if (e_dtmf_last == '*')
1764                                         e_dtmf_last = param->dtmf;
1765                         } else if (param->dtmf == '#') {
1766                                 /* the hash key */
1767                                 if (e_dtmf_last>='0' && e_dtmf_last<='9') {
1768                                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dtmf sequence *%c# detected.\n", ea_endpoint->ep_serial, e_dtmf_last);
1769                                         if (e_dtmf_last == '0') {
1770                                                 hookflash();
1771                                                 return;
1772                                         }
1773                                         /* processing keypad function */
1774                                         if (param->dtmf)
1775                                                 keypad_function(e_dtmf_last);
1776                                         e_dtmf_last = '\0';
1777                                 }
1778                         }
1779                 }
1780
1781                 /* set last time of dtmf */
1782                 e_dtmf_time = now;
1783                 return;
1784         }
1785
1786         /* check for ## hookflash during dialing */
1787         if (e_action)
1788         if (e_action->index==ACTION_PASSWORD
1789          || e_action->index==ACTION_PASSWORD_WRITE)
1790                 goto password;
1791         if (param->dtmf=='#') { /* current digit is '#' */
1792                 if (e_state==EPOINT_STATE_IN_DISCONNECT
1793                  || (e_state!=EPOINT_STATE_CONNECT && e_dtmf_time+3>=now && e_dtmf_last=='#')) { /* when disconnected, just #. when dialing, ##. */
1794                         hookflash();
1795                         return;
1796                 } else {
1797                         e_dtmf_time = now;
1798                         e_dtmf_last = '#';
1799                 }
1800         } else {
1801                 password:
1802                 e_dtmf_time = now;
1803                 e_dtmf_last = '\0';
1804         }
1805         
1806
1807         /* dialing using dtmf digit */
1808         if (e_state==EPOINT_STATE_IN_OVERLAP){ // && e_state==e_connectedmode)
1809                 if (e_dialinginfo.id[0]=='\0' && !e_action) {
1810                         set_tone(portlist, "dialing");
1811                 }
1812                 /* concat dialing string */
1813                 if (strlen(e_dialinginfo.id)+1 < sizeof(e_dialinginfo.id)) {
1814                         e_dialinginfo.id[strlen(e_dialinginfo.id)+1] = '\0';
1815                         e_dialinginfo.id[strlen(e_dialinginfo.id)] = param->dtmf;
1816                         process_dialing(0);
1817                 }
1818         }
1819 }
1820
1821 /* port MESSAGE_CRYPT */
1822 void EndpointAppPBX::port_crypt(struct port_list *portlist, int message_type, union parameter *param)
1823 {
1824         /* send crypt response to cryptman */
1825         if (param->crypt.type == CR_MESSAGE_IND)
1826                 cryptman_msg2man(param->crypt.data, param->crypt.len);
1827         else
1828                 cryptman_message(param->crypt.type, param->crypt.data, param->crypt.len);
1829 }
1830
1831 /* port MESSAGE_OVERLAP */
1832 void EndpointAppPBX::port_overlap(struct port_list *portlist, int message_type, union parameter *param)
1833 {
1834         struct lcr_msg *message;
1835
1836         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
1837
1838         /* signal to call tool */
1839         admin_call_response(e_adminid, ADMIN_CALL_SETUP_ACK, "", 0, 0, 0);
1840
1841         if (e_dialing_queue[0] && portlist) {
1842                 /* send what we have not dialed yet, because we had no setup complete */
1843                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dialing pending digits: '%s'\n", ea_endpoint->ep_serial, e_dialing_queue);
1844                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_INFORMATION);
1845                 SCPY(message->param.information.id, e_dialing_queue);
1846                 message->param.information.ntype = INFO_NTYPE_UNKNOWN;
1847                 message_put(message);
1848                 logmessage(message->type, &message->param, ea_endpoint->ep_portlist->port_id, DIRECTION_OUT);
1849                 e_dialing_queue[0] = '\0';
1850         }
1851         /* check if pattern is available */
1852         if (!ea_endpoint->ep_portlist->next && portlist->early_b) { /* one port_list relation and tones available */
1853                 /* indicate patterns */
1854                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
1855                 message_put(message);
1856
1857                 /* connect audio, if not already */
1858                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
1859                 message->param.audiopath = 1;
1860                 message_put(message);
1861         } else {
1862                 /* indicate no patterns */
1863                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
1864                 message_put(message);
1865
1866                 /* disconnect audio, if not already */
1867                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
1868                 message->param.audiopath = 0;
1869                 message_put(message);
1870         }
1871         new_state(EPOINT_STATE_OUT_OVERLAP);
1872         /* if we are in a join */
1873         if (ea_endpoint->ep_join_id) { 
1874                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
1875                 memcpy(&message->param, param, sizeof(union parameter));
1876                 message_put(message);
1877         }
1878 }
1879
1880 /* port MESSAGE_PROCEEDING */
1881 void EndpointAppPBX::port_proceeding(struct port_list *portlist, int message_type, union parameter *param)
1882 {
1883         struct lcr_msg *message;
1884
1885         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
1886
1887         /* signal to call tool */
1888         admin_call_response(e_adminid, ADMIN_CALL_PROCEEDING, "", 0, 0, 0);
1889
1890         e_state = EPOINT_STATE_OUT_PROCEEDING;
1891         /* check if pattern is availatle */
1892         if (!ea_endpoint->ep_portlist->next && (portlist->early_b || portlist->port_type==PORT_TYPE_VBOX_OUT)) { /* one port_list relation and tones available */
1893                 /* indicate patterns */
1894                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
1895                 message_put(message);
1896
1897                 /* connect audio, if not already */
1898                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
1899                 message->param.audiopath = 1;
1900                 message_put(message);
1901         } else {
1902                 /* indicate no patterns */
1903                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
1904                 message_put(message);
1905
1906                 /* disconnect audio, if not already */
1907                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
1908                 message->param.audiopath = 0;
1909                 message_put(message);
1910         }
1911         /* if we are in a call */
1912         if (ea_endpoint->ep_join_id) { 
1913                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
1914                 memcpy(&message->param, param, sizeof(union parameter));
1915                 message_put(message);
1916         }
1917 }
1918
1919 /* port MESSAGE_ALERTING */
1920 void EndpointAppPBX::port_alerting(struct port_list *portlist, int message_type, union parameter *param)
1921 {
1922         struct lcr_msg *message;
1923
1924         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
1925
1926         /* signal to call tool */
1927         admin_call_response(e_adminid, ADMIN_CALL_ALERTING, "", 0, 0, 0);
1928 //#warning hack!!
1929 //      if (e_adminid)
1930 //              set_tone(portlist, "hold");
1931
1932         new_state(EPOINT_STATE_OUT_ALERTING);
1933         /* check if pattern is available */
1934         if (!ea_endpoint->ep_portlist->next && (portlist->early_b || portlist->port_type==PORT_TYPE_VBOX_OUT)) { /* one port_list relation and tones available */
1935                 /* indicate patterns */
1936                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
1937                 message_put(message);
1938
1939                 /* connect audio, if not already */
1940                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
1941                 message->param.audiopath = 1;
1942                 message_put(message);
1943         } else {
1944                 /* indicate no patterns */
1945                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
1946                 message_put(message);
1947
1948                 /* disconnect audio, if not already */
1949                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
1950                 message->param.audiopath = 0;
1951                 message_put(message);
1952         }
1953         /* if we are in a call */
1954         if (ea_endpoint->ep_join_id) { 
1955                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
1956                 memcpy(&message->param, param, sizeof(union parameter));
1957                 message_put(message);
1958         }
1959 }
1960
1961 /* port MESSAGE_CONNECT */
1962 void EndpointAppPBX::port_connect(struct port_list *portlist, int message_type, union parameter *param)
1963 {
1964         struct lcr_msg *message;
1965         char buffer[256];
1966         unsigned int port_id = portlist->port_id;
1967         struct port_list *tportlist;
1968         class Port *port;
1969         struct interface        *interface;
1970         time_t now;
1971
1972         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
1973
1974         /* signal to call tool */
1975         admin_call_response(e_adminid, ADMIN_CALL_CONNECT, numberrize_callerinfo(param->connectinfo.id,param->connectinfo.ntype, options.national, options.international), 0, 0, 0);
1976
1977         memcpy(&e_connectinfo, &param->connectinfo, sizeof(e_connectinfo));
1978         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) removing all other ports (start)\n", ea_endpoint->ep_serial);
1979         while(ea_endpoint->ep_portlist->next) { /* as long as we have at least two ports */
1980                 tportlist = ea_endpoint->ep_portlist;
1981                 if (tportlist->port_id == port_id) /* if the first portlist is the calling one, the second must be a different one */
1982                         tportlist = tportlist->next;
1983                 if (tportlist->port_id == port_id)
1984                         FATAL("EPOINT(%d) this should not happen since the portlist list must not have two links to the same port - exitting.\n");
1985                 message = message_create(ea_endpoint->ep_serial, tportlist->port_id, EPOINT_TO_PORT, MESSAGE_RELEASE);
1986                 message->param.disconnectinfo.cause = CAUSE_NONSELECTED; /* non selected user clearing */
1987                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1988                 message_put(message);
1989                 logmessage(message->type, &message->param, tportlist->port_id, DIRECTION_OUT);
1990                 ea_endpoint->free_portlist(tportlist);
1991         }
1992         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) removing all other ports (end)\n", ea_endpoint->ep_serial);
1993
1994         time(&now);
1995         e_start = now;
1996
1997         /* screen incoming connected id */
1998         interface = interface_first;
1999         while(interface) {
2000                 if (!strcmp(e_connectinfo.interface, interface->name)) {
2001                         break;
2002                 }
2003                 interface = interface->next;
2004         }
2005         if (interface)
2006                 do_screen(0, e_connectinfo.id, sizeof(e_connectinfo.id), &e_connectinfo.ntype, &e_connectinfo.present, interface);
2007
2008         /* screen connected name */
2009         if (e_ext.name[0])
2010                 SCPY(e_connectinfo.name, e_ext.name);
2011
2012         /* add internal id to colp */
2013         SCPY(e_connectinfo.extension, e_ext.number);
2014
2015         /* we store the connected port number */
2016         SCPY(e_extension_interface, e_connectinfo.interface);
2017
2018         /* for internal and am calls, we get the extension's id */
2019         if (portlist->port_type==PORT_TYPE_VBOX_OUT || e_ext.colp==COLP_HIDE) {
2020                 SCPY(e_connectinfo.id, e_ext.callerid);
2021                 SCPY(e_connectinfo.extension, e_ext.number);
2022                 e_connectinfo.itype = INFO_ITYPE_ISDN_EXTENSION;
2023                 e_connectinfo.ntype = e_ext.callerid_type;
2024                 e_connectinfo.present = e_ext.callerid_present;
2025         }
2026         if (portlist->port_type==PORT_TYPE_VBOX_OUT) {
2027                 e_connectinfo.itype = INFO_ITYPE_VBOX;
2028                 e_connectinfo.ntype = INFO_NTYPE_UNKNOWN;
2029         }
2030
2031         new_state(EPOINT_STATE_CONNECT);
2032
2033         /* set volume of rx and tx */
2034         if (e_ext.tx_gain!=0 || e_ext.rx_gain!=0) {
2035                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_mISDNSIGNAL);
2036                 message->param.mISDNsignal.message = mISDNSIGNAL_VOLUME;
2037                 message->param.mISDNsignal.rx_gain = e_ext.tx_gain;
2038                 message->param.mISDNsignal.tx_gain = e_ext.rx_gain;
2039                 message_put(message);
2040         }
2041
2042         unsched_timer(&e_cfnr_timeout);
2043         unsched_timer(&e_cfnr_call_timeout);
2044         if (e_ext.number[0])
2045                 e_dtmf = 1; /* allow dtmf */
2046
2047         /* modify colp */
2048         /* other calls with no caller id (or not available for the extension) and force colp */
2049         if ((e_connectinfo.id[0]=='\0' || (e_connectinfo.present==INFO_PRESENT_RESTRICTED && !e_ext.anon_ignore))&& e_ext.colp==COLP_FORCE) {
2050                 e_connectinfo.ntype = INFO_NTYPE_NOTPRESENT;
2051                 if (portlist->port_type==PORT_TYPE_DSS1_TE_OUT
2052                  || portlist->port_type==PORT_TYPE_DSS1_NT_OUT
2053                  || portlist->port_type==PORT_TYPE_GSM_BS_OUT
2054                  || portlist->port_type==PORT_TYPE_GSM_MS_OUT) { /* external extension answered */
2055                         port = find_port_id(portlist->port_id);
2056                         if (port) {
2057                                 SCPY(e_connectinfo.id, nationalize_callerinfo(port->p_dialinginfo.id, &e_connectinfo.ntype, options.national, options.international));
2058                                 e_connectinfo.present = INFO_PRESENT_ALLOWED;
2059                         }
2060                 }
2061         }
2062
2063         /* send connect to join */
2064         if (ea_endpoint->ep_join_id) {
2065                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
2066                 memcpy(&message->param.connectinfo, &e_connectinfo, sizeof(struct connect_info));
2067                 message_put(message);
2068
2069                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2070                 message->param.audiopath = 1;
2071                 message_put(message);
2072         } else if (!e_adminid) {
2073                 /* callback */
2074                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we have a callback, so we create a call with cbcaller: \"%s\".\n", ea_endpoint->ep_serial, e_cbcaller);
2075                 SCPY(e_ext.number, e_cbcaller);
2076                 new_state(EPOINT_STATE_IN_OVERLAP);
2077                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) callback from extension '%s'\n", ea_endpoint->ep_serial, e_ext.number);
2078
2079                 /* get extension's info about terminal */
2080                 if (!read_extension(&e_ext, e_ext.number)) {
2081                         /* extension doesn't exist */
2082                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) rejecting callback from not existing extension: '%s'\n", ea_endpoint->ep_serial, e_ext.number);
2083                         message_disconnect_port(portlist, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, "");
2084                         new_state(EPOINT_STATE_OUT_DISCONNECT);
2085                         set_tone(portlist, "cause_80"); /* pbx cause: extension not authorized */
2086                         return;
2087                 }
2088
2089                 /* put prefix in front of e_cbdialing */
2090                 SPRINT(buffer, "%s%s", e_ext.prefix, e_cbdialing);
2091                 SCPY(e_dialinginfo.id, buffer);
2092                 e_dialinginfo.itype = INFO_ITYPE_ISDN;
2093                 e_dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
2094
2095                 /* use caller id (or if exist: id_next_call) for this call */
2096                 e_callerinfo.screen = INFO_SCREEN_NETWORK;
2097                 SCPY(e_callerinfo.extension, e_ext.number);
2098                 if (e_ext.id_next_call_present >= 0) {
2099                         SCPY(e_callerinfo.id, e_ext.id_next_call);
2100                         e_callerinfo.present = e_ext.id_next_call_present;
2101                         e_callerinfo.ntype = e_ext.id_next_call_type;
2102                         e_ext.id_next_call_present = -1;
2103                         /* extension is written */
2104                         write_extension(&e_ext, e_ext.number);
2105                 } else {
2106                         SCPY(e_callerinfo.id, e_ext.callerid);
2107                         e_callerinfo.present = e_ext.callerid_present;
2108                         e_callerinfo.ntype = e_ext.callerid_type;
2109                 }
2110                 e_callerinfo.ntype2 = INFO_NTYPE_NOTPRESENT;
2111
2112                 e_connectedmode = 1; /* dtmf-hangup & disconnect prevention */
2113                 e_dtmf = 1;
2114
2115                 /* check if caller id is NOT authenticated */
2116                 if (!parse_callbackauth(e_ext.number, &e_callbackinfo)) {
2117                         /* make call state to enter password */
2118                         new_state(EPOINT_STATE_IN_OVERLAP);
2119                         e_action = &action_password_write;
2120                         unsched_timer(&e_match_timeout);
2121                         e_match_to_action = NULL;
2122                         e_dialinginfo.id[0] = '\0';
2123                         e_extdialing = strchr(e_dialinginfo.id, '\0');
2124                         schedule_timer(&e_password_timeout, 20, 0);
2125                         process_dialing(0);
2126                 } else {
2127                         /* incoming call (callback) */
2128                         e_ruleset = ruleset_main;
2129                         if (e_ruleset)
2130                                 e_rule = e_ruleset->rule_first;
2131                         e_action = NULL;
2132                         e_extdialing = e_dialinginfo.id;
2133                         if (e_dialinginfo.id[0]) {
2134                                 set_tone(portlist, "dialing");
2135                                 process_dialing(0);
2136                         } else {
2137                                 set_tone(portlist, "dialpbx");
2138                         }
2139                 }
2140         } else { /* testcall */
2141                 set_tone(portlist, "hold");
2142         }
2143
2144         /* start recording if enabled, not when answering machine answers */
2145         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)) {
2146                 /* check if we are a terminal */
2147                 if (e_ext.number[0] == '\0')
2148                         PERROR("Port(%d) cannot record because we are not a terminal\n", ea_endpoint->ep_serial);
2149                 else {
2150                         port = find_port_id(portlist->port_id);
2151                         if (port)
2152                                 port->open_record(e_ext.record, 0, 0, e_ext.number, e_ext.anon_ignore, "", 0);
2153                 }
2154         }
2155 }
2156
2157 /* port MESSAGE_DISCONNECT MESSAGE_RELEASE */
2158 void EndpointAppPBX::port_disconnect_release(struct port_list *portlist, int message_type, union parameter *param)
2159 {
2160         struct lcr_msg  *message;
2161         char            buffer[256];
2162         unsigned int    port_id = portlist->port_id;
2163         int             cause,
2164                         location;
2165
2166         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
2167
2168         /* signal to call tool */
2169         admin_call_response(e_adminid, (message_type==MESSAGE_DISCONNECT)?ADMIN_CALL_DISCONNECT:ADMIN_CALL_RELEASE, "", param->disconnectinfo.cause, param->disconnectinfo.location, 0);
2170
2171 //#warning does this work? only disconnect when incoming port hat not already disconnected yet?
2172         if (e_state==EPOINT_STATE_IN_DISCONNECT && message_type!=MESSAGE_RELEASE){ // || e_state==EPOINT_STATE_OUT_DISCONNECT || e_state==EPOINT_STATE_IDLE)
2173                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are already disconnected.\n", ea_endpoint->ep_serial);
2174                 return;
2175         }
2176
2177         /* collect cause */
2178         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);
2179         collect_cause(&e_multipoint_cause, &e_multipoint_location, param->disconnectinfo.cause, param->disconnectinfo.location);
2180         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) new multipoint cause %d location %d.\n", ea_endpoint->ep_serial, e_multipoint_cause, e_multipoint_location);
2181
2182         /* check if we have more than one portlist relation and we just ignore the disconnect */
2183         if (ea_endpoint->ep_portlist) if (ea_endpoint->ep_portlist->next) {
2184                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) the disconnect was from a multipoint call. we just release that relation.\n", ea_endpoint->ep_serial);
2185                 portlist = ea_endpoint->ep_portlist;
2186                 while(portlist) {
2187                         if (portlist->port_id == port_id)
2188                                 break;
2189                         portlist = portlist->next;
2190                 }
2191                 if (!portlist)
2192                         FATAL("EPOINT(%d) no portlist related to the calling port.\n", ea_endpoint->ep_serial);
2193                 if (message_type != MESSAGE_RELEASE) {
2194                         message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_RELEASE);
2195                         message->param.disconnectinfo.cause = CAUSE_NORMAL; /* normal clearing */
2196                         message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2197                         message_put(message);
2198                         logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2199                 }
2200                 ea_endpoint->free_portlist(portlist);
2201                 return; /* one relation removed */ 
2202         }
2203         if (e_state == EPOINT_STATE_CONNECT) {
2204                 /* use cause from port after connect */
2205                 cause = param->disconnectinfo.cause;
2206                 location = param->disconnectinfo.location;
2207         } else {
2208                 /* use multipoint cause if no connect yet */
2209                 if (e_multipoint_cause) {
2210                         cause = e_multipoint_cause;
2211                         location = e_multipoint_location;
2212                 } else {
2213                         cause = CAUSE_NOUSER;
2214                         location = LOCATION_PRIVATE_LOCAL;
2215                 }
2216         }
2217
2218         unsched_timer(&e_cfnr_timeout);
2219         unsched_timer(&e_cfnr_call_timeout);
2220
2221         /* process hangup */
2222         process_hangup(e_join_cause, e_join_location);
2223         e_multipoint_cause = 0;
2224         e_multipoint_location = 0;
2225
2226         if (message_type == MESSAGE_DISCONNECT) {
2227                 /* tone to disconnected end */
2228                 SPRINT(buffer, "cause_%02x", cause);
2229                 if (ea_endpoint->ep_portlist)
2230                         set_tone(ea_endpoint->ep_portlist, buffer);
2231
2232                 new_state(EPOINT_STATE_IN_DISCONNECT);
2233         }
2234
2235         if (ea_endpoint->ep_join_id) {
2236                 int haspatterns = 0;
2237                 /* check if pattern is available */
2238                 if (ea_endpoint->ep_portlist)
2239                 if (!ea_endpoint->ep_portlist->next && ea_endpoint->ep_portlist->early_b)
2240                 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 
2241                  && message_type != MESSAGE_RELEASE) // if we release, we are done
2242                         haspatterns = 1;
2243                 if (haspatterns) {
2244                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) the port has patterns.\n", ea_endpoint->ep_serial);
2245                         /* indicate patterns */
2246                         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
2247                         message_put(message);
2248                         /* connect audio, if not already */
2249                         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2250                         message->param.audiopath = 1;
2251                         message_put(message);
2252                         /* send disconnect */
2253                         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
2254                         memcpy(&message->param, param, sizeof(union parameter));
2255                         message_put(message);
2256                         /* disable encryption if disconnected */
2257 //PERROR("REMOVE ME: state =%d, %d\n", e_crypt_state, e_crypt);
2258                         if (e_crypt_state)
2259                                 cryptman_message(CI_DISCONNECT_IND, NULL, 0);
2260                         return;
2261                 } else {
2262                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) the port has no patterns.\n", ea_endpoint->ep_serial);
2263                 }
2264         }
2265         if (message_type == MESSAGE_RELEASE)
2266                 ea_endpoint->free_portlist(portlist);
2267         release(RELEASE_ALL, location, cause, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0); /* RELEASE_TYPE, callcause, portcause */
2268         return; /* must exit here */
2269 }
2270
2271 /* port MESSAGE_TIMEOUT */
2272 void EndpointAppPBX::port_timeout(struct port_list *portlist, int message_type, union parameter *param)
2273 {
2274         char cause[16];
2275
2276         trace_header("TIMEOUT", DIRECTION_IN);
2277         message_type = MESSAGE_DISCONNECT;
2278         switch (param->state) {
2279                 case PORT_STATE_OUT_SETUP:
2280                 case PORT_STATE_OUT_OVERLAP:
2281                 add_trace("state", NULL, "outgoing setup/dialing");
2282                 end_trace();
2283                 /* no user responding */
2284                 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NOUSER, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0);
2285                 return; /* must exit here */
2286
2287                 case PORT_STATE_IN_SETUP:
2288                 case PORT_STATE_IN_OVERLAP:
2289                 add_trace("state", NULL, "incoming setup/dialing");
2290                 param->disconnectinfo.cause = CAUSE_INVALID; /* number incomplete */
2291                 param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2292                 break;
2293
2294                 case PORT_STATE_OUT_PROCEEDING:
2295                 add_trace("state", NULL, "outgoing proceeding");
2296                 end_trace();
2297                 param->disconnectinfo.cause = CAUSE_NOUSER; /* no user responding */
2298                 param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2299                 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NOUSER, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0);
2300                 return; /* must exit here */
2301
2302                 case PORT_STATE_IN_PROCEEDING:
2303                 add_trace("state", NULL, "incoming proceeding");
2304                 param->disconnectinfo.cause = CAUSE_NOUSER;
2305                 param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL; /* no user responding */
2306                 break;
2307
2308                 case PORT_STATE_OUT_ALERTING:
2309                 add_trace("state", NULL, "outgoing alerting");
2310                 end_trace();
2311                 param->disconnectinfo.cause = CAUSE_NOANSWER; /* no answer */
2312                 param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2313                 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NOANSWER, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0);
2314                 return; /* must exit here */
2315
2316                 case PORT_STATE_CONNECT:
2317                 add_trace("state", NULL, "connect");
2318                 end_trace();
2319                 param->disconnectinfo.cause = CAUSE_NORMAL; /* normal */
2320                 param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2321                 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0);
2322                 return; /* must exit here */
2323
2324                 case PORT_STATE_IN_ALERTING:
2325                 add_trace("state", NULL, "incoming alerting");
2326                 param->disconnectinfo.cause = CAUSE_NOANSWER;
2327                 param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2328                 break;
2329
2330                 case PORT_STATE_IN_DISCONNECT:
2331                 case PORT_STATE_OUT_DISCONNECT:
2332                 add_trace("state", NULL, "disconnect");
2333                 end_trace();
2334                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) in this special case, we release due to disconnect timeout.\n", ea_endpoint->ep_serial);
2335                 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0);
2336                 return; /* must exit here */
2337
2338                 default:
2339                 param->disconnectinfo.cause = 31; /* normal unspecified */
2340                 param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2341         }
2342         end_trace();
2343         /* release call, disconnect isdn */
2344         e_join_pattern = 0;
2345         new_state(EPOINT_STATE_OUT_DISCONNECT);
2346         SPRINT(cause, "cause_%02x", param->disconnectinfo.cause);
2347         SCPY(e_tone, cause);
2348         while(portlist) {
2349                 set_tone(portlist, cause);
2350                 message_disconnect_port(portlist, param->disconnectinfo.cause, param->disconnectinfo.location, "");
2351                 portlist = portlist->next;
2352         }
2353         release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0); /* RELEASE_TYPE, join, port */
2354 }
2355
2356 /* port MESSAGE_NOTIFY */
2357 void EndpointAppPBX::port_notify(struct port_list *portlist, int message_type, union parameter *param)
2358 {
2359         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
2360
2361         struct lcr_msg *message;
2362         const char *logtext = "";
2363         char buffer[64];
2364
2365         /* signal to call tool */
2366         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);
2367         if (param->notifyinfo.notify) {
2368                 e_rx_state = track_notify(e_rx_state, param->notifyinfo.notify);
2369         }
2370
2371         /* if we get notification from stack, local shows if we disabled/enabled audio stream */
2372         if (param->notifyinfo.local) switch(param->notifyinfo.notify) {
2373                 case INFO_NOTIFY_REMOTE_HOLD:
2374                 case INFO_NOTIFY_USER_SUSPENDED:
2375                 /* tell call about it */
2376                 if (ea_endpoint->ep_join_id) {
2377                         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2378                         message->param.audiopath = 0;
2379                         message_put(message);
2380                 }
2381                 break;
2382
2383                 case INFO_NOTIFY_REMOTE_RETRIEVAL:
2384                 case INFO_NOTIFY_USER_RESUMED:
2385                 /* set volume of rx and tx */
2386                 if (param->setup.callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION)
2387                 if (e_ext.tx_gain!=0 || e_ext.rx_gain!=0)
2388                 if (portlist) {
2389                         message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_mISDNSIGNAL);
2390                         message->param.mISDNsignal.message = mISDNSIGNAL_VOLUME;
2391                         message->param.mISDNsignal.rx_gain = e_ext.tx_gain;
2392                         message->param.mISDNsignal.tx_gain = e_ext.rx_gain;
2393                         message_put(message);
2394                 }
2395                 /* set current tone */
2396                 if (portlist)
2397                         set_tone(portlist, e_tone);
2398                 /* tell call about it */
2399                 if (ea_endpoint->ep_join_id) {
2400                         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2401                         message->param.audiopath = 1;
2402                         message_put(message);
2403                 }
2404                 break;
2405         }
2406
2407         /* get name of notify */
2408         switch(param->notifyinfo.notify) {
2409                 case 0x00:
2410                 logtext = "NULL";
2411                 break;
2412                 case 0x80:
2413                 logtext = "USER_SUSPENDED";
2414                 break;
2415                 case 0x82:
2416                 logtext = "BEARER_SERVICE_CHANGED";
2417                 break;
2418                 case 0x81:
2419                 logtext = "USER_RESUMED";
2420                 break;
2421                 case 0xc2:
2422                 logtext = "CONFERENCE_ESTABLISHED";
2423                 break;
2424                 case 0xc3:
2425                 logtext = "CONFERENCE_DISCONNECTED";
2426                 break;
2427                 case 0xc4:
2428                 logtext = "OTHER_PARTY_ADDED";
2429                 break;
2430                 case 0xc5:
2431                 logtext = "ISOLATED";
2432                 break;
2433                 case 0xc6:
2434                 logtext = "REATTACHED";
2435                 break;
2436                 case 0xc7:
2437                 logtext = "OTHER_PARTY_ISOLATED";
2438                 break;
2439                 case 0xc8:
2440                 logtext = "OTHER_PARTY_REATTACHED";
2441                 break;
2442                 case 0xc9:
2443                 logtext = "OTHER_PARTY_SPLIT";
2444                 break;
2445                 case 0xca:
2446                 logtext = "OTHER_PARTY_DISCONNECTED";
2447                 break;
2448                 case 0xcb:
2449                 logtext = "CONFERENCE_FLOATING";
2450                 break;
2451                 case 0xcc:
2452                 logtext = "CONFERENCE_DISCONNECTED_PREEMTED";
2453                 break;
2454                 case 0xcf:
2455                 logtext = "CONFERENCE_FLOATING_SERVED_USER_PREEMTED";
2456                 break;
2457                 case 0xe0:
2458                 logtext = "CALL_IS_A_WAITING_CALL";
2459                 break;
2460                 case 0xe8:
2461                 logtext = "DIVERSION_ACTIVATED";
2462                 break;
2463                 case 0xe9:
2464                 logtext = "RESERVED_CT_1";
2465                 break;
2466                 case 0xea:
2467                 logtext = "RESERVED_CT_2";
2468                 break;
2469                 case 0xee:
2470                 logtext = "REVERSE_CHARGING";
2471                 break;
2472                 case 0xf9:
2473                 logtext = "REMOTE_HOLD";
2474                 break;
2475                 case 0xfa:
2476                 logtext = "REMOTE_RETRIEVAL";
2477                 break;
2478                 case 0xfb:
2479                 logtext = "CALL_IS_DIVERTING";
2480                 break;
2481                 default:
2482                 SPRINT(buffer, "%d", param->notifyinfo.notify - 0x80);
2483                 logtext = buffer;
2484
2485         }
2486
2487         /* notify call if available */
2488         if (ea_endpoint->ep_join_id) {
2489                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOTIFY);
2490                 memcpy(&message->param.notifyinfo, &param->notifyinfo, sizeof(struct notify_info));
2491                 message_put(message);
2492         }
2493
2494 }
2495
2496 /* port MESSAGE_PROGRESS */
2497 void EndpointAppPBX::port_progress(struct port_list *portlist, int message_type, union parameter *param)
2498 {
2499         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
2500
2501         struct lcr_msg *message;
2502
2503         /* signal to call tool */
2504         admin_call_response(e_adminid, ADMIN_CALL_PROGRESS, "", 0, param->progressinfo.location, param->progressinfo.progress);
2505
2506         /* send progress to call if available */
2507         if (ea_endpoint->ep_join_id) {
2508                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PROGRESS);
2509                 memcpy(&message->param.progressinfo, &param->progressinfo, sizeof(struct progress_info));
2510                 message_put(message);
2511         }
2512
2513 }
2514
2515 /* port MESSAGE_FACILITY */
2516 void EndpointAppPBX::port_facility(struct port_list *portlist, int message_type, union parameter *param)
2517 {
2518         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
2519
2520         struct lcr_msg *message;
2521
2522         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_FACILITY);
2523         memcpy(&message->param.facilityinfo, &param->facilityinfo, sizeof(struct facility_info));
2524         message_put(message);
2525 }
2526
2527 /* port MESSAGE_SUSPEND */
2528 /* NOTE: before supending, the inactive-notification must be done in order to set call mixer */
2529 void EndpointAppPBX::port_suspend(struct port_list *portlist, int message_type, union parameter *param)
2530 {
2531         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
2532
2533         /* epoint is now parked */
2534         ea_endpoint->ep_park = 1;
2535         memcpy(ea_endpoint->ep_park_callid, param->parkinfo.callid, sizeof(ea_endpoint->ep_park_callid));
2536         ea_endpoint->ep_park_len = (param->parkinfo.len>8)?8:param->parkinfo.len;
2537
2538         /* remove port relation */
2539         ea_endpoint->free_portlist(portlist);
2540 }
2541
2542 /* port MESSAGE_RESUME */
2543 /* NOTE: before resume, the active-notification must be done in order to set call mixer */
2544 void EndpointAppPBX::port_resume(struct port_list *portlist, int message_type, union parameter *param)
2545 {
2546         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
2547
2548         /* epoint is now resumed */
2549         ea_endpoint->ep_park = 0;
2550
2551 }
2552
2553 /* port MESSAGE_ENABLEKEYPAD */
2554 void EndpointAppPBX::port_enablekeypad(struct port_list *portlist, int message_type, union parameter *param)
2555 {
2556         struct lcr_msg *message;
2557
2558         logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
2559
2560         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_ENABLEKEYPAD);
2561         memcpy(&message->param, param, sizeof(union parameter));
2562         message_put(message);
2563 }
2564
2565
2566 /* port sends message to the endpoint
2567  */
2568 void EndpointAppPBX::ea_message_port(unsigned int port_id, int message_type, union parameter *param)
2569 {
2570         struct port_list *portlist;
2571
2572         portlist = ea_endpoint->ep_portlist;
2573         while(portlist) {
2574                 if (port_id == portlist->port_id)
2575                         break;
2576                 portlist = portlist->next;
2577         }
2578         if (!portlist) {
2579                 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);
2580                 return;
2581         }
2582
2583 //      PDEBUG(DEBUG_EPOINT, "received message %d (terminal %s, caller id %s)\n", message, e_ext.number, e_callerinfo.id);
2584         switch(message_type) {
2585                 case MESSAGE_DATA: /* data from port */
2586                 /* check if there is a call */
2587                 if (!ea_endpoint->ep_join_id)
2588                         break;
2589                 /* continue if only one portlist */
2590                 if (ea_endpoint->ep_portlist->next != NULL)
2591                         break;
2592                 /* forward message */
2593                 message_forward(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, param);  
2594                 break;
2595
2596                 case MESSAGE_TONE_EOF: /* tone is end of file */
2597                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) current tone is now end of file.\n", ea_endpoint->ep_serial);
2598                 if (e_action) {
2599                         if (e_action->index == ACTION_VBOX_PLAY) {
2600                                 vbox_message_eof();
2601                         }
2602                         if (e_action->index == ACTION_EFI) {
2603                                 efi_message_eof();
2604                         }
2605                 }
2606                 break;
2607
2608                 case MESSAGE_TONE_COUNTER: /* counter info received */
2609                 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);
2610                 if (e_action)
2611                 if (e_action->index == ACTION_VBOX_PLAY) {
2612                         e_vbox_counter = param->counter.current;
2613                         if (param->counter.max >= 0)
2614                                 e_vbox_counter_max = param->counter.max;
2615                 }
2616                 break;
2617
2618                 /* PORT sends SETUP message */
2619                 case MESSAGE_SETUP:
2620                 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);
2621                 if (e_state!=EPOINT_STATE_IDLE) {
2622                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in idle state.\n", ea_endpoint->ep_serial);
2623                         break;
2624                 }
2625                 port_setup(portlist, message_type, param);
2626                 break;
2627
2628                 /* PORT sends INFORMATION message */
2629                 case MESSAGE_INFORMATION: /* additional digits received */
2630                 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);
2631                 port_information(portlist, message_type, param);
2632                 break;
2633
2634                 /* PORT sends FACILITY message */
2635                 case MESSAGE_FACILITY:
2636                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming facility (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
2637                 port_facility(portlist, message_type, param);
2638                 break;
2639
2640                 /* PORT sends DTMF message */
2641                 case MESSAGE_DTMF: /* dtmf digits received */
2642                 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);
2643                 port_dtmf(portlist, message_type, param);
2644                 break;
2645
2646                 /* PORT sends CRYPT message */
2647                 case MESSAGE_CRYPT: /* crypt response received */
2648                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) crypt response=%d\n", ea_endpoint->ep_serial, param->crypt.type);
2649                 port_crypt(portlist, message_type, param);
2650                 break;
2651
2652                 /* PORT sends MORE message */
2653                 case MESSAGE_OVERLAP:
2654                 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);
2655                 if (e_state != EPOINT_STATE_OUT_SETUP) {
2656                         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);
2657                         break;
2658                 }
2659                 port_overlap(portlist, message_type, param);
2660                 break;
2661
2662                 /* PORT sends PROCEEDING message */
2663                 case MESSAGE_PROCEEDING: /* port is proceeding */
2664                 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);
2665                 if (e_state!=EPOINT_STATE_OUT_SETUP
2666                  && e_state!=EPOINT_STATE_OUT_OVERLAP) {
2667                         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);
2668                         break;
2669                 }
2670                 port_proceeding(portlist, message_type, param);
2671                 break;
2672
2673                 /* PORT sends ALERTING message */
2674                 case MESSAGE_ALERTING:
2675                 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);
2676                 if (e_state!=EPOINT_STATE_OUT_SETUP
2677                  && e_state!=EPOINT_STATE_OUT_OVERLAP
2678                  && e_state!=EPOINT_STATE_OUT_PROCEEDING) {
2679                         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);
2680                         break;
2681                 }
2682                 port_alerting(portlist, message_type, param);
2683                 break;
2684
2685                 /* PORT sends CONNECT message */
2686                 case MESSAGE_CONNECT:
2687                 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);
2688                 if (e_state!=EPOINT_STATE_OUT_SETUP
2689                  && e_state!=EPOINT_STATE_OUT_OVERLAP
2690                  && e_state!=EPOINT_STATE_OUT_PROCEEDING
2691                  && e_state!=EPOINT_STATE_OUT_ALERTING) {
2692                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup, proceeding or alerting state.\n", ea_endpoint->ep_serial);
2693                         break;
2694                 }
2695                 port_connect(portlist, message_type, param);
2696                 break;
2697
2698                 /* PORT sends DISCONNECT message */
2699                 case MESSAGE_DISCONNECT: /* port is disconnected */
2700                 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);
2701                 port_disconnect_release(portlist, message_type, param);
2702                 break;
2703
2704                 /* PORT sends a RELEASE message */
2705                 case MESSAGE_RELEASE: /* port releases */
2706                 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);
2707                 /* portlist is release at port_disconnect_release, thanx Paul */
2708                 port_disconnect_release(portlist, message_type, param);
2709                 break;
2710
2711                 /* PORT sends a TIMEOUT message */
2712                 case MESSAGE_TIMEOUT:
2713                 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);
2714                 port_timeout(portlist, message_type, param);
2715                 break; /* release */
2716
2717                 /* PORT sends a NOTIFY message */
2718                 case MESSAGE_NOTIFY:
2719                 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);
2720                 port_notify(portlist, message_type, param);
2721                 break;
2722
2723                 /* PORT sends a PROGRESS message */
2724                 case MESSAGE_PROGRESS:
2725                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received progress.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
2726                 port_progress(portlist, message_type, param);
2727                 break;
2728
2729                 /* PORT sends a SUSPEND message */
2730                 case MESSAGE_SUSPEND:
2731                 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);
2732                 port_suspend(portlist, message_type, param);
2733                 break; /* suspend */
2734
2735                 /* PORT sends a RESUME message */
2736                 case MESSAGE_RESUME:
2737                 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);
2738                 port_resume(portlist, message_type, param);
2739                 break;
2740
2741 #if 0
2742                 kann nach dem test gelöscht werden, da eine direkte funktion im join und im mISDN zum austausch der message existiert
2743                 /* port assigns bchannel */
2744                 case MESSAGE_BCHANNEL: /* bchannel assignment messafe */
2745                 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);
2746                 /* only one port is expected to be connected to bchannel */
2747                 message = message_forward(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, param);
2748                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_IN);
2749                 break;
2750 #endif
2751
2752                 /* PORT requests DTMF */
2753                 case MESSAGE_ENABLEKEYPAD:
2754                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') requests DTMF/KEYPAD.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
2755                 port_enablekeypad(portlist, message_type, param);
2756                 break;
2757
2758
2759                 default:
2760                 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);
2761         }
2762
2763         /* Note: this endpoint may be destroyed, so we MUST return */
2764 }
2765
2766
2767 /* messages from join
2768  */
2769 /* join MESSAGE_CRYPT */
2770 void EndpointAppPBX::join_crypt(struct port_list *portlist, int message_type, union parameter *param)
2771 {
2772         switch(param->crypt.type) {
2773                 /* message from remote port to "crypt manager" */
2774                 case CU_ACTK_REQ:           /* activate key-exchange */
2775                 case CU_ACTS_REQ:            /* activate shared key */
2776                 case CU_DACT_REQ:          /* deactivate */
2777                 case CU_INFO_REQ:         /* request last info message */
2778                 cryptman_message(param->crypt.type, param->crypt.data, param->crypt.len);
2779                 break;
2780
2781                 /* message from "crypt manager" to user */
2782                 case CU_ACTK_CONF:          /* key-echange done */
2783                 case CU_ACTS_CONF:          /* shared key done */
2784                 case CU_DACT_CONF:           /* deactivated */
2785                 case CU_DACT_IND:           /* deactivated */
2786                 case CU_ERROR_IND:         /* receive error message */
2787                 case CU_INFO_IND:         /* receive info message */
2788                 case CU_INFO_CONF:         /* receive info message */
2789                 encrypt_result(param->crypt.type, (char *)param->crypt.data);
2790                 break;
2791
2792                 default:
2793                 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);
2794         }
2795 }
2796
2797 /* join MESSAGE_INFORMATION */
2798 void EndpointAppPBX::join_information(struct port_list *portlist, int message_type, union parameter *param)
2799 {
2800         struct lcr_msg *message;
2801
2802         e_overlap = 1;
2803
2804         while(portlist) {
2805                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_INFORMATION);
2806                 memcpy(&message->param.information, &param->information, sizeof(struct dialing_info));
2807                 message_put(message);
2808                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2809                 portlist = portlist->next;
2810         }
2811 }
2812
2813 /* join MESSAGE_FACILITY */
2814 void EndpointAppPBX::join_facility(struct port_list *portlist, int message_type, union parameter *param)
2815 {
2816         struct lcr_msg *message;
2817
2818         if (!e_ext.facility && e_ext.number[0]) {
2819                 return;
2820         }
2821
2822         while(portlist) {
2823                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_FACILITY);
2824                 memcpy(&message->param.facilityinfo, &param->facilityinfo, sizeof(struct facility_info));
2825                 message_put(message);
2826                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2827                 portlist = portlist->next;
2828         }
2829 }
2830
2831 /* join MESSAGE_MORE */
2832 void EndpointAppPBX::join_overlap(struct port_list *portlist, int message_type, union parameter *param)
2833 {
2834         struct lcr_msg *message;
2835
2836         new_state(EPOINT_STATE_IN_OVERLAP);
2837         
2838         /* own dialtone */
2839         if (e_join_pattern && e_ext.own_setup) {
2840                 /* disconnect audio */
2841                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2842                 message->param.audiopath = 0;
2843                 message_put(message);
2844         }
2845         if (e_action) if (e_action->index == ACTION_OUTDIAL || e_action->index == ACTION_EXTERNAL) {
2846                         if (e_dialinginfo.id[0])
2847                                 set_tone(portlist, "dialing");
2848                         else
2849                                 set_tone(portlist, "dialtone");
2850                         return;
2851         }
2852         if (e_dialinginfo.id[0]) {
2853                 set_tone(portlist, "dialing");
2854         } else {
2855                 if (e_ext.number[0])
2856                         set_tone(portlist, "dialpbx");
2857                 else
2858                         set_tone(portlist, "dialtone");
2859         }
2860 }
2861
2862 /* join MESSAGE_PROCEEDING */
2863 void EndpointAppPBX::join_proceeding(struct port_list *portlist, int message_type, union parameter *param)
2864 {
2865         struct lcr_msg *message;
2866
2867         new_state(EPOINT_STATE_IN_PROCEEDING);
2868
2869         /* own proceeding tone */
2870         if (e_join_pattern) {
2871                 /* connect / disconnect audio */
2872                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2873                 if (e_ext.own_proceeding)
2874                         message->param.audiopath = 0;
2875                 else
2876                         message->param.audiopath = 1;
2877                 message_put(message);
2878         }
2879 //                      UCPY(e_join_tone, "proceeding");
2880         if (portlist) {
2881                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
2882                 message_put(message);
2883                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2884         }
2885         set_tone(portlist, "proceeding");
2886 }
2887
2888 /* join MESSAGE_ALERTING */
2889 void EndpointAppPBX::join_alerting(struct port_list *portlist, int message_type, union parameter *param)
2890 {
2891         struct lcr_msg *message;
2892
2893         new_state(EPOINT_STATE_IN_ALERTING);
2894
2895         /* own alerting tone */
2896         if (e_join_pattern) {
2897                 /* connect / disconnect audio */
2898                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2899                 if (e_ext.own_alerting)
2900                         message->param.audiopath = 0;
2901                 else
2902                         message->param.audiopath = 1;
2903                 message_put(message);
2904         }
2905         if (portlist) {
2906                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_ALERTING);
2907                 message_put(message);
2908                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2909         }
2910         if (e_action) if (e_action->index == ACTION_OUTDIAL || e_action->index == ACTION_EXTERNAL) {
2911                 set_tone(portlist, "ringing");
2912                 return;
2913         }
2914         if (e_ext.number[0])
2915                 set_tone(portlist, "ringpbx");
2916         else
2917                 set_tone(portlist, "ringing");
2918
2919         if (e_ext.number[0])
2920                 e_dtmf = 1; /* allow dtmf */
2921 }
2922
2923 /* join MESSAGE_CONNECT */
2924 void EndpointAppPBX::join_connect(struct port_list *portlist, int message_type, union parameter *param)
2925 {
2926         struct lcr_msg *message;
2927         time_t now;
2928
2929         new_state(EPOINT_STATE_CONNECT);
2930 //                      UCPY(e_join_tone, "");
2931 //                      
2932         if (e_ext.number[0])
2933                 e_dtmf = 1; /* allow dtmf */
2934
2935         e_powerdial_on = 0;
2936         unsched_timer(&e_powerdial_timeout);
2937         memcpy(&e_connectinfo, &param->connectinfo, sizeof(e_callerinfo));
2938         if(portlist) {
2939                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
2940                 memcpy(&message->param, param, sizeof(union parameter));
2941
2942                 /* screen clip if prefix is required */
2943                 if (e_ext.number[0] && message->param.connectinfo.id[0] && e_ext.clip_prefix[0]) {
2944                         SCPY(message->param.connectinfo.id, e_ext.clip_prefix);
2945                         SCAT(message->param.connectinfo.id, numberrize_callerinfo(e_connectinfo.id,e_connectinfo.ntype, options.national, options.international));
2946                         message->param.connectinfo.ntype = INFO_NTYPE_UNKNOWN;
2947                 }
2948
2949                 /* use internal caller id */
2950                 if (e_ext.number[0] && e_connectinfo.extension[0] && (message->param.connectinfo.present!=INFO_PRESENT_RESTRICTED || e_ext.anon_ignore)) {
2951                         SCPY(message->param.connectinfo.id, e_connectinfo.extension);
2952                         message->param.connectinfo.ntype = INFO_NTYPE_UNKNOWN;
2953                 }
2954
2955                 /* handle restricted caller ids */
2956                 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);
2957                 /* display callerid if desired for extension */
2958                 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));
2959
2960                 /* use conp, if enabld */
2961 //              if (!e_ext.centrex)
2962 //                      message->param.connectinfo.name[0] = '\0';
2963
2964                 /* send connect */
2965                 message_put(message);
2966                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2967         }
2968         set_tone(portlist, NULL);
2969         e_join_pattern = 0;
2970         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
2971         message->param.audiopath = 1;
2972         message_put(message);
2973         time(&now);
2974         e_start = now;
2975 }
2976
2977 /* join MESSAGE_DISCONNECT MESSAGE_RELEASE */
2978 void EndpointAppPBX::join_disconnect_release(int message_type, union parameter *param)
2979 {
2980         char cause[16];
2981         struct lcr_msg *message;
2982         struct port_list *portlist = NULL;
2983         time_t now;
2984
2985
2986         /* be sure that we are active */
2987         notify_active();
2988         e_tx_state = NOTIFY_STATE_ACTIVE;
2989
2990         /* we are powerdialing, if e_powerdial_on is set and limit is not exceeded if given */
2991         if (e_powerdial_on && ((e_powercount+1)<e_powerlimit || e_powerlimit<1)) {
2992                 release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL,0 ); /* RELEASE_TYPE, join, port */
2993
2994                 /* set time for power dialing */
2995                 schedule_timer(&e_powerdial_timeout, (int)e_powerdelay, 0); /* set redial in the future */
2996                 e_powercount++;
2997
2998                 /* set redial tone */
2999                 if (ea_endpoint->ep_portlist) {
3000                         e_join_pattern = 0;
3001                 }
3002                 set_tone(ea_endpoint->ep_portlist, "redial");
3003                 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);
3004                 /* send proceeding when powerdialing and still setup (avoid dialing timeout) */
3005                 if (e_state==EPOINT_STATE_IN_OVERLAP) {
3006                         new_state(EPOINT_STATE_IN_PROCEEDING);
3007                         if (ea_endpoint->ep_portlist) {
3008                                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
3009                                 message_put(message);
3010                                 logmessage(message->type, &message->param, ea_endpoint->ep_portlist->port_id, DIRECTION_OUT);
3011                         }
3012 /* caused the error, that the first knock sound was not there */
3013 /*                                      set_tone(portlist, "proceeding"); */
3014                 }
3015                 /* send display of powerdialing */
3016                 if (e_ext.display_dialing) {
3017                         portlist = ea_endpoint->ep_portlist;
3018                         while (portlist) {
3019                                 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
3020                                 if (e_powerlimit)
3021                                         SPRINT(message->param.notifyinfo.display, "Retry %d of %d", e_powercount, e_powerlimit);
3022                                 else
3023                                         SPRINT(message->param.notifyinfo.display, "Retry %d", e_powercount);
3024                                 message_put(message);
3025                                 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
3026                                 portlist = portlist->next;
3027                         }
3028                 }
3029                 return;
3030         }
3031
3032         /* set stop time */
3033         time(&now);
3034         e_stop = now;
3035
3036         if ((e_state!=EPOINT_STATE_CONNECT
3037           && e_state!=EPOINT_STATE_OUT_DISCONNECT
3038           && e_state!=EPOINT_STATE_IN_OVERLAP
3039           && e_state!=EPOINT_STATE_IN_PROCEEDING
3040           && e_state!=EPOINT_STATE_IN_ALERTING)
3041          || !ea_endpoint->ep_portlist) { /* or no port */
3042                 process_hangup(param->disconnectinfo.cause, param->disconnectinfo.location);
3043                 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, param->disconnectinfo.cause, 0); /* RELEASE_TYPE, join, port */
3044                 return; /* must exit here */
3045         }
3046         /* save cause */
3047         if (!e_join_cause) {
3048                 e_join_cause = param->disconnectinfo.cause;
3049                 e_join_location = param->disconnectinfo.location;
3050         }
3051
3052         /* on release we need the audio again! */
3053         if (message_type == MESSAGE_RELEASE) {
3054                 e_join_pattern = 0;
3055                 ea_endpoint->ep_join_id = 0;
3056         }
3057         /* disconnect and select tone */
3058         new_state(EPOINT_STATE_OUT_DISCONNECT);
3059         SPRINT(cause, "cause_%02x", param->disconnectinfo.cause);
3060         /* if own_cause, we must release the join */
3061         if (e_ext.own_cause /* own cause */
3062          || !e_join_pattern) { /* no patterns */
3063                 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);
3064                 if (message_type != MESSAGE_RELEASE)
3065                         release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0); /* RELEASE_TYPE, join, port */
3066                 e_join_pattern = 0;
3067         } else { /* else we enable audio */
3068                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
3069                 message->param.audiopath = 1;
3070                 message_put(message);
3071         }
3072         /* send disconnect message */
3073         SCPY(e_tone, cause);
3074         portlist = ea_endpoint->ep_portlist;
3075         while(portlist) {
3076                 set_tone(portlist, cause);
3077                 message_disconnect_port(portlist, param->disconnectinfo.cause, param->disconnectinfo.location, "");
3078                 portlist = portlist->next;
3079         }
3080 }