dss1.cpp

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