socket mISDN work
[lcr.git] / dss1.cpp
1 /*****************************************************************************\
2 **                                                                           **
3 ** PBX4Linux                                                                 **
4 **                                                                           **
5 **---------------------------------------------------------------------------**
6 ** Copyright: Andreas Eversberg                                              **
7 **                                                                           **
8 ** mISDN dss1                                                                **
9 **                                                                           **
10 \*****************************************************************************/ 
11
12 #include "main.h"
13 #include "myisdn.h"
14 #ifndef SOCKET_MISDN
15 // old mISDN
16 extern "C" {
17 #include <mISDNuser/net_l2.h>
18 }
19 #else
20 // socket mISDN
21 #include <sys/socket.h>
22 extern "C" {
23 }
24 #include <q931.h>
25 extern unsigned long mt_assign_pid;
26 #endif
27
28 #include "ie.cpp"
29
30 /*
31  * constructor
32  */
33 Pdss1::Pdss1(int type, struct mISDNport *mISDNport, char *portname, struct port_settings *settings, int channel, int exclusive) : PmISDN(type, mISDNport, portname, settings, channel, exclusive)
34 {
35         p_callerinfo.itype = (mISDNport->ifport->interface->extension)?INFO_ITYPE_ISDN_EXTENSION:INFO_ITYPE_ISDN;
36         p_m_d_ntmode = mISDNport->ntmode;
37         p_m_d_l3id = 0;
38         p_m_d_ces = -1;
39         p_m_d_queue = NULL;
40         p_m_d_notify_pending = NULL;
41         p_m_d_collect_cause = 0;
42         p_m_d_collect_location = 0;
43
44         PDEBUG(DEBUG_ISDN, "Created new mISDNPort(%s). Currently %d objects use, %s port #%d\n", portname, mISDNport->use, (mISDNport->ntmode)?"NT":"TE", p_m_portnum);
45 }
46
47
48 /*
49  * destructor
50  */
51 Pdss1::~Pdss1()
52 {
53         /* remove queued message */
54         if (p_m_d_queue)
55                 message_free(p_m_d_queue);
56
57         if (p_m_d_notify_pending)
58                 message_free(p_m_d_notify_pending);
59
60 #ifndef SOCKET_MISDN
61         /* check how many processes are left */
62         if (p_m_d_ntmode == 1)
63         {
64                 if (p_m_mISDNport->nst.layer3->proc)
65                         PDEBUG(DEBUG_ISDN, "destroyed mISDNPort(%s). WARNING: There is still a layer 3 process left. Ignore this, if currently are other calls. This message is not an error!\n", p_name);
66         }
67 #endif
68 }
69
70
71 /*
72  * create layer 3 message
73  */
74 #ifdef SOCKET_MISDN
75 static struct l3_msg *create_l3msg(void)
76 #else
77 static msg_t *create_l3msg(int prim, int mt, int dinfo, int size, int ntmode)
78 #endif
79 {
80 #ifdef SOCKET_MISDN
81         struct l3_msg *l3m;
82
83         l3m = alloc_l3_msg();
84         if (l3m)
85                 return(l3m);
86 #else
87         msg_t *dmsg;
88         Q931_info_t *qi;
89         iframe_t *frm;
90
91         if (!ntmode)
92                 size = sizeof(Q931_info_t)+2;
93
94         if (ntmode)
95         {
96                 dmsg = prep_l3data_msg(prim, dinfo, size, 256, NULL);
97                 if (dmsg)
98                 {
99                         return(dmsg);
100                 }
101         } else
102         {
103                 dmsg = alloc_msg(size+256+mISDN_HEADER_LEN+DEFAULT_HEADROOM);
104                 if (dmsg)
105                 {
106                         memset(msg_put(dmsg,size+mISDN_HEADER_LEN), 0, size+mISDN_HEADER_LEN);
107                         frm = (iframe_t *)dmsg->data;
108                         frm->prim = prim;
109                         frm->dinfo = dinfo;
110                         qi = (Q931_info_t *)(dmsg->data + mISDN_HEADER_LEN);
111                         qi->type = mt;
112                         return(dmsg);
113                 }
114         }
115 #endif
116
117         FATAL("Cannot allocate memory, system overloaded.\n");
118         exit(0); // make gcc happy
119 }
120
121 #ifndef SOCKET_MISDN
122 msg_t *create_l2msg(int prim, int dinfo, int size) /* NT only */
123 {
124         msg_t *dmsg;
125
126         dmsg = prep_l3data_msg(prim, dinfo, size, 256, NULL);
127         if (dmsg)
128                 return(dmsg);
129
130         FATAL("Cannot allocate memory, system overloaded.\n");
131         exit(0); // make gcc happy
132 }
133 #endif
134
135 /*
136  * if we received a first reply to the setup message,
137  * we will check if we have now channel information 
138  * return: <0: error, call is released, -cause is given
139  *          0: ok, nothing to do
140  */
141 #ifdef SOCKET_MISDN
142 int Pdss1::received_first_reply_to_setup(unsigned long cmd, int channel, int exclusive)
143 #else
144 int Pdss1::received_first_reply_to_setup(unsigned long prim, int channel, int exclusive)
145 #endif
146 {
147         int ret;
148 #ifdef SOCKET_MISDN
149         l3_msg *l3m;
150 #else
151         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
152         RELEASE_COMPLETE_t *release_complete;
153         msg_t *dmsg;
154 #endif
155
156         /* correct exclusive to 0, if no explicit channel was given */
157         if (exclusive<0 || channel<=0)
158                 exclusive = 0;
159         
160         /* select scenario */
161         if (p_m_b_channel && p_m_b_exclusive)
162         {
163                 /*** we gave an exclusive channel (or if we are done) ***/
164
165                 /* if not first reply, we are done */
166                 if (p_state != PORT_STATE_OUT_SETUP)
167                         return(0);
168
169                 chan_trace_header(p_m_mISDNport, this, "CHANNEL SELECTION (first reply to setup)", DIRECTION_NONE);
170                 add_trace("channel", "request", "%d (forced)", p_m_b_channel);
171                 add_trace("channel", "reply", (channel>=0)?"%d":"(none)", channel);
172
173                 /* if give channel not accepted or not equal */
174                 if (channel!=-1 && p_m_b_channel!=channel)
175                 {
176                         add_trace("conclusion", NULL, "forced channel not accepted");
177                         end_trace();
178                         ret = -44;
179                         goto channelerror;
180                 }
181
182                 add_trace("conclusion", NULL, "channel was accepted");
183                 add_trace("connect", "channel", "%d", p_m_b_channel);
184                 end_trace();
185
186                 /* activate our exclusive channel */
187                 bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_USE);
188         } else
189         if (p_m_b_channel)
190         {
191                 /*** we gave a non-exclusive channel ***/
192
193                 /* if not first reply, we are done */
194                 if (p_state != PORT_STATE_OUT_SETUP)
195                         return(0);
196
197                 chan_trace_header(p_m_mISDNport, this, "CHANNEL SELECTION (first reply to setup)", DIRECTION_NONE);
198                 add_trace("channel", "request", "%d (suggest)", p_m_b_channel);
199                 add_trace("channel", "reply", (channel>=0)?"%d":"(none)", channel);
200
201                 /* if channel was accepted as given */
202                 if (channel==-1 || p_m_b_channel==channel)
203                 {
204                         add_trace("conclusion", NULL, "channel was accepted as given");
205                         add_trace("connect", "channel", "%d", p_m_b_channel);
206                         end_trace();
207                         p_m_b_exclusive = 1; // we are done
208                         bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_USE);
209                         return(0);
210                 }
211
212                 /* if channel value is faulty */
213                 if (channel <= 0)
214                 {
215                         add_trace("conclusion", NULL, "illegal reply");
216                         end_trace();
217                         ret = -111; // protocol error
218                         goto channelerror;
219                 }
220
221                 /* if channel was not accepted, try to get it */
222                 ret = seize_bchannel(channel, 1); // exclusively
223                 add_trace("channel", "available", ret<0?"no":"yes");
224                 if (ret < 0)
225                 {
226                         add_trace("conclusion", NULL, "replied channel not available");
227                         end_trace();
228                         goto channelerror;
229                 }
230                 add_trace("conclusion", NULL, "replied channel accepted");
231                 add_trace("connect", "channel", "%d", p_m_b_channel);
232                 end_trace();
233
234                 /* activate channel given by remote */
235                 bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_USE);
236         } else
237         if (p_m_b_reserve)
238         {
239                 /*** we sent 'any channel acceptable' ***/
240
241                 /* if not first reply, we are done */
242                 if (p_state != PORT_STATE_OUT_SETUP)
243                         return(0);
244
245                 chan_trace_header(p_m_mISDNport, this, "CHANNEL SELECTION (first reply to setup)", DIRECTION_NONE);
246                 add_trace("channel", "request", "any");
247                 add_trace("channel", "reply", (channel>=0)?"%d":"(none)", channel);
248                 /* if no channel was replied */
249                 if (channel <= 0)
250                 {
251                         add_trace("conclusion", NULL, "no channel, protocol error");
252                         end_trace();
253                         ret = -111; // protocol error
254                         goto channelerror;
255                 }
256
257                 /* we will see, if our received channel is available */
258                 ret = seize_bchannel(channel, 1); // exclusively
259                 add_trace("channel", "available", ret<0?"no":"yes");
260                 if (ret < 0)
261                 {
262                         add_trace("conclusion", NULL, "replied channel not available");
263                         end_trace();
264                         goto channelerror;
265                 }
266                 add_trace("conclusion", NULL, "replied channel accepted");
267                 add_trace("connect", "channel", "%d", p_m_b_channel);
268                 end_trace();
269
270                 /* activate channel given by remote */
271                 bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_USE);
272         } else
273         {
274                 /*** we sent 'no channel available' ***/
275
276                 /* if not the first reply, but a connect, we are forced */
277 #ifdef SOCKET_MISDN
278                 if (cmd==MT_CONNECT && p_state!=PORT_STATE_OUT_SETUP)
279 #else
280                 if (prim==(CC_CONNECT | INDICATION) && p_state!=PORT_STATE_OUT_SETUP)
281 #endif
282                 {
283                         chan_trace_header(p_m_mISDNport, this, "CHANNEL SELECTION (connect)", DIRECTION_NONE);
284                         add_trace("channel", "request", "no-channel");
285                         add_trace("channel", "reply", (channel>=0)?"%d%s":"(none)", channel, exclusive?" (forced)":"");
286                         if (channel > 0)
287                         {
288                                 goto use_from_connect;
289                         }
290                         ret = seize_bchannel(CHANNEL_ANY, 0); // any channel
291                         add_trace("channel", "available", ret<0?"no":"yes");
292                         if (ret < 0)
293                         {
294                                 add_trace("conclusion", NULL, "no channel available during call-waiting");
295                                 end_trace();
296                                 goto channelerror;
297                         }
298                         add_trace("conclusion", NULL, "using channel %d", p_m_b_channel);
299                         add_trace("connect", "channel", "%d", p_m_b_channel);
300                         end_trace();
301                         p_m_b_exclusive = 1; // we are done
302
303                         /* activate channel given by remote */
304                         bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_USE);
305                         return(0);
306                 }
307                 
308                 /* if not first reply, we are done */
309                 if (p_state != PORT_STATE_OUT_SETUP)
310                         return(0);
311
312                 chan_trace_header(p_m_mISDNport, this, "CHANNEL SELECTION (first reply to setup)", DIRECTION_NONE);
313                 add_trace("channel", "request", "no-channel");
314                 add_trace("channel", "reply", (channel>=0)?"%d":"(none)", channel);
315                 /* if first reply has no channel, we are done */
316                 if (channel <= 0)
317                 {
318                         add_trace("conclusion", NULL, "no channel until connect");
319                         end_trace();
320                         return(0);
321                 }
322
323                 /* we will see, if our received channel is available */
324                 use_from_connect:
325                 ret = seize_bchannel(channel, exclusive);
326                 add_trace("channel", "available", ret<0?"no":"yes");
327                 if (ret < 0)
328                 {
329                         add_trace("conclusion", NULL, "replied channel not available");
330                         end_trace();
331                         goto channelerror;
332                 }
333                 add_trace("conclusion", NULL, "replied channel accepted");
334                 add_trace("connect", "channel", "%d", p_m_b_channel);
335                 end_trace();
336                 p_m_b_exclusive = 1; // we are done
337
338                 /* activate channel given by remote */
339                 bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_USE);
340         }
341         return(0);
342
343         channelerror:
344         /*
345          * NOTE: we send MT_RELEASE_COMPLETE to "REJECT" the channel
346          * in response to the setup reply
347          */
348 #ifdef SOCKET_MISDN
349         l3m = create_l3msg();
350 #else
351         dmsg = create_l3msg(CC_RELEASE_COMPLETE | REQUEST, MT_RELEASE_COMPLETE, p_m_d_l3id, sizeof(RELEASE_COMPLETE_t), p_m_d_ntmode);
352         release_complete = (RELEASE_COMPLETE_t *)(dmsg->data + headerlen);
353 #endif
354         l1l2l3_trace_header(p_m_mISDNport, this, L3_RELEASE_COMPLETE_REQ, DIRECTION_OUT);
355 #ifdef SOCKET_MISDN
356         enc_ie_cause(l3m, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, -ret);
357 #else
358         enc_ie_cause(&release_complete->CAUSE, dmsg, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, -ret);
359 #endif
360         end_trace();
361 #ifdef SOCKET_MISDN
362         p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_RELEASE_COMPLETE, p_m_d_l3id, l3m);
363 #else
364         msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
365 #endif
366         new_state(PORT_STATE_RELEASE);
367         p_m_delete = 1;
368         return(-34); /* to epoint: no channel available */
369 }
370
371
372 /*
373  * hunt bchannel for incoming setup or retrieve or resume
374  */
375 int Pdss1::hunt_bchannel(int channel, int exclusive)
376 {
377         struct select_channel *selchannel;
378         struct interface_port *ifport = p_m_mISDNport->ifport;
379         int i;
380
381         chan_trace_header(p_m_mISDNport, this, "CHANNEL SELECTION (setup)", DIRECTION_NONE);
382         if (exclusive<0)
383                 exclusive = 0;
384         if (channel == CHANNEL_NO)
385                 add_trace("channel", "request", "no-channel");
386         else
387                 add_trace("channel", "request", (channel>0)?"%d%s":"any", channel, exclusive?" (forced)":"");
388         if (channel==CHANNEL_NO && p_type==PORT_TYPE_DSS1_TE_IN)
389         {
390                 add_trace("conclusion", NULL, "incoming call-waiting not supported for TE-mode");
391                 end_trace();
392                 return(-6); // channel unacceptable
393         }
394         if (channel <= 0) /* not given, no channel, whatever.. */
395                 channel = CHANNEL_ANY; /* any channel */
396         add_trace("channel", "reserved", "%d", p_m_mISDNport->b_reserved);
397         if (p_m_mISDNport->b_reserved >= p_m_mISDNport->b_num) // of out chan..
398         {
399                 add_trace("conclusion", NULL, "all channels are reserved");
400                 end_trace();
401                 return(-34); // no channel
402         }
403         if (channel == CHANNEL_ANY)
404                 goto get_from_list;
405         if (channel > 0)
406         {
407                 /* check for given channel in selection list */
408                 selchannel = ifport->in_channel;
409                 while(selchannel)
410                 {
411                         if (selchannel->channel == channel || selchannel->channel == CHANNEL_FREE)
412                                 break;
413                         selchannel = selchannel->next;
414                 }
415                 if (!selchannel)
416                         channel = 0;
417
418                 /* exclusive channel requests must be in the list */
419                 if (exclusive)
420                 {
421                         if (!channel)
422                         {
423                                 add_trace("conclusion", NULL, "exclusively requested channel not in list");
424                                 end_trace();
425                                 return(-6); // channel unacceptable
426                         }
427                         i = selchannel->channel-1-(selchannel->channel>=17);
428                         if (p_m_mISDNport->b_port[i] == NULL)
429                                 goto use_channel;
430                         add_trace("conclusion", NULL, "exclusively requested channel is busy");
431                         end_trace();
432                         return(-6); // channel unacceptable
433                 }
434
435                 /* requested channels in list will be used */
436                 if (channel)
437                 {
438                         i = selchannel->channel-1-(selchannel->channel>=17);
439                         if (p_m_mISDNport->b_port[i] == NULL)
440                                 goto use_channel;
441                 }
442
443                 /* if channel is not available or not in list, it must be searched */
444                 get_from_list:
445                 /* check for first free channel in list */
446                 channel = 0;
447                 selchannel = ifport->in_channel;
448                 while(selchannel)
449                 {
450                         switch(selchannel->channel)
451                         {
452                                 case CHANNEL_FREE: /* free channel */
453                                 add_trace("hunting", "channel", "free");
454                                 if (p_m_mISDNport->b_reserved >= p_m_mISDNport->b_num)
455                                         break; /* all channel in use or reserverd */
456                                 /* find channel */
457                                 i = 0;
458                                 while(i < p_m_mISDNport->b_num)
459                                 {
460                                         if (p_m_mISDNport->b_port[i] == NULL)
461                                         {
462                                                 channel = i+1+(i>=15);
463                                                 break;
464                                         }
465                                         i++;
466                                 }
467                                 break;
468
469                                 default:
470                                 add_trace("hunting", "channel", "%d", selchannel->channel);
471                                 if (selchannel->channel<1 || selchannel->channel==16)
472                                         break; /* invalid channels */
473                                 i = selchannel->channel-1-(selchannel->channel>=17);
474                                 if (i >= p_m_mISDNport->b_num)
475                                         break; /* channel not in port */
476                                 if (p_m_mISDNport->b_port[i] == NULL)
477                                 {
478                                         channel = selchannel->channel;
479                                         break;
480                                 }
481                                 break;
482                         }
483                         if (channel)
484                                 break; /* found channel */
485                         selchannel = selchannel->next;
486                 }
487                 if (!channel)
488                 {
489                         add_trace("conclusion", NULL, "no channel available");
490                         end_trace();
491                         return(-6); // channel unacceptable
492                 }
493         }
494 use_channel:
495         add_trace("conclusion", NULL, "channel available");
496         add_trace("connect", "channel", "%d", channel);
497         end_trace();
498         return(channel);
499 }
500
501 /*
502  * handles all indications
503  */
504 /* CC_SETUP INDICATION */
505 #ifdef SOCKET_MISDN
506 void Pdss1::setup_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
507 {
508 #else
509 void Pdss1::setup_ind(unsigned long prim, unsigned long dinfo, void *data)
510 {
511         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
512         msg_t *dmsg;
513         SETUP_t *setup = (SETUP_t *)((unsigned long)data + headerlen);
514 #endif
515         int calling_type, calling_plan, calling_present, calling_screen;
516         int called_type, called_plan;
517         int redir_type, redir_plan, redir_present, redir_screen, redir_reason;
518         int hlc_coding, hlc_presentation, hlc_interpretation, hlc_hlc, hlc_exthlc;
519         int bearer_coding, bearer_capability, bearer_mode, bearer_rate, bearer_multi, bearer_user;
520         int exclusive, channel;
521         int ret;
522         unsigned char keypad[32] = "";
523         unsigned char useruser[128];
524         int useruser_len = 0, useruser_protocol;
525         class Endpoint *epoint;
526         struct message *message;
527
528 #ifdef SOCKET_MISDN
529         /* process given callref */
530         l1l2l3_trace_header(p_m_mISDNport, this, L3_NEW_L3ID_IND, DIRECTION_IN);
531         add_trace("callref", "new", "0x%x", pid);
532         if (p_m_d_l3id != pid)
533         {
534                 /* release in case the ID is already in use */
535                 add_trace("error", NULL, "callref already in use");
536                 end_trace();
537                 l3m = create_l3msg();
538                 l1l2l3_trace_header(p_m_mISDNport, this, L3_RELEASE_COMPLETE_REQ, DIRECTION_OUT);
539                 enc_ie_cause(l3m, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, 47);
540                 add_trace("reason", NULL, "callref already in use");
541                 end_trace();
542                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_RELEASE_COMPLETE, pid, l3m);
543                 new_state(PORT_STATE_RELEASE);
544                 p_m_delete = 1;
545                 return;
546         }
547         p_m_d_l3id = pid;
548         p_m_d_ces = pid >> 16;
549         end_trace();
550 #else
551         /* callref from nt-lib */
552         if (p_m_d_ntmode)
553         {
554                 /* nt-library now gives us the id via CC_SETUP */
555                 if (dinfo&(~0xff) == 0xff00)
556                         FATAL("l3-stack gives us a process id 0xff00-0xffff\n");
557                 l1l2l3_trace_header(p_m_mISDNport, this, L3_NEW_CR_IND, DIRECTION_IN);
558                 if (p_m_d_l3id)
559                         add_trace("callref", "old", "0x%x", p_m_d_l3id);
560                 add_trace("callref", "new", "0x%x", dinfo);
561                 end_trace();
562                 if (p_m_d_l3id&(~0xff) == 0xff00)
563                         p_m_mISDNport->procids[p_m_d_l3id&0xff] = 0;
564                 p_m_d_l3id = dinfo;
565                 p_m_d_ces = setup->ces;
566         }
567 #endif
568
569         l1l2l3_trace_header(p_m_mISDNport, this, L3_SETUP_IND, DIRECTION_IN);
570 #ifdef SOCKET_MISDN
571         dec_ie_calling_pn(l3m, &calling_type, &calling_plan, &calling_present, &calling_screen, (unsigned char *)p_callerinfo.id, sizeof(p_callerinfo.id));
572         dec_ie_called_pn(l3m, &called_type, &called_plan, (unsigned char *)p_dialinginfo.id, sizeof(p_dialinginfo.id));
573         dec_ie_keypad(l3m, (unsigned char *)keypad, sizeof(keypad));
574         /* te-mode: CNIP (calling name identification presentation) */
575         if (!p_m_d_ntmode)
576                 dec_facility_centrex(l3m, (unsigned char *)p_callerinfo.name, sizeof(p_callerinfo.name));
577         dec_ie_useruser(l3m, &useruser_protocol, useruser, &useruser_len);
578         dec_ie_complete(l3m, &p_dialinginfo.sending_complete);
579         dec_ie_redir_nr(l3m, &redir_type, &redir_plan, &redir_present, &redir_screen, &redir_reason, (unsigned char *)p_redirinfo.id, sizeof(p_redirinfo.id));
580         dec_ie_channel_id(l3m, &exclusive, &channel);
581         dec_ie_hlc(l3m, &hlc_coding, &hlc_interpretation, &hlc_presentation, &hlc_hlc, &hlc_exthlc);
582         dec_ie_bearer(l3m, &bearer_coding, &bearer_capability, &bearer_mode, &bearer_rate, &bearer_multi, &bearer_user);
583 #else
584         dec_ie_calling_pn(setup->CALLING_PN, (Q931_info_t *)((unsigned long)data+headerlen), &calling_type, &calling_plan, &calling_present, &calling_screen, (unsigned char *)p_callerinfo.id, sizeof(p_callerinfo.id));
585         dec_ie_called_pn(setup->CALLED_PN, (Q931_info_t *)((unsigned long)data+headerlen), &called_type, &called_plan, (unsigned char *)p_dialinginfo.id, sizeof(p_dialinginfo.id));
586         dec_ie_keypad(setup->KEYPAD, (Q931_info_t *)((unsigned long)data+headerlen), (unsigned char *)keypad, sizeof(keypad));
587         /* te-mode: CNIP (calling name identification presentation) */
588         if (!p_m_d_ntmode)
589                 dec_facility_centrex(setup->FACILITY, (Q931_info_t *)((unsigned long)data+headerlen), (unsigned char *)p_callerinfo.name, sizeof(p_callerinfo.name));
590         dec_ie_useruser(setup->USER_USER, (Q931_info_t *)((unsigned long)data+headerlen), &useruser_protocol, useruser, &useruser_len);
591         dec_ie_complete(setup->COMPLETE, (Q931_info_t *)((unsigned long)data+headerlen), &p_dialinginfo.sending_complete);
592         dec_ie_redir_nr(setup->REDIR_NR, (Q931_info_t *)((unsigned long)data+headerlen), &redir_type, &redir_plan, &redir_present, &redir_screen, &redir_reason, (unsigned char *)p_redirinfo.id, sizeof(p_redirinfo.id));
593         dec_ie_channel_id(setup->CHANNEL_ID, (Q931_info_t *)((unsigned long)data+headerlen), &exclusive, &channel);
594         dec_ie_hlc(setup->HLC, (Q931_info_t *)((unsigned long)data+headerlen), &hlc_coding, &hlc_interpretation, &hlc_presentation, &hlc_hlc, &hlc_exthlc);
595         dec_ie_bearer(setup->BEARER, (Q931_info_t *)((unsigned long)data+headerlen), &bearer_coding, &bearer_capability, &bearer_mode, &bearer_rate, &bearer_multi, &bearer_user);
596 #endif
597         end_trace();
598
599         /* if blocked, release call with MT_RELEASE_COMPLETE */
600         if (p_m_mISDNport->ifport->block)
601         {
602 #ifdef SOCKET_MISDN
603                 l3m = create_l3msg();
604 #else
605                 RELEASE_COMPLETE_t *release_complete;
606                 dmsg = create_l3msg(CC_RELEASE_COMPLETE | REQUEST, MT_RELEASE_COMPLETE, dinfo, sizeof(RELEASE_COMPLETE_t), p_m_d_ntmode);
607                 release_complete = (RELEASE_COMPLETE_t *)(dmsg->data + headerlen);
608 #endif
609                 l1l2l3_trace_header(p_m_mISDNport, this, L3_RELEASE_COMPLETE_REQ, DIRECTION_OUT);
610 #ifdef SOCKET_MISDN
611                 enc_ie_cause(l3m, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, 27); /* temporary unavailable */
612 #else
613                 enc_ie_cause(&release_complete->CAUSE, dmsg, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, 27); /* temporary unavailable */
614 #endif
615                 add_trace("reason", NULL, "port blocked");
616                 end_trace();
617 #ifdef SOCKET_MISDN
618                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_RELEASE_COMPLETE, p_m_d_l3id, l3m);
619 #else
620                 msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
621 #endif
622                 new_state(PORT_STATE_RELEASE);
623                 p_m_delete = 1;
624                 return;
625         }
626
627         /* caller info */
628         switch (calling_present)
629         {
630                 case 1:
631                 p_callerinfo.present = INFO_PRESENT_RESTRICTED;
632                 break;
633                 case 2:
634                 p_callerinfo.present = INFO_PRESENT_NOTAVAIL;
635                 break;
636                 default:
637                 p_callerinfo.present = INFO_PRESENT_ALLOWED;
638                 break;
639         }
640         switch (calling_screen)
641         {
642                 case 0:
643                 p_callerinfo.screen = INFO_SCREEN_USER;
644                 break;
645                 default:
646                 p_callerinfo.screen = INFO_SCREEN_NETWORK;
647                 break;
648         }
649         switch (calling_type)
650         {
651                 case -1:
652                 p_callerinfo.ntype = INFO_NTYPE_UNKNOWN;
653                 p_callerinfo.present = INFO_PRESENT_NOTAVAIL;
654                 p_callerinfo.screen = INFO_SCREEN_NETWORK;
655                 break;
656                 case 0x1:
657                 p_callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
658                 break;
659                 case 0x2:
660                 p_callerinfo.ntype = INFO_NTYPE_NATIONAL;
661                 break;
662                 case 0x4:
663                 p_callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
664                 break;
665                 default:
666                 p_callerinfo.ntype = INFO_NTYPE_UNKNOWN;
667                 break;
668         }
669         p_callerinfo.isdn_port = p_m_portnum;
670         SCPY(p_callerinfo.interface, p_m_mISDNport->ifport->interface->name);
671
672         /* dialing information */
673         SCAT(p_dialinginfo.id, (char *)keypad);
674         switch (called_type)
675         {
676                 case 0x1:
677                 p_dialinginfo.ntype = INFO_NTYPE_INTERNATIONAL;
678                 break;
679                 case 0x2:
680                 p_dialinginfo.ntype = INFO_NTYPE_NATIONAL;
681                 break;
682                 case 0x4:
683                 p_dialinginfo.ntype = INFO_NTYPE_SUBSCRIBER;
684                 break;
685                 default:
686                 p_dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
687                 break;
688         }
689
690         /* redir info */
691         switch (redir_present)
692         {
693                 case 1:
694                 p_redirinfo.present = INFO_PRESENT_RESTRICTED;
695                 break;
696                 case 2:
697                 p_redirinfo.present = INFO_PRESENT_NOTAVAIL;
698                 break;
699                 default:
700                 p_redirinfo.present = INFO_PRESENT_ALLOWED;
701                 break;
702         }
703         switch (redir_screen)
704         {
705                 case 0:
706                 p_redirinfo.screen = INFO_SCREEN_USER;
707                 break;
708                 default:
709                 p_redirinfo.screen = INFO_SCREEN_NETWORK;
710                 break;
711         }
712         switch (redir_reason)
713         {
714                 case 1:
715                 p_redirinfo.reason = INFO_REDIR_BUSY;
716                 break;
717                 case 2:
718                 p_redirinfo.reason = INFO_REDIR_NORESPONSE;
719                 break;
720                 case 15:
721                 p_redirinfo.reason = INFO_REDIR_UNCONDITIONAL;
722                 break;
723                 case 10:
724                 p_redirinfo.reason = INFO_REDIR_CALLDEFLECT;
725                 break;
726                 case 9:
727                 p_redirinfo.reason = INFO_REDIR_OUTOFORDER;
728                 break;
729                 default:
730                 p_redirinfo.reason = INFO_REDIR_UNKNOWN;
731                 break;
732         }
733         switch (redir_type)
734         {
735                 case -1:
736                 p_redirinfo.ntype = INFO_NTYPE_UNKNOWN;
737                 p_redirinfo.present = INFO_PRESENT_NULL; /* not redirecting */
738                 p_redirinfo.reason = INFO_REDIR_UNKNOWN;
739                 break;
740                 case 0x1:
741                 p_redirinfo.ntype = INFO_NTYPE_INTERNATIONAL;
742                 break;
743                 case 0x2:
744                 p_redirinfo.ntype = INFO_NTYPE_NATIONAL;
745                 break;
746                 case 0x4:
747                 p_redirinfo.ntype = INFO_NTYPE_SUBSCRIBER;
748                 break;
749                 default:
750                 p_redirinfo.ntype = INFO_NTYPE_UNKNOWN;
751                 break;
752         }
753         p_redirinfo.isdn_port = p_m_portnum;
754
755         /* bearer capability */
756         switch (bearer_capability)
757         {
758                 case -1:
759                 p_capainfo.bearer_capa = INFO_BC_AUDIO;
760                 bearer_user = (options.law=='a')?3:2;
761                 break;
762                 default:
763                 p_capainfo.bearer_capa = bearer_capability;
764                 break;
765         }
766         switch (bearer_mode)
767         {
768                 case 2:
769                 p_capainfo.bearer_mode = INFO_BMODE_PACKET;
770                 break;
771                 default:
772                 p_capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
773                 break;
774         }
775         switch (bearer_user)
776         {
777                 case -1:
778                 p_capainfo.bearer_info1 = INFO_INFO1_NONE;
779                 break;
780                 default:
781                 p_capainfo.bearer_info1 = bearer_user + 0x80;
782                 break;
783         }
784
785         /* hlc */
786         switch (hlc_hlc)
787         {
788                 case -1:
789                 p_capainfo.hlc = INFO_HLC_NONE;
790                 break;
791                 default:
792                 p_capainfo.hlc = hlc_hlc + 0x80;
793                 break;
794         }
795         switch (hlc_exthlc)
796         {
797                 case -1:
798                 p_capainfo.exthlc = INFO_HLC_NONE;
799                 break;
800                 default:
801                 p_capainfo.exthlc = hlc_exthlc + 0x80;
802                 break;
803         }
804
805         /* hunt channel */
806         ret = channel = hunt_bchannel(channel, exclusive);
807         if (ret < 0)
808                 goto no_channel;
809
810         /* open channel */
811         ret = seize_bchannel(channel, 1);
812         if (ret < 0)
813         {
814                 no_channel:
815                 /*
816                  * NOTE: we send MT_RELEASE_COMPLETE to "REJECT" the channel
817                  * in response to the setup
818                  */
819 #ifdef SOCKET_MISDN
820                 l3m = create_l3msg();
821 #else
822                 RELEASE_COMPLETE_t *release_complete;
823                 dmsg = create_l3msg(CC_RELEASE_COMPLETE | REQUEST, MT_RELEASE_COMPLETE, dinfo, sizeof(RELEASE_COMPLETE_t), p_m_d_ntmode);
824                 release_complete = (RELEASE_COMPLETE_t *)(dmsg->data + headerlen);
825 #endif
826                 l1l2l3_trace_header(p_m_mISDNport, this, L3_RELEASE_COMPLETE_REQ, DIRECTION_OUT);
827 #ifdef SOCKET_MISDN
828                 enc_ie_cause(l3m, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, -ret);
829 #else
830                 enc_ie_cause(&release_complete->CAUSE, dmsg, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, -ret);
831 #endif
832                 end_trace();
833 #ifdef SOCKET_MISDN
834                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_RELEASE_COMPLETE, p_m_d_l3id, l3m);
835 #else
836                 msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
837 #endif
838                 new_state(PORT_STATE_RELEASE);
839                 p_m_delete = 1;
840                 return;
841         }
842         bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_USE);
843
844         /* create endpoint */
845         if (p_epointlist)
846                 FATAL("Incoming call but already got an endpoint.\n");
847         if (!(epoint = new Endpoint(p_serial, 0)))
848                 FATAL("No memory for Endpoint instance\n");
849         if (!(epoint->ep_app = new DEFAULT_ENDPOINT_APP(epoint, 0))) //incoming
850                 FATAL("No memory for Endpoint Application instance\n");
851         epointlist_new(epoint->ep_serial);
852
853         /* send setup message to endpoit */
854         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_SETUP);
855         message->param.setup.isdn_port = p_m_portnum;
856         message->param.setup.port_type = p_type;
857         message->param.setup.dtmf = !p_m_mISDNport->ifport->nodtmf;
858         memcpy(&message->param.setup.dialinginfo, &p_dialinginfo, sizeof(struct dialing_info));
859         memcpy(&message->param.setup.callerinfo, &p_callerinfo, sizeof(struct caller_info));
860         memcpy(&message->param.setup.redirinfo, &p_redirinfo, sizeof(struct redir_info));
861         memcpy(&message->param.setup.capainfo, &p_capainfo, sizeof(struct capa_info));
862         memcpy(message->param.setup.useruser.data, &useruser, useruser_len);
863         message->param.setup.useruser.len = useruser_len;
864         message->param.setup.useruser.protocol = useruser_protocol;
865         message_put(message);
866
867         new_state(PORT_STATE_IN_SETUP);
868 }
869
870 /* CC_INFORMATION INDICATION */
871 #ifdef SOCKET_MISDN
872 void Pdss1::information_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
873 {
874 #else
875 void Pdss1::information_ind(unsigned long prim, unsigned long dinfo, void *data)
876 {
877         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
878         INFORMATION_t *information = (INFORMATION_t *)((unsigned long)data + headerlen);
879 #endif
880         int type, plan;
881         unsigned char keypad[32] = "";
882         struct message *message;
883
884         l1l2l3_trace_header(p_m_mISDNport, this, L3_INFORMATION_IND, DIRECTION_IN);
885 #ifdef SOCKET_MISDN
886         dec_ie_called_pn(l3m, &type, &plan, (unsigned char *)p_dialinginfo.id, sizeof(p_dialinginfo.id));
887         dec_ie_keypad(l3m, (unsigned char *)keypad, sizeof(keypad));
888         dec_ie_complete(l3m, &p_dialinginfo.sending_complete);
889 #else
890         dec_ie_called_pn(information->CALLED_PN, (Q931_info_t *)((unsigned long)data+headerlen), &type, &plan, (unsigned char *)p_dialinginfo.id, sizeof(p_dialinginfo.id));
891         dec_ie_keypad(information->KEYPAD, (Q931_info_t *)((unsigned long)data+headerlen), (unsigned char *)keypad, sizeof(keypad));
892         dec_ie_complete(information->COMPLETE, (Q931_info_t *)((unsigned long)data+headerlen), &p_dialinginfo.sending_complete);
893 #endif
894         end_trace();
895
896         SCAT(p_dialinginfo.id, (char *)keypad);
897         switch (type)
898         {
899                 case 0x1:
900                 p_dialinginfo.ntype = INFO_NTYPE_INTERNATIONAL;
901                 break;
902                 case 0x2:
903                 p_dialinginfo.ntype = INFO_NTYPE_NATIONAL;
904                 break;
905                 case 0x4:
906                 p_dialinginfo.ntype = INFO_NTYPE_SUBSCRIBER;
907                 break;
908                 default:
909                 p_dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
910                 break;
911         }
912         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_INFORMATION);
913         memcpy(&message->param.information, &p_dialinginfo, sizeof(struct dialing_info));
914         message_put(message);
915         /* reset overlap timeout */
916         new_state(p_state);
917 }
918
919 /* CC_SETUP_ACCNOWLEDGE INDICATION */
920 #ifdef SOCKET_MISDN
921 void Pdss1::setup_acknowledge_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
922 {
923 #else
924 void Pdss1::setup_acknowledge_ind(unsigned long prim, unsigned long dinfo, void *data)
925 {
926         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
927         SETUP_ACKNOWLEDGE_t *setup_acknowledge = (SETUP_ACKNOWLEDGE_t *)((unsigned long)data + headerlen);
928 #endif
929         int exclusive, channel;
930         int coding, location, progress;
931         int ret;
932         struct message *message;
933
934         l1l2l3_trace_header(p_m_mISDNport, this, L3_SETUP_ACKNOWLEDGE_IND, DIRECTION_IN);
935 #ifdef SOCKET_MISDN
936         dec_ie_channel_id(l3m, &exclusive, &channel);
937         dec_ie_progress(l3m, &coding, &location, &progress);
938 #else
939         dec_ie_channel_id(setup_acknowledge->CHANNEL_ID, (Q931_info_t *)((unsigned long)data+headerlen), &exclusive, &channel);
940         dec_ie_progress(setup_acknowledge->PROGRESS, (Q931_info_t *)((unsigned long)data+headerlen), &coding, &location, &progress);
941 #endif
942         end_trace();
943
944         /* process channel */
945 #ifdef SOCKET_MISDN
946         ret = received_first_reply_to_setup(cmd, channel, exclusive);
947 #else
948         ret = received_first_reply_to_setup(prim, channel, exclusive);
949 #endif
950         if (ret < 0)
951         {
952                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE);
953                 message->param.disconnectinfo.cause = -ret;
954                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
955                 message_put(message);
956                 new_state(PORT_STATE_RELEASE);
957                 p_m_delete = 1;
958                 return;
959         }
960
961         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_OVERLAP);
962         message_put(message);
963
964         new_state(PORT_STATE_OUT_OVERLAP);
965 }
966
967 /* CC_PROCEEDING INDICATION */
968 #ifdef SOCKET_MISDN
969 void Pdss1::proceeding_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
970 {
971 #else
972 void Pdss1::proceeding_ind(unsigned long prim, unsigned long dinfo, void *data)
973 {
974         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
975         CALL_PROCEEDING_t *proceeding = (CALL_PROCEEDING_t *)((unsigned long)data + headerlen);
976 #endif
977         int exclusive, channel;
978         int coding, location, progress;
979         int ret;
980         struct message *message;
981         int notify = -1, type, plan, present;
982         char redir[32];
983
984         l1l2l3_trace_header(p_m_mISDNport, this, L3_PROCEEDING_IND, DIRECTION_IN);
985 #ifdef SOCKET_MISDN
986         dec_ie_channel_id(l3m, &exclusive, &channel);
987         dec_ie_progress(l3m, &coding, &location, &progress);
988         dec_ie_notify(l3m, &notify);
989         dec_ie_redir_dn(l3m, &type, &plan, &present, (unsigned char *)redir, sizeof(redir));
990 #else
991         dec_ie_channel_id(proceeding->CHANNEL_ID, (Q931_info_t *)((unsigned long)data+headerlen), &exclusive, &channel);
992         dec_ie_progress(proceeding->PROGRESS, (Q931_info_t *)((unsigned long)data+headerlen), &coding, &location, &progress);
993         dec_ie_notify(NULL/*proceeding->NOTIFY*/, (Q931_info_t *)((unsigned long)data+headerlen), &notify);
994         dec_ie_redir_dn(proceeding->REDIR_DN, (Q931_info_t *)((unsigned long)data+headerlen), &type, &plan, &present, (unsigned char *)redir, sizeof(redir));
995 #endif
996         end_trace();
997
998 #ifdef SOCKET_MISDN
999         ret = received_first_reply_to_setup(cmd, channel, exclusive);
1000 #else
1001         ret = received_first_reply_to_setup(prim, channel, exclusive);
1002 #endif
1003         if (ret < 0)
1004         {
1005                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE);
1006                 message->param.disconnectinfo.cause = -ret;
1007                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1008                 message_put(message);
1009                 new_state(PORT_STATE_RELEASE);
1010                 p_m_delete = 1;
1011                 return;
1012         }
1013         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_PROCEEDING);
1014         message_put(message);
1015
1016         new_state(PORT_STATE_OUT_PROCEEDING);
1017         
1018         if (notify >= 0)
1019                 notify |= 0x80;
1020         else
1021                 notify = 0;
1022         if (type >= 0 || notify)
1023         {
1024                 if (!notify && type >= 0)
1025                         notify = 251;
1026                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_NOTIFY);
1027                 message->param.notifyinfo.notify = notify;
1028                 SCPY(message->param.notifyinfo.id, redir);
1029                 /* redirection number */
1030                 switch (present)
1031                 {
1032                         case 1:
1033                         message->param.notifyinfo.present = INFO_PRESENT_RESTRICTED;
1034                         break;
1035                         case 2:
1036                         message->param.notifyinfo.present = INFO_PRESENT_NOTAVAIL;
1037                         break;
1038                         default:
1039                         message->param.notifyinfo.present = INFO_PRESENT_ALLOWED;
1040                         break;
1041                 }
1042                 switch (type)
1043                 {
1044                         case -1:
1045                         message->param.notifyinfo.ntype = INFO_NTYPE_UNKNOWN;
1046                         message->param.notifyinfo.present = INFO_PRESENT_NULL;
1047                         break;
1048                         case 1:
1049                         message->param.notifyinfo.ntype = INFO_NTYPE_INTERNATIONAL;
1050                         break;
1051                         case 2:
1052                         message->param.notifyinfo.ntype = INFO_NTYPE_NATIONAL;
1053                         break;
1054                         case 4:
1055                         message->param.notifyinfo.ntype = INFO_NTYPE_SUBSCRIBER;
1056                         break;
1057                         default:
1058                         message->param.notifyinfo.ntype = INFO_NTYPE_UNKNOWN;
1059                         break;
1060                 }
1061                 message->param.notifyinfo.isdn_port = p_m_portnum;
1062                 message_put(message);
1063         }
1064 }
1065
1066 /* CC_ALERTING INDICATION */
1067 #ifdef SOCKET_MISDN
1068 void Pdss1::alerting_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1069 {
1070 #else
1071 void Pdss1::alerting_ind(unsigned long prim, unsigned long dinfo, void *data)
1072 {
1073         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
1074         ALERTING_t *alerting = (ALERTING_t *)((unsigned long)data + headerlen);
1075 #endif
1076         int exclusive, channel;
1077         int coding, location, progress;
1078         int ret;
1079         struct message *message;
1080         int notify = -1, type, plan, present;
1081         char redir[32];
1082
1083         l1l2l3_trace_header(p_m_mISDNport, this, L3_ALERTING_IND, DIRECTION_IN);
1084 #ifdef SOCKET_MISDN
1085         dec_ie_channel_id(l3m, &exclusive, &channel);
1086         dec_ie_progress(l3m, &coding, &location, &progress);
1087         dec_ie_notify(l3m, &notify);
1088         dec_ie_redir_dn(l3m, &type, &plan, &present, (unsigned char *)redir, sizeof(redir));
1089 #else
1090         dec_ie_channel_id(alerting->CHANNEL_ID, (Q931_info_t *)((unsigned long)data+headerlen), &exclusive, &channel);
1091         dec_ie_progress(alerting->PROGRESS, (Q931_info_t *)((unsigned long)data+headerlen), &coding, &location, &progress);
1092         dec_ie_notify(NULL/*alerting->NOTIFY*/, (Q931_info_t *)((unsigned long)data+headerlen), &notify);
1093         dec_ie_redir_dn(alerting->REDIR_DN, (Q931_info_t *)((unsigned long)data+headerlen), &type, &plan, &present, (unsigned char *)redir, sizeof(redir));
1094 #endif
1095         end_trace();
1096
1097         /* process channel */
1098 #ifdef SOCKET_MISDN
1099         ret = received_first_reply_to_setup(cmd, channel, exclusive);
1100 #else
1101         ret = received_first_reply_to_setup(prim, channel, exclusive);
1102 #endif
1103         if (ret < 0)
1104         {
1105                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE);
1106                 message->param.disconnectinfo.cause = -ret;
1107                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1108                 message_put(message);
1109                 new_state(PORT_STATE_RELEASE);
1110                 p_m_delete = 1;
1111                 return;
1112         }
1113         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_ALERTING);
1114         message_put(message);
1115
1116         new_state(PORT_STATE_OUT_ALERTING);
1117
1118         if (notify >= 0)
1119                 notify |= 0x80;
1120         else
1121                 notify = 0;
1122         if (type >= 0 || notify)
1123         {
1124                 if (!notify && type >= 0)
1125                         notify = 251;
1126                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_NOTIFY);
1127                 message->param.notifyinfo.notify = notify;
1128                 SCPY(message->param.notifyinfo.id, redir);
1129                 switch (present)
1130                 {
1131                         case 1:
1132                         message->param.notifyinfo.present = INFO_PRESENT_RESTRICTED;
1133                         break;
1134                         case 2:
1135                         message->param.notifyinfo.present = INFO_PRESENT_NOTAVAIL;
1136                         break;
1137                         default:
1138                         message->param.notifyinfo.present = INFO_PRESENT_ALLOWED;
1139                         break;
1140                 }
1141                 switch (type)
1142                 {
1143                         case -1:
1144                         message->param.notifyinfo.ntype = INFO_NTYPE_UNKNOWN;
1145                         message->param.notifyinfo.present = INFO_PRESENT_NULL;
1146                         break;
1147                         case 1:
1148                         message->param.notifyinfo.ntype = INFO_NTYPE_INTERNATIONAL;
1149                         break;
1150                         case 2:
1151                         message->param.notifyinfo.ntype = INFO_NTYPE_NATIONAL;
1152                         break;
1153                         case 4:
1154                         message->param.notifyinfo.ntype = INFO_NTYPE_SUBSCRIBER;
1155                         break;
1156                         default:
1157                         message->param.notifyinfo.ntype = INFO_NTYPE_UNKNOWN;
1158                         break;
1159                 }
1160                 message->param.notifyinfo.isdn_port = p_m_portnum;
1161                 message_put(message);
1162         }
1163 }
1164
1165 /* CC_CONNECT INDICATION */
1166 #ifdef SOCKET_MISDN
1167 void Pdss1::connect_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1168 {
1169 #else
1170 void Pdss1::connect_ind(unsigned long prim, unsigned long dinfo, void *data)
1171 {
1172         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
1173         msg_t *dmsg;
1174         CONNECT_t *connect = (CONNECT_t *)((unsigned long)data + headerlen);
1175         CONNECT_ACKNOWLEDGE_t *connect_acknowledge;
1176 #endif
1177         int exclusive, channel;
1178         int type, plan, present, screen;
1179         int ret;
1180         struct message *message;
1181         int bchannel_before;
1182
1183         if (p_m_d_ntmode)
1184 #ifdef SOCKET_MISDN
1185                 p_m_d_ces = pid >> 16;
1186 #else
1187                 p_m_d_ces = connect->ces;
1188 #endif
1189
1190         l1l2l3_trace_header(p_m_mISDNport, this, L3_CONNECT_IND, DIRECTION_IN);
1191 #ifdef SOCKET_MISDN
1192         dec_ie_channel_id(l3m, &exclusive, &channel);
1193         dec_ie_connected_pn(l3m, &type, &plan, &present, &screen, (unsigned char *)p_connectinfo.id, sizeof(p_connectinfo.id));
1194         /* te-mode: CONP (connected name identification presentation) */
1195         if (!p_m_d_ntmode)
1196                 dec_facility_centrex(l3m, (unsigned char *)p_connectinfo.name, sizeof(p_connectinfo.name));
1197 #else
1198         dec_ie_channel_id(connect->CHANNEL_ID, (Q931_info_t *)((unsigned long)data+headerlen), &exclusive, &channel);
1199         dec_ie_connected_pn(connect->CONNECT_PN, (Q931_info_t *)((unsigned long)data+headerlen), &type, &plan, &present, &screen, (unsigned char *)p_connectinfo.id, sizeof(p_connectinfo.id));
1200         /* te-mode: CONP (connected name identification presentation) */
1201         if (!p_m_d_ntmode)
1202                 dec_facility_centrex(connect->FACILITY, (Q931_info_t *)((unsigned long)data+headerlen), (unsigned char *)p_connectinfo.name, sizeof(p_connectinfo.name));
1203 #endif
1204         end_trace();
1205
1206         /* select channel */
1207         bchannel_before = p_m_b_channel;
1208 #ifdef SOCKET_MISDN
1209         ret = received_first_reply_to_setup(cmd, channel, exclusive);
1210 #else
1211         ret = received_first_reply_to_setup(prim, channel, exclusive);
1212 #endif
1213         if (ret < 0)
1214         {
1215                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE);
1216                 message->param.disconnectinfo.cause = -ret;
1217                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1218                 message_put(message);
1219                 new_state(PORT_STATE_RELEASE);
1220                 p_m_delete = 1;
1221                 return;
1222         }
1223
1224         /* connect information */
1225         switch (present)
1226         {
1227                 case 1:
1228                 p_connectinfo.present = INFO_PRESENT_RESTRICTED;
1229                 break;
1230                 case 2:
1231                 p_connectinfo.present = INFO_PRESENT_NOTAVAIL;
1232                 break;
1233                 default:
1234                 p_connectinfo.present = INFO_PRESENT_ALLOWED;
1235                 break;
1236         }
1237         switch (screen)
1238         {
1239                 case 0:
1240                 p_connectinfo.screen = INFO_SCREEN_USER;
1241                 break;
1242                 default:
1243                 p_connectinfo.screen = INFO_SCREEN_NETWORK;
1244                 break;
1245         }
1246         switch (type)
1247         {
1248                 case 0x0:
1249                 p_connectinfo.present = INFO_PRESENT_NULL; /* no COLP info */
1250                 p_connectinfo.ntype = INFO_NTYPE_UNKNOWN;
1251                 break;
1252                 case 0x1:
1253                 p_connectinfo.ntype = INFO_NTYPE_INTERNATIONAL;
1254                 break;
1255                 case 0x2:
1256                 p_connectinfo.ntype = INFO_NTYPE_NATIONAL;
1257                 break;
1258                 case 0x4:
1259                 p_connectinfo.ntype = INFO_NTYPE_SUBSCRIBER;
1260                 break;
1261                 default:
1262                 p_connectinfo.ntype = INFO_NTYPE_UNKNOWN;
1263                 break;
1264         }
1265         p_connectinfo.isdn_port = p_m_portnum;
1266         SCPY(p_connectinfo.interface, p_m_mISDNport->ifport->interface->name);
1267
1268         /* only in nt-mode we send connect ack. in te-mode it is done by stack itself or optional */
1269         if (p_m_d_ntmode)
1270         {
1271                 /* send connect acknowledge */
1272 #ifdef SOCKET_MISDN
1273                 l3m = create_l3msg();
1274 #else
1275                 dmsg = create_l3msg(CC_CONNECT | RESPONSE, MT_CONNECT, dinfo, sizeof(CONNECT_ACKNOWLEDGE_t), p_m_d_ntmode);
1276                 connect_acknowledge = (CONNECT_ACKNOWLEDGE_t *)(dmsg->data + headerlen);
1277 #endif
1278                 l1l2l3_trace_header(p_m_mISDNport, this, L3_CONNECT_RES, DIRECTION_OUT);
1279                 /* if we had no bchannel before, we send it now */
1280                 if (!bchannel_before && p_m_b_channel)
1281 #ifdef SOCKET_MISDN
1282                         enc_ie_channel_id(l3m, 1, p_m_b_channel);
1283 #else
1284                         enc_ie_channel_id(&connect_acknowledge->CHANNEL_ID, dmsg, 1, p_m_b_channel);
1285 #endif
1286                 end_trace();
1287 #ifdef SOCKET_MISDN
1288                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_CONNECT, p_m_d_l3id, l3m);
1289 #else
1290                 msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
1291 #endif
1292         }
1293         
1294         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CONNECT);
1295         memcpy(&message->param.connectinfo, &p_connectinfo, sizeof(struct connect_info));
1296         message_put(message);
1297
1298         new_state(PORT_STATE_CONNECT);
1299 }
1300
1301 /* CC_DISCONNECT INDICATION */
1302 #ifdef SOCKET_MISDN
1303 void Pdss1::disconnect_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1304 {
1305 #else
1306 void Pdss1::disconnect_ind(unsigned long prim, unsigned long dinfo, void *data)
1307 {
1308         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
1309         DISCONNECT_t *disconnect = (DISCONNECT_t *)((unsigned long)data + headerlen);
1310 #endif
1311         int location, cause;
1312         int coding, proglocation, progress;
1313         struct message *message;
1314
1315         l1l2l3_trace_header(p_m_mISDNport, this, L3_DISCONNECT_IND, DIRECTION_IN);
1316 #ifdef SOCKET_MISDN
1317         dec_ie_progress(l3m, &coding, &proglocation, &progress);
1318         dec_ie_cause(l3m, &location, &cause);
1319 #else
1320         dec_ie_progress(disconnect->PROGRESS, (Q931_info_t *)((unsigned long)data+headerlen), &coding, &proglocation, &progress);
1321         dec_ie_cause(disconnect->CAUSE, (Q931_info_t *)((unsigned long)data+headerlen), &location, &cause);
1322 #endif
1323         end_trace();
1324         if (location == LOCATION_PRIVATE_LOCAL)
1325                 location = LOCATION_PRIVATE_REMOTE;
1326
1327         if (cause < 0)
1328                 cause = 16;
1329
1330         /* release if remote sends us no tones */
1331         if (!p_m_mISDNport->earlyb)
1332         {
1333 #ifdef SOCKET_MISDN
1334                 l3_msg *l3m;
1335 #else
1336                 msg_t *dmsg;
1337                 RELEASE_t *release;
1338 #endif
1339
1340 #ifdef SOCKET_MISDN
1341                 l3m = create_l3msg();
1342 #else
1343                 dmsg = create_l3msg(CC_RELEASE | REQUEST, MT_RELEASE, dinfo, sizeof(RELEASE_t), p_m_d_ntmode);
1344                 release = (RELEASE_t *)(dmsg->data + headerlen);
1345 #endif
1346                 l1l2l3_trace_header(p_m_mISDNport, this, L3_RELEASE_REQ, DIRECTION_OUT);
1347 #ifdef SOCKET_MISDN
1348                 enc_ie_cause(l3m, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, 16); /* normal */
1349 #else
1350                 enc_ie_cause(&release->CAUSE, dmsg, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, 16); /* normal */
1351 #endif
1352                 add_trace("reason", NULL, "no remote patterns");
1353                 end_trace();
1354 #ifdef SOCKET_MISDN
1355                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_RELEASE, p_m_d_l3id, l3m);
1356 #else
1357                 msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
1358 #endif
1359
1360                 /* sending release to endpoint */
1361                 while(p_epointlist)
1362                 {
1363                         message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
1364                         message->param.disconnectinfo.cause = cause;
1365                         message->param.disconnectinfo.location = location;
1366                         message_put(message);
1367                         /* remove epoint */
1368                         free_epointlist(p_epointlist);
1369                 }
1370                 new_state(PORT_STATE_RELEASE);
1371                 p_m_delete = 1;
1372                 return;
1373         }
1374
1375         /* sending disconnect to active endpoint and release to inactive endpoints */
1376         if (ACTIVE_EPOINT(p_epointlist))
1377         {
1378                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_DISCONNECT);
1379                 message->param.disconnectinfo.location = location;
1380                 message->param.disconnectinfo.cause = cause;
1381                 message_put(message);
1382         }
1383         while(INACTIVE_EPOINT(p_epointlist))
1384         {
1385                 message = message_create(p_serial, INACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE);
1386                 message->param.disconnectinfo.location = location;
1387                 message->param.disconnectinfo.cause = cause;
1388                 message_put(message);
1389                 /* remove epoint */
1390                 free_epointid(INACTIVE_EPOINT(p_epointlist));
1391         }
1392         new_state(PORT_STATE_IN_DISCONNECT);
1393 }
1394
1395 /* CC_DISCONNECT INDICATION */
1396 #ifdef SOCKET_MISDN
1397 void Pdss1::disconnect_ind_i(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1398 {
1399 #else
1400 void Pdss1::disconnect_ind_i(unsigned long prim, unsigned long dinfo, void *data)
1401 {
1402         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
1403         DISCONNECT_t *disconnect = (DISCONNECT_t *)((unsigned long)data + headerlen);
1404 #endif
1405         int location, cause;
1406
1407         /* cause */
1408         l1l2l3_trace_header(p_m_mISDNport, this, L3_DISCONNECT_IND, DIRECTION_IN);
1409         if (p_m_d_collect_cause > 0)
1410         {
1411                 add_trace("old-cause", "location", "%d", p_m_d_collect_location);
1412                 add_trace("old-cause", "value", "%d", p_m_d_collect_cause);
1413         }
1414 #ifdef SOCKET_MISDN
1415         dec_ie_cause(l3m, &location, &cause);
1416 #else
1417         dec_ie_cause(disconnect->CAUSE, (Q931_info_t *)((unsigned long)data+headerlen), &location, &cause);
1418 #endif
1419         if (location == LOCATION_PRIVATE_LOCAL)
1420                 location = LOCATION_PRIVATE_REMOTE;
1421
1422         /* collect cause */
1423         collect_cause(&p_m_d_collect_cause, &p_m_d_collect_location, cause, location);
1424         add_trace("new-cause", "location", "%d", p_m_d_collect_location);
1425         add_trace("new-cause", "value", "%d", p_m_d_collect_cause);
1426         end_trace();
1427
1428 }
1429
1430 /* CC_RELEASE INDICATION */
1431 #ifdef SOCKET_MISDN
1432 void Pdss1::release_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1433 {
1434 #else
1435 void Pdss1::release_ind(unsigned long prim, unsigned long dinfo, void *data)
1436 {
1437         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
1438         msg_t *dmsg;
1439         RELEASE_t *release = (RELEASE_t *)((unsigned long)data + headerlen);
1440 #endif
1441         int location, cause;
1442         struct message *message;
1443
1444         l1l2l3_trace_header(p_m_mISDNport, this, L3_RELEASE_IND, DIRECTION_IN);
1445 #ifdef SOCKET_MISDN
1446         dec_ie_cause(l3m, &location, &cause);
1447 #else
1448         dec_ie_cause(release->CAUSE, (Q931_info_t *)((unsigned long)data+headerlen), &location, &cause);
1449 #endif
1450         end_trace();
1451         if (location == LOCATION_PRIVATE_LOCAL)
1452                 location = LOCATION_PRIVATE_REMOTE;
1453
1454         if (cause < 0)
1455                 cause = 16;
1456
1457         /* sending release to endpoint */
1458         while(p_epointlist)
1459         {
1460                 message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
1461                 message->param.disconnectinfo.cause = cause;
1462                 message->param.disconnectinfo.location = location;
1463                 message_put(message);
1464                 /* remove epoint */
1465                 free_epointlist(p_epointlist);
1466         }
1467
1468         /* only in NT mode we must send release_complete, if we got a release confirm */
1469 #ifdef SOCKET_MISDN
1470         if (cmd == MT_RELEASE)
1471 #else
1472         if (prim == (CC_RELEASE | CONFIRM))
1473 #endif
1474         {
1475                 /* sending release complete */
1476 #ifdef SOCKET_MISDN
1477                 l3m = create_l3msg();
1478 #else
1479                 RELEASE_COMPLETE_t *release_complete;
1480                 dmsg = create_l3msg(CC_RELEASE_COMPLETE | REQUEST, MT_RELEASE_COMPLETE, dinfo, sizeof(RELEASE_COMPLETE_t), p_m_d_ntmode);
1481                 release_complete = (RELEASE_COMPLETE_t *)(dmsg->data + headerlen);
1482 #endif
1483                 l1l2l3_trace_header(p_m_mISDNport, this, L3_RELEASE_COMPLETE_REQ, DIRECTION_OUT);
1484 #ifdef SOCKET_MISDN
1485                 enc_ie_cause(l3m, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, 16);
1486 #else
1487                 enc_ie_cause(&release_complete->CAUSE, dmsg, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, 16);
1488 #endif
1489                 end_trace();
1490 #ifdef SOCKET_MISDN
1491                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_RELEASE_COMPLETE, p_m_d_l3id, l3m);
1492 #else
1493                 msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
1494 #endif
1495         }
1496
1497         new_state(PORT_STATE_RELEASE);
1498         p_m_delete = 1;
1499 }
1500
1501 /* CC_RELEASE_COMPLETE INDICATION (a reject) */
1502 #ifdef SOCKET_MISDN
1503 void Pdss1::release_complete_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1504 {
1505 #else
1506 void Pdss1::release_complete_ind(unsigned long prim, unsigned long dinfo, void *data)
1507 {
1508         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
1509         RELEASE_COMPLETE_t *release_complete = (RELEASE_COMPLETE_t *)((unsigned long)data + headerlen);
1510 #endif
1511         int location, cause;
1512         struct message *message;
1513
1514         l1l2l3_trace_header(p_m_mISDNport, this, L3_RELEASE_COMPLETE_IND, DIRECTION_IN);
1515 #ifdef SOCKET_MISDN
1516         dec_ie_cause(l3m, &location, &cause);
1517 #else
1518         dec_ie_cause(release_complete->CAUSE, (Q931_info_t *)((unsigned long)data+headerlen), &location, &cause);
1519 #endif
1520         end_trace();
1521         if (location == LOCATION_PRIVATE_LOCAL)
1522                 location = LOCATION_PRIVATE_REMOTE;
1523
1524         if (cause < 0)
1525                 cause = 16;
1526
1527         /* sending release to endpoint */
1528         while(p_epointlist)
1529         {
1530                 message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
1531                 message->param.disconnectinfo.cause = cause;
1532                 message->param.disconnectinfo.location = location;
1533                 message_put(message);
1534                 /* remove epoint */
1535                 free_epointlist(p_epointlist);
1536         }
1537
1538         new_state(PORT_STATE_RELEASE);
1539         p_m_delete = 1;
1540 }
1541
1542 /* T312 timeout  */
1543 #ifdef SOCKET_MISDN
1544 void Pdss1::t312_timeout_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1545 {
1546 #else
1547 void Pdss1::t312_timeout_ind(unsigned long prim, unsigned long dinfo, void *data)
1548 {
1549 #endif
1550         struct message *message;
1551
1552         // trace is done at message_isdn()
1553         
1554         /* sending release to endpoint */
1555         while(p_epointlist)
1556         {
1557                 message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
1558                 if (p_m_d_collect_cause)
1559                 {
1560                         message->param.disconnectinfo.cause = p_m_d_collect_cause;
1561                         message->param.disconnectinfo.location = p_m_d_collect_location;
1562                 } else
1563                 {
1564                         message->param.disconnectinfo.cause = CAUSE_NOUSER;
1565                         message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1566                 }
1567                 message_put(message);
1568                 /* remove epoint */
1569                 free_epointlist(p_epointlist);
1570         }
1571
1572         new_state(PORT_STATE_RELEASE);
1573         p_m_delete = 1;
1574 }
1575
1576 /* CC_NOTIFY INDICATION */
1577 #ifdef SOCKET_MISDN
1578 void Pdss1::notify_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1579 {
1580 #else
1581 void Pdss1::notify_ind(unsigned long prim, unsigned long dinfo, void *data)
1582 {
1583         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
1584         NOTIFY_t *notifying = (NOTIFY_t *)((unsigned long)data + headerlen);
1585 #endif
1586         struct message *message;
1587         int notify, type, plan, present;
1588         unsigned char notifyid[sizeof(message->param.notifyinfo.id)];
1589
1590         l1l2l3_trace_header(p_m_mISDNport, this, L3_NOTIFY_IND, DIRECTION_IN);
1591 #ifdef SOCKET_MISDN
1592         dec_ie_notify(l3m, &notify);
1593         dec_ie_redir_dn(l3m, &type, &plan, &present, notifyid, sizeof(notifyid));
1594 #else
1595         dec_ie_notify(notifying->NOTIFY, (Q931_info_t *)((unsigned long)data+headerlen), &notify);
1596         dec_ie_redir_dn(notifying->REDIR_DN, (Q931_info_t *)((unsigned long)data+headerlen), &type, &plan, &present, notifyid, sizeof(notifyid));
1597 #endif
1598         end_trace();
1599
1600         if (!ACTIVE_EPOINT(p_epointlist))
1601                 return;
1602         /* notification indicator */
1603         if (notify < 0)
1604                 return;
1605         notify |= 0x80;
1606         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_NOTIFY);
1607         message->param.notifyinfo.notify = notify;
1608         SCPY(message->param.notifyinfo.id, (char *)notifyid);
1609         /* redirection number */
1610         switch (present)
1611         {
1612                 case 1:
1613                 message->param.notifyinfo.present = INFO_PRESENT_RESTRICTED;
1614                 break;
1615                 case 2:
1616                 message->param.notifyinfo.present = INFO_PRESENT_NOTAVAIL;
1617                 break;
1618                 default:
1619                 message->param.notifyinfo.present = INFO_PRESENT_ALLOWED;
1620                 break;
1621         }
1622         switch (type)
1623         {
1624                 case -1:
1625                 message->param.notifyinfo.ntype = INFO_NTYPE_UNKNOWN;
1626                 message->param.notifyinfo.present = INFO_PRESENT_NULL;
1627                 break;
1628                 case 1:
1629                 message->param.notifyinfo.ntype = INFO_NTYPE_INTERNATIONAL;
1630                 break;
1631                 case 2:
1632                 message->param.notifyinfo.ntype = INFO_NTYPE_NATIONAL;
1633                 break;
1634                 case 4:
1635                 message->param.notifyinfo.ntype = INFO_NTYPE_SUBSCRIBER;
1636                 break;
1637                 default:
1638                 message->param.notifyinfo.ntype = INFO_NTYPE_UNKNOWN;
1639                 break;
1640         }
1641         message->param.notifyinfo.isdn_port = p_m_portnum;
1642         message_put(message);
1643 }
1644
1645
1646 /* CC_HOLD INDICATION */
1647         struct message *message;
1648 #ifdef SOCKET_MISDN
1649 void Pdss1::hold_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1650 {
1651 #else
1652 void Pdss1::hold_ind(unsigned long prim, unsigned long dinfo, void *data)
1653 {
1654         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
1655         msg_t *dmsg;
1656 //      HOLD_t *hold = (HOLD_t *)((unsigned long)data + headerlen);
1657         HOLD_REJECT_t *hold_reject;
1658         HOLD_ACKNOWLEDGE_t *hold_acknowledge;
1659 #endif
1660 //      class Endpoint *epoint;
1661
1662         l1l2l3_trace_header(p_m_mISDNport, this, L3_HOLD_IND, DIRECTION_IN);
1663         end_trace();
1664
1665         if (!ACTIVE_EPOINT(p_epointlist) || p_m_hold)
1666         {
1667 #ifdef SOCKET_MISDN
1668                 l3m = create_l3msg();
1669 #else
1670                 dmsg = create_l3msg(CC_HOLD_REJECT | REQUEST, MT_HOLD_REJECT, dinfo, sizeof(HOLD_REJECT_t), p_m_d_ntmode);
1671                 hold_reject = (HOLD_REJECT_t *)(dmsg->data + headerlen);
1672 #endif
1673                 l1l2l3_trace_header(p_m_mISDNport, this, L3_HOLD_REJECT_REQ, DIRECTION_OUT);
1674 #ifdef SOCKET_MISDN
1675                 enc_ie_cause(l3m, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, p_m_hold?101:31); /* normal unspecified / incompatible state */
1676 #else
1677                 enc_ie_cause(&hold_reject->CAUSE, dmsg, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, p_m_hold?101:31); /* normal unspecified / incompatible state */
1678 #endif
1679                 add_trace("reason", NULL, "no endpoint");
1680                 end_trace();
1681 #ifdef SOCKET_MISDN
1682                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_HOLD_REJECT, p_m_d_l3id, l3m);
1683 #else
1684                 msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
1685 #endif
1686
1687                 return;
1688         }
1689
1690         /* notify the hold of call */
1691         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_NOTIFY);
1692         message->param.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
1693         message->param.notifyinfo.local = 1; /* call is held by supplementary service */
1694         message_put(message);
1695
1696         /* deactivate bchannel */
1697         chan_trace_header(p_m_mISDNport, this, "CHANNEL RELEASE (hold)", DIRECTION_NONE);
1698         add_trace("disconnect", "channel", "%d", p_m_b_channel);
1699         end_trace();
1700         drop_bchannel();
1701
1702         /* set hold state */
1703         p_m_hold = 1;
1704 #if 0
1705         epoint = find_epoint_id(ACTIVE_EPOINT(p_epointlist));
1706         if (epoint && p_m_d_ntmode)
1707         {
1708                 p_m_timeout = p_settings.tout_hold;
1709                 time(&p_m_timer);
1710         }
1711 #endif
1712
1713         /* acknowledge hold */
1714 #ifdef SOCKET_MISDN
1715         l3m = create_l3msg();
1716 #else
1717         dmsg = create_l3msg(CC_HOLD_ACKNOWLEDGE | REQUEST, MT_HOLD_ACKNOWLEDGE, dinfo, sizeof(HOLD_ACKNOWLEDGE_t), p_m_d_ntmode);
1718         hold_acknowledge = (HOLD_ACKNOWLEDGE_t *)(dmsg->data + headerlen);
1719 #endif
1720         l1l2l3_trace_header(p_m_mISDNport, this, L3_HOLD_ACKNOWLEDGE_REQ, DIRECTION_OUT);
1721         end_trace();
1722 #ifdef SOCKET_MISDN
1723         p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_HOLD_ACKNOWLEDGE, p_m_d_l3id, l3m);
1724 #else
1725         msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
1726 #endif
1727 }
1728
1729
1730 /* CC_RETRIEVE INDICATION */
1731 #ifdef SOCKET_MISDN
1732 void Pdss1::retrieve_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1733 {
1734 #else
1735 void Pdss1::retrieve_ind(unsigned long prim, unsigned long dinfo, void *data)
1736 {
1737         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
1738         msg_t *dmsg;
1739         RETRIEVE_t *retrieve = (RETRIEVE_t *)((unsigned long)data + headerlen);
1740         RETRIEVE_REJECT_t *retrieve_reject;
1741         RETRIEVE_ACKNOWLEDGE_t *retrieve_acknowledge;
1742 #endif
1743         struct message *message;
1744         int channel, exclusive, cause;
1745         int ret;
1746
1747         l1l2l3_trace_header(p_m_mISDNport, this, L3_RETRIEVE_IND, DIRECTION_IN);
1748 #ifdef SOCKET_MISDN
1749         dec_ie_channel_id(l3m, &exclusive, &channel);
1750 #else
1751         dec_ie_channel_id(retrieve->CHANNEL_ID, (Q931_info_t *)((unsigned long)data+headerlen), &exclusive, &channel);
1752 #endif
1753         end_trace();
1754
1755         if (!p_m_hold)
1756         {
1757                 cause = 101; /* incompatible state */
1758                 reject:
1759
1760 #ifdef SOCKET_MISDN
1761                 l3m = create_l3msg();
1762 #else
1763                 dmsg = create_l3msg(CC_RETRIEVE_REJECT | REQUEST, MT_RETRIEVE_REJECT, dinfo, sizeof(RETRIEVE_REJECT_t), p_m_d_ntmode);
1764                 retrieve_reject = (RETRIEVE_REJECT_t *)(dmsg->data + headerlen);
1765 #endif
1766                 l1l2l3_trace_header(p_m_mISDNport, this, L3_RETRIEVE_REJECT_REQ, DIRECTION_OUT);
1767 #ifdef SOCKET_MISDN
1768                 enc_ie_cause(l3m, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, cause);
1769 #else
1770                 enc_ie_cause(&retrieve_reject->CAUSE, dmsg, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, cause);
1771 #endif
1772                 end_trace();
1773 #ifdef SOCKET_MISDN
1774                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_RETRIEVE_REJECT, p_m_d_l3id, l3m);
1775 #else
1776                 msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
1777 #endif
1778
1779                 return;
1780         }
1781
1782         /* notify the retrieve of call */
1783         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_NOTIFY);
1784         message->param.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
1785         message->param.notifyinfo.local = 1; /* call is retrieved by supplementary service */
1786         message_put(message);
1787
1788         /* hunt channel */
1789         ret = channel = hunt_bchannel(channel, exclusive);
1790         if (ret < 0)
1791                 goto no_channel;
1792
1793         /* open channel */
1794         ret = seize_bchannel(channel, 1);
1795         if (ret < 0)
1796         {
1797                 no_channel:
1798                 cause = -ret;
1799                 goto reject;
1800         }
1801         bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_USE);
1802
1803         /* set hold state */
1804         p_m_hold = 0;
1805         p_m_timeout = 0;
1806
1807         /* acknowledge retrieve */
1808 #ifdef SOCKET_MISDN
1809         l3m = create_l3msg();
1810 #else
1811         dmsg = create_l3msg(CC_RETRIEVE_ACKNOWLEDGE | REQUEST, MT_RETRIEVE_ACKNOWLEDGE, dinfo, sizeof(RETRIEVE_ACKNOWLEDGE_t), p_m_d_ntmode);
1812         retrieve_acknowledge = (RETRIEVE_ACKNOWLEDGE_t *)(dmsg->data + headerlen);
1813 #endif
1814         l1l2l3_trace_header(p_m_mISDNport, this, L3_RETRIEVE_ACKNOWLEDGE_REQ, DIRECTION_OUT);
1815 #ifdef SOCKET_MISDN
1816         enc_ie_channel_id(l3m, 1, p_m_b_channel);
1817 #else
1818         enc_ie_channel_id(&retrieve_acknowledge->CHANNEL_ID, dmsg, 1, p_m_b_channel);
1819 #endif
1820         end_trace();
1821 #ifdef SOCKET_MISDN
1822         p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_RETRIEVE_ACKNOWLEDGE, p_m_d_l3id, l3m);
1823 #else
1824         msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
1825 #endif
1826 }
1827
1828 /* CC_SUSPEND INDICATION */
1829 #ifdef SOCKET_MISDN
1830 void Pdss1::suspend_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1831 {
1832 #else
1833 void Pdss1::suspend_ind(unsigned long prim, unsigned long dinfo, void *data)
1834 {
1835         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
1836         msg_t *dmsg;
1837         SUSPEND_t *suspend = (SUSPEND_t *)((unsigned long)data + headerlen);
1838         SUSPEND_ACKNOWLEDGE_t *suspend_acknowledge;
1839         SUSPEND_REJECT_t *suspend_reject;
1840 #endif
1841         struct message *message;
1842         class Endpoint *epoint;
1843         unsigned char callid[8];
1844         int len;
1845         int ret = -31; /* normal, unspecified */
1846
1847         l1l2l3_trace_header(p_m_mISDNport, this, L3_SUSPEND_IND, DIRECTION_IN);
1848 #ifdef SOCKET_MISDN
1849         dec_ie_call_id(l3m, callid, &len);
1850 #else
1851         dec_ie_call_id(suspend->CALL_ID, (Q931_info_t *)((unsigned long)data+headerlen), callid, &len);
1852 #endif
1853         end_trace();
1854
1855         if (!ACTIVE_EPOINT(p_epointlist))
1856         {
1857                 reject:
1858 #ifdef SOCKET_MISDN
1859                 l3m = create_l3msg();
1860 #else
1861                 dmsg = create_l3msg(CC_SUSPEND_REJECT | REQUEST, MT_SUSPEND_REJECT, dinfo, sizeof(SUSPEND_REJECT_t), p_m_d_ntmode);
1862                 suspend_reject = (SUSPEND_REJECT_t *)(dmsg->data + headerlen);
1863 #endif
1864                 l1l2l3_trace_header(p_m_mISDNport, this, L3_SUSPEND_REJECT_REQ, DIRECTION_OUT);
1865 #ifdef SOCKET_MISDN
1866                 enc_ie_cause(l3m, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, -ret);
1867 #else
1868                 enc_ie_cause(&suspend_reject->CAUSE, dmsg, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, -ret);
1869 #endif
1870                 end_trace();
1871 #ifdef SOCKET_MISDN
1872                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_SUSPEND_REJECT, p_m_d_l3id, l3m);
1873 #else
1874                 msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
1875 #endif
1876
1877                 return;
1878         }
1879
1880         /* call id */
1881         if (len<0) len = 0;
1882
1883         /* check if call id is in use */
1884         epoint = epoint_first;
1885         while(epoint)
1886         {
1887                 if (epoint->ep_park)
1888                 {
1889                         if (epoint->ep_park_len == len)
1890                         if (!memcmp(epoint->ep_park_callid, callid, len))
1891                         {
1892                                 ret = -84; /* call id in use */
1893                                 goto reject;
1894                         }
1895                 }
1896                 epoint = epoint->next;
1897         }
1898
1899         /* notify the hold of call */
1900         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_NOTIFY);
1901         message->param.notifyinfo.notify = INFO_NOTIFY_USER_SUSPENDED;
1902         message->param.notifyinfo.local = 1; /* call is held by supplementary service */
1903         message_put(message);
1904
1905         /* deactivate bchannel */
1906         chan_trace_header(p_m_mISDNport, this, "CHANNEL RELEASE (suspend)", DIRECTION_NONE);
1907         add_trace("disconnect", "channel", "%d", p_m_b_channel);
1908         end_trace();
1909         drop_bchannel();
1910
1911         /* sending suspend to endpoint */
1912         while (p_epointlist)
1913         {
1914                 message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_SUSPEND);
1915                 memcpy(message->param.parkinfo.callid, callid, sizeof(message->param.parkinfo.callid));
1916                 message->param.parkinfo.len = len;
1917                 message_put(message);
1918                 /* remove epoint */
1919                 free_epointlist(p_epointlist);
1920         }
1921
1922         /* sending SUSPEND_ACKNOWLEDGE */
1923 #ifdef SOCKET_MISDN
1924         l3m = create_l3msg();
1925 #else
1926         dmsg = create_l3msg(CC_SUSPEND_ACKNOWLEDGE | REQUEST, MT_SUSPEND_ACKNOWLEDGE, dinfo, sizeof(SUSPEND_ACKNOWLEDGE_t), p_m_d_ntmode);
1927         suspend_acknowledge = (SUSPEND_ACKNOWLEDGE_t *)(dmsg->data + headerlen);
1928 #endif
1929         l1l2l3_trace_header(p_m_mISDNport, this, L3_SUSPEND_ACKNOWLEDGE_REQ, DIRECTION_OUT);
1930         end_trace();
1931 #ifdef SOCKET_MISDN
1932         p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_SUSPEND_ACKNOWLEDGE, p_m_d_l3id, l3m);
1933 #else
1934         msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
1935 #endif
1936
1937         new_state(PORT_STATE_RELEASE);
1938         p_m_delete = 1;
1939 }
1940
1941 /* CC_RESUME INDICATION */
1942 #ifdef SOCKET_MISDN
1943 void Pdss1::resume_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1944 {
1945 #else
1946 void Pdss1::resume_ind(unsigned long prim, unsigned long dinfo, void *data)
1947 {
1948         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
1949         msg_t *dmsg;
1950         RESUME_t *resume = (RESUME_t *)((unsigned long)data + headerlen);
1951         RESUME_REJECT_t *resume_reject;
1952         RESUME_ACKNOWLEDGE_t *resume_acknowledge;
1953 #endif
1954         unsigned char callid[8];
1955         int len;
1956         int channel, exclusive;
1957         class Endpoint *epoint;
1958         struct message *message;
1959         int ret;
1960
1961 #ifdef SOCKET_MISDN
1962         /* process given callref */
1963         l1l2l3_trace_header(p_m_mISDNport, this, L3_NEW_L3ID_IND, DIRECTION_IN);
1964         add_trace("callref", "new", "0x%x", pid);
1965         if (p_m_d_l3id != pid)
1966         {
1967                 /* release is case the ID is already in use */
1968                 add_trace("error", NULL, "callref already in use");
1969                 end_trace();
1970                 l3m = create_l3msg();
1971                 l1l2l3_trace_header(p_m_mISDNport, this, L3_RESUME_REJECT_REQ, DIRECTION_OUT);
1972                 enc_ie_cause(l3m, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, 47);
1973                 add_trace("reason", NULL, "callref already in use");
1974                 end_trace();
1975                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_RESUME_REJECT, pid, l3m);
1976                 new_state(PORT_STATE_RELEASE);
1977                 p_m_delete = 1;
1978                 return;
1979         }
1980         p_m_d_l3id = pid;
1981         p_m_d_ces = pid >> 16;
1982         end_trace();
1983 #else
1984         /* callref from nt-lib */
1985         if (p_m_d_ntmode)
1986         {
1987                 /* nt-library now gives us the id via CC_RESUME */
1988                 if (dinfo&(~0xff) == 0xff00)
1989                         FATAL("l3-stack gives us a process id 0xff00-0xffff\n");
1990                 l1l2l3_trace_header(p_m_mISDNport, this, L3_NEW_CR_IND, DIRECTION_IN);
1991                 if (p_m_d_l3id)
1992                         add_trace("callref", "old", "0x%x", p_m_d_l3id);
1993                 add_trace("callref", "new", "0x%x", dinfo);
1994                 end_trace();
1995                 if (p_m_d_l3id&(~0xff) == 0xff00)
1996                         p_m_mISDNport->procids[p_m_d_l3id&0xff] = 0;
1997                 p_m_d_l3id = dinfo;
1998                 p_m_d_ces = resume->ces;
1999         }
2000 #endif
2001
2002         l1l2l3_trace_header(p_m_mISDNport, this, L3_RESUME_IND, DIRECTION_IN);
2003 #ifdef SOCKET_MISDN
2004         dec_ie_call_id(l3m, callid, &len);
2005 #else
2006         dec_ie_call_id(resume->CALL_ID, (Q931_info_t *)((unsigned long)data+headerlen), callid, &len);
2007 #endif
2008         end_trace();
2009
2010         /* if blocked, release call */
2011         if (p_m_mISDNport->ifport->block)
2012         {
2013                 ret = -27;
2014                 goto reject;
2015         }
2016
2017         /* call id */
2018         if (len<0) len = 0;
2019
2020         /* channel_id (no channel is possible in message) */
2021         exclusive = 0;
2022         channel = -1; /* any channel */
2023
2024         /* hunt channel */
2025         ret = channel = hunt_bchannel(channel, exclusive);
2026         if (ret < 0)
2027                 goto no_channel;
2028
2029         /* open channel */
2030         ret = seize_bchannel(channel, 1);
2031         if (ret < 0)
2032         {
2033                 no_channel:
2034                 reject:
2035 #ifdef SOCKET_MISDN
2036                 l3m = create_l3msg();
2037 #else
2038                 dmsg = create_l3msg(CC_RESUME_REJECT | REQUEST, MT_RESUME_REJECT, dinfo, sizeof(RESUME_REJECT_t), p_m_d_ntmode);
2039                 resume_reject = (RESUME_REJECT_t *)(dmsg->data + headerlen);
2040 #endif
2041                 l1l2l3_trace_header(p_m_mISDNport, this, L3_RESUME_REJECT_REQ, DIRECTION_OUT);
2042 #ifdef SOCKET_MISDN
2043                 enc_ie_cause(l3m, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, -ret);
2044 #else
2045                 enc_ie_cause(&resume_reject->CAUSE, dmsg, (p_m_mISDNport->locally)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, -ret);
2046 #endif
2047                 if (ret == -27)
2048                         add_trace("reason", NULL, "port blocked");
2049                 end_trace();
2050 #ifdef SOCKET_MISDN
2051                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_RESUME_REJECT, p_m_d_l3id, l3m);
2052 #else
2053                 msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
2054 #endif
2055                 new_state(PORT_STATE_RELEASE);
2056                 p_m_delete = 1;
2057                 return;
2058         }
2059         bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_USE);
2060
2061         /* create endpoint */
2062         if (p_epointlist)
2063                 FATAL("Incoming resume but already got an endpoint.\n");
2064         ret = -85; /* no call suspended */
2065         epoint = epoint_first;
2066         while(epoint)
2067         {
2068                 if (epoint->ep_park)
2069                 {
2070                         ret = -83; /* suspended call exists, but this not */
2071                         if (epoint->ep_park_len == len)
2072                         if (!memcmp(epoint->ep_park_callid, callid, len))
2073                                 break;
2074                 }
2075                 epoint = epoint->next;
2076         }
2077         if (!epoint)
2078                 goto reject;
2079
2080         epointlist_new(epoint->ep_serial);
2081         if (!(epoint->portlist_new(p_serial, p_type, p_m_mISDNport->earlyb)))
2082                 FATAL("No memory for portlist\n");
2083         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_RESUME);
2084         message_put(message);
2085
2086         /* notify the resume of call */
2087         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_NOTIFY);
2088         message->param.notifyinfo.notify = INFO_NOTIFY_USER_RESUMED;
2089         message->param.notifyinfo.local = 1; /* call is retrieved by supplementary service */
2090         message_put(message);
2091
2092         /* sending RESUME_ACKNOWLEDGE */
2093 #ifdef SOCKET_MISDN
2094         l3m = create_l3msg();
2095 #else
2096         dmsg = create_l3msg(CC_RESUME_ACKNOWLEDGE | REQUEST, MT_RESUME_ACKNOWLEDGE, dinfo, sizeof(RESUME_ACKNOWLEDGE_t), p_m_d_ntmode);
2097         resume_acknowledge = (RESUME_ACKNOWLEDGE_t *)(dmsg->data + headerlen);
2098 #endif
2099         l1l2l3_trace_header(p_m_mISDNport, this, L3_RESUME_ACKNOWLEDGE_REQ, DIRECTION_OUT);
2100 #ifdef SOCKET_MISDN
2101         enc_ie_channel_id(l3m, 1, p_m_b_channel);
2102 #else
2103         enc_ie_channel_id(&resume_acknowledge->CHANNEL_ID, dmsg, 1, p_m_b_channel);
2104 #endif
2105         end_trace();
2106 #ifdef SOCKET_MISDN
2107         p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_RESUME_ACKNOWLEDGE, p_m_d_l3id, l3m);
2108 #else
2109         msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
2110 #endif
2111
2112         new_state(PORT_STATE_CONNECT);
2113 }
2114
2115
2116 /* CC_FACILITY INDICATION */
2117 #ifdef SOCKET_MISDN
2118 void Pdss1::facility_ind(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
2119 {
2120 #else
2121 void Pdss1::facility_ind(unsigned long prim, unsigned long dinfo, void *data)
2122 {
2123         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
2124         FACILITY_t *facility = (FACILITY_t *)((unsigned long)data + headerlen);
2125 #endif
2126         unsigned char facil[256];
2127         int facil_len;
2128         struct message *message;
2129
2130         l1l2l3_trace_header(p_m_mISDNport, this, L3_FACILITY_IND, DIRECTION_IN);
2131 #ifdef SOCKET_MISDN
2132         dec_ie_facility(l3m, facil, &facil_len);
2133 #else
2134         dec_ie_facility(facility->FACILITY, (Q931_info_t *)((unsigned long)data+headerlen), facil, &facil_len);
2135 #endif
2136         end_trace();
2137
2138         /* facility */
2139         if (facil_len<=0)
2140                 return;
2141
2142         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_FACILITY);
2143         message->param.facilityinfo.len = facil_len;
2144         memcpy(message->param.facilityinfo.data, facil, facil_len);
2145         message_put(message);
2146 }
2147
2148
2149 /*
2150  * handler for isdn connections
2151  * incoming information are parsed and sent via message to the endpoint
2152  */
2153 #ifdef SOCKET_MISDN
2154 void Pdss1::message_isdn(unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
2155 {
2156         int timer_hex=0;
2157
2158         switch (cmd)
2159         {
2160                 case MT_TIMEOUT:
2161                 if (!l3m->cause)
2162                 {
2163                         PERROR("Pdss1(%s) timeout without cause.\n", p_name);
2164                         break;
2165                 }
2166                 if (l3m->cause[1] != 5)
2167                 {
2168                         PERROR("Pdss1(%s) expecting timeout with timer diagnostic.\n", p_name);
2169                         break;
2170                 }
2171                 if (l3m->cause[4]=='3' && l3m->cause[5]=='1' && l3m->cause[6]=='2')
2172                 {
2173                         l1l2l3_trace_header(p_m_mISDNport, this, L3_TIMEOUT_IND, DIRECTION_IN);
2174                         add_trace("timer", NULL, "%x", timer_hex);
2175                         end_trace();
2176                         t312_timeout_ind(cmd, pid, l3m);
2177                 }
2178                 break;
2179
2180                 case MT_SETUP:
2181                 if (p_state != PORT_STATE_IDLE)
2182                         break;
2183                 setup_ind(cmd, pid, l3m);
2184                 break;
2185
2186                 case MT_INFORMATION:
2187                 information_ind(cmd, pid, l3m);
2188                 break;
2189
2190                 case MT_SETUP_ACKNOWLEDGE:
2191                 if (p_state != PORT_STATE_OUT_SETUP)
2192                 {
2193                         PERROR("Pdss1(%s) received setup_acknowledge, but we are not in outgoing setup state, IGNORING.\n", p_name);
2194                         break;
2195                 }
2196                 setup_acknowledge_ind(cmd, pid, l3m);
2197                 break;
2198
2199                 case MT_CALL_PROCEEDING:
2200                 if (p_state != PORT_STATE_OUT_SETUP
2201                  && p_state != PORT_STATE_OUT_OVERLAP)
2202                 {
2203                         PERROR("Pdss1(%s) received proceeding, but we are not in outgoing setup OR overlap state, IGNORING.\n", p_name);
2204                         break;
2205                 }
2206                 proceeding_ind(cmd, pid, l3m);
2207                 break;
2208
2209                 case MT_ALERTING:
2210                 if (p_state != PORT_STATE_OUT_SETUP
2211                  && p_state != PORT_STATE_OUT_OVERLAP
2212                  && p_state != PORT_STATE_OUT_PROCEEDING)
2213                 {
2214                         PERROR("Pdss1(%s) received alerting, but we are not in outgoing setup OR overlap OR proceeding state, IGNORING.\n", p_name);
2215                         break;
2216                 }
2217                 alerting_ind(cmd, pid, l3m);
2218                 break;
2219
2220                 case MT_CONNECT:
2221                 if (p_state != PORT_STATE_OUT_SETUP
2222                  && p_state != PORT_STATE_OUT_OVERLAP
2223                  && p_state != PORT_STATE_OUT_PROCEEDING
2224                  && p_state != PORT_STATE_OUT_ALERTING)
2225                 {
2226                         PERROR("Pdss1(%s) received alerting, but we are not in outgoing setup OR overlap OR proceeding OR ALERTING state, IGNORING.\n", p_name);
2227                         break;
2228                 }
2229                 connect_ind(cmd, pid, l3m);
2230                 if (p_m_d_notify_pending)
2231                 {
2232                         /* send pending notify message during connect */
2233                         message_notify(ACTIVE_EPOINT(p_epointlist), p_m_d_notify_pending->type, &p_m_d_notify_pending->param);
2234                         message_free(p_m_d_notify_pending);
2235                         p_m_d_notify_pending = NULL;
2236                 }
2237                 break;
2238
2239                 case MT_CONNECT_ACKNOWLEDGE:
2240                 if (p_state == PORT_STATE_CONNECT_WAITING)
2241                         new_state(PORT_STATE_CONNECT);
2242                 if (p_m_d_notify_pending)
2243                 {
2244                         /* send pending notify message during connect-ack */
2245                         message_notify(ACTIVE_EPOINT(p_epointlist), p_m_d_notify_pending->type, &p_m_d_notify_pending->param);
2246                         message_free(p_m_d_notify_pending);
2247                         p_m_d_notify_pending = NULL;
2248                 }
2249                 break;
2250
2251                 case MT_DISCONNECT:
2252                 disconnect_ind(cmd, pid, l3m);
2253                 break;
2254
2255                 case MT_RELEASE:
2256                 release_ind(cmd, pid, l3m);
2257                 break;
2258
2259                 case MT_RELEASE_COMPLETE:
2260                 release_complete_ind(cmd, pid, l3m);
2261                 break;
2262
2263                 case MT_NOTIFY:
2264                 notify_ind(cmd, pid, l3m);
2265                 break;
2266
2267                 case MT_HOLD:
2268                 hold_ind(cmd, pid, l3m);
2269                 break;
2270
2271                 case MT_RETRIEVE:
2272                 retrieve_ind(cmd, pid, l3m);
2273                 break;
2274
2275                 case MT_SUSPEND:
2276                 suspend_ind(cmd, pid, l3m);
2277                 break;
2278
2279                 case MT_RESUME:
2280                 resume_ind(cmd, pid, l3m);
2281                 break;
2282
2283                 case MT_FACILITY:
2284                 facility_ind(cmd, pid, l3m);
2285                 break;
2286
2287                 case MT_FREE:
2288                 l1l2l3_trace_header(p_m_mISDNport, this, L3_RELEASE_L3ID_IND, DIRECTION_IN);
2289                 add_trace("callref", NULL, "0x%x", p_m_d_l3id);
2290                 end_trace();
2291                 p_m_d_l3id = 0;
2292                 p_m_d_ces = -1;
2293                 p_m_delete = 1;
2294 //#warning remove me
2295 //PDEBUG(DEBUG_LOG, "JOLLY release cr %d\n", p_serial);
2296                 /* sending release to endpoint in case we still have an endpoint
2297                  * this is because we don't get any response if a release_complete is received (or a release in release state)
2298                  */
2299                 while(p_epointlist)
2300                 {
2301                         struct message *message;
2302                         message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
2303                         message->param.disconnectinfo.cause = (p_m_d_collect_cause!=CAUSE_NOUSER)?p_m_d_collect_cause:CAUSE_UNSPECIFIED;
2304                         message->param.disconnectinfo.location = (p_m_d_collect_cause!=CAUSE_NOUSER)?p_m_d_collect_location:LOCATION_PRIVATE_LOCAL;
2305                         message_put(message);
2306                         /* remove epoint */
2307                         free_epointlist(p_epointlist);
2308
2309                         new_state(PORT_STATE_RELEASE);
2310                 }
2311                 break;
2312
2313                 default:
2314                 l1l2l3_trace_header(p_m_mISDNport, this, L3_UNKNOWN, DIRECTION_IN);
2315                 add_trace("unhandled", "cmd", "0x%x", cmd);
2316                 end_trace();
2317         }
2318 }
2319 #else
2320 void Pdss1::message_isdn(unsigned long prim, unsigned long dinfo, void *data)
2321 {
2322         int new_l3id;
2323         int timer_hex=0;
2324
2325         switch (prim)
2326         {
2327                 case CC_TIMEOUT | INDICATION:
2328                 if (p_m_d_ntmode)
2329                 {
2330                         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
2331                         timer_hex = *((int *)(((char *)data)+headerlen));
2332                 }
2333                 if (timer_hex==0x312 && p_m_d_ntmode)
2334                 {
2335                         l1l2l3_trace_header(p_m_mISDNport, this, L3_TIMEOUT_IND, DIRECTION_IN);
2336                         add_trace("timer", NULL, "%x", timer_hex);
2337                         end_trace();
2338                         t312_timeout_ind(prim, dinfo, data);
2339                 }
2340                 break;
2341
2342                 case CC_SETUP | INDICATION:
2343                 if (p_state != PORT_STATE_IDLE)
2344                         break;
2345                 setup_ind(prim, dinfo, data);
2346                 break;
2347
2348                 case CC_SETUP | CONFIRM:
2349                 if (p_m_d_ntmode)
2350                 {
2351                         l1l2l3_trace_header(p_m_mISDNport, this, L3_NEW_CR_IND, DIRECTION_IN);
2352                         add_trace("callref", "old", "0x%x", p_m_d_l3id);
2353                         /* nt-library now gives us a new id via CC_SETUP_CONFIRM */
2354                         if ((p_m_d_l3id&0xff00) != 0xff00)
2355                                 PERROR("    strange setup-procid 0x%x\n", p_m_d_l3id);
2356                         p_m_d_l3id = *((int *)(((u_char *)data)+ mISDNUSER_HEAD_SIZE));
2357                         add_trace("callref", "new", "0x%x", p_m_d_l3id);
2358                         end_trace();
2359                 }
2360                 break;
2361
2362                 case CC_INFORMATION | INDICATION:
2363                 information_ind(prim, dinfo, data);
2364                 break;
2365
2366                 case CC_SETUP_ACKNOWLEDGE | INDICATION:
2367                 if (p_state != PORT_STATE_OUT_SETUP)
2368                 {
2369                         PERROR("Pdss1(%s) received setup_acknowledge, but we are not in outgoing setup state, IGNORING.\n", p_name);
2370                         break;
2371                 }
2372                 setup_acknowledge_ind(prim, dinfo, data);
2373                 break;
2374
2375                 case CC_PROCEEDING | INDICATION:
2376                 if (p_state != PORT_STATE_OUT_SETUP
2377                  && p_state != PORT_STATE_OUT_OVERLAP)
2378                 {
2379                         PERROR("Pdss1(%s) received proceeding, but we are not in outgoing setup OR overlap state, IGNORING.\n", p_name);
2380                         break;
2381                 }
2382                 proceeding_ind(prim, dinfo, data);
2383                 break;
2384
2385                 case CC_ALERTING | INDICATION:
2386                 if (p_state != PORT_STATE_OUT_SETUP
2387                  && p_state != PORT_STATE_OUT_OVERLAP
2388                  && p_state != PORT_STATE_OUT_PROCEEDING)
2389                 {
2390                         PERROR("Pdss1(%s) received alerting, but we are not in outgoing setup OR overlap OR proceeding state, IGNORING.\n", p_name);
2391                         break;
2392                 }
2393                 alerting_ind(prim, dinfo, data);
2394                 break;
2395
2396                 case CC_CONNECT | INDICATION:
2397                 if (p_state != PORT_STATE_OUT_SETUP
2398                  && p_state != PORT_STATE_OUT_OVERLAP
2399                  && p_state != PORT_STATE_OUT_PROCEEDING
2400                  && p_state != PORT_STATE_OUT_ALERTING)
2401                 {
2402                         PERROR("Pdss1(%s) received alerting, but we are not in outgoing setup OR overlap OR proceeding OR ALERTING state, IGNORING.\n", p_name);
2403                         break;
2404                 }
2405                 connect_ind(prim, dinfo, data);
2406                 if (p_m_d_notify_pending)
2407                 {
2408                         /* send pending notify message during connect */
2409                         message_notify(ACTIVE_EPOINT(p_epointlist), p_m_d_notify_pending->type, &p_m_d_notify_pending->param);
2410                         message_free(p_m_d_notify_pending);
2411                         p_m_d_notify_pending = NULL;
2412                 }
2413                 break;
2414
2415                 case CC_CONNECT_ACKNOWLEDGE | INDICATION:
2416                 case CC_CONNECT | CONFIRM:
2417                 if (p_state == PORT_STATE_CONNECT_WAITING)
2418                         new_state(PORT_STATE_CONNECT);
2419                 if (p_m_d_notify_pending)
2420                 {
2421                         /* send pending notify message during connect-ack */
2422                         message_notify(ACTIVE_EPOINT(p_epointlist), p_m_d_notify_pending->type, &p_m_d_notify_pending->param);
2423                         message_free(p_m_d_notify_pending);
2424                         p_m_d_notify_pending = NULL;
2425                 }
2426                 break;
2427
2428                 case CC_DISCONNECT | INDICATION:
2429                 disconnect_ind(prim, dinfo, data);
2430                 break;
2431
2432                 case CC_RELEASE | CONFIRM:
2433                 case CC_RELEASE | INDICATION:
2434                 release_ind(prim, dinfo, data);
2435                 break;
2436
2437                 case CC_RELEASE_COMPLETE | INDICATION:
2438                 release_complete_ind(prim, dinfo, data);
2439                 break;
2440
2441                 case CC_RELEASE_COMPLETE | CONFIRM:
2442                 break;
2443
2444                 case CC_NOTIFY | INDICATION:
2445                 notify_ind(prim, dinfo, data);
2446                 break;
2447
2448                 case CC_HOLD | INDICATION:
2449                 hold_ind(prim, dinfo, data);
2450                 break;
2451
2452                 case CC_RETRIEVE | INDICATION:
2453                 retrieve_ind(prim, dinfo, data);
2454                 break;
2455
2456                 case CC_SUSPEND | INDICATION:
2457                 suspend_ind(prim, dinfo, data);
2458                 break;
2459
2460                 case CC_RESUME | INDICATION:
2461                 resume_ind(prim, dinfo, data);
2462                 break;
2463
2464                 case CC_FACILITY | INDICATION:
2465                 facility_ind(prim, dinfo, data);
2466                 break;
2467
2468                 case CC_RELEASE_CR | INDICATION:
2469                 l1l2l3_trace_header(p_m_mISDNport, this, L3_RELEASE_CR_IND, DIRECTION_IN);
2470                 add_trace("callref", NULL, "0x%x", p_m_d_l3id);
2471                 end_trace();
2472                 if (p_m_d_ntmode)
2473                 {
2474                         if ((p_m_d_l3id&0xff00) == 0xff00)
2475                                 p_m_mISDNport->procids[p_m_d_l3id&0xff] = 0;
2476                 }
2477                 p_m_d_l3id = 0;
2478                 p_m_d_ces = -1;
2479                 p_m_delete = 1;
2480 //#warning remove me
2481 //PDEBUG(DEBUG_LOG, "JOLLY release cr %d\n", p_serial);
2482                 /* sending release to endpoint in case we still have an endpoint
2483                  * this is because we don't get any response if a release_complete is received (or a release in release state)
2484                  */
2485                 while(p_epointlist)
2486                 {
2487                         struct message *message;
2488                         message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
2489                         message->param.disconnectinfo.cause = (p_m_d_collect_cause!=CAUSE_NOUSER)?p_m_d_collect_cause:CAUSE_UNSPECIFIED;
2490                         message->param.disconnectinfo.location = (p_m_d_collect_cause!=CAUSE_NOUSER)?p_m_d_collect_location:LOCATION_PRIVATE_LOCAL;
2491                         message_put(message);
2492                         /* remove epoint */
2493                         free_epointlist(p_epointlist);
2494
2495                         new_state(PORT_STATE_RELEASE);
2496                 }
2497                 break;
2498
2499                 case CC_NEW_CR | INDICATION:
2500                 l1l2l3_trace_header(p_m_mISDNport, this, L3_NEW_CR_IND, DIRECTION_IN);
2501                 if (p_m_d_l3id)
2502                         add_trace("callref", "old", "0x%x", p_m_d_l3id);
2503                 if (p_m_d_ntmode)
2504                 {
2505                         new_l3id = *((int *)(((u_char *)data+mISDNUSER_HEAD_SIZE)));
2506                         if (((new_l3id&0xff00)!=0xff00) && ((p_m_d_l3id&0xff00)==0xff00))
2507                                 p_m_mISDNport->procids[p_m_d_l3id&0xff] = 0;
2508                 } else
2509                 {
2510                         new_l3id = dinfo;
2511                 }
2512                 p_m_d_l3id = new_l3id;
2513                 add_trace("callref", "new", "0x%x", p_m_d_l3id);
2514                 end_trace();
2515                 break;
2516
2517                 default:
2518                 l1l2l3_trace_header(p_m_mISDNport, this, L3_UNKNOWN, DIRECTION_IN);
2519                 add_trace("unhandled", "prim", "0x%x", prim);
2520                 end_trace();
2521         }
2522 }
2523 #endif
2524
2525 void Pdss1::new_state(int state)
2526 {
2527 //      class Endpoint *epoint;
2528
2529         /* set timeout */
2530         if (state == PORT_STATE_IN_OVERLAP)
2531         {
2532                 p_m_timeout = p_m_mISDNport->ifport->tout_dialing;
2533                 time(&p_m_timer);
2534         }
2535         if (state != p_state)
2536         {
2537                 if (state == PORT_STATE_IN_SETUP
2538                  || state == PORT_STATE_OUT_SETUP
2539                  || state == PORT_STATE_IN_OVERLAP
2540                  || state == PORT_STATE_OUT_OVERLAP)
2541                 {
2542                         p_m_timeout = p_m_mISDNport->ifport->tout_setup;
2543                         time(&p_m_timer);
2544                 }
2545                 if (state == PORT_STATE_IN_PROCEEDING
2546                  || state == PORT_STATE_OUT_PROCEEDING)
2547                 {
2548                         p_m_timeout = p_m_mISDNport->ifport->tout_proceeding;
2549                         time(&p_m_timer);
2550                 }
2551                 if (state == PORT_STATE_IN_ALERTING
2552                  || state == PORT_STATE_OUT_ALERTING)
2553                 {
2554                         p_m_timeout = p_m_mISDNport->ifport->tout_alerting;
2555                         time(&p_m_timer);
2556                 }
2557                 if (state == PORT_STATE_CONNECT
2558                  || state == PORT_STATE_CONNECT_WAITING)
2559                 {
2560                         p_m_timeout = 0;
2561                 }
2562                 if (state == PORT_STATE_IN_DISCONNECT
2563                  || state == PORT_STATE_OUT_DISCONNECT)
2564                 {
2565                         p_m_timeout = p_m_mISDNport->ifport->tout_disconnect;
2566                         time(&p_m_timer);
2567                 }
2568         }
2569         
2570         Port::new_state(state);
2571 }
2572
2573
2574 /*
2575  * handler
2576  */
2577 int Pdss1::handler(void)
2578 {
2579         int ret;
2580
2581         if ((ret = PmISDN::handler()))
2582                 return(ret);
2583
2584         /* handle destruction */
2585         if (p_m_delete && p_m_d_l3id==0)
2586         {
2587                 delete this;
2588                 return(-1);
2589         }
2590
2591         return(0);
2592 }
2593
2594
2595 /*
2596  * handles all messages from endpoint
2597  */
2598 /* MESSAGE_INFORMATION */
2599 void Pdss1::message_information(unsigned long epoint_id, int message_id, union parameter *param)
2600 {
2601 #ifdef SOCKET_MISDN
2602         l3_msg *l3m;
2603 #else
2604         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
2605         msg_t *dmsg;
2606         INFORMATION_t *information;
2607 #endif
2608
2609         if (param->information.id[0]) /* only if we have something to dial */
2610         {
2611 #ifdef SOCKET_MISDN
2612                 l3m = create_l3msg();
2613 #else
2614                 dmsg = create_l3msg(CC_INFORMATION | REQUEST, MT_INFORMATION, p_m_d_l3id, sizeof(INFORMATION_t), p_m_d_ntmode);
2615                 information = (INFORMATION_t *)(dmsg->data + headerlen);
2616 #endif
2617                 l1l2l3_trace_header(p_m_mISDNport, this, L3_INFORMATION_REQ, DIRECTION_OUT);
2618 #ifdef SOCKET_MISDN
2619                 enc_ie_called_pn(l3m, 0, 1, (unsigned char *)param->information.id);
2620 #else
2621                 enc_ie_called_pn(&information->CALLED_PN, dmsg, 0, 1, (unsigned char *)param->information.id);
2622 #endif
2623                 end_trace();
2624 #ifdef SOCKET_MISDN
2625                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_INFORMATION, p_m_d_l3id, l3m);
2626 #else
2627                 msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
2628 #endif
2629         }
2630         new_state(p_state);
2631 }
2632
2633
2634 int newteid = 0;
2635
2636 /* MESSAGE_SETUP */
2637 void Pdss1::message_setup(unsigned long epoint_id, int message_id, union parameter *param)
2638 {
2639 #ifdef SOCKET_MISDN
2640         l3_msg *l3m;
2641         int ret;
2642 #else
2643         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
2644         msg_t *dmsg;
2645         INFORMATION_t *information;
2646         SETUP_t *setup;
2647         int i;
2648 #endif
2649         int plan, type, screen, present, reason;
2650         int capability, mode, rate, coding, user, presentation, interpretation, hlc, exthlc;
2651         int channel, exclusive;
2652         struct epoint_list *epointlist;
2653
2654         /* release if port is blocked */
2655         if (p_m_mISDNport->ifport->block)
2656         {
2657                 struct message *message;
2658
2659                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE);
2660                 message->param.disconnectinfo.cause = 27; // temp. unavail.
2661                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2662                 message_put(message);
2663                 new_state(PORT_STATE_RELEASE);
2664                 p_m_delete = 1;
2665                 return;
2666         }
2667
2668         /* copy setup infos to port */
2669         memcpy(&p_callerinfo, &param->setup.callerinfo, sizeof(p_callerinfo));
2670         memcpy(&p_dialinginfo, &param->setup.dialinginfo, sizeof(p_dialinginfo));
2671         memcpy(&p_capainfo, &param->setup.capainfo, sizeof(p_capainfo));
2672         memcpy(&p_redirinfo, &param->setup.redirinfo, sizeof(p_redirinfo));
2673 //              SCPY(&p_m_tones_dir, param->setup.ext.tones_dir);
2674         /* screen outgoing caller id */
2675         do_screen(1, p_callerinfo.id, sizeof(p_callerinfo.id), &p_callerinfo.ntype, &p_callerinfo.present, p_m_mISDNport->ifport->interface);
2676
2677         /* only display at connect state: this case happens if endpoint is in connected mode */
2678         if (p_state==PORT_STATE_CONNECT)
2679         {
2680                 if (p_type!=PORT_TYPE_DSS1_NT_OUT
2681                  && p_type!=PORT_TYPE_DSS1_NT_IN)
2682                         return;
2683                 if (p_callerinfo.display[0])
2684                 {
2685                         /* sending information */
2686 #ifdef SOCKET_MISDN
2687                         l3m = create_l3msg();
2688 #else
2689                         dmsg = create_l3msg(CC_INFORMATION | REQUEST, MT_INFORMATION, p_m_d_l3id, sizeof(INFORMATION_t), p_m_d_ntmode);
2690                         information = (INFORMATION_t *)(dmsg->data + headerlen);
2691 #endif
2692                         l1l2l3_trace_header(p_m_mISDNport, this, L3_INFORMATION_REQ, DIRECTION_OUT);
2693                         if (p_m_d_ntmode)
2694 #ifdef SOCKET_MISDN
2695                                 enc_ie_display(l3m, (unsigned char *)p_callerinfo.display);
2696 #else
2697                                 enc_ie_display(&information->DISPLAY, dmsg, (unsigned char *)p_callerinfo.display);
2698 #endif
2699                         end_trace();
2700 #ifdef SOCKET_MISDN
2701                         p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_INFORMATION, p_m_d_l3id, l3m);
2702 #else
2703                         msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
2704 #endif
2705                         return;
2706                 }
2707         }
2708
2709         /* attach only if not already */
2710         epointlist = p_epointlist;
2711         while(epointlist)
2712         {
2713                 if (epointlist->epoint_id == epoint_id)
2714                         break;
2715                 epointlist = epointlist->next;
2716         }
2717         if (!epointlist)
2718                 epointlist_new(epoint_id);
2719
2720         /* get channel */
2721         exclusive = 0;
2722         if (p_m_b_channel)
2723         {
2724                 channel = p_m_b_channel;
2725                 exclusive = p_m_b_exclusive;
2726         } else
2727                 channel = CHANNEL_ANY;
2728         /* nt-port with no channel, not reserverd */
2729         if (!p_m_b_channel && !p_m_b_reserve && p_type==PORT_TYPE_DSS1_NT_OUT)
2730                 channel = CHANNEL_NO;
2731
2732 #ifdef SOCKET_MISDN
2733         /* creating l3id */
2734         l1l2l3_trace_header(p_m_mISDNport, this, L3_NEW_L3ID_REQ, DIRECTION_OUT);
2735         /* see MT_ASSIGN notes at do_layer3() */
2736         mt_assign_pid = 0;
2737         ret = p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_ASSIGN, 0, NULL);
2738         if (mt_assign_pid == 0 || ret < 0)
2739         {
2740                 struct message *message;
2741
2742                 add_trace("callref", NULL, "no free id");
2743                 end_trace();
2744                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE);
2745                 message->param.disconnectinfo.cause = 47;
2746                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2747                 message_put(message);
2748                 new_state(PORT_STATE_RELEASE);
2749                 p_m_delete = 1;
2750                 return;
2751         }
2752         p_m_d_l3id = mt_assign_pid;
2753         mt_assign_pid = ~0;
2754 #else
2755         /* creating l3id */
2756         l1l2l3_trace_header(p_m_mISDNport, this, L3_NEW_CR_REQ, DIRECTION_OUT);
2757         if (p_m_d_ntmode)
2758         {
2759                 i = 0;
2760                 while(i < 0x100)
2761                 {
2762                         if (p_m_mISDNport->procids[i] == 0)
2763                                 break;
2764                         i++;
2765                 }
2766                 if (i == 0x100)
2767                 {
2768                         struct message *message;
2769
2770                         add_trace("callref", NULL, "no free id");
2771                         end_trace();
2772                         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE);
2773                         message->param.disconnectinfo.cause = 47;
2774                         message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2775                         message_put(message);
2776                         new_state(PORT_STATE_RELEASE);
2777                         p_m_delete = 1;
2778                         return;
2779                 }
2780                 p_m_mISDNport->procids[i] = 1;
2781                 p_m_d_l3id = 0xff00 | i;
2782         } else
2783         {
2784                 iframe_t ncr;
2785                 /* if we are in te-mode, we need to create a process first */
2786                 if (newteid++ > 0x7fff)
2787                         newteid = 0x0001;
2788                 p_m_d_l3id = (entity<<16) | newteid;
2789                 /* preparing message */
2790                 ncr.prim = CC_NEW_CR | REQUEST; 
2791                 ncr.addr = p_m_mISDNport->upper_id | FLG_MSG_DOWN;
2792                 ncr.dinfo = p_m_d_l3id;
2793                 ncr.len = 0;
2794                 /* send message */
2795                 mISDN_write(mISDNdevice, &ncr, mISDN_HEADER_LEN+ncr.len, TIMEOUT_1SEC);
2796 //              if (!dmsg)
2797 //                      goto nomem;
2798         }
2799         add_trace("callref", "new", "0x%x", p_m_d_l3id);
2800 #endif
2801         end_trace();
2802
2803         /* preparing setup message */
2804 #ifdef SOCKET_MISDN
2805         l3m = create_l3msg();
2806 #else
2807         dmsg = create_l3msg(CC_SETUP | REQUEST, MT_SETUP, p_m_d_l3id, sizeof(SETUP_t), p_m_d_ntmode);
2808         setup = (SETUP_t *)(dmsg->data + headerlen);
2809 #endif
2810         l1l2l3_trace_header(p_m_mISDNport, this, L3_SETUP_REQ, DIRECTION_OUT);
2811         /* channel information */
2812         if (channel >= 0) /* it should */
2813         {
2814 #ifdef SOCKET_MISDN
2815                 enc_ie_channel_id(l3m, exclusive, channel);
2816 #else
2817                 enc_ie_channel_id(&setup->CHANNEL_ID, dmsg, exclusive, channel);
2818 #endif
2819         }
2820         /* caller information */
2821         plan = 1;
2822         switch (p_callerinfo.ntype)
2823         {
2824                 case INFO_NTYPE_INTERNATIONAL:
2825                 type = 0x1;
2826                 break;
2827                 case INFO_NTYPE_NATIONAL:
2828                 type = 0x2;
2829                 break;
2830                 case INFO_NTYPE_SUBSCRIBER:
2831                 type = 0x4;
2832                 break;
2833                 default: /* INFO_NTYPE_UNKNOWN */
2834                 type = 0x0;
2835                 break;
2836         }
2837         switch (p_callerinfo.screen)
2838         {
2839                 case INFO_SCREEN_USER:
2840                 screen = 0;
2841                 break;
2842                 default: /* INFO_SCREEN_NETWORK */
2843                 screen = 3;
2844                 break;
2845         }
2846         switch (p_callerinfo.present)
2847         {
2848                 case INFO_PRESENT_RESTRICTED:
2849                 present = 1;
2850                 break;
2851                 case INFO_PRESENT_NOTAVAIL:
2852                 present = 2;
2853                 break;
2854                 default: /* INFO_PRESENT_ALLOWED */
2855                 present = 0;
2856                 break;
2857         }
2858         if (type >= 0)
2859 #ifdef SOCKET_MISDN
2860                 enc_ie_calling_pn(l3m, type, plan, present, screen, (unsigned char *)p_callerinfo.id);
2861 #else
2862                 enc_ie_calling_pn(&setup->CALLING_PN, dmsg, type, plan, present, screen, (unsigned char *)p_callerinfo.id);
2863 #endif
2864         /* dialing information */
2865         if (p_dialinginfo.id[0]) /* only if we have something to dial */
2866         {
2867 #ifdef SOCKET_MISDN
2868                 enc_ie_called_pn(l3m, 0, 1, (unsigned char *)p_dialinginfo.id);
2869 #else
2870                 enc_ie_called_pn(&setup->CALLED_PN, dmsg, 0, 1, (unsigned char *)p_dialinginfo.id);
2871 #endif
2872         }
2873         /* sending complete */
2874         if (p_dialinginfo.sending_complete)
2875 #ifdef SOCKET_MISDN
2876                 enc_ie_complete(l3m, 1);
2877 #else
2878                 enc_ie_complete(&setup->COMPLETE, dmsg, 1);
2879 #endif
2880         /* sending user-user */
2881         if (param->setup.useruser.len)
2882         {
2883 #ifdef SOCKET_MISDN
2884                 enc_ie_useruser(l3m, param->setup.useruser.protocol, param->setup.useruser.data, param->setup.useruser.len);
2885 #else
2886                 enc_ie_useruser(&setup->USER_USER, dmsg, param->setup.useruser.protocol, param->setup.useruser.data, param->setup.useruser.len);
2887 #endif
2888         }
2889         /* redirecting number */
2890         plan = 1;
2891         switch (p_redirinfo.ntype)
2892         {
2893                 case INFO_NTYPE_INTERNATIONAL:
2894                 type = 0x1;
2895                 break;
2896                 case INFO_NTYPE_NATIONAL:
2897                 type = 0x2;
2898                 break;
2899                 case INFO_NTYPE_SUBSCRIBER:
2900                 type = 0x4;
2901                 break;
2902                 default: /* INFO_NTYPE_UNKNOWN */
2903                 type = 0x0;
2904                 break;
2905         }
2906         switch (p_redirinfo.screen)
2907         {
2908                 case INFO_SCREEN_USER:
2909                 screen = 0;
2910                 break;
2911                 default: /* INFO_SCREE_NETWORK */
2912                 screen = 3;
2913                 break;
2914         }
2915         switch (p_redirinfo.reason)
2916         {
2917                 case INFO_REDIR_BUSY:
2918                 reason = 1;
2919                 break;
2920                 case INFO_REDIR_NORESPONSE:
2921                 reason = 2;
2922                 break;
2923                 case INFO_REDIR_UNCONDITIONAL:
2924                 reason = 15;
2925                 break;
2926                 case INFO_REDIR_CALLDEFLECT:
2927                 reason = 10;
2928                 break;
2929                 case INFO_REDIR_OUTOFORDER:
2930                 reason = 9;
2931                 break;
2932                 default: /* INFO_REDIR_UNKNOWN */
2933                 reason = 0;
2934                 break;
2935         }
2936         switch (p_redirinfo.present)
2937         {
2938                 case INFO_PRESENT_NULL: /* no redir at all */
2939                 present = -1;
2940                 screen = -1;
2941                 reason = -1;
2942                 plan = -1;
2943                 type = -1;
2944                 break;
2945                 case INFO_PRESENT_RESTRICTED:
2946                 present = 1;
2947                 break;
2948                 case INFO_PRESENT_NOTAVAIL:
2949                 present = 2;
2950                 break;
2951                 default: /* INFO_PRESENT_ALLOWED */
2952                 present = 0;
2953                 break;
2954         }
2955         /* sending redirecting number only in ntmode */
2956         if (type >= 0 && p_m_d_ntmode)
2957 #ifdef SOCKET_MISDN
2958                 enc_ie_redir_nr(l3m, type, plan, present, screen, reason, (unsigned char *)p_redirinfo.id);
2959 #else
2960                 enc_ie_redir_nr(&setup->REDIR_NR, dmsg, type, plan, present, screen, reason, (unsigned char *)p_redirinfo.id);
2961 #endif
2962         /* bearer capability */
2963 //printf("hlc=%d\n",p_capainfo.hlc);
2964         coding = 0;
2965         capability = p_capainfo.bearer_capa;
2966         mode = p_capainfo.bearer_mode;
2967         rate = (mode==INFO_BMODE_CIRCUIT)?0x10:0x00;
2968         switch (p_capainfo.bearer_info1)
2969         {
2970                 case INFO_INFO1_NONE:
2971                 user = -1;
2972                 break;
2973                 default:
2974                 user = p_capainfo.bearer_info1 & 0x7f;
2975                 break;
2976         }
2977 #ifdef SOCKET_MISDN
2978         enc_ie_bearer(l3m, coding, capability, mode, rate, -1, user);
2979 #else
2980         enc_ie_bearer(&setup->BEARER, dmsg, coding, capability, mode, rate, -1, user);
2981 #endif
2982         /* hlc */
2983         if (p_capainfo.hlc)
2984         {
2985                 coding = 0;
2986                 interpretation = 4;
2987                 presentation = 1;
2988                 hlc = p_capainfo.hlc & 0x7f;
2989                 exthlc = -1;
2990                 if (p_capainfo.exthlc)
2991                         exthlc = p_capainfo.exthlc & 0x7f;
2992 #ifdef SOCKET_MISDN
2993                 enc_ie_hlc(l3m, coding, interpretation, presentation, hlc, exthlc);
2994 #else
2995                 enc_ie_hlc(&setup->HLC, dmsg, coding, interpretation, presentation, hlc, exthlc);
2996 #endif
2997         }
2998
2999         /* display */
3000         if (p_callerinfo.display[0] && p_m_d_ntmode)
3001 #ifdef SOCKET_MISDN
3002                 enc_ie_display(l3m, (unsigned char *)p_callerinfo.display);
3003 #else
3004                 enc_ie_display(&setup->DISPLAY, dmsg, (unsigned char *)p_callerinfo.display);
3005 #endif
3006         /* nt-mode: CNIP (calling name identification presentation) */
3007 //      if (p_callerinfo.name[0] && p_m_d_ntmode)
3008 //              enc_facility_centrex(&setup->FACILITY, dmsg, (unsigned char *)p_callerinfo.name, 1);
3009         end_trace();
3010
3011         /* send setup message now */
3012 #ifdef SOCKET_MISDN
3013         p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_SETUP, p_m_d_l3id, l3m);
3014 #else
3015         msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
3016 #endif
3017
3018         new_state(PORT_STATE_OUT_SETUP);
3019 }
3020
3021 /* MESSAGE_FACILITY */
3022 void Pdss1::message_facility(unsigned long epoint_id, int message_id, union parameter *param)
3023 {
3024 #ifdef SOCKET_MISDN
3025         l3_msg *l3m;
3026 #else
3027         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
3028         msg_t *dmsg;
3029         FACILITY_t *facility;
3030 #endif
3031
3032         /* facility will not be sent to external lines */
3033         if (!p_m_d_ntmode)
3034                 return;
3035
3036         /* sending facility */
3037 #ifdef SOCKET_MISDN
3038         l3m = create_l3msg();
3039 #else
3040         dmsg = create_l3msg(CC_FACILITY | REQUEST, MT_FACILITY, p_m_d_l3id, sizeof(FACILITY_t), p_m_d_ntmode);
3041         facility = (FACILITY_t *)(dmsg->data + headerlen);
3042 #endif
3043         l1l2l3_trace_header(p_m_mISDNport, this, L3_FACILITY_REQ, DIRECTION_OUT);
3044 #ifdef SOCKET_MISDN
3045         enc_ie_facility(l3m, (unsigned char *)param->facilityinfo.data, param->facilityinfo.len);
3046 #else
3047         enc_ie_facility(&facility->FACILITY, dmsg, (unsigned char *)param->facilityinfo.data, param->facilityinfo.len);
3048 #endif
3049         end_trace();
3050 #ifdef SOCKET_MISDN
3051         p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_FACILITY, p_m_d_l3id, l3m);
3052 #else
3053         msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
3054 #endif
3055 }
3056
3057 /* MESSAGE_NOTIFY */
3058 void Pdss1::message_notify(unsigned long epoint_id, int message_id, union parameter *param)
3059 {
3060 #ifdef SOCKET_MISDN
3061         l3_msg *l3m;
3062 #else
3063         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
3064         msg_t *dmsg;
3065         INFORMATION_t *information;
3066         NOTIFY_t *notification;
3067 #endif
3068         int notify;
3069         int plan, type = -1, present;
3070
3071         if (param->notifyinfo.notify>INFO_NOTIFY_NONE)
3072                 notify = param->notifyinfo.notify & 0x7f;
3073         else
3074                 notify = -1;
3075         if (p_state != PORT_STATE_CONNECT)
3076         {
3077                 /* notify only allowed in active state */
3078                 notify = -1;
3079         }
3080         if (notify >= 0)
3081         {
3082                 plan = 1;
3083                 switch (param->notifyinfo.ntype)
3084                 {
3085                         case INFO_NTYPE_INTERNATIONAL:
3086                         type = 1;
3087                         break;
3088                         case INFO_NTYPE_NATIONAL:
3089                         type = 2;
3090                         break;
3091                         case INFO_NTYPE_SUBSCRIBER:
3092                         type = 4;
3093                         break;
3094                         default: /* INFO_NTYPE_UNKNOWN */
3095                         type = 0;
3096                         break;
3097                 }
3098                 switch (param->notifyinfo.present)
3099                 {
3100                         case INFO_PRESENT_NULL: /* no redir at all */
3101                         present = -1;
3102                         plan = -1;
3103                         type = -1;
3104                         break;
3105                         case INFO_PRESENT_RESTRICTED:
3106                         present = 1;
3107                         break;
3108                         case INFO_PRESENT_NOTAVAIL:
3109                         present = 2;
3110                         break;
3111                         default: /* INFO_PRESENT_ALLOWED */
3112                         present = 0;
3113                         break;
3114                 }
3115         }
3116
3117         if (notify<0 && !param->notifyinfo.display[0])
3118         {
3119                 /* nothing to notify, nothing to display */
3120                 return;
3121         }
3122
3123         if (notify >= 0)
3124         {
3125                 if (p_state!=PORT_STATE_CONNECT)
3126                 {
3127                         /* queue notification */
3128                         if (p_m_d_notify_pending)
3129                                 message_free(p_m_d_notify_pending);
3130                         p_m_d_notify_pending = message_create(ACTIVE_EPOINT(p_epointlist), p_serial, EPOINT_TO_PORT, message_id);
3131                         memcpy(&p_m_d_notify_pending->param, param, sizeof(union parameter));
3132                 } else
3133                 {
3134                         /* sending notification */
3135 #ifdef SOCKET_MISDN
3136                         l3m = create_l3msg();
3137 #else
3138                         dmsg = create_l3msg(CC_NOTIFY | REQUEST, MT_NOTIFY, p_m_d_l3id, sizeof(NOTIFY_t), p_m_d_ntmode);
3139                         notification = (NOTIFY_t *)(dmsg->data + headerlen);
3140 #endif
3141                         l1l2l3_trace_header(p_m_mISDNport, this, L3_NOTIFY_REQ, DIRECTION_OUT);
3142 #ifdef SOCKET_MISDN
3143                         enc_ie_notify(l3m, notify);
3144 #else
3145                         enc_ie_notify(&notification->NOTIFY, dmsg, notify);
3146 #endif
3147                         /* sending redirection number only in ntmode */
3148                         if (type >= 0 && p_m_d_ntmode)
3149 #ifdef SOCKET_MISDN
3150                                 enc_ie_redir_dn(l3m, type, plan, present, (unsigned char *)param->notifyinfo.id);
3151 #else
3152                                 enc_ie_redir_dn(&notification->REDIR_DN, dmsg, type, plan, present, (unsigned char *)param->notifyinfo.id);
3153 #endif
3154                         if (param->notifyinfo.display[0] && p_m_d_ntmode)
3155 #ifdef SOCKET_MISDN
3156                                 enc_ie_display(l3m, (unsigned char *)param->notifyinfo.display);
3157 #else
3158                                 enc_ie_display(&notification->DISPLAY, dmsg, (unsigned char *)param->notifyinfo.display);
3159 #endif
3160                         end_trace();
3161 #ifdef SOCKET_MISDN
3162                         p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_NOTIFY, p_m_d_l3id, l3m);
3163 #else
3164                         msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
3165 #endif
3166                 }
3167         } else if (p_m_d_ntmode)
3168         {
3169                 /* sending information */
3170 #ifdef SOCKET_MISDN
3171                 l3m = create_l3msg();
3172 #else
3173                 dmsg = create_l3msg(CC_INFORMATION | REQUEST, MT_INFORMATION, p_m_d_l3id, sizeof(INFORMATION_t), p_m_d_ntmode);
3174                 information = (INFORMATION_t *)(dmsg->data + headerlen);
3175 #endif
3176                 l1l2l3_trace_header(p_m_mISDNport, this, L3_INFORMATION_REQ, DIRECTION_OUT);
3177 #ifdef SOCKET_MISDN
3178                 enc_ie_display(l3m, (unsigned char *)param->notifyinfo.display);
3179 #else
3180                 enc_ie_display(&information->DISPLAY, dmsg, (unsigned char *)param->notifyinfo.display);
3181 #endif
3182                 end_trace();
3183 #ifdef SOCKET_MISDN
3184                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_INFORMATION, p_m_d_l3id, l3m);
3185 #else
3186                 msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
3187 #endif
3188         }
3189 }
3190
3191 /* MESSAGE_OVERLAP */
3192 void Pdss1::message_overlap(unsigned long epoint_id, int message_id, union parameter *param)
3193 {
3194 #ifdef SOCKET_MISDN
3195         l3_msg *l3m;
3196 #else
3197         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
3198         msg_t *dmsg;
3199         SETUP_ACKNOWLEDGE_t *setup_acknowledge;
3200 #endif
3201
3202         /* sending setup_acknowledge */
3203 #ifdef SOCKET_MISDN
3204         l3m = create_l3msg();
3205 #else
3206         dmsg = create_l3msg(CC_SETUP_ACKNOWLEDGE | REQUEST, MT_SETUP_ACKNOWLEDGE, p_m_d_l3id, sizeof(SETUP_ACKNOWLEDGE_t), p_m_d_ntmode);
3207         setup_acknowledge = (SETUP_ACKNOWLEDGE_t *)(dmsg->data + headerlen);
3208 #endif
3209         l1l2l3_trace_header(p_m_mISDNport, this, L3_SETUP_ACKNOWLEDGE_REQ, DIRECTION_OUT);
3210         /* channel information */
3211         if (p_state == PORT_STATE_IN_SETUP)
3212 #ifdef SOCKET_MISDN
3213                 enc_ie_channel_id(l3m, 1, p_m_b_channel);
3214 #else
3215                 enc_ie_channel_id(&setup_acknowledge->CHANNEL_ID, dmsg, 1, p_m_b_channel);
3216 #endif
3217         /* progress information */
3218         if (p_capainfo.bearer_capa==INFO_BC_SPEECH
3219          || p_capainfo.bearer_capa==INFO_BC_AUDIO
3220          || p_capainfo.bearer_capa==INFO_BC_DATAUNRESTRICTED_TONES)
3221         if (p_m_mISDNport->tones)
3222 #ifdef SOCKET_MISDN
3223                 enc_ie_progress(l3m, 0, p_m_d_ntmode?1:5, 8);
3224 #else
3225                 enc_ie_progress(&setup_acknowledge->PROGRESS, dmsg, 0, p_m_d_ntmode?1:5, 8);
3226 #endif
3227         end_trace();
3228 #ifdef SOCKET_MISDN
3229         p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_SETUP_ACKNOWLEDGE, p_m_d_l3id, l3m);
3230 #else
3231         msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
3232 #endif
3233
3234         new_state(PORT_STATE_IN_OVERLAP);
3235 }
3236
3237 /* MESSAGE_PROCEEDING */
3238 void Pdss1::message_proceeding(unsigned long epoint_id, int message_id, union parameter *param)
3239 {
3240 #ifdef SOCKET_MISDN
3241         l3_msg *l3m;
3242 #else
3243         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
3244         msg_t *dmsg;
3245         CALL_PROCEEDING_t *proceeding;
3246 #endif
3247
3248         /* sending proceeding */
3249 #ifdef SOCKET_MISDN
3250         l3m = create_l3msg();
3251 #else
3252         dmsg = create_l3msg(CC_PROCEEDING | REQUEST, MT_CALL_PROCEEDING, p_m_d_l3id, sizeof(CALL_PROCEEDING_t), p_m_d_ntmode);
3253         proceeding = (CALL_PROCEEDING_t *)(dmsg->data + headerlen);
3254 #endif
3255         l1l2l3_trace_header(p_m_mISDNport, this, L3_PROCEEDING_REQ, DIRECTION_OUT);
3256         /* channel information */
3257         if (p_state == PORT_STATE_IN_SETUP)
3258 #ifdef SOCKET_MISDN
3259                 enc_ie_channel_id(l3m, 1, p_m_b_channel);
3260 #else
3261                 enc_ie_channel_id(&proceeding->CHANNEL_ID, dmsg, 1, p_m_b_channel);
3262 #endif
3263         /* progress information */
3264         if (p_capainfo.bearer_capa==INFO_BC_SPEECH
3265          || p_capainfo.bearer_capa==INFO_BC_AUDIO
3266          || p_capainfo.bearer_capa==INFO_BC_DATAUNRESTRICTED_TONES)
3267         if (p_m_mISDNport->tones)
3268 #ifdef SOCKET_MISDN
3269                 enc_ie_progress(l3m, 0, p_m_d_ntmode?1:5, 8);
3270 #else
3271                 enc_ie_progress(&proceeding->PROGRESS, dmsg, 0, p_m_d_ntmode?1:5, 8);
3272 #endif
3273         end_trace();
3274 #ifdef SOCKET_MISDN
3275         p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_CALL_PROCEEDING, p_m_d_l3id, l3m);
3276 #else
3277         msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
3278 #endif
3279
3280         new_state(PORT_STATE_IN_PROCEEDING);
3281 }
3282
3283 /* MESSAGE_ALERTING */
3284 void Pdss1::message_alerting(unsigned long epoint_id, int message_id, union parameter *param)
3285 {
3286 #ifdef SOCKET_MISDN
3287         l3_msg *l3m;
3288 #else
3289         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
3290         msg_t *dmsg;
3291         ALERTING_t *alerting;
3292 #endif
3293
3294         /* NT-MODE in setup state we must send PROCEEDING first */
3295         if (p_m_d_ntmode && p_state==PORT_STATE_IN_SETUP)
3296         {
3297                 /* sending proceeding */
3298 #ifdef SOCKET_MISDN
3299                 l3m = create_l3msg();
3300 #else
3301                 CALL_PROCEEDING_t *proceeding;
3302                 dmsg = create_l3msg(CC_PROCEEDING | REQUEST, MT_CALL_PROCEEDING, p_m_d_l3id, sizeof(CALL_PROCEEDING_t), p_m_d_ntmode);
3303                 proceeding = (CALL_PROCEEDING_t *)(dmsg->data + headerlen);
3304 #endif
3305                 l1l2l3_trace_header(p_m_mISDNport, this, L3_PROCEEDING_REQ, DIRECTION_OUT);
3306                 /* channel information */
3307 #ifdef SOCKET_MISDN
3308                 enc_ie_channel_id(l3m, 1, p_m_b_channel);
3309 #else
3310                 enc_ie_channel_id(&proceeding->CHANNEL_ID, dmsg, 1, p_m_b_channel);
3311 #endif
3312                 /* progress information */
3313                 if (p_capainfo.bearer_capa==INFO_BC_SPEECH
3314                  || p_capainfo.bearer_capa==INFO_BC_AUDIO
3315                  || p_capainfo.bearer_capa==INFO_BC_DATAUNRESTRICTED_TONES)
3316 #ifdef SOCKET_MISDN
3317                 enc_ie_progress(l3m, 0, p_m_d_ntmode?1:5, 8);
3318 #else
3319                 enc_ie_progress(&proceeding->PROGRESS, dmsg, 0, p_m_d_ntmode?1:5, 8);
3320 #endif
3321                 end_trace();
3322 #ifdef SOCKET_MISDN
3323                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_CALL_PROCEEDING, p_m_d_l3id, l3m);
3324 #else
3325                 msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
3326 #endif
3327                 new_state(PORT_STATE_IN_PROCEEDING);
3328         }
3329
3330         /* sending alerting */
3331 #ifdef SOCKET_MISDN
3332         l3m = create_l3msg();
3333 #else
3334         dmsg = create_l3msg(CC_ALERTING | REQUEST, MT_ALERTING, p_m_d_l3id, sizeof(ALERTING_t), p_m_d_ntmode);
3335         alerting = (ALERTING_t *)(dmsg->data + headerlen);
3336 #endif
3337         l1l2l3_trace_header(p_m_mISDNport, this, L3_ALERTING_REQ, DIRECTION_OUT);
3338         /* channel information */
3339         if (p_state == PORT_STATE_IN_SETUP)
3340 #ifdef SOCKET_MISDN
3341                 enc_ie_channel_id(l3m, 1, p_m_b_channel);
3342 #else
3343                 enc_ie_channel_id(&alerting->CHANNEL_ID, dmsg, 1, p_m_b_channel);
3344 #endif
3345         /* progress information */
3346         if (p_capainfo.bearer_capa==INFO_BC_SPEECH
3347          || p_capainfo.bearer_capa==INFO_BC_AUDIO
3348          || p_capainfo.bearer_capa==INFO_BC_DATAUNRESTRICTED_TONES)
3349         if (p_m_mISDNport->tones)
3350 #ifdef SOCKET_MISDN
3351                 enc_ie_progress(l3m, 0, p_m_d_ntmode?1:5, 8);
3352 #else
3353                 enc_ie_progress(&alerting->PROGRESS, dmsg, 0, p_m_d_ntmode?1:5, 8);
3354 #endif
3355         end_trace();
3356 #ifdef SOCKET_MISDN
3357         p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_ALERTING, p_m_d_l3id, l3m);
3358 #else
3359         msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
3360 #endif
3361
3362         new_state(PORT_STATE_IN_ALERTING);
3363 }
3364
3365 /* MESSAGE_CONNECT */
3366 void Pdss1::message_connect(unsigned long epoint_id, int message_id, union parameter *param)
3367 {
3368 #ifdef SOCKET_MISDN
3369         l3_msg *l3m;
3370 #else
3371         int headerlen = (p_m_d_ntmode)?mISDNUSER_HEAD_SIZE:mISDN_HEADER_LEN;
3372         msg_t *dmsg;
3373         INFORMATION_t *information;
3374         CONNECT_t *connect;
3375 #endif
3376         int type, plan, present, screen;
3377         class Endpoint *epoint;
3378
3379         /* NT-MODE in setup state we must send PROCEEDING first */
3380         if (p_m_d_ntmode && p_state==PORT_STATE_IN_SETUP)
3381         {
3382                 /* sending proceeding */
3383 #ifdef SOCKET_MISDN
3384                 l3m = create_l3msg();
3385 #else
3386                 CALL_PROCEEDING_t *proceeding;
3387                 dmsg = create_l3msg(CC_PROCEEDING | REQUEST, MT_CALL_PROCEEDING, p_m_d_l3id, sizeof(CALL_PROCEEDING_t), p_m_d_ntmode);
3388                 proceeding = (CALL_PROCEEDING_t *)(dmsg->data + headerlen);
3389 #endif
3390                 l1l2l3_trace_header(p_m_mISDNport, this, L3_PROCEEDING_REQ, DIRECTION_OUT);
3391                 /* channel information */
3392 #ifdef SOCKET_MISDN
3393                 enc_ie_channel_id(l3m, 1, p_m_b_channel);
3394 #else
3395                 enc_ie_channel_id(&proceeding->CHANNEL_ID, dmsg, 1, p_m_b_channel);
3396 #endif
3397 //              /* progress information */
3398 //              if (p_capainfo.bearer_capa==INFO_BC_SPEECH
3399 //               || p_capainfo.bearer_capa==INFO_BC_AUDIO
3400 //               || p_capainfo.bearer_capa==INFO_BC_DATAUNRESTRICTED_TONES)
3401 #ifdef SOCKET_MISDN
3402 //              enc_ie_progress(l3m, 0, p_m_d_ntmode?1:5, 8);
3403 #else
3404 //              enc_ie_progress(&proceeding->PROGRESS, dmsg, 0, p_m_d_ntmode?1:5, 8);
3405 #endif
3406                 end_trace();
3407 #ifdef SOCKET_MISDN
3408                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_CALL_PROCEEDING, p_m_d_l3id, l3m);
3409 #else
3410                 msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
3411 #endif
3412                 new_state(PORT_STATE_IN_PROCEEDING);
3413         }
3414
3415         /* copy connected information */
3416         memcpy(&p_connectinfo, &param->connectinfo, sizeof(p_connectinfo));
3417         /* screen outgoing caller id */
3418         do_screen(1, p_connectinfo.id, sizeof(p_connectinfo.id), &p_connectinfo.ntype, &p_connectinfo.present, p_m_mISDNport->ifport->interface);
3419
3420         /* only display at connect state */
3421         if (p_state == PORT_STATE_CONNECT)
3422         if (p_connectinfo.display[0])
3423         {
3424                 /* sending information */
3425 #ifdef SOCKET_MISDN
3426                 l3m = create_l3msg();
3427 #else
3428                 dmsg = create_l3msg(CC_INFORMATION | REQUEST, MT_INFORMATION, p_m_d_l3id, sizeof(INFORMATION_t), p_m_d_ntmode);
3429                 information = (INFORMATION_t *)(dmsg->data + headerlen);
3430 #endif
3431                 l1l2l3_trace_header(p_m_mISDNport, this, L3_INFORMATION_REQ, DIRECTION_OUT);
3432                 if (p_m_d_ntmode)
3433 #ifdef SOCKET_MISDN
3434                         enc_ie_display(l3m, (unsigned char *)p_connectinfo.display);
3435 #else
3436                         enc_ie_display(&information->DISPLAY, dmsg, (unsigned char *)p_connectinfo.display);
3437 #endif
3438                 end_trace();
3439 #ifdef SOCKET_MISDN
3440                 p_m_mISDNport->ml3->to_layer3(p_m_mISDNport->ml3, MT_INFORMATION, p_m_d_l3id, l3m);
3441 #else
3442                 msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
3443 #endif
3444                 return;
3445         }
3446
3447         if (p_state!=PORT_STATE_IN_SETUP && p_state!=PORT_STATE_IN_OVERLAP && p_state!=PORT_STATE_IN_PROCEEDING && p_state!=PORT_STATE_IN_ALERTING)
3448         {
3449                 /* connect command only possible in setup, proceeding or alerting state */
3450                 return;