mISDN.cpp

   1 /*****************************************************************************\
   2 **                                                                           **
   3 ** Linux Call Router                                                         **
   4 **                                                                           **
   5 **---------------------------------------------------------------------------**
   6 ** Copyright: Andreas Eversberg                                              **
   7 **                                                                           **
   8 ** mISDN port abstraction for dss1 and sip                                   **
   9 **                                                                           **
  10 \*****************************************************************************/
  11
  12
  13 #include "main.h"
  14 #include <poll.h>
  15 #include <errno.h>
  16 #include <sys/ioctl.h>
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <fcntl.h>
  20 #ifdef SOCKET_MISDN
  21 #include <netinet/udp.h>
  22 #include <netinet/in.h>
  23 #include <netdb.h>
  24 #include <sys/socket.h>
  25 #include <pthread.h>
  26 #include <linux/mISDNif.h>
  27 #include <q931.h>
  28 #include <mlayer3.h>
  29 #else
  30 extern "C" {
  31 #include <mISDNuser/net_l2.h>
  32 }
  33 #endif
  34
  35 #ifndef ISDN_PID_L4_B_USER
  36 #define ISDN_PID_L4_B_USER 0x440000ff
  37 #endif
  38
  39 /* list of mISDN ports */
  40 struct mISDNport *mISDNport_first;
  41
  42 /* noise randomizer */
  43 unsigned char mISDN_rand[256];
  44 int mISDN_rand_count = 0;
  45
  46 #ifdef MISDN_SOCKET
  47 int mISDNsocket = -1;
  48
  49 int mISDN_initialize(void)
  50 {
  51         /* try to open raw socket to check kernel */
  52         mISDNsocket = socket(PF_ISDN, SOCK_RAW, ISDN_P_BASE);
  53         if (mISDNsocket < 0)
  54         {
  55                 fprintf(stderr, "Cannot open mISDN due to %s. (Does your Kernel support socket based mISDN?)\n", strerror(errno));
  56                 return(-1);
  57         }
  58
  59         /* initialize stuff of the NT lib */
  60         if (options.deb & DEBUG_STACK)
  61         {
  62                 global_debug = 0xffffffff & ~DBGM_MSG;
  63 //              global_debug = DBGM_L3DATA;
  64         } else
  65                 global_debug = DBGM_MAN;
  66         SPRINT(debug_log, "%s/debug.log", INSTALL_DATA);
  67         if (options.deb & DEBUG_LOG)
  68                 mISDN_debug_init(global_debug, debug_log, debug_log, debug_log);
  69         else
  70                 mISDN_debug_init(global_debug, NULL, NULL, NULL);
  71
  72         /* init mlayer3 */
  73         init_layer3(4); // buffer of 4
  74
  75         return(0);
  76 }
  77
  78 void mISDN_deinitialize(void)
  79 {
  80         cleanup_layer3();
  81
  82         mISDN_debug_close();
  83
  84         if (mISDNsocket > -1)
  85                 close(mISDNsocket);
  86 }
  87 #else
  88 int entity = 0; /* used for udevice */
  89 int mISDNdevice = -1; /* the device handler and port list */
  90
  91 int mISDN_initialize(void)
  92 {
  93         char debug_log[128];
  94         unsigned char buff[1025];
  95         iframe_t *frm = (iframe_t *)buff;
  96         int ret;
  97
  98         /* initialize stuff of the NT lib */
  99         if (options.deb & DEBUG_STACK)
 100         {
 101                 global_debug = 0xffffffff & ~DBGM_MSG;
 102 //              global_debug = DBGM_L3DATA;
 103         } else
 104                 global_debug = DBGM_MAN;
 105         SPRINT(debug_log, "%s/debug.log", INSTALL_DATA);
 106         if (options.deb & DEBUG_LOG)
 107                 debug_init(global_debug, debug_log, debug_log, debug_log);
 108         else
 109                 debug_init(global_debug, NULL, NULL, NULL);
 110         msg_init();
 111
 112         /* open mISDNdevice if not already open */
 113         if (mISDNdevice < 0)
 114         {
 115                 ret = mISDN_open();
 116                 if (ret < 0)
 117                 {
 118                         fprintf(stderr, "cannot open mISDN device ret=%d errno=%d (%s) Check for mISDN modules!\nAlso did you create \"/dev/mISDN\"? Do: \"mknod /dev/mISDN c 46 0\"\n", ret, errno, strerror(errno));
 119                         return(-1);
 120                 }
 121                 mISDNdevice = ret;
 122                 PDEBUG(DEBUG_ISDN, "mISDN device opened.\n");
 123
 124                 /* create entity for layer 3 TE-mode */
 125                 mISDN_write_frame(mISDNdevice, buff, 0, MGR_NEWENTITY | REQUEST, 0, 0, NULL, TIMEOUT_1SEC);
 126                 ret = mISDN_read_frame(mISDNdevice, frm, sizeof(iframe_t), 0, MGR_NEWENTITY | CONFIRM, TIMEOUT_1SEC);
 127                 if (ret < (int)mISDN_HEADER_LEN)
 128                 {
 129                         noentity:
 130                         FATAL("Cannot request MGR_NEWENTITY from mISDN. Exitting due to software bug.");
 131                 }
 132                 entity = frm->dinfo & 0xffff;
 133                 if (!entity)
 134                         goto noentity;
 135                 PDEBUG(DEBUG_ISDN, "our entity for l3-processes is %d.\n", entity);
 136         }
 137         return(0);
 138 }
 139
 140 void mISDN_deinitialize(void)
 141 {
 142         unsigned char buff[1025];
 143
 144         debug_close();
 145
 146         if (mISDNdevice >= 0)
 147         {
 148                 /* free entity */
 149                 mISDN_write_frame(mISDNdevice, buff, 0, MGR_DELENTITY | REQUEST, entity, 0, NULL, TIMEOUT_1SEC);
 150                 /* close device */
 151                 mISDN_close(mISDNdevice);
 152                 mISDNdevice = -1;
 153                 PDEBUG(DEBUG_ISDN, "mISDN device closed.\n");
 154         }
 155 }
 156 #endif
 157
 158 /*
 159  * constructor
 160  */
 161 PmISDN::PmISDN(int type, mISDNport *mISDNport, char *portname, struct port_settings *settings, int channel, int exclusive) : Port(type, portname, settings)
 162 {
 163         p_m_mISDNport = mISDNport;
 164         p_m_portnum = mISDNport->portnum;
 165         p_m_b_index = -1;
 166         p_m_b_channel = 0;
 167         p_m_b_exclusive = 0;
 168         p_m_b_reserve = 0;
 169         p_m_delete = 0;
 170         p_m_hold = 0;
 171         p_m_txvol = p_m_rxvol = 0;
 172         p_m_conf = 0;
 173         p_m_txdata = 0;
 174         p_m_delay = 0;
 175         p_m_echo = 0;
 176         p_m_tone = 0;
 177         p_m_rxoff = 0;
 178         p_m_joindata = 0;
 179         p_m_dtmf = !mISDNport->ifport->nodtmf;
 180         p_m_timeout = 0;
 181         p_m_timer = 0;
 182         p_m_remote_ref = 0; /* channel shall be exported to given remote */
 183         p_m_remote_id = 0; /* channel shall be exported to given remote */
 184
 185         /* audio */
 186         p_m_load = 0;
 187         p_m_last_tv_sec = 0;
 188
 189         /* crypt */
 190         p_m_crypt = 0;
 191         p_m_crypt_listen = 0;
 192         p_m_crypt_msg_loops = 0;
 193         p_m_crypt_msg_loops = 0;
 194         p_m_crypt_msg_len = 0;
 195         p_m_crypt_msg[0] = '\0';
 196         p_m_crypt_msg_current = 0;
 197         p_m_crypt_key[0] = '\0';
 198         p_m_crypt_key_len = 0;
 199         p_m_crypt_listen = 0;
 200         p_m_crypt_listen_state = 0;
 201         p_m_crypt_listen_len = 0;
 202         p_m_crypt_listen_msg[0] = '\0';
 203         p_m_crypt_listen_crc = 0;
 204
 205         /* if any channel requested by constructor */
 206         if (channel == CHANNEL_ANY)
 207         {
 208                 /* reserve channel */
 209                 p_m_b_reserve = 1;
 210                 mISDNport->b_reserved++;
 211         }
 212
 213         /* reserve channel */
 214         if (channel > 0) // only if constructor was called with a channel resevation
 215                 seize_bchannel(channel, exclusive);
 216
 217         /* we increase the number of objects: */
 218         mISDNport->use++;
 219         PDEBUG(DEBUG_ISDN, "Created new mISDNPort(%s). Currently %d objects use, port #%d\n", portname, mISDNport->use, p_m_portnum);
 220 }
 221
 222
 223 /*
 224  * destructor
 225  */
 226 PmISDN::~PmISDN()
 227 {
 228         struct message *message;
 229
 230         /* remove bchannel relation */
 231         drop_bchannel();
 232
 233         /* release epoint */
 234         while (p_epointlist)
 235         {
 236                 PDEBUG(DEBUG_ISDN, "destroy mISDNPort(%s). endpoint still exists, releaseing.\n", p_name);
 237                 message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
 238                 message->param.disconnectinfo.cause = 16;
 239                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
 240                 message_put(message);
 241                 /* remove from list */
 242                 free_epointlist(p_epointlist);
 243         }
 244
 245         /* we decrease the number of objects: */
 246         p_m_mISDNport->use--;
 247         PDEBUG(DEBUG_ISDN, "destroyed mISDNPort(%s). Currently %d objects\n", p_name, p_m_mISDNport->use);
 248 }
 249
 250
 251 /*
 252  * trace
 253  */
 254 void chan_trace_header(struct mISDNport *mISDNport, class PmISDN *port, char *msgtext, int direction)
 255 {
 256         /* init trace with given values */
 257         start_trace(mISDNport?mISDNport->portnum:0,
 258                     (mISDNport)?((mISDNport->ifport)?mISDNport->ifport->interface:NULL):NULL,
 259                     port?numberrize_callerinfo(port->p_callerinfo.id, port->p_callerinfo.ntype):NULL,
 260                     port?port->p_dialinginfo.id:NULL,
 261                     direction,
 262                     CATEGORY_CH,
 263                     port?port->p_serial:0,
 264                     msgtext);
 265 }
 266
 267
 268 /*
 269  * layer trace header
 270  */
 271 static struct isdn_message {
 272         char *name;
 273         unsigned long value;
 274 } isdn_message[] = {
 275         {"TIMEOUT", CC_TIMEOUT},
 276         {"SETUP", CC_SETUP},
 277         {"SETUP_ACK", CC_SETUP_ACKNOWLEDGE},
 278         {"PROCEEDING", CC_PROCEEDING},
 279         {"ALERTING", CC_ALERTING},
 280         {"CONNECT", CC_CONNECT},
 281         {"CONNECT RES", CC_CONNECT},
 282         {"CONNECT_ACK", CC_CONNECT_ACKNOWLEDGE},
 283         {"DISCONNECT", CC_DISCONNECT},
 284         {"RELEASE", CC_RELEASE},
 285         {"RELEASE_COMP", CC_RELEASE_COMPLETE},
 286         {"INFORMATION", CC_INFORMATION},
 287         {"PROGRESS", CC_PROGRESS},
 288         {"NOTIFY", CC_NOTIFY},
 289         {"SUSPEND", CC_SUSPEND},
 290         {"SUSPEND_ACK", CC_SUSPEND_ACKNOWLEDGE},
 291         {"SUSPEND_REJ", CC_SUSPEND_REJECT},
 292         {"RESUME", CC_RESUME},
 293         {"RESUME_ACK", CC_RESUME_ACKNOWLEDGE},
 294         {"RESUME_REJ", CC_RESUME_REJECT},
 295         {"HOLD", CC_HOLD},
 296         {"HOLD_ACK", CC_HOLD_ACKNOWLEDGE},
 297         {"HOLD_REJ", CC_HOLD_REJECT},
 298         {"RETRIEVE", CC_RETRIEVE},
 299         {"RETRIEVE_ACK", CC_RETRIEVE_ACKNOWLEDGE},
 300         {"RETRIEVE_REJ", CC_RETRIEVE_REJECT},
 301         {"FACILITY", CC_FACILITY},
 302         {"STATUS", CC_STATUS},
 303         {"RESTART", CC_RESTART},
 304         {"RELEASE_CR", CC_RELEASE_CR},
 305         {"NEW_CR", CC_NEW_CR},
 306         {"DL_ESTABLISH", DL_ESTABLISH},
 307         {"DL_RELEASE", DL_RELEASE},
 308         {"PH_ACTIVATE", PH_ACTIVATE},
 309         {"PH_DEACTIVATE", PH_DEACTIVATE},
 310
 311         {NULL, 0},
 312 };
 313 static char *isdn_prim[4] = {
 314         " REQUEST",
 315         " CONFIRM",
 316         " INDICATION",
 317         " RESPONSE",
 318 };
 319 void l1l2l3_trace_header(struct mISDNport *mISDNport, class PmISDN *port, unsigned long prim, int direction)
 320 {
 321         int i;
 322         char msgtext[64] = "<<UNKNOWN MESSAGE>>";
 323
 324         /* select message and primitive text */
 325         i = 0;
 326         while(isdn_message[i].name)
 327         {
 328                 if (isdn_message[i].value == (prim&0xffffff00))
 329                 {
 330                         SCPY(msgtext, isdn_message[i].name);
 331                         break;
 332                 }
 333                 i++;
 334         }
 335         SCAT(msgtext, isdn_prim[prim&0x00000003]);
 336
 337         /* add direction */
 338         if (direction && (prim&0xffffff00)!=CC_NEW_CR && (prim&0xffffff00)!=CC_RELEASE_CR)
 339         {
 340                 if (mISDNport)
 341                 {
 342                         if (mISDNport->ntmode)
 343                         {
 344                                 if (direction == DIRECTION_OUT)
 345                                         SCAT(msgtext, " N->U");
 346                                 else
 347                                         SCAT(msgtext, " N<-U");
 348                         } else
 349                         {
 350                                 if (direction == DIRECTION_OUT)
 351                                         SCAT(msgtext, " U->N");
 352                                 else
 353                                         SCAT(msgtext, " U<-N");
 354                         }
 355                 }
 356         }
 357
 358         /* init trace with given values */
 359         start_trace(mISDNport?mISDNport->portnum:0,
 360                     mISDNport?mISDNport->ifport->interface:NULL,
 361                     port?numberrize_callerinfo(port->p_callerinfo.id, port->p_callerinfo.ntype):NULL,
 362                     port?port->p_dialinginfo.id:NULL,
 363                     direction,
 364                     CATEGORY_CH,
 365                     port?port->p_serial:0,
 366                     msgtext);
 367 }
 368
 369
 370 /*
 371  * send control information to the channel (dsp-module)
 372  */
 373 void ph_control(struct mISDNport *mISDNport, class PmISDN *isdnport, unsigned long handle, unsigned long c1, unsigned long c2, char *trace_name, int trace_value)
 374 {
 375 #ifdef SOCKET_MISDN
 376         unsigned char buffer[MISDN_HEADER_LEN+sizeof(int)+sizeof(int)];
 377         struct mISDNhead *ctrl = (struct mISDNhead *)buffer;
 378         unsigned long *d = buffer+MISDN_HEADER_LEN;
 379         int ret;
 380
 381         ctrl->prim = PH_CONTROL_REQ;
 382         ctrl->id = 0;
 383         *d++ = c1;
 384         *d++ = c2;
 385         ret = sendto(handle, buffer, MISDN_HEADER_LEN+sizeof(int)*2, 0, NULL, 0);
 386         if (!ret)
 387                 PERROR("Failed to send to socket %d\n", handle);
 388 #else
 389         unsigned char buffer[mISDN_HEADER_LEN+sizeof(int)+sizeof(int)];
 390         iframe_t *ctrl = (iframe_t *)buffer;
 391         unsigned long *d = (unsigned long *)&ctrl->data.p;
 392
 393         ctrl->prim = PH_CONTROL | REQUEST;
 394         ctrl->addr = handle | FLG_MSG_DOWN;
 395         ctrl->dinfo = 0;
 396         ctrl->len = sizeof(int)*2;
 397         *d++ = c1;
 398         *d++ = c2;
 399         mISDN_write(mISDNdevice, ctrl, mISDN_HEADER_LEN+ctrl->len, TIMEOUT_1SEC);
 400 #endif
 401         chan_trace_header(mISDNport, isdnport, "BCHANNEL control", DIRECTION_OUT);
 402         if (c1 == CMX_CONF_JOIN)
 403                 add_trace(trace_name, NULL, "0x%08x", trace_value);
 404         else
 405                 add_trace(trace_name, NULL, "%d", trace_value);
 406         end_trace();
 407 }
 408
 409 void ph_control_block(struct mISDNport *mISDNport, class PmISDN *isdnport, unsigned long handle, unsigned long c1, void *c2, int c2_len, char *trace_name, int trace_value)
 410 {
 411 #ifdef SOCKET_MISDN
 412         unsigned char buffer[MISDN_HEADER_LEN+sizeof(int)+c2_len];
 413         struct mISDNhead *ctrl = (struct mISDNhead *)buffer;
 414         unsigned long *d = buffer+MISDN_HEADER_LEN;
 415         int ret;
 416
 417         ctrl->prim = PH_CONTROL_REQ;
 418         ctrl->id = 0;
 419         *d++ = c1;
 420         memcpy(d, c2, c2_len);
 421         ret = sendto(handle, buffer, MISDN_HEADER_LEN+sizeof(int)+c2_len, 0, NULL, 0);
 422         if (!ret)
 423                 PERROR("Failed to send to socket %d\n", handle);
 424 #else
 425         unsigned char buffer[mISDN_HEADER_LEN+sizeof(int)+c2_len];
 426         iframe_t *ctrl = (iframe_t *)buffer;
 427         unsigned long *d = (unsigned long *)&ctrl->data.p;
 428
 429         ctrl->prim = PH_CONTROL | REQUEST;
 430         ctrl->addr = handle | FLG_MSG_DOWN;
 431         ctrl->dinfo = 0;
 432         ctrl->len = sizeof(int)+c2_len;
 433         *d++ = c1;
 434         memcpy(d, c2, c2_len);
 435         mISDN_write(mISDNdevice, ctrl, mISDN_HEADER_LEN+ctrl->len, TIMEOUT_1SEC);
 436 #endif
 437         chan_trace_header(mISDNport, isdnport, "BCHANNEL control", DIRECTION_OUT);
 438         add_trace(trace_name, NULL, "%d", trace_value);
 439         end_trace();
 440 }
 441
 442
 443 /*
 444  * subfunction for bchannel_event
 445  * create stack
 446  */
 447 static int _bchannel_create(struct mISDNport *mISDNport, int i)
 448 {
 449         unsigned char buff[1024];
 450         int ret;
 451 #ifdef SOCKET_MISDN
 452         unsigned long on = 1;
 453         struct sockadd_mISDN addr;
 454
 455         if (mISDNport->b_socket[i])
 456         {
 457                 PERROR("Error: Socket already created for index %d\n", i);
 458                 return(0);
 459         }
 460
 461         /* open socket */
 462         mISDNport->b_socket[i] = socket(PF_ISDN, SOCK_DGRAM, ISDN_P_B_L2DSP);
 463         if (mISDNport->b_socket[i])
 464         {
 465                 PERROR("Error: Failed to open bchannel-socket for index %d with mISDN-DSP layer. Did you load mISDNdsp.ko?\n", i);
 466                 return(0);
 467         }
 468
 469         /* set nonblocking io */
 470         ret = ioctl(mISDNport->b_socket[i], FIONBIO, &on);
 471         if (ret < 0)
 472         {
 473                 PERROR("Error: Failed to set bchannel-socket index %d into nonblocking IO\n", i);
 474                 close(mISDNport->b_socket[i]);
 475                 mISDNport->b_socket[i] = -1;
 476                 return(0);
 477         }
 478
 479         /* bind socket to bchannel */
 480         addr.family = AF_ISDN;
 481         addr.dev = mISDNport->port-1;
 482         addr.channel = i+1+(i>=15);
 483         ret = bind(di->bchan, (struct sockaddr *)&addr, sizeof(addr));
 484         if (ret < 0)
 485         {
 486                 PERROR("Error: Failed to bind bchannel-socket for index %d with mISDN-DSP layer. Did you load mISDNdsp.ko?\n", i);
 487                 close(mISDNport->b_socket[i]);
 488                 mISDNport->b_socket[i] = -1;
 489                 return(0);
 490         }
 491
 492         chan_trace_header(mISDNport, mISDNport->b_port[i], "BCHANNEL create socket", DIRECTION_OUT);
 493         add_trace("channel", NULL, "%d", i+1+(i>=15));
 494         add_trace("socket", NULL, "%d", mISDNport->b_socket[i]);
 495         end_trace();
 496 #else
 497         layer_info_t li;
 498         mISDN_pid_t pid;
 499
 500         if (!mISDNport->b_stid[i])
 501         {
 502                 PERROR("Error: no stack for index %d\n", i);
 503                 return(0);
 504         }
 505         if (mISDNport->b_addr[i])
 506         {
 507                 PERROR("Error: stack already created for index %d\n", i);
 508                 return(0);
 509         }
 510
 511         /* create new layer */
 512         PDEBUG(DEBUG_BCHANNEL, "creating new layer for bchannel %d (index %d).\n" , i+1+(i>=15), i);
 513         memset(&li, 0, sizeof(li));
 514         memset(&pid, 0, sizeof(pid));
 515         li.object_id = -1;
 516         li.extentions = 0;
 517         li.st = mISDNport->b_stid[i];
 518         UCPY(li.name, "B L4");
 519         li.pid.layermask = ISDN_LAYER((4));
 520         li.pid.protocol[4] = ISDN_PID_L4_B_USER;
 521         ret = mISDN_new_layer(mISDNdevice, &li);
 522         if (ret)
 523         {
 524                 failed_new_layer:
 525                 PERROR("mISDN_new_layer() failed to add bchannel %d (index %d)\n", i+1+(i>=15), i);
 526                 goto failed;
 527         }
 528         mISDNport->b_addr[i] = li.id;
 529         if (!li.id)
 530         {
 531                 goto failed_new_layer;
 532         }
 533         PDEBUG(DEBUG_BCHANNEL, "new layer (b_addr=0x%x)\n", mISDNport->b_addr[i]);
 534
 535         /* create new stack */
 536         pid.protocol[1] = ISDN_PID_L1_B_64TRANS;
 537         pid.protocol[2] = ISDN_PID_L2_B_TRANS;
 538         pid.protocol[3] = ISDN_PID_L3_B_DSP;
 539         pid.protocol[4] = ISDN_PID_L4_B_USER;
 540         pid.layermask = ISDN_LAYER((1)) | ISDN_LAYER((2)) | ISDN_LAYER((3)) | ISDN_LAYER((4));
 541         ret = mISDN_set_stack(mISDNdevice, mISDNport->b_stid[i], &pid);
 542         if (ret)
 543         {
 544                 stack_error:
 545                 PERROR("mISDN_set_stack() failed (ret=%d) to add bchannel (index %d) stid=0x%x\n", ret, i, mISDNport->b_stid[i]);
 546                 mISDN_write_frame(mISDNdevice, buff, mISDNport->b_addr[i], MGR_DELLAYER | REQUEST, 0, 0, NULL, TIMEOUT_1SEC);
 547                 goto failed;
 548         }
 549         ret = mISDN_get_setstack_ind(mISDNdevice, mISDNport->b_addr[i]);
 550         if (ret)
 551                 goto stack_error;
 552
 553         /* get layer id */
 554         mISDNport->b_addr[i] = mISDN_get_layerid(mISDNdevice, mISDNport->b_stid[i], 4);
 555         if (!mISDNport->b_addr[i])
 556                 goto stack_error;
 557         chan_trace_header(mISDNport, mISDNport->b_port[i], "BCHANNEL create stack", DIRECTION_OUT);
 558         add_trace("channel", NULL, "%d", i+1+(i>=15));
 559         add_trace("stack", "id", "0x%08x", mISDNport->b_stid[i]);
 560         add_trace("stack", "address", "0x%08x", mISDNport->b_addr[i]);
 561         end_trace();
 562 #endif
 563
 564         return(1);
 565
 566 failed:
 567         mISDNport->b_addr[i] = 0;
 568         return(0);
 569 }
 570
 571
 572 /*
 573  * subfunction for bchannel_event
 574  * activate / deactivate request
 575  */
 576 static void _bchannel_activate(struct mISDNport *mISDNport, int i, int activate)
 577 {
 578 #ifdef SOCKET_MISDN
 579         struct mISDNhead act;
 580         int ret;
 581
 582         act.prim = (activate)?DL_ESTABLISH_REQ:DL_RELEASE_REQ;
 583         act.id = 0;
 584         ret = sendto(mISDNport->b_socket[i], &act, MISDN_HEADER_LEN, 0, NULL, 0);
 585         if (!ret)
 586                 PERROR("Failed to send to socket %d\n", mISDNport->b_socket[i]);
 587 #else
 588         iframe_t act;
 589
 590         /* activate bchannel */
 591         act.prim = (activate?DL_ESTABLISH:DL_RELEASE) | REQUEST;
 592         act.addr = mISDNport->b_addr[i] | FLG_MSG_DOWN;
 593         act.dinfo = 0;
 594         act.len = 0;
 595         mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
 596 #endif
 597
 598         /* trace */
 599         chan_trace_header(mISDNport, mISDNport->b_port[i], activate?(char*)"BCHANNEL activate":(char*)"BCHANNEL deactivate", DIRECTION_OUT);
 600         add_trace("channel", NULL, "%d", i+1+(i>=15));
 601         end_trace();
 602 }
 603
 604
 605 /*
 606  * subfunction for bchannel_event
 607  * set features
 608  */
 609 static void _bchannel_configure(struct mISDNport *mISDNport, int i)
 610 {
 611         struct PmISDN *port;
 612 #ifdef SOCKET_MISDN
 613         int handle;
 614
 615         handle = mISDNport->b_socket[i];
 616 #else
 617         unsigned long handle;
 618
 619         handle = mISDNport->b_addr[i];
 620 #endif
 621         port = mISDNport->b_port[i];
 622         if (!port)
 623         {
 624                 PERROR("bchannel index i=%d not associated with a port object\n", i);
 625                 return;
 626         }
 627
 628         /* set dsp features */
 629         if (port->p_m_txdata)
 630                 ph_control(mISDNport, port, handle, (port->p_m_txdata)?CMX_TXDATA_ON:CMX_TXDATA_OFF, 0, "DSP-TXDATA", port->p_m_txdata);
 631         if (port->p_m_delay)
 632                 ph_control(mISDNport, port, handle, CMX_DELAY, port->p_m_delay, "DSP-DELAY", port->p_m_delay);
 633         if (port->p_m_txvol)
 634                 ph_control(mISDNport, port, handle, VOL_CHANGE_TX, port->p_m_txvol, "DSP-TXVOL", port->p_m_txvol);
 635         if (port->p_m_rxvol)
 636                 ph_control(mISDNport, port, handle, VOL_CHANGE_RX, port->p_m_rxvol, "DSP-RXVOL", port->p_m_rxvol);
 637         if (port->p_m_conf)
 638                 ph_control(mISDNport, port, handle, CMX_CONF_JOIN, port->p_m_conf, "DSP-CONF", port->p_m_conf);
 639         if (port->p_m_echo)
 640                 ph_control(mISDNport, port, handle, CMX_ECHO_ON, 0, "DSP-ECHO", 1);
 641         if (port->p_m_tone)
 642                 ph_control(mISDNport, port, handle, TONE_PATT_ON, port->p_m_tone, "DSP-TONE", port->p_m_tone);
 643         if (port->p_m_rxoff)
 644                 ph_control(mISDNport, port, handle, CMX_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
 645 //      if (port->p_m_txmix)
 646 //              ph_control(mISDNport, port, handle, CMX_MIX_ON, 0, "DSP-MIX", 1);
 647         if (port->p_m_dtmf)
 648                 ph_control(mISDNport, port, handle, DTMF_TONE_START, 0, "DSP-DTMF", 1);
 649         if (port->p_m_crypt)
 650                 ph_control_block(mISDNport, port, handle, BF_ENABLE_KEY, port->p_m_crypt_key, port->p_m_crypt_key_len, "DSP-CRYPT", port->p_m_crypt_key_len);
 651 }
 652
 653 /*
 654  * subfunction for bchannel_event
 655  * destroy stack
 656  */
 657 static void _bchannel_destroy(struct mISDNport *mISDNport, int i)
 658 {
 659 #ifdef SOCKET_MISDN
 660         chan_trace_header(mISDNport, mISDNport->b_port[i], "BCHANNEL remove socket", DIRECTION_OUT);
 661         add_trace("channel", NULL, "%d", i+1+(i>=15));
 662         add_trace("socket", NULL, "%d", mISDNport->b_socket[i]);
 663         end_trace();
 664         if (mISDNport->b_socket[i] > -1)
 665         {
 666                 close(mISDNport->b_socket[i]);
 667                 mISDNport->b_socket[i] = -1;
 668         }
 669 #else
 670         unsigned char buff[1024];
 671
 672         chan_trace_header(mISDNport, mISDNport->b_port[i], "BCHANNEL remove stack", DIRECTION_OUT);
 673         add_trace("channel", NULL, "%d", i+1+(i>=15));
 674         add_trace("stack", "id", "0x%08x", mISDNport->b_stid[i]);
 675         add_trace("stack", "address", "0x%08x", mISDNport->b_addr[i]);
 676         end_trace();
 677         /* remove our stack only if set */
 678         if (mISDNport->b_addr[i])
 679         {
 680                 PDEBUG(DEBUG_BCHANNEL, "free stack (b_addr=0x%x)\n", mISDNport->b_addr[i]);
 681                 mISDN_clear_stack(mISDNdevice, mISDNport->b_stid[i]);
 682                 mISDN_write_frame(mISDNdevice, buff, mISDNport->b_addr[i] | FLG_MSG_DOWN, MGR_DELLAYER | REQUEST, 0, 0, NULL, TIMEOUT_1SEC);
 683                 mISDNport->b_addr[i] = 0;
 684         }
 685 #endif
 686 }
 687
 688
 689 /*
 690 bchannel procedure
 691 ------------------
 692
 693 A bchannel goes through the following states in this order:
 694
 695 - B_STATE_IDLE
 696 No one is using the bchannel.
 697 It is available and not linked to Port class, nor reserved.
 698
 699 - B_STATE_ACTIVATING
 700 The bchannel stack is created and an activation request is sent.
 701 It MAY be linked to Port class, but already unlinked due to Port class removal.
 702
 703 - B_STATE_ACTIVE
 704 The bchannel is active and cofigured to the Port class needs.
 705 Also it is linked to a Port class, otherwhise it would be deactivated.
 706
 707 - B_STATE_DEACTIVATING
 708 The bchannel is in deactivating state, due to deactivation request.
 709 It may be linked to a Port class, that likes to reactivate it.
 710
 711 - B_STATE_IDLE
 712 See above.
 713 After deactivating bchannel, and if not used, the bchannel becomes idle again.
 714
 715 Also the bchannel may be exported, but only if the state is or becomes idle:
 716
 717 - B_STATE_EXPORTING
 718 The bchannel assignment has been sent to the remove application.
 719
 720 - B_STATE_REMOTE
 721 The bchannel assignment is acknowledged by the remote application.
 722
 723 - B_STATE_IMPORTING
 724 The bchannel is re-imported by mISDN port object.
 725
 726 - B_STATE_IDLE
 727 See above.
 728 After re-importing bchannel, and if not used, the bchannel becomes idle again.
 729
 730
 731 A bchannel can have the following events:
 732
 733 - B_EVENT_USE
 734 A bchannel is required by a Port class.
 735 The bchannel shall be exported to the remote application.
 736
 737 - B_EVENT_ACTIVATED
 738 The bchannel beomes active.
 739
 740 - B_EVENT_DROP
 741 The bchannel is not required by Port class anymore
 742
 743 - B_EVENT_DEACTIVATED
 744 The bchannel becomes inactive.
 745
 746 - B_EVENT_EXPORTED
 747 The bchannel is now used by remote application.
 748
 749 - B_EVENT_IMPORTED
 750 The bchannel is not used by remote application.
 751
 752 All actions taken on these events depend on the current bchannel's state and if it is linked to a Port class.
 753
 754 if an export request is receive by remote application, p_m_remote_* is set.
 755 the b_remote_*[index] indicates if and where the channel is exported to. (set from the point on, where export is initiated, until imported is acknowledged.)
 756 - set on export request from remote application (if port is assigned)
 757 - set on channel use, if requested by remote application (p_m_remote_*)
 758 - cleared on drop request
 759
 760 the bchannel will be exported with ref and stack given. remote application uses the ref to link bchannel to the call.
 761 the bchannel will be imported with stack given only. remote application must store stack id with the bchannel process.
 762 the bchannel import/export is acknowledged with stack given.
 763
 764 if exporting, b_remote_*[index] is set to the remote socket id.
 765 if importing has been acknowledged. b_remote_*[index] is cleared.
 766
 767 */
 768
 769 /*
 770  * process bchannel events
 771  * - mISDNport is a pointer to the port's structure
 772  * - i is the index of the bchannel
 773  * - event is the B_EVENT_* value
 774  * - port is the PmISDN class pointer
 775  */
 776 void bchannel_event(struct mISDNport *mISDNport, int i, int event)
 777 {
 778         class PmISDN *b_port = mISDNport->b_port[i];
 779         int state = mISDNport->b_state[i];
 780         unsigned long p_m_remote_ref = 0;
 781         unsigned long p_m_remote_id = 0;
 782 #ifdef SOCKET_MISDN
 783         unsigned long portid = (mISDNport->portnum<<8) + i+1+(i>=15);
 784 #else
 785         unsigned long portid = mISDNport->b_addr[i];
 786 #endif
 787
 788         if (b_port)
 789         {
 790                 p_m_remote_id = b_port->p_m_remote_id;
 791                 p_m_remote_ref = b_port->p_m_remote_ref;
 792         }
 793
 794         switch(event)
 795         {
 796                 case B_EVENT_USE:
 797                 /* port must be linked in order to allow activation */
 798                 if (!b_port)
 799                         FATAL("bchannel must be linked to a Port class\n");
 800                 switch(state)
 801                 {
 802                         case B_STATE_IDLE:
 803                         if (p_m_remote_ref)
 804                         {
 805                                 /* export bchannel */
 806                                 message_bchannel_to_join(p_m_remote_id, p_m_remote_ref, BCHANNEL_ASSIGN, portid);
 807                                 chan_trace_header(mISDNport, b_port, "MESSAGE_BCHANNEL (to remote application)", DIRECTION_NONE);
 808                                 add_trace("type", NULL, "assign");
 809 #ifdef SOCKET_MISDN
 810                                 add_trace("channel", NULL, "%d.%d", portid>>8, portid&0xff);
 811 #else
 812                                 add_trace("socket", "id", "%d", portid);
 813 #endif
 814                                 end_trace();
 815                                 state = B_STATE_EXPORTING;
 816                                 mISDNport->b_remote_id[i] = p_m_remote_id;
 817                                 mISDNport->b_remote_ref[i] = p_m_remote_ref;
 818                         } else
 819                         {
 820                                 /* create stack and send activation request */
 821                                 if (_bchannel_create(mISDNport, i))
 822                                 {
 823                                         _bchannel_activate(mISDNport, i, 1);
 824                                         state = B_STATE_ACTIVATING;
 825                                 }
 826                         }
 827                         break;
 828
 829                         case B_STATE_ACTIVATING:
 830                         case B_STATE_EXPORTING:
 831                         /* do nothing, because it is already activating */
 832                         break;
 833
 834                         case B_STATE_DEACTIVATING:
 835                         case B_STATE_IMPORTING:
 836                         /* do nothing, because we must wait until we can reactivate */
 837                         break;
 838
 839                         default:
 840                         /* problems that might ocurr:
 841                          * B_EVENT_USE is received when channel already in use.
 842                          * bchannel exported, but not freed by other port
 843                          */
 844                         PERROR("Illegal event %d at state %d, please correct.\n", event, state);
 845                 }
 846                 break;
 847
 848                 case B_EVENT_EXPORTREQUEST:
 849                 /* special case where the bchannel is requested by remote */
 850                 if (!p_m_remote_ref)
 851                 {
 852                         PERROR("export request without remote channel set, please correct.\n");
 853                         break;
 854                 }
 855                 switch(state)
 856                 {
 857                         case B_STATE_IDLE:
 858                         /* in case, the bchannel is exported right after seize_bchannel */
 859                         /* export bchannel */
 860                         /* p_m_remote_id is set, when this event happens. */
 861                         message_bchannel_to_join(p_m_remote_id, p_m_remote_ref, BCHANNEL_ASSIGN, portid);
 862                         chan_trace_header(mISDNport, b_port, "MESSAGE_BCHANNEL (to remote application)", DIRECTION_NONE);
 863                         add_trace("type", NULL, "assign");
 864 #ifdef SOCKET_MISDN
 865                         add_trace("channel", NULL, "%d.%d", portid>>8, portid&0xff);
 866 #else
 867                         add_trace("socket", "id", "%d", portid);
 868 #endif
 869                         end_trace();
 870                         state = B_STATE_EXPORTING;
 871                         mISDNport->b_remote_id[i] = p_m_remote_id;
 872                         mISDNport->b_remote_ref[i] = p_m_remote_ref;
 873                         break;
 874
 875                         case B_STATE_ACTIVATING:
 876                         case B_STATE_EXPORTING:
 877                         /* do nothing, because it is already activating */
 878                         break;
 879
 880                         case B_STATE_DEACTIVATING:
 881                         case B_STATE_IMPORTING:
 882                         /* do nothing, because we must wait until we can reactivate */
 883                         break;
 884
 885                         case B_STATE_ACTIVE:
 886                         /* bchannel is active, so we deactivate */
 887                         _bchannel_activate(mISDNport, i, 0);
 888                         state = B_STATE_DEACTIVATING;
 889                         break;
 890
 891                         default:
 892                         /* problems that might ocurr:
 893                          * ... when channel already in use.
 894                          * bchannel exported, but not freed by other port
 895                          */
 896                         PERROR("Illegal event %d at state %d, please correct.\n", event, state);
 897                 }
 898                 break;
 899
 900                 case B_EVENT_ACTIVATED:
 901                 switch(state)
 902                 {
 903                         case B_STATE_ACTIVATING:
 904                         if (b_port && !p_m_remote_id)
 905                         {
 906                                 /* bchannel is active and used by Port class, so we configure bchannel */
 907                                 _bchannel_configure(mISDNport, i);
 908                                 state = B_STATE_ACTIVE;
 909                         } else
 910                         {
 911                                 /* bchannel is active, but exported OR not used anymore (or has wrong stack config), so we deactivate */
 912                                 _bchannel_activate(mISDNport, i, 0);
 913                                 state = B_STATE_DEACTIVATING;
 914                         }
 915                         break;
 916
 917                         default:
 918                         PERROR("Illegal event %d at state %d, please correct.\n", event, state);
 919                 }
 920                 break;
 921
 922                 case B_EVENT_EXPORTED:
 923                 switch(state)
 924                 {
 925                         case B_STATE_EXPORTING:
 926                         if (b_port && p_m_remote_ref && p_m_remote_ref==mISDNport->b_remote_ref[i])
 927                         {
 928                                 /* remote export done */
 929                                 state = B_STATE_REMOTE;
 930                         } else
 931                         {
 932                                 /* bchannel is now exported, but we need bchannel back
 933                                  * OR bchannel is not used anymore
 934                                  * OR bchannel has been exported to an obsolete ref,
 935                                  * so reimport, to later export to new remote */
 936                                 message_bchannel_to_join(mISDNport->b_remote_id[i], 0, BCHANNEL_REMOVE, portid);
 937                                 chan_trace_header(mISDNport, b_port, "MESSAGE_BCHANNEL (to remote application)", DIRECTION_NONE);
 938                                 add_trace("type", NULL, "remove");
 939 #ifdef SOCKET_MISDN
 940                                 add_trace("channel", NULL, "%d.%d", portid>>8, portid&0xff);
 941 #else
 942                                 add_trace("socket", "id", "%d", portid);
 943 #endif
 944                                 end_trace();
 945                                 state = B_STATE_IMPORTING;
 946                         }
 947                         break;
 948
 949                         default:
 950                         PERROR("Illegal event %d at state %d, please correct.\n", event, state);
 951                 }
 952                 break;
 953
 954                 case B_EVENT_DROP:
 955                 if (!b_port)
 956                         FATAL("bchannel must be linked to a Port class\n");
 957                 switch(state)
 958                 {
 959                         case B_STATE_IDLE:
 960                         /* bchannel is idle due to an error, so we do nothing */
 961                         break;
 962
 963                         case B_STATE_ACTIVATING:
 964                         case B_STATE_EXPORTING:
 965                         /* do nothing because we must wait until bchanenl is active before deactivating */
 966                         break;
 967
 968                         case B_STATE_ACTIVE:
 969                         /* bchannel is active, so we deactivate */
 970                         _bchannel_activate(mISDNport, i, 0);
 971                         state = B_STATE_DEACTIVATING;
 972                         break;
 973
 974                         case B_STATE_REMOTE:
 975                         /* bchannel is exported, so we re-import */
 976                         message_bchannel_to_join(mISDNport->b_remote_id[i], 0, BCHANNEL_REMOVE, portid);
 977                         chan_trace_header(mISDNport, b_port, "MESSAGE_BCHANNEL (to remote application)", DIRECTION_NONE);
 978                         add_trace("type", NULL, "remove");
 979 #ifdef SOCKET_MISDN
 980                         add_trace("channel", NULL, "%d.%d", portid>>8, portid&0xff);
 981 #else
 982                         add_trace("socket", "id", "%d", portid);
 983 #endif
 984                         end_trace();
 985                         state = B_STATE_IMPORTING;
 986                         break;
 987
 988                         case B_STATE_DEACTIVATING:
 989                         case B_STATE_IMPORTING:
 990                         /* we may have taken an already deactivating bchannel, but do not require it anymore, so we do nothing */
 991                         break;
 992
 993                         default:
 994                         PERROR("Illegal event %d at state %d, please correct.\n", event, state);
 995                 }
 996                 break;
 997
 998                 case B_EVENT_DEACTIVATED:
 999                 switch(state)
1000                 {
1001                         case B_STATE_IDLE:
1002                         /* ignore due to deactivation confirm after unloading */
1003                         break;
1004
1005                         case B_STATE_DEACTIVATING:
1006                         _bchannel_destroy(mISDNport, i);
1007                         state = B_STATE_IDLE;
1008                         if (b_port)
1009                         {
1010                                 /* bchannel is now deactivate, but is requied by Port class, so we reactivate / export */
1011                                 if (p_m_remote_ref)
1012                                 {
1013                                         message_bchannel_to_join(p_m_remote_id, p_m_remote_ref, BCHANNEL_ASSIGN, portid);
1014                                         chan_trace_header(mISDNport, b_port, "MESSAGE_BCHANNEL (to remote application)", DIRECTION_NONE);
1015                                         add_trace("type", NULL, "assign");
1016 #ifdef SOCKET_MISDN
1017                                         add_trace("channel", NULL, "%d.%d", portid>>8, portid&0xff);
1018 #else
1019                                         add_trace("socket", "id", "%d", portid);
1020 #endif
1021                                         end_trace();
1022                                         state = B_STATE_EXPORTING;
1023                                         mISDNport->b_remote_id[i] = p_m_remote_id;
1024                                         mISDNport->b_remote_ref[i] = p_m_remote_ref;
1025                                 } else
1026                                 {
1027                                         if (_bchannel_create(mISDNport, i))
1028                                         {
1029                                                 _bchannel_activate(mISDNport, i, 1);
1030                                                 state = B_STATE_ACTIVATING;
1031                                         }
1032                                 }
1033                         }
1034                         break;
1035
1036                         default:
1037                         PERROR("Illegal event %d at state %d, please correct.\n", event, state);
1038                 }
1039                 break;
1040
1041                 case B_EVENT_IMPORTED:
1042                 switch(state)
1043                 {
1044                         case B_STATE_IMPORTING:
1045                         state = B_STATE_IDLE;
1046                         mISDNport->b_remote_id[i] = 0;
1047                         mISDNport->b_remote_ref[i] = 0;
1048                         if (b_port)
1049                         {
1050                                 /* bchannel is now imported, but is requied by Port class, so we reactivate / export */
1051                                 if (p_m_remote_ref)
1052                                 {
1053                                         message_bchannel_to_join(p_m_remote_id, p_m_remote_ref, BCHANNEL_ASSIGN, portid);
1054                                         chan_trace_header(mISDNport, b_port, "MESSAGE_BCHANNEL (to remote application)", DIRECTION_NONE);
1055                                         add_trace("type", NULL, "assign");
1056 #ifdef SOCKET_MISDN
1057                                         add_trace("channel", NULL, "%d.%d", portid>>8, portid&0xff);
1058 #else
1059                                         add_trace("socket", "id", "%d", portid);
1060 #endif
1061                                         end_trace();
1062                                         state = B_STATE_EXPORTING;
1063                                         mISDNport->b_remote_id[i] = p_m_remote_id;
1064                                         mISDNport->b_remote_ref[i] = p_m_remote_ref;
1065                                 } else
1066                                 {
1067                                         if (_bchannel_create(mISDNport, i))
1068                                         {
1069                                                 _bchannel_activate(mISDNport, i, 1);
1070                                                 state = B_STATE_ACTIVATING;
1071                                         }
1072                                 }
1073                         }
1074                         break;
1075
1076                         default:
1077                         /* ignore, because not assigned */
1078                         ;
1079                 }
1080                 break;
1081
1082                 default:
1083                 PERROR("Illegal event %d, please correct.\n", event);
1084         }
1085
1086         mISDNport->b_state[i] = state;
1087 }
1088
1089
1090
1091
1092 /*
1093  * check for available channel and reserve+set it.
1094  * give channel number or SEL_CHANNEL_ANY or SEL_CHANNEL_NO
1095  * give exclusiv flag
1096  * returns -(cause value) or x = channel x or 0 = no channel
1097  * NOTE: no activation is done here
1098  */
1099 int PmISDN::seize_bchannel(int channel, int exclusive)
1100 {
1101         int i;
1102
1103         /* the channel is what we have */
1104         if (p_m_b_channel == channel)
1105                 return(channel);
1106
1107         /* if channel already in use, release it */
1108         if (p_m_b_channel)
1109                 drop_bchannel();
1110
1111         /* if CHANNEL_NO */
1112         if (channel==CHANNEL_NO || channel==0)
1113                 return(0);
1114
1115         /* is channel in range ? */
1116         if (channel==16
1117          || (channel>p_m_mISDNport->b_num && channel<16)
1118          || ((channel-1)>p_m_mISDNport->b_num && channel>16)) /* channel-1 because channel 16 is not counted */
1119                 return(-6); /* channel unacceptable */
1120
1121         /* request exclusive channel */
1122         if (exclusive && channel>0)
1123         {
1124                 i = channel-1-(channel>16);
1125                 if (p_m_mISDNport->b_port[i])
1126                         return(-44); /* requested channel not available */
1127                 goto seize;
1128         }
1129
1130         /* ask for channel */
1131         if (channel>0)
1132         {
1133                 i = channel-1-(channel>16);
1134                 if (p_m_mISDNport->b_port[i] == NULL)
1135                         goto seize;
1136         }
1137
1138         /* search for channel */
1139         i = 0;
1140         while(i < p_m_mISDNport->b_num)
1141         {
1142                 if (!p_m_mISDNport->b_port[i])
1143                 {
1144                         channel = i+1+(i>=15);
1145                         goto seize;
1146                 }
1147                 i++;
1148         }
1149         return(-34); /* no free channel */
1150
1151 seize:
1152         PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) seizing bchannel %d (index %d)\n", p_name, channel, i);
1153
1154         /* link Port */
1155         p_m_mISDNport->b_port[i] = this;
1156         p_m_b_index = i;
1157         p_m_b_channel = channel;
1158         p_m_b_exclusive = exclusive;
1159
1160         /* reserve channel */
1161         if (!p_m_b_reserve)
1162         {
1163                 p_m_b_reserve = 1;
1164                 p_m_mISDNport->b_reserved++;
1165         }
1166
1167         return(channel);
1168 }
1169
1170 /*
1171  * drop reserved channel and unset it.
1172  * deactivation is also done
1173  */
1174 void PmISDN::drop_bchannel(void)
1175 {
1176         /* unreserve channel */
1177         if (p_m_b_reserve)
1178                 p_m_mISDNport->b_reserved--;
1179         p_m_b_reserve = 0;
1180
1181         /* if not in use */
1182         if (p_m_b_index < 0)
1183                 return;
1184         if (!p_m_b_channel)
1185                 return;
1186
1187         PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) dropping bchannel\n", p_name);
1188
1189         if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_IDLE)
1190                 bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_DROP);
1191         p_m_mISDNport->b_port[p_m_b_index] = NULL;
1192         p_m_b_index = -1;
1193         p_m_b_channel = 0;
1194         p_m_b_exclusive = 0;
1195 }
1196
1197 /* process bchannel export/import message from join */
1198 void message_bchannel_from_join(class JoinRemote *joinremote, int type, unsigned long handle)
1199 {
1200         class Endpoint *epoint;
1201         class Port *port;
1202         class PmISDN *isdnport;
1203         struct mISDNport *mISDNport;
1204         int i, ii;
1205
1206         switch(type)
1207         {
1208                 case BCHANNEL_REQUEST:
1209                 /* find the port object for the join object ref */
1210                 if (!(epoint = find_epoint_id(joinremote->j_epoint_id)))
1211                 {
1212                         PDEBUG(DEBUG_BCHANNEL, "join %d has no endpoint (anymore)\n", joinremote->j_serial);
1213                         return;
1214                 }
1215                 if (!epoint->ep_portlist)
1216                 {
1217                         PDEBUG(DEBUG_BCHANNEL, "join %d has no port (anymore in portlist)\n", joinremote->j_serial);
1218                         return;
1219                 }
1220                 if (epoint->ep_portlist->next)
1221                 {
1222                         PERROR("join %d has enpoint %d with more than one port. this shall not happen to remote joins.\n", joinremote->j_serial, epoint->ep_serial);
1223                 }
1224                 if (!(port = find_port_id(epoint->ep_portlist->port_id)))
1225                 {
1226                         PDEBUG(DEBUG_BCHANNEL, "join %d has no port (anymore as object)\n", joinremote->j_serial);
1227                         return;
1228                 }
1229                 if (!((port->p_type&PORT_CLASS_MASK) != PORT_CLASS_mISDN))
1230                 {
1231                         PERROR("join %d has port %d not of mISDN type. This shall not happen.\n", joinremote->j_serial, port->p_serial);
1232                 }
1233                 isdnport = (class PmISDN *)port;
1234
1235                 /* assign */
1236                 if (isdnport->p_m_remote_id)
1237                 {
1238                         PERROR("join %d recevied bchannel request from remote, but channel is already assinged.\n", joinremote->j_serial);
1239                         break;
1240                 }
1241                 mISDNport = isdnport->p_m_mISDNport;
1242                 i = isdnport->p_m_b_index;
1243                 chan_trace_header(mISDNport, isdnport, "MESSAGE_BCHANNEL (from remote application)", DIRECTION_NONE);
1244                 add_trace("type", NULL, "export request");
1245                 isdnport->p_m_remote_ref = joinremote->j_serial;
1246                 isdnport->p_m_remote_id = joinremote->j_remote_id;
1247                 if (mISDNport && i>=0)
1248                 {
1249                         bchannel_event(mISDNport, i, B_EVENT_EXPORTREQUEST);
1250                 }
1251                 end_trace();
1252                 break;
1253
1254                 case BCHANNEL_ASSIGN_ACK:
1255                 case BCHANNEL_REMOVE_ACK:
1256                 /* find mISDNport for stack ID */
1257                 mISDNport = mISDNport_first;
1258                 while(mISDNport)
1259                 {
1260                         i = 0;
1261                         ii = mISDNport->b_num;
1262                         while(i < ii)
1263                         {
1264 #ifdef SOCKET_MISDN
1265                                 if (mISDNport->b_socket[i] == handle)
1266 #else
1267                                 if ((unsigned long)(mISDNport->portnum<<8)+i+1+(i>=15) == handle)
1268 #endif
1269                                         break;
1270                                 i++;
1271                         }
1272                         if (i != ii)
1273                                 break;
1274                         mISDNport = mISDNport->next;
1275                 }
1276                 if (!mISDNport)
1277                 {
1278                         PERROR("received assign/remove ack for handle=%x, but handle does not exist in any mISDNport structure.\n", handle);
1279                         break;
1280                 }
1281                 /* mISDNport may now be set or NULL */
1282
1283                 /* set */
1284                 chan_trace_header(mISDNport, mISDNport->b_port[i], "MESSAGE_BCHANNEL (from remote application)", DIRECTION_NONE);
1285                 add_trace("type", NULL, (type==BCHANNEL_ASSIGN_ACK)?"assign_ack":"remove_ack");
1286                 if (mISDNport && i>=0)
1287                         bchannel_event(mISDNport, i, (type==BCHANNEL_ASSIGN_ACK)?B_EVENT_EXPORTED:B_EVENT_IMPORTED);
1288                 end_trace();
1289                 break;
1290                 default:
1291                 PERROR("received wrong bchannel message type %d from remote\n", type);
1292         }
1293 }
1294
1295
1296 /*
1297  * handler
1298
1299 audio transmission procedure:
1300 -----------------------------
1301
1302 * priority
1303 three sources of audio transmission:
1304 - crypto-data high priority
1305 - tones high priority (also high)
1306 - remote-data low priority
1307
1308 * elapsed
1309 a variable that temporarily shows the number of samples elapsed since last transmission process.
1310 p_m_last_tv_* is used to store that last timestamp. this is used to calculate the time elapsed.
1311
1312 * load
1313 a variable that is increased whenever data is transmitted.
1314 it is decreased while time elapses. it stores the number of samples that
1315 are currently loaded to dsp module.
1316 since clock in dsp module is the same clock for user space process, these
1317 times have no skew.
1318
1319 * levels
1320 there are two levels:
1321 ISDN_LOAD will give the load that have to be kept in dsp.
1322 ISDN_MAXLOAD will give the maximum load before dropping.
1323
1324 * procedure for low priority data
1325 see txfromup() for procedure
1326 in short: remote data is ignored during high priority tones
1327
1328 * procedure for high priority data
1329 whenever load is below ISDN_LOAD, load is filled up to ISDN_LOAD
1330 if no more data is available, load becomes empty again.
1331
1332 'load' variable:
1333 0                    ISDN_LOAD           ISDN_MAXLOAD
1334 +--------------------+----------------------+
1335 |                    |                      |
1336 +--------------------+----------------------+
1337
1338 on empty load or on load below ISDN_LOAD, the load is inceased to ISDN_LOAD:
1339 0                    ISDN_LOAD           ISDN_MAXLOAD
1340 +--------------------+----------------------+
1341 |TTTTTTTTTTTTTTTTTTTT|                      |
1342 +--------------------+----------------------+
1343
1344 on empty load, remote-audio causes the load with the remote audio to be increased to ISDN_LOAD.
1345 0                    ISDN_LOAD           ISDN_MAXLOAD
1346 +--------------------+----------------------+
1347 |TTTTTTTTTTTTTTTTTTTTRRRRR                  |
1348 +--------------------+----------------------+
1349
1350  */
1351 int PmISDN::handler(void)
1352 {
1353         struct message *message;
1354         int elapsed = 0;
1355         int ret;
1356
1357         if ((ret = Port::handler()))
1358                 return(ret);
1359
1360         /* get elapsed */
1361         if (p_m_last_tv_sec)
1362         {
1363                 elapsed = 8000 * (now_tv.tv_sec - p_m_last_tv_sec)
1364                         + 8 * (now_tv.tv_usec/1000 - p_m_last_tv_msec);
1365         } else
1366         {
1367                 /* set clock of first process ever in this instance */
1368                 p_m_last_tv_sec = now_tv.tv_sec;
1369                 p_m_last_tv_msec = now_tv.tv_usec/1000;
1370         }
1371         /* process only if we have a minimum of samples, to make packets not too small */
1372         if (elapsed >= ISDN_TRANSMIT)
1373         {
1374                 /* set clock of last process! */
1375                 p_m_last_tv_sec = now_tv.tv_sec;
1376                 p_m_last_tv_msec = now_tv.tv_usec/1000;
1377
1378                 /* update load */
1379                 if (elapsed < p_m_load)
1380                         p_m_load -= elapsed;
1381                 else
1382                         p_m_load = 0;
1383
1384                 /* to send data, tone must be active OR crypt messages must be on */
1385                 if ((p_tone_name[0] || p_m_crypt_msg_loops) && p_m_load < ISDN_LOAD)
1386                 {
1387                         int tosend = ISDN_LOAD - p_m_load, length;
1388 #ifdef SOCKET_MISDN
1389                         unsigned char buf[MISDN_HEADER_LEN+tosend];
1390                         struct mISDNhead *frm = (struct mISDNhead *)buf;
1391                         unsigned long *d = buf+MISDN_HEADER_LEN;
1392 #else
1393                         unsigned char buf[mISDN_HEADER_LEN+tosend];
1394                         iframe_t *frm = (iframe_t *)buf;
1395                         unsigned char *p = buf+mISDN_HEADER_LEN;
1396 #endif
1397
1398                         /* copy crypto loops */
1399                         while (p_m_crypt_msg_loops && tosend)
1400                         {
1401                                 /* how much do we have to send */
1402                                 length = p_m_crypt_msg_len - p_m_crypt_msg_current;
1403
1404                                 /* clip tosend */
1405                                 if (length > tosend)
1406                                         length = tosend;
1407
1408                                 /* copy message (part) to buffer */
1409                                 memcpy(p, p_m_crypt_msg+p_m_crypt_msg_current, length);
1410
1411                                 /* new position */
1412                                 p_m_crypt_msg_current += length;
1413                                 if (p_m_crypt_msg_current == p_m_crypt_msg_len)
1414                                 {
1415                                         /* next loop */
1416                                         p_m_crypt_msg_current = 0;
1417                                         p_m_crypt_msg_loops--;
1418 //                                      puts("eine loop weniger");
1419                                 }
1420
1421                                 /* new length */
1422                                 tosend -= length;
1423                         }
1424
1425                         /* copy tones */
1426                         if (p_tone_name[0] && tosend)
1427                         {
1428                                 tosend -= read_audio(p, tosend);
1429                         }
1430
1431                         /* send data */
1432 #ifdef SOCKET_MISDN
1433                         frm->prim = DL_DATA_REQ;
1434                         frm->id = 0;
1435                         ret = sendto(handle, buffer, MISDN_HEADER_LEN+ISDN_LOAD-p_m_load-tosend, 0, NULL, 0);
1436                         if (!ret)
1437                                 PERROR("Failed to send to socket %d\n", handle);
1438 #else
1439                         frm->prim = DL_DATA | REQUEST;
1440                         frm->addr = p_m_mISDNport->b_addr[p_m_b_index] | FLG_MSG_DOWN;
1441                         frm->dinfo = 0;
1442                         frm->len = ISDN_LOAD - p_m_load - tosend;
1443 #endif
1444                         if (frm->len)
1445                                 mISDN_write(mISDNdevice, frm, mISDN_HEADER_LEN+frm->len, TIMEOUT_1SEC);
1446                         p_m_load += frm->len;
1447                 }
1448         }
1449
1450         // NOTE: deletion is done by the child class
1451
1452         /* handle timeouts */
1453         if (p_m_timeout)
1454         {
1455                 if (p_m_timer+p_m_timeout < now_d)
1456                 {
1457                         PDEBUG(DEBUG_ISDN, "(%s) timeout after %d seconds detected (state=%d).\n", p_name, p_m_timeout, p_state);
1458                         p_m_timeout = 0;
1459                         /* send timeout to endpoint */
1460                         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_TIMEOUT);
1461                         message->param.state = p_state;
1462                         message_put(message);
1463                         return(1);
1464                 }
1465         }
1466
1467         return(0); /* nothing done */
1468 }
1469
1470
1471 /*
1472  * whenever we get audio data from bchannel, we process it here
1473  */
1474 #ifdef SOCKET_MISDN
1475 void PmISDN::bchannel_receive(mISDNhead *hh, unsigned char *data, int len)
1476 {
1477         unsigned long cont = *((unsigned long *)data);
1478 #else
1479 void PmISDN::bchannel_receive(iframe_t *frm)
1480 {
1481         int len = frm->len;
1482         unsigned long cont = *((unsigned long *)&frm->data.p);
1483         unsigned char *data =(unsigned char *)&frm->data.p;
1484 #endif
1485         unsigned char *data_temp;
1486         unsigned long length_temp;
1487         struct message *message;
1488         unsigned char *p;
1489         int l;
1490
1491 #ifdef SOCKET_MISDN
1492         if (hh->prim == PH_CONTROL_IND)
1493 #else
1494         if (frm->prim == (PH_CONTROL | INDICATION))
1495 #endif
1496         {
1497                 if (len < 4)
1498                 {
1499                         PERROR("SHORT READ OF PH_CONTROL INDICATION\n");
1500                         return;
1501                 }
1502                 if ((cont&(~DTMF_TONE_MASK)) == DTMF_TONE_VAL)
1503                 {
1504                         chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1505                         add_trace("DTMF", NULL, "%c", cont & DTMF_TONE_MASK);
1506                         end_trace();
1507                         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_DTMF);
1508                         message->param.dtmf = cont & DTMF_TONE_MASK;
1509                         PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION  DTMF digit '%c'\n", p_name, message->param.dtmf);
1510                         message_put(message);
1511                         return;
1512                 }
1513                 switch(cont)
1514                 {
1515                         case BF_REJECT:
1516                         chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1517                         add_trace("DSP-CRYPT", NULL, "error");
1518                         end_trace();
1519                         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1520                         message->param.crypt.type = CC_ERROR_IND;
1521                         PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION  reject of blowfish.\n", p_name);
1522                         message_put(message);
1523                         break;
1524
1525                         case BF_ACCEPT:
1526                         chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1527                         add_trace("DSP-CRYPT", NULL, "ok");
1528                         end_trace();
1529                         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1530                         message->param.crypt.type = CC_ACTBF_CONF;
1531                         PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION  accept of blowfish.\n", p_name);
1532                         message_put(message);
1533                         break;
1534
1535                         default:
1536                         chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1537                         add_trace("unknown", NULL, "0x%x", cont);
1538                         end_trace();
1539                 }
1540                 return;
1541         }
1542 #ifdef SOCKET_MISDN
1543         if (hh->prim == PH_SIGNAL_IND)
1544 #else
1545         if (frm->prim == (PH_SIGNAL | INDICATION))
1546 #endif
1547         {
1548                 switch(frm->dinfo)
1549                 {
1550                         case CMX_TX_DATA:
1551                         if (!p_m_txdata)
1552                         {
1553                                 /* if tx is off, it may happen that fifos send us pending informations, we just ignore them */
1554                                 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring tx data, because 'txdata' is turned off\n", p_name);
1555                                 return;
1556                         }
1557                         /* see below (same condition) */
1558                         if (p_state!=PORT_STATE_CONNECT
1559                                  && !p_m_mISDNport->tones)
1560                                 break;
1561 //                      printf(".");fflush(stdout);return;
1562                         if (p_record)
1563                                 record(data, len, 1); // from up
1564                         break;
1565
1566                         default:
1567                         chan_trace_header(p_m_mISDNport, this, "BCHANNEL signal", DIRECTION_IN);
1568                         add_trace("unknown", NULL, "0x%x", frm->dinfo);
1569                         end_trace();
1570                 }
1571                 return;
1572         }
1573 #ifdef SOCKET_MISDN
1574         if (hh->prim != PH_DATA_IND && hh->prim != DL_DATA_IND)
1575         {
1576                 PERROR("Bchannel received unknown primitve: 0x%x\n", hh->prim);
1577 #else
1578         if (frm->prim != (PH_DATA | INDICATION) && frm->prim != (DL_DATA | INDICATION))
1579         {
1580                 PERROR("Bchannel received unknown primitve: 0x%x\n", frm->prim);
1581 #endif
1582                 return;
1583         }
1584         /* calls will not process any audio data unless
1585          * the call is connected OR interface features audio during call setup.
1586          */
1587 //printf("%d -> %d prim=%x joindata=%d tones=%d\n", p_serial, ACTIVE_EPOINT(p_epointlist), frm->prim, p_m_joindata, p_m_mISDNport->earlyb);
1588 #ifndef DEBUG_COREBRIDGE
1589         if (p_state!=PORT_STATE_CONNECT
1590          && !p_m_mISDNport->tones)
1591                 return;
1592 #endif
1593
1594         /* if rx is off, it may happen that fifos send us pending informations, we just ignore them */
1595         if (p_m_rxoff)
1596         {
1597                 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring data, because rx is turned off\n", p_name);
1598                 return;
1599         }
1600
1601         /* record data */
1602         if (p_record)
1603                 record(data, len, 0); // from down
1604
1605         /* randomize and listen to crypt message if enabled */
1606         if (p_m_crypt_listen)
1607         {
1608                 /* the noisy randomizer */
1609                 p = data;
1610                 l = len;
1611                 while(l--)
1612                         mISDN_rand[mISDN_rand_count & 0xff] += *p++;
1613
1614                 cryptman_listen_bch(data, len);
1615         }
1616
1617         p = data;
1618
1619         /* send data to epoint */
1620         if (p_m_joindata && ACTIVE_EPOINT(p_epointlist)) /* only if we have an epoint object */
1621         {
1622                 length_temp = len;
1623                 data_temp = p;
1624                 while(length_temp)
1625                 {
1626                         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_DATA);
1627                         message->param.data.len = (length_temp>sizeof(message->param.data.data))?sizeof(message->param.data.data):length_temp;
1628                         memcpy(message->param.data.data, data_temp, message->param.data.len);
1629                         message_put(message);
1630                         if (length_temp <= sizeof(message->param.data.data))
1631                                 break;
1632                         data_temp += sizeof(message->param.data.data);
1633                         length_temp -= sizeof(message->param.data.data);
1634                 }
1635         }
1636 }
1637
1638
1639 /*
1640  * set echotest
1641  */
1642 void PmISDN::set_echotest(int echo)
1643 {
1644         if (p_m_echo != echo)
1645         {
1646                 p_m_echo = echo;
1647                 PDEBUG(DEBUG_ISDN, "we set echo to echo=%d.\n", p_m_echo);
1648                 if (p_m_b_channel)
1649                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1650 #ifdef SOCKET_MISDN
1651                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_socket[p_m_b_index], p_m_echo?CMX_ECHO_ON:CMX_ECHO_OFF, 0, "DSP-ECHO", p_m_echo);
1652 #else
1653                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_addr[p_m_b_index], p_m_echo?CMX_ECHO_ON:CMX_ECHO_OFF, 0, "DSP-ECHO", p_m_echo);
1654 #endif
1655         }
1656 }
1657
1658 /*
1659  * set tone
1660  */
1661 void PmISDN::set_tone(char *dir, char *tone)
1662 {
1663         int id;
1664
1665         if (!tone)
1666                 tone = "";
1667         PDEBUG(DEBUG_ISDN, "isdn port now plays tone:'%s'.\n", tone);
1668         if (!tone[0])
1669         {
1670                 id = TONE_OFF;
1671                 goto setdsp;
1672         }
1673
1674         /* check if we NOT really have to use a dsp-tone */
1675         if (!options.dsptones)
1676         {
1677                 nodsp:
1678                 if (p_m_tone)
1679                 if (p_m_b_index >= 0)
1680                 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1681                 {
1682                         PDEBUG(DEBUG_ISDN, "we reset tone from id=%d to OFF.\n", p_m_tone);
1683 #ifdef SOCKET_MISDN
1684                         ph_control(p_m_mISDNport, this, p_m_mISDNport->b_socket[p_m_b_index], TONE_PATT_OFF, 0, "DSP-TONE", 0);
1685 #else
1686                         ph_control(p_m_mISDNport, this, p_m_mISDNport->b_addr[p_m_b_index], TONE_PATT_OFF, 0, "DSP-TONE", 0);
1687 #endif
1688                 }
1689                 p_m_tone = 0;
1690                 Port::set_tone(dir, tone);
1691                 return;
1692         }
1693         if (p_tone_dir[0])
1694                 goto nodsp;
1695
1696         /* now we USE dsp-tone, convert name */
1697         else if (!strcmp(tone, "dialtone"))
1698         {
1699                 switch(options.dsptones) {
1700                 case DSP_AMERICAN: id = TONE_AMERICAN_DIALTONE; break;
1701                 case DSP_GERMAN: id = TONE_GERMAN_DIALTONE; break;
1702                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALTONE; break;
1703                 }
1704         } else if (!strcmp(tone, "dialpbx"))
1705         {
1706                 switch(options.dsptones) {
1707                 case DSP_AMERICAN: id = TONE_AMERICAN_DIALPBX; break;
1708                 case DSP_GERMAN: id = TONE_GERMAN_DIALPBX; break;
1709                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALPBX; break;
1710                 }
1711         } else if (!strcmp(tone, "ringing"))
1712         {
1713                 switch(options.dsptones) {
1714                 case DSP_AMERICAN: id = TONE_AMERICAN_RINGING; break;
1715                 case DSP_GERMAN: id = TONE_GERMAN_RINGING; break;
1716                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGING; break;
1717                 }
1718         } else if (!strcmp(tone, "ringpbx"))
1719         {
1720                 switch(options.dsptones) {
1721                 case DSP_AMERICAN: id = TONE_AMERICAN_RINGPBX; break;
1722                 case DSP_GERMAN: id = TONE_GERMAN_RINGPBX; break;
1723                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGPBX; break;
1724                 }
1725         } else if (!strcmp(tone, "busy"))
1726         {
1727                 busy:
1728                 switch(options.dsptones) {
1729                 case DSP_AMERICAN: id = TONE_AMERICAN_BUSY; break;
1730                 case DSP_GERMAN: id = TONE_GERMAN_BUSY; break;
1731                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1732                 }
1733         } else if (!strcmp(tone, "release"))
1734         {
1735                 hangup:
1736                 switch(options.dsptones) {
1737                 case DSP_AMERICAN: id = TONE_AMERICAN_HANGUP; break;
1738                 case DSP_GERMAN: id = TONE_GERMAN_HANGUP; break;
1739                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDHANGUP; break;
1740                 }
1741         } else if (!strcmp(tone, "cause_10"))
1742                 goto hangup;
1743         else if (!strcmp(tone, "cause_11"))
1744                 goto busy;
1745         else if (!strcmp(tone, "cause_22"))
1746         {
1747                 switch(options.dsptones) {
1748                 case DSP_AMERICAN: id = TONE_SPECIAL_INFO; break;
1749                 case DSP_GERMAN: id = TONE_GERMAN_GASSENBESETZT; break;
1750                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1751                 }
1752         } else if (!strncmp(tone, "cause_", 6))
1753                 id = TONE_SPECIAL_INFO;
1754         else
1755                 id = TONE_OFF;
1756
1757         /* if we have a tone that is not supported by dsp */
1758         if (id==TONE_OFF && tone[0])
1759                 goto nodsp;
1760
1761         setdsp:
1762         if (p_m_tone != id)
1763         {
1764                 /* set new tone */
1765                 p_m_tone = id;
1766                 PDEBUG(DEBUG_ISDN, "we set tone to id=%d.\n", p_m_tone);
1767                 if (p_m_b_index >= 0)
1768                 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1769 #ifdef SOCKET_MISDN
1770                         ph_control(p_m_mISDNport, this, p_m_mISDNport->b_socket[p_m_b_index], p_m_tone?TONE_PATT_ON:TONE_PATT_OFF, p_m_tone, "DSP-TONE", p_m_tone);
1771 #else
1772                         ph_control(p_m_mISDNport, this, p_m_mISDNport->b_addr[p_m_b_index], p_m_tone?TONE_PATT_ON:TONE_PATT_OFF, p_m_tone, "DSP-TONE", p_m_tone);
1773 #endif
1774         }
1775         /* turn user-space tones off in cases of no tone OR dsp tone */
1776         Port::set_tone("",NULL);
1777 }
1778
1779
1780 /* MESSAGE_mISDNSIGNAL */
1781 //extern struct message *dddebug;
1782 void PmISDN::message_mISDNsignal(unsigned long epoint_id, int message_id, union parameter *param)
1783 {
1784         switch(param->mISDNsignal.message)
1785         {
1786                 case mISDNSIGNAL_VOLUME:
1787                 if (p_m_txvol != param->mISDNsignal.txvol)
1788                 {
1789                         p_m_txvol = param->mISDNsignal.txvol;
1790                         PDEBUG(DEBUG_BCHANNEL, "we change tx-volume to shift=%d.\n", p_m_txvol);
1791                         if (p_m_b_index >= 0)
1792                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1793 #ifdef SOCKET_MISDN
1794                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_socket[p_m_b_index], VOL_CHANGE_TX, p_m_txvol, "DSP-TXVOL", p_m_txvol);
1795 #else
1796                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_addr[p_m_b_index], VOL_CHANGE_TX, p_m_txvol, "DSP-TXVOL", p_m_txvol);
1797 #endif
1798                 } else
1799                         PDEBUG(DEBUG_BCHANNEL, "we already have tx-volume shift=%d.\n", p_m_rxvol);
1800                 if (p_m_rxvol != param->mISDNsignal.rxvol)
1801                 {
1802                         p_m_rxvol = param->mISDNsignal.rxvol;
1803                         PDEBUG(DEBUG_BCHANNEL, "we change rx-volume to shift=%d.\n", p_m_rxvol);
1804                         if (p_m_b_index >= 0)
1805                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1806 #ifdef SOCKET_MISDN
1807                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_socket[p_m_b_index], VOL_CHANGE_RX, p_m_rxvol, "DSP-RXVOL", p_m_rxvol);
1808 #else
1809                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_addr[p_m_b_index], VOL_CHANGE_RX, p_m_rxvol, "DSP-RXVOL", p_m_rxvol);
1810 #endif
1811                 } else
1812                         PDEBUG(DEBUG_BCHANNEL, "we already have rx-volume shift=%d.\n", p_m_rxvol);
1813                 break;
1814
1815                 case mISDNSIGNAL_CONF:
1816 //if (dddebug) PDEBUG(DEBUG_ISDN, "dddebug = %d\n", dddebug->type);
1817 //tone          if (!p_m_tone && p_m_conf!=param->mISDNsignal.conf)
1818                 if (p_m_conf != param->mISDNsignal.conf)
1819                 {
1820                         p_m_conf = param->mISDNsignal.conf;
1821                         PDEBUG(DEBUG_BCHANNEL, "we change conference to conf=%d.\n", p_m_conf);
1822                         if (p_m_b_index >= 0)
1823                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1824 #ifdef SOCKET_MISDN
1825                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_socket[p_m_b_index], (p_m_conf)?CMX_CONF_JOIN:CMX_CONF_SPLIT, p_m_conf, "DSP-CONF", p_m_conf);
1826 #else
1827                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_addr[p_m_b_index], (p_m_conf)?CMX_CONF_JOIN:CMX_CONF_SPLIT, p_m_conf, "DSP-CONF", p_m_conf);
1828 #endif
1829                 } else
1830                         PDEBUG(DEBUG_BCHANNEL, "we already have conf=%d.\n", p_m_conf);
1831                 /* we must set, even if currently tone forbids conf */
1832                 p_m_conf = param->mISDNsignal.conf;
1833 //if (dddebug) PDEBUG(DEBUG_ISDN, "dddebug = %d\n", dddebug->type);
1834                 break;
1835
1836                 case mISDNSIGNAL_JOINDATA:
1837                 if (p_m_joindata != param->mISDNsignal.joindata)
1838                 {
1839                         p_m_joindata = param->mISDNsignal.joindata;
1840                         PDEBUG(DEBUG_BCHANNEL, "we change to joindata=%d.\n", p_m_joindata);
1841                 } else
1842                         PDEBUG(DEBUG_BCHANNEL, "we already have joindata=%d.\n", p_m_joindata);
1843                 break;
1844
1845                 case mISDNSIGNAL_DELAY:
1846                 if (p_m_delay != param->mISDNsignal.delay)
1847                 {
1848                         p_m_delay = param->mISDNsignal.delay;
1849                         PDEBUG(DEBUG_BCHANNEL, "we change delay mode to delay=%d.\n", p_m_delay);
1850                         if (p_m_b_index >= 0)
1851                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1852 #ifdef SOCKET_MISDN
1853                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_socket[p_m_b_index], p_m_delay?CMX_DELAY:CMX_JITTER, p_m_delay, "DSP-DELAY", p_m_delay);
1854 #else
1855                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_addr[p_m_b_index], p_m_delay?CMX_DELAY:CMX_JITTER, p_m_delay, "DSP-DELAY", p_m_delay);
1856 #endif
1857                 } else
1858                         PDEBUG(DEBUG_BCHANNEL, "we already have delay=%d.\n", p_m_delay);
1859                 break;
1860
1861                 default:
1862                 PERROR("PmISDN(%s) unsupported signal message %d.\n", p_name, param->mISDNsignal.message);
1863         }
1864 }
1865
1866 /* MESSAGE_CRYPT */
1867 void PmISDN::message_crypt(unsigned long epoint_id, int message_id, union parameter *param)
1868 {
1869         struct message *message;
1870
1871         switch(param->crypt.type)
1872         {
1873                 case CC_ACTBF_REQ:           /* activate blowfish */
1874                 p_m_crypt = 1;
1875                 p_m_crypt_key_len = param->crypt.len;
1876                 if (p_m_crypt_key_len > (int)sizeof(p_m_crypt_key))
1877                 {
1878                         PERROR("PmISDN(%s) key too long %d > %d\n", p_name, p_m_crypt_key_len, sizeof(p_m_crypt_key));
1879                         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1880                         message->param.crypt.type = CC_ERROR_IND;
1881                         message_put(message);
1882                         break;
1883                 }
1884                 memcpy(p_m_crypt_key, param->crypt.data, p_m_crypt_key_len);
1885                 crypt_off:
1886                 PDEBUG(DEBUG_BCHANNEL, "we set encryption to crypt=%d. (0 means OFF)\n", p_m_crypt);
1887                 if (p_m_b_index >= 0)
1888                 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1889 #ifdef SOCKET_MISDN
1890                         ph_control_block(p_m_mISDNport, this, p_m_mISDNport->b_socket[p_m_b_index], p_m_crypt?BF_ENABLE_KEY:BF_DISABLE, p_m_crypt_key, p_m_crypt_key_len, "DSP-CRYPT", p_m_crypt_key_len);
1891 #else
1892                         ph_control_block(p_m_mISDNport, this, p_m_mISDNport->b_addr[p_m_b_index], p_m_crypt?BF_ENABLE_KEY:BF_DISABLE, p_m_crypt_key, p_m_crypt_key_len, "DSP-CRYPT", p_m_crypt_key_len);
1893 #endif
1894                 break;
1895
1896                 case CC_DACT_REQ:            /* deactivate session encryption */
1897                 p_m_crypt = 0;
1898                 goto crypt_off;
1899                 break;
1900
1901                 case CR_LISTEN_REQ:          /* start listening to messages */
1902                 p_m_crypt_listen = 1;
1903                 p_m_crypt_listen_state = 0;
1904                 break;
1905
1906                 case CR_UNLISTEN_REQ:        /* stop listening to messages */
1907                 p_m_crypt_listen = 0;
1908                 break;
1909
1910                 case CR_MESSAGE_REQ:         /* send message */
1911                 p_m_crypt_msg_len = cryptman_encode_bch(param->crypt.data, param->crypt.len, p_m_crypt_msg, sizeof(p_m_crypt_msg));
1912                 if (!p_m_crypt_msg_len)
1913                 {
1914                         PERROR("PmISDN(%s) message too long %d > %d\n", p_name, param->crypt.len-1, sizeof(p_m_crypt_msg));
1915                         break;
1916                 }
1917                 p_m_crypt_msg_current = 0; /* reset */
1918                 p_m_crypt_msg_loops = 6; /* enable */
1919 #if 0
1920                 /* disable txmix, or we get corrupt data due to audio process */
1921                 if (p_m_txmix && p_m_b_index>=0)
1922                 {
1923                         PDEBUG(DEBUG_BCHANNEL, "for sending CR_MESSAGE_REQ, we reset txmix from txmix=%d.\n", p_m_txmix);
1924 #ifdef SOCKET_MISDN
1925                         ph_control(p_m_mISDNport, this, p_mISDNport->b_socket[p_m_b_index], CMX_MIX_OFF, 0, "DSP-TXMIX", 0);
1926 #else
1927                         ph_control(p_m_mISDNport, this, p_mISDNport->b_addr[p_m_b_index], CMX_MIX_OFF, 0, "DSP-TXMIX", 0);
1928 #endif
1929                 }
1930 #endif
1931                 break;
1932
1933                 default:
1934                 PERROR("PmISDN(%s) unknown crypt message %d\n", p_name, param->crypt.type);
1935         }
1936
1937 }
1938
1939 /*
1940  * endpoint sends messages to the port
1941  */
1942 int PmISDN::message_epoint(unsigned long epoint_id, int message_id, union parameter *param)
1943 {
1944         if (Port::message_epoint(epoint_id, message_id, param))
1945                 return(1);
1946
1947         switch(message_id)
1948         {
1949                 case MESSAGE_DATA: /* tx-data from upper layer */
1950                 txfromup(param->data.data, param->data.len);
1951                 return(1);
1952
1953                 case MESSAGE_mISDNSIGNAL: /* user command */
1954                 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received special ISDN SIGNAL %d.\n", p_name, param->mISDNsignal.message);
1955                 message_mISDNsignal(epoint_id, message_id, param);
1956                 return(1);
1957
1958                 case MESSAGE_CRYPT: /* crypt control command */
1959                 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received encryption command '%d'.\n", p_name, param->crypt.type);
1960                 message_crypt(epoint_id, message_id, param);
1961                 return(1);
1962         }
1963
1964         return(0);
1965 }
1966
1967
1968 /*
1969  * main loop for processing messages from mISDN
1970  */
1971 #ifdef SOCKET_MISDN
1972 int mISDN_handler(void)
1973 {
1974         int ret, work = 0;
1975         struct mISDNport *mISDNport;
1976         class PmISDN *isdnport;
1977         int i;
1978         char buffer[2048+MISDN_HEADER_LEN];
1979         struct mISDNhead *hh = (struct mISDNhead *)buffer;
1980
1981         /* process all ports */
1982         mISDNport = mISDNport_first;
1983         while(mISDNport)
1984         {
1985                 /* process all bchannels */
1986                 i = 0;
1987                 while(i < mISDNport->b_num)
1988                 {
1989                         /* handle port of bchannel */
1990                         isdnport=mISDNport->b_port[i];
1991                         if (isdnport)
1992                         {
1993                                 /* call bridges in user space OR crypto OR recording */
1994                                 if (isdnport->p_m_joindata || isdnport->p_m_crypt_msg_loops || isdnport->p_m_crypt_listen || isdnport->p_record)
1995                                 {
1996                                         /* rx IS required */
1997                                         if (isdnport->p_m_rxoff)
1998                                         {
1999                                                 /* turn on RX */
2000                                                 isdnport->p_m_rxoff = 0;
2001                                                 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is required, so we turn them on\n");
2002                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
2003                                                         ph_control(mISDNport, isdnport, mISDNport->b_socket[isdnport->p_m_b_index], CMX_RECEIVE_ON, 0, "DSP-RXOFF", 0);
2004                                                 return(1);
2005                                         }
2006                                 } else
2007                                 {
2008                                         /* rx NOT required */
2009                                         if (!isdnport->p_m_rxoff)
2010                                         {
2011                                                 /* turn off RX */
2012                                                 isdnport->p_m_rxoff = 1;
2013                                                 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is not required, so we turn them off\n");
2014                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
2015                                                         ph_control(mISDNport, isdnport, mISDNport->b_socket[isdnport->p_m_b_index], CMX_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
2016                                                 return(1);
2017                                         }
2018                                 }
2019                                 /* recording */
2020                                 if (isdnport->p_record)
2021                                 {
2022                                         /* txdata IS required */
2023                                         if (!isdnport->p_m_txdata)
2024                                         {
2025                                                 /* turn on RX */
2026                                                 isdnport->p_m_txdata = 1;
2027                                                 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is required, so we turn them on\n");
2028                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
2029                                                         ph_control(mISDNport, isdnport, mISDNport->b_socket[isdnport->p_m_b_index], CMX_TXDATA_ON, 0, "DSP-TXDATA", 1);
2030                                                 return(1);
2031                                         }
2032                                 } else
2033                                 {
2034                                         /* txdata NOT required */
2035                                         if (isdnport->p_m_txdata)
2036                                         {
2037                                                 /* turn off RX */
2038                                                 isdnport->p_m_txdata = 0;
2039                                                 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is not required, so we turn them off\n");
2040                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
2041                                                         ph_control(mISDNport, isdnport, mISDNport->b_socket[isdnport->p_m_b_index], CMX_TXDATA_OFF, 0, "DSP-TXDATA", 0);
2042                                                 return(1);
2043                                         }
2044                                 }
2045                         }
2046
2047                         /* handle message from bchannel */
2048                         if (mISDNport->b_stack[i] > -1)
2049                         {
2050                                 ret = recv(mISDNport->b_stack[i], buffer, sizeof(buffer), 0);
2051                                 if (ret >= MISDN_HEADER_LEN)
2052                                 {
2053                                         work = 1;
2054                                         switch(hh->prim)
2055                                         {
2056                                                 /* we don't care about confirms, we use rx data to sync tx */
2057                                                 case PH_DATA_CONF:
2058                                                 case DL_DATA_CONF:
2059                                                 break;
2060
2061                                                 /* we receive audio data, we respond to it AND we send tones */
2062                                                 case PH_DATA_IND:
2063                                                 case DL_DATA_IND:
2064                                                 case PH_SIGNAL_IND:
2065                                                 case PH_CONTROL_IND:
2066                                                 if (mISDNport->b_port[i])
2067                                                         mISDNport->b_port[i]->bchannel_receive(hh, buffer+MISDN_HEADER_LEN, ret-MISDN_HEADER_LEN);
2068                                                 else
2069                                                         PDEBUG(DEBUG_BCHANNEL, "b-channel is not associated to an ISDNPort (socket %d), ignoring.\n", mISDNport->b_stack[i]);
2070                                                 break;
2071
2072                                                 case PH_ACTIVATE_IND:
2073                                                 case DL_ESTABLISH_IND:
2074                                                 case PH_ACTIVATE_CONF:
2075                                                 case DL_ESTABLISH_CONF:
2076                                                 PDEBUG(DEBUG_BCHANNEL, "DL_ESTABLISH confirm: bchannel is now activated (socket %d).\n", mISDNport->b_socket[i]);
2077                                                 bchannel_event(mISDNport, i, B_EVENT_ACTIVATED);
2078                                                 break;
2079
2080                                                 case PH_DEACTIVATE_IND:
2081                                                 case DL_RELEASE_IND:
2082                                                 case PH_DEACTIVATE_CONF:
2083                                                 case DL_RELEASE_CONF:
2084                                                 PDEBUG(DEBUG_BCHANNEL, "DL_RELEASE confirm: bchannel is now de-activated (socket %d).\n", mISDNport->b_socket[i]);
2085                                                 bchannel_event(mISDNport, i, B_EVENT_DEACTIVATED);
2086                                                 break;
2087
2088                                                 default:
2089                                                 PERROR("child message not handled: prim(0x%x) socket(%d) msg->len(%d)\n", hh->prim, mISDNport->b_socket[i], msg->len);
2090                                         }
2091                                 } else
2092                                 {
2093                                         if (ret < 0 && errno != EWOULDBLOCK)
2094                                                 PERROR("Read from port %d, index %d failed with return code %d\n", mISDNport->portnum, i, ret);
2095                                 }
2096                         }
2097
2098                         i++;
2099                 }
2100 #if 0
2101                 if (mISDNport->l1timeout && now>mISDNport->l1timeout)
2102                 { ---}
2103                         PDEBUG(DEBUG_ISDN, "the L1 establish timer expired, we release all pending messages.\n", mISDNport->portnum);
2104                         mISDNport->l1timeout = 0;
2105 #endif
2106
2107                 /* layer 2 establish timer */
2108                 if (mISDNport->l2establish)
2109                 {
2110                         if (now-mISDNport->l2establish > 5)
2111                         {
2112
2113                                 PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link portnum=%d.\n", mISDNport->portnum);
2114                                 mISDNport->ml3->to_layer2(mISDNport->ml3, DL_ESTABLISH_REQ);
2115                                 l1l2l3_trace_header(mISDNport, NULL, DL_ESTABLISH_REQ, DIRECTION_OUT);
2116                                 end_trace();
2117                                 return(1);
2118                         }
2119                 }
2120
2121
2122                 mISDNport = mISDNport->next;
2123         }
2124
2125         /* if we received at least one b-frame, we will return 1 */
2126         return(work);
2127 }
2128 #else
2129 int mISDN_handler(void)
2130 {
2131         int ret;
2132         struct mISDNport *mISDNport;
2133         class PmISDN *isdnport;
2134         int i;
2135         msg_t *msg;
2136         iframe_t *frm;
2137         msg_t *dmsg;
2138         mISDNuser_head_t *hh;
2139         net_stack_t *nst;
2140
2141         /* the que avoids loopbacks when replying to stack after receiving
2142          * from stack. */
2143         mISDNport = mISDNport_first;
2144         while(mISDNport)
2145         {
2146                 /* process turning on/off rx */
2147                 i = 0;
2148                 while(i < mISDNport->b_num)
2149                 {
2150                         isdnport=mISDNport->b_port[i];
2151                         if (isdnport)
2152                         {
2153                                 /* call bridges in user space OR crypto OR recording */
2154                                 if (isdnport->p_m_joindata || isdnport->p_m_crypt_msg_loops || isdnport->p_m_crypt_listen || isdnport->p_record)
2155                                 {
2156                                         /* rx IS required */
2157                                         if (isdnport->p_m_rxoff)
2158                                         {
2159                                                 /* turn on RX */
2160                                                 isdnport->p_m_rxoff = 0;
2161                                                 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is required, so we turn them on\n");
2162                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
2163                                                         ph_control(mISDNport, isdnport, mISDNport->b_addr[isdnport->p_m_b_index], CMX_RECEIVE_ON, 0, "DSP-RXOFF", 0);
2164                                                 return(1);
2165                                         }
2166                                 } else
2167                                 {
2168                                         /* rx NOT required */
2169                                         if (!isdnport->p_m_rxoff)
2170                                         {
2171                                                 /* turn off RX */
2172                                                 isdnport->p_m_rxoff = 1;
2173                                                 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is not required, so we turn them off\n");
2174                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
2175                                                         ph_control(mISDNport, isdnport, mISDNport->b_addr[isdnport->p_m_b_index], CMX_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
2176                                                 return(1);
2177                                         }
2178                                 }
2179                                 /* recording */
2180                                 if (isdnport->p_record)
2181                                 {
2182                                         /* txdata IS required */
2183                                         if (!isdnport->p_m_txdata)
2184                                         {
2185                                                 /* turn on RX */
2186                                                 isdnport->p_m_txdata = 1;
2187                                                 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is required, so we turn them on\n");
2188                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
2189                                                         ph_control(mISDNport, isdnport, mISDNport->b_addr[isdnport->p_m_b_index], CMX_TXDATA_ON, 0, "DSP-TXDATA", 1);
2190                                                 return(1);
2191                                         }
2192                                 } else
2193                                 {
2194                                         /* txdata NOT required */
2195                                         if (isdnport->p_m_txdata)
2196                                         {
2197                                                 /* turn off RX */
2198                                                 isdnport->p_m_txdata = 0;
2199                                                 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is not required, so we turn them off\n");
2200                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
2201                                                         ph_control(mISDNport, isdnport, mISDNport->b_addr[isdnport->p_m_b_index], CMX_TXDATA_OFF, 0, "DSP-TXDATA", 0);
2202                                                 return(1);
2203                                         }
2204                                 }
2205                         }
2206                         i++;
2207                 }
2208 #if 0
2209                 if (mISDNport->l1timeout && now>mISDNport->l1timeout)
2210                 { ---}
2211                         PDEBUG(DEBUG_ISDN, "the L1 establish timer expired, we release all pending messages.\n", mISDNport->portnum);
2212                         mISDNport->l1timeout = 0;
2213 #endif
2214
2215                 if (mISDNport->l2establish)
2216                 {
2217                         if (now-mISDNport->l2establish > 5)
2218                         {
2219                                 if (mISDNport->ntmode)
2220                                 {
2221                                         PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link NT portnum=%d.\n", mISDNport->portnum);
2222                                         time(&mISDNport->l2establish);
2223                                         /* establish */
2224                                         dmsg = create_l2msg(DL_ESTABLISH | REQUEST, 0, 0);
2225                                         if (mISDNport->nst.manager_l3(&mISDNport->nst, dmsg))
2226                                                 free_msg(dmsg);
2227                                 } else {
2228                                         iframe_t act;
2229
2230                                         PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link TE portnum=%d.\n", mISDNport->portnum);
2231                                         time(&mISDNport->l2establish);
2232                                         /* establish */
2233                                         act.prim = DL_ESTABLISH | REQUEST;
2234                                         act.addr = (mISDNport->upper_id & ~LAYER_ID_MASK) | 3 | FLG_MSG_DOWN;
2235                                         act.dinfo = 0;
2236                                         act.len = 0;
2237                                         mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
2238                                 }
2239                                 l1l2l3_trace_header(mISDNport, NULL, DL_ESTABLISH | REQUEST, DIRECTION_OUT);
2240                                 end_trace();
2241                                 return(1);
2242                         }
2243                 }
2244                 if ((dmsg = msg_dequeue(&mISDNport->downqueue)))
2245                 {
2246                         if (mISDNport->ntmode)
2247                         {
2248                                 hh = (mISDNuser_head_t *)dmsg->data;
2249                                 PDEBUG(DEBUG_ISDN, "sending queued NT l3-down-message: prim(0x%x) dinfo(0x%x) msg->len(%d)\n", hh->prim, hh->dinfo, dmsg->len);
2250                                 if (mISDNport->nst.manager_l3(&mISDNport->nst, dmsg))
2251                                         free_msg(dmsg);
2252                         } else
2253                         {
2254                                 frm = (iframe_t *)dmsg->data;
2255                                 frm->addr = mISDNport->upper_id | FLG_MSG_DOWN;
2256                                 frm->len = (dmsg->len) - mISDN_HEADER_LEN;
2257                                 PDEBUG(DEBUG_ISDN, "sending queued TE l3-down-message: prim(0x%x) dinfo(0x%x) msg->len(%d)\n", frm->prim, frm->dinfo, dmsg->len);
2258                                 mISDN_write(mISDNdevice, dmsg->data, dmsg->len, TIMEOUT_1SEC);
2259                                 free_msg(dmsg);
2260                         }
2261                         return(1);
2262                 }
2263                 mISDNport = mISDNport->next;
2264         }
2265
2266         /* no device, no read */
2267         if (mISDNdevice < 0)
2268                 return(0);
2269
2270         /* get message from kernel */
2271         if (!(msg = alloc_msg(MAX_MSG_SIZE)))
2272                 return(1);
2273         ret = mISDN_read(mISDNdevice, msg->data, MAX_MSG_SIZE, 0);
2274         if (ret < 0)
2275         {
2276                 free_msg(msg);
2277                 if (errno == EAGAIN)
2278                         return(0);
2279                 FATAL("Failed to do mISDN_read()\n");
2280         }
2281         if (!ret)
2282         {
2283                 free_msg(msg);
2284 //              printf("%s: ERROR: mISDN_read() returns nothing\n");
2285                 return(0);
2286         }
2287         msg->len = ret;
2288         frm = (iframe_t *)msg->data;
2289
2290         /* global prim */
2291         switch(frm->prim)
2292         {
2293                 case MGR_DELLAYER | CONFIRM:
2294                 case MGR_INITTIMER | CONFIRM:
2295                 case MGR_ADDTIMER | CONFIRM:
2296                 case MGR_DELTIMER | CONFIRM:
2297                 case MGR_REMOVETIMER | CONFIRM:
2298                 free_msg(msg);
2299                 return(1);
2300         }
2301
2302         /* handle timer events from mISDN for NT-stack
2303          * note: they do not associate with a stack */
2304         if (frm->prim == (MGR_TIMER | INDICATION))
2305         {
2306                 itimer_t *it;
2307
2308                 /* find mISDNport */
2309                 mISDNport = mISDNport_first;
2310                 while(mISDNport)
2311                 {
2312                         /* nt mode only */
2313                         if (mISDNport->ntmode)
2314                         {
2315                                 it = mISDNport->nst.tlist;
2316                                 /* find timer */
2317                                 while(it)
2318                                 {
2319                                         if (it->id == (int)frm->addr)
2320                                                 break;
2321                                         it = it->next;
2322                                 }
2323                                 if (it)
2324                                         break;
2325                         }
2326                         mISDNport = mISDNport->next;
2327                 }
2328                 if (mISDNport)
2329                 {
2330                         mISDN_write_frame(mISDNdevice, msg->data, mISDNport->upper_id | FLG_MSG_DOWN,
2331                                 MGR_TIMER | RESPONSE, 0, 0, NULL, TIMEOUT_1SEC);
2332
2333                         PDEBUG(DEBUG_ISDN, "timer-indication port %d it=%p\n", mISDNport->portnum, it);
2334                         test_and_clear_bit(FLG_TIMER_RUNING, (long unsigned int *)&it->Flags);
2335                         ret = it->function(it->data);
2336                 } else
2337                 {
2338                         PDEBUG(DEBUG_ISDN, "timer-indication not handled\n");
2339                 }
2340                 goto out;
2341         }
2342
2343         /* find the mISDNport that belongs to the stack */
2344         mISDNport = mISDNport_first;
2345         while(mISDNport)
2346         {
2347                 if ((frm->addr&MASTER_ID_MASK) == (unsigned int)(mISDNport->upper_id&MASTER_ID_MASK))
2348                         break;
2349                 mISDNport = mISDNport->next;
2350         }
2351         if (!mISDNport)
2352         {
2353                 PERROR("message belongs to no mISDNport: prim(0x%x) addr(0x%x) msg->len(%d)\n", frm->prim, frm->addr, msg->len);
2354                 goto out;
2355         }
2356
2357         /* master stack */
2358         if (!(frm->addr&FLG_CHILD_STACK))
2359         {
2360                 /* d-message */
2361                 switch(frm->prim)
2362                 {
2363                         case MGR_SHORTSTATUS | INDICATION:
2364                         case MGR_SHORTSTATUS | CONFIRM:
2365                         switch(frm->dinfo) {
2366                                 case SSTATUS_L1_ACTIVATED:
2367                                 l1l2l3_trace_header(mISDNport, NULL, PH_ACTIVATE | (frm->prim & 0x3), DIRECTION_IN);
2368                                 end_trace();
2369                                 goto ss_act;
2370                                 case SSTATUS_L1_DEACTIVATED:
2371                                 l1l2l3_trace_header(mISDNport, NULL, PH_DEACTIVATE | (frm->prim & 0x3), DIRECTION_IN);
2372                                 end_trace();
2373                                 goto ss_deact;
2374                                 case SSTATUS_L2_ESTABLISHED:
2375                                 l1l2l3_trace_header(mISDNport, NULL, DL_ESTABLISH | (frm->prim & 0x3), DIRECTION_IN);
2376                                 end_trace();
2377                                 goto ss_estab;
2378                                 case SSTATUS_L2_RELEASED:
2379                                 l1l2l3_trace_header(mISDNport, NULL, DL_RELEASE | (frm->prim & 0x3), DIRECTION_IN);
2380                                 end_trace();
2381                                 goto ss_rel;
2382                         }
2383                         break;
2384
2385                         case PH_ACTIVATE | CONFIRM:
2386                         case PH_ACTIVATE | INDICATION:
2387                         l1l2l3_trace_header(mISDNport, NULL, frm->prim, DIRECTION_IN);
2388                         end_trace();
2389                         if (mISDNport->ntmode)
2390                         {
2391                                 mISDNport->l1link = 1;
2392                                 setup_queue(mISDNport, 1);
2393                                 goto l1_msg;
2394                         }
2395                         ss_act:
2396                         mISDNport->l1link = 1;
2397                         setup_queue(mISDNport, 1);
2398                         break;
2399
2400                         case PH_DEACTIVATE | CONFIRM:
2401                         case PH_DEACTIVATE | INDICATION:
2402                         l1l2l3_trace_header(mISDNport, NULL, frm->prim, DIRECTION_IN);
2403                         end_trace();
2404                         if (mISDNport->ntmode)
2405                         {
2406                                 mISDNport->l1link = 0;
2407                                 setup_queue(mISDNport, 0);
2408                                 goto l1_msg;
2409                         }
2410                         ss_deact:
2411                         mISDNport->l1link = 0;
2412                         setup_queue(mISDNport, 0);
2413                         break;
2414
2415                         case PH_CONTROL | CONFIRM:
2416                         case PH_CONTROL | INDICATION:
2417                         PDEBUG(DEBUG_ISDN, "Received PH_CONTROL for port %d (%s).\n", mISDNport->portnum, mISDNport->ifport->interface->name);
2418                         break;
2419
2420                         case DL_ESTABLISH | INDICATION:
2421                         case DL_ESTABLISH | CONFIRM:
2422                         l1l2l3_trace_header(mISDNport, NULL, frm->prim, DIRECTION_IN);
2423                         end_trace();
2424                         if (!mISDNport->ntmode) break; /* !!!!!!!!!!!!!!!! */
2425                         ss_estab:
2426                         if (mISDNport->l2establish)
2427                         {
2428                                 mISDNport->l2establish = 0;
2429                                 PDEBUG(DEBUG_ISDN, "the link became active before l2establish timer expiry.\n");
2430                         }
2431                         mISDNport->l2link = 1;
2432                         break;
2433
2434                         case DL_RELEASE | INDICATION:
2435                         case DL_RELEASE | CONFIRM:
2436                         l1l2l3_trace_header(mISDNport, NULL, frm->prim, DIRECTION_IN);
2437                         end_trace();
2438                         if (!mISDNport->ntmode) break; /* !!!!!!!!!!!!!!!! */
2439                         ss_rel:
2440                         mISDNport->l2link = 0;
2441                         if (mISDNport->ptp)
2442                         {
2443                                 time(&mISDNport->l2establish);
2444                                 PDEBUG(DEBUG_ISDN, "because we are ptp, we set a l2establish timer.\n");
2445                         }
2446                         break;
2447
2448                         default:
2449                         l1_msg:
2450                         PDEBUG(DEBUG_STACK, "GOT d-msg from %s port %d prim 0x%x dinfo 0x%x addr 0x%x\n", (mISDNport->ntmode)?"NT":"TE", mISDNport->portnum, frm->prim, frm->dinfo, frm->addr);
2451                         if (frm->dinfo==(signed long)0xffffffff && frm->prim==(PH_DATA|CONFIRM))
2452                         {
2453                                 PERROR("SERIOUS BUG, dinfo == 0xffffffff, prim == PH_DATA | CONFIRM !!!!\n");
2454                         }
2455                         /* d-message */
2456                         if (mISDNport->ntmode)
2457                         {
2458                                 /* l1-data enters the nt-mode library */
2459                                 nst = &mISDNport->nst;
2460                                 if (nst->l1_l2(nst, msg))
2461                                         free_msg(msg);
2462                                 return(1);
2463                         } else
2464                         {
2465                                 /* l3-data is sent to pbx */
2466                                 if (stack2manager_te(mISDNport, msg))
2467                                         free_msg(msg);
2468                                 return(1);
2469                         }
2470                 }
2471         } else
2472         /* child stack */
2473         {
2474                 /* b-message */
2475                 switch(frm->prim)
2476                 {
2477                         /* we don't care about confirms, we use rx data to sync tx */
2478                         case PH_DATA | CONFIRM:
2479                         case DL_DATA | CONFIRM:
2480                         break;
2481
2482                         /* we receive audio data, we respond to it AND we send tones */
2483                         case PH_DATA | INDICATION:
2484                         case DL_DATA | INDICATION:
2485                         case PH_CONTROL | INDICATION:
2486                         case PH_SIGNAL | INDICATION:
2487                         i = 0;
2488                         while(i < mISDNport->b_num)
2489                         {
2490                                 if ((unsigned int)(mISDNport->b_addr[i]&STACK_ID_MASK) == (frm->addr&STACK_ID_MASK))
2491                                         break;
2492                                 i++;
2493                         }
2494                         if (i == mISDNport->b_num)
2495                         {
2496                                 PERROR("unhandled b-message (prim 0x%x address 0x%x).\n", frm->prim, frm->addr);
2497                                 break;
2498                         }
2499                         if (mISDNport->b_port[i])
2500                         {
2501 //PERROR("port sech: %s data\n", mISDNport->b_port[i]->p_name);
2502                                 mISDNport->b_port[i]->bchannel_receive(frm);
2503                         } else
2504                                 PDEBUG(DEBUG_BCHANNEL, "b-channel is not associated to an ISDNPort (address 0x%x), ignoring.\n", frm->addr);
2505                         break;
2506
2507                         case PH_ACTIVATE | INDICATION:
2508                         case DL_ESTABLISH | INDICATION:
2509                         case PH_ACTIVATE | CONFIRM:
2510                         case DL_ESTABLISH | CONFIRM:
2511                         PDEBUG(DEBUG_BCHANNEL, "DL_ESTABLISH confirm: bchannel is now activated (address 0x%x).\n", frm->addr);
2512                         i = 0;
2513                         while(i < mISDNport->b_num)
2514                         {
2515                                 if ((unsigned int)(mISDNport->b_addr[i]&STACK_ID_MASK) == (frm->addr&STACK_ID_MASK))
2516                                         break;
2517                                 i++;
2518                         }
2519                         if (i == mISDNport->b_num)
2520                         {
2521                                 PERROR("unhandled b-establish (prim 0x%x address 0x%x).\n", frm->prim, frm->addr);
2522                                 break;
2523                         }
2524                         bchannel_event(mISDNport, i, B_EVENT_ACTIVATED);
2525                         break;
2526
2527                         case PH_DEACTIVATE | INDICATION:
2528                         case DL_RELEASE | INDICATION:
2529                         case PH_DEACTIVATE | CONFIRM:
2530                         case DL_RELEASE | CONFIRM:
2531                         PDEBUG(DEBUG_BCHANNEL, "DL_RELEASE confirm: bchannel is now de-activated (address 0x%x).\n", frm->addr);
2532                         i = 0;
2533                         while(i < mISDNport->b_num)
2534                         {
2535                                 if ((unsigned int)(mISDNport->b_addr[i]&STACK_ID_MASK) == (frm->addr&STACK_ID_MASK))
2536                                         break;
2537                                 i++;
2538                         }
2539                         if (i == mISDNport->b_num)
2540                         {
2541                                 PERROR("unhandled b-release (prim 0x%x address 0x%x).\n", frm->prim, frm->addr);
2542                                 break;
2543                         }
2544                         bchannel_event(mISDNport, i, B_EVENT_DEACTIVATED);
2545                         break;
2546
2547                         default:
2548                         PERROR("child message not handled: prim(0x%x) addr(0x%x) msg->len(%d)\n", frm->prim, frm->addr, msg->len);
2549                 }
2550         }
2551
2552         out:
2553         free_msg(msg);
2554         return(1);
2555 }
2556 #endif
2557
2558 #ifdef SOCKET_MISDN
2559 int do_layer3(struct mlayer3 *ml3, unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
2560 {
2561         struct mISDNport *mISDNport = ml3->private;
2562
2563         if (cmd == MT_ASSIGN)
2564         {
2565                 ueberdenken!!!
2566         }
2567
2568         /* lock LCR */
2569         achtung MT_ASSIGN kommt hier an
2570         lock it baby
2571
2572         /* d-message */
2573         switch(cmd)
2574         {
2575                 case MGR_SHORTSTATUS_IND:
2576                 case MGR_SHORTSTATUS_CONF:
2577                 switch(frm->dinfo) {
2578                         case SSTATUS_L1_ACTIVATED:
2579                         l1l2l3_trace_header(mISDNport, NULL, PH_ACTIVATE_IND, DIRECTION_IN);
2580                         end_trace();
2581                         goto ss_act;
2582                         case SSTATUS_L1_DEACTIVATED:
2583                         l1l2l3_trace_header(mISDNport, NULL, PH_DEACTIVATE_IND, DIRECTION_IN);
2584                         end_trace();
2585                         goto ss_deact;
2586                         case SSTATUS_L2_ESTABLISHED:
2587                         l1l2l3_trace_header(mISDNport, NULL, DL_ESTABLISH_IND, DIRECTION_IN);
2588                         end_trace();
2589                         goto ss_estab;
2590                         case SSTATUS_L2_RELEASED:
2591                         l1l2l3_trace_header(mISDNport, NULL, DL_RELEASE_IND, DIRECTION_IN);
2592                         end_trace();
2593                         goto ss_rel;
2594                 }
2595                 break;
2596
2597                 case PH_ACTIVATE_CONF:
2598                 case PH_ACTIVATE_IND:
2599                 l1l2l3_trace_header(mISDNport, NULL, cmd, DIRECTION_IN);
2600                 end_trace();
2601                 ss_act:
2602                 mISDNport->l1link = 1;
2603 #if 0
2604                 if (mISDNport->ntmode)
2605                         setup_queue(mISDNport, 1);
2606 #endif
2607                 break;
2608
2609                 case PH_DEACTIVATE | CONFIRM:
2610                 case PH_DEACTIVATE | INDICATION:
2611                 l1l2l3_trace_header(mISDNport, NULL, cmd, DIRECTION_IN);
2612                 end_trace();
2613                 ss_deact:
2614                 mISDNport->l1link = 0;
2615 raus mit der setup-queue, da dies im stack geschieht
2616 #if 0
2617                 if (mISDNport->ntmode)
2618                         setup_queue(mISDNport, 0);
2619 #endif
2620                 break;
2621
2622                 case PH_CONTROL_CONFIRM:
2623                 case PH_CONTROL_INDICATION:
2624                 PDEBUG(DEBUG_ISDN, "Received PH_CONTROL for port %d (%s).\n", mISDNport->portnum, mISDNport->ifport->interface->name);
2625                 break;
2626
2627                 case DL_ESTABLISH_IND:
2628                 case DL_ESTABLISH_CONF:
2629                 l1l2l3_trace_header(mISDNport, NULL, cmd, DIRECTION_IN);
2630                 end_trace();
2631                 if (!mISDNport->ntmode) break; /* !!!!!!!!!!!!!!!! */
2632                 ss_estab:
2633                 if (mISDNport->l2establish)
2634                 {
2635                         mISDNport->l2establish = 0;
2636                         PDEBUG(DEBUG_ISDN, "the link became active before l2establish timer expiry.\n");
2637                 }
2638                 mISDNport->l2link = 1;
2639                 break;
2640
2641                 case DL_RELEASE_IND:
2642                 case DL_RELEASE_CONF:
2643                 l1l2l3_trace_header(mISDNport, NULL, cmd, DIRECTION_IN);
2644                 end_trace();
2645                 ss_rel:
2646                 mISDNport->l2link = 0;
2647                 if (mISDNport->ptp)
2648                 {
2649                         time(&mISDNport->l2establish);
2650                         PDEBUG(DEBUG_ISDN, "because we are ptp, we set a l2establish timer.\n");
2651                 }
2652                 break;
2653
2654                 default:
2655                 /* l3-data is sent to LCR */
2656                 message_from_mlayer3(mISDNport, cmd, pid, l3m);
2657         }
2658
2659         /* unlock LCR */
2660         unlock it baby
2661
2662         /* free message */
2663         if (l3m)
2664                 free_l3_msg(l3m);
2665         return(0);
2666
2667 }
2668 #endif
2669
2670
2671 /*
2672  * global function to add a new card (port)
2673  */
2674 struct mISDNport *mISDNport_open(int port, int ptp, int ptmp, int force_nt, struct interface *interface)
2675 {
2676         int ret;
2677         unsigned char buff[1025];
2678         iframe_t *frm = (iframe_t *)buff;
2679         struct mISDNport *mISDNport, **mISDNportp;
2680         int i, cnt;
2681         int pri, bri, ports;
2682         int nt, te;
2683 #ifdef SOCKET_MISDN
2684         struct mlayer3 *ml3;
2685         struct mISDN_devinfo devinfo;
2686
2687         ret = ioctl(mISDNsocket, IMGETCOUNT, &cnt);
2688         if (ret < 0)
2689         {
2690                 fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret);
2691                 return(NULL);
2692         }
2693 #else
2694 //      interface_info_t ii;
2695         net_stack_t *nst;
2696         manager_t *mgr;
2697         layer_info_t li;
2698         stack_info_t *stinf;
2699
2700         /* query port's requirements */
2701         cnt = mISDN_get_stack_count(mISDNdevice);
2702 #endif
2703
2704         if (cnt <= 0)
2705         {
2706                 PERROR_RUNTIME("Found no card. Please be sure to load card drivers.\n");
2707                 return(NULL);
2708         }
2709         if (port>cnt || port<1)
2710         {
2711                 PERROR_RUNTIME("Port (%d) given at 'ports' (options.conf) is out of existing port range (%d-%d)\n", port, 1, cnt);
2712                 return(NULL);
2713         }
2714
2715         pri = bri = ports = nt = te = 0;
2716 #ifdef SOCKET_MISDN
2717         devinfo.id = port - 1;
2718         ret = ioctl(socket, IMGETDEVINFO, &devinfo);
2719         if (ret <= 0)
2720         {
2721                 PERROR_RUNTIME("Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", i, ret);
2722                 break;
2723         }
2724         /* output the port info */
2725         if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0))
2726         {
2727                 bri = 1;
2728                 te = 1;
2729         }
2730         if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0))
2731         {
2732                 bri = 1;
2733                 nt = 1;
2734         }
2735 #ifdef ISDN_P_TE_E1
2736         if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1))
2737         {
2738                 pri = 1;
2739                 te = 1;
2740         }
2741 #endif
2742 #ifdef ISDN_P_NT_E1
2743         if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1))
2744         {
2745                 pri = 1;
2746                 nt = 1;
2747         }
2748 #endif
2749 #ifdef ISDN_P_FXS
2750         if (devinfo.Dprotocols & (1 << ISDN_P_FXS))
2751         {
2752                 pots = 1;
2753                 te = 1;
2754         }
2755 #endif
2756 #ifdef ISDN_P_FXO
2757         if (devinfo.Dprotocols & (1 << ISDN_P_FXO))
2758         {
2759                 pots = 1;
2760                 nt = 1;
2761         }
2762 #endif
2763         if (force_nt && !nt)
2764         {
2765                 PERROR_RUNTIME("Port %d does not support NT-mode.\n", port);
2766                 return(NULL);
2767         }
2768         if (bri && pri)
2769         {
2770                 PERROR_RUNTIME("Port %d supports BRI and PRI?? What kind of controller is that?. (Can't use this!)\n", port);
2771                 return(NULL);
2772         }
2773         if (pots && !bri && !pri)
2774         {
2775                 PERROR_RUNTIME("Port %d supports POTS, LCR does not!\n", port);
2776                 return(NULL);
2777         }
2778         if (!bri && !pri)
2779         {
2780                 PERROR_RUNTIME("Port %d does not support BRI nor PRI!\n", port);
2781                 return(NULL);
2782         }
2783         if (!nt && !te)
2784         {
2785                 PERROR_RUNTIME("Port %d does not support NT-mode nor TE-mode!\n", port);
2786                 return(NULL);
2787         }
2788         /* force nt, by turning off TE */
2789         if (force_nt && nt)
2790                 te = 0;
2791         /* if TE an NT is supported (and not forced to NT), turn off NT */
2792         if (te && nt)
2793                 nt = 0;
2794 #else
2795         ret = mISDN_get_stack_info(mISDNdevice, port, buff, sizeof(buff));
2796         if (ret < 0)
2797         {
2798                 PERROR_RUNTIME("Cannot get stack info for port %d (ret=%d)\n", port, ret);
2799                 return(NULL);
2800         }
2801         stinf = (stack_info_t *)&frm->data.p;
2802         switch(stinf->pid.protocol[0] & ~ISDN_PID_FEATURE_MASK)
2803         {
2804                 case ISDN_PID_L0_TE_S0:
2805                 PDEBUG(DEBUG_ISDN, "TE-mode BRI S/T interface line\n");
2806                 break;
2807                 case ISDN_PID_L0_NT_S0:
2808                 PDEBUG(DEBUG_ISDN, "NT-mode BRI S/T interface port\n");
2809                 nt = 1;
2810                 break;
2811                 case ISDN_PID_L0_TE_E1:
2812                 PDEBUG(DEBUG_ISDN, "TE-mode PRI E1  interface line\n");
2813                 pri = 1;
2814                 break;
2815                 case ISDN_PID_L0_NT_E1:
2816                 PDEBUG(DEBUG_ISDN, "LT-mode PRI E1  interface port\n");
2817                 pri = 1;
2818                 nt = 1;
2819                 break;
2820                 default:
2821                 PERROR_RUNTIME("unknown port(%d) type 0x%08x\n", port, stinf->pid.protocol[0]);
2822                 return(NULL);
2823         }
2824         if (nt)
2825         {
2826                 /* NT */
2827                 if (stinf->pid.protocol[1] == 0)
2828                 {
2829                         PERROR_RUNTIME("Given port %d: Missing layer 1 NT-mode protocol.\n", port);
2830                         return(NULL);
2831                 }
2832                 if (stinf->pid.protocol[2])
2833                 {
2834                         PERROR_RUNTIME("Given port %d: Layer 2 protocol 0x%08x is detected, but not allowed for NT lib.\n", port, stinf->pid.protocol[2]);
2835                         return(NULL);
2836                 }
2837         }
2838         if (te)
2839         {
2840                 /* TE */
2841                 if (stinf->pid.protocol[1] == 0)
2842                 {
2843                         PERROR_RUNTIME("Given port %d: Missing layer 1 protocol.\n", port);
2844                         return(NULL);
2845                 }
2846                 if (stinf->pid.protocol[2] == 0)
2847                 {
2848                         PERROR_RUNTIME("Given port %d: Missing layer 2 protocol.\n", port);
2849                         return(NULL);
2850                 }
2851                 if (stinf->pid.protocol[3] == 0)
2852                 {
2853                         PERROR_RUNTIME("Given port %d: Missing layer 3 protocol.\n", port);
2854                         return(NULL);
2855                 } else
2856                 {
2857                         switch(stinf->pid.protocol[3] & ~ISDN_PID_FEATURE_MASK)
2858                         {
2859                                 case ISDN_PID_L3_DSS1USER:
2860                                 break;
2861
2862                                 default:
2863                                 PERROR_RUNTIME("Given port %d: own protocol 0x%08x", port,stinf->pid.protocol[3]);
2864                                 return(NULL);
2865                         }
2866                 }
2867                 if (stinf->pid.protocol[4])
2868                 {
2869                         PERROR_RUNTIME("Given port %d: Layer 4 protocol not allowed.\n", port);
2870                         return(NULL);
2871                 }
2872         }
2873 #endif
2874
2875         /* add mISDNport structure */
2876         mISDNportp = &mISDNport_first;
2877         while(*mISDNportp)
2878                 mISDNportp = &((*mISDNportp)->next);
2879         mISDNport = (struct mISDNport *)MALLOC(sizeof(struct mISDNport));
2880         pmemuse++;
2881         *mISDNportp = mISDNport;
2882
2883         /* allocate ressources of port */
2884 #ifdef SOCKET_MISDN
2885         /* open layer 3 */
2886         protocol = (nt)?L3_PROTOCOL_DSS1_USER:L3_PROTOCOL_DSS1_NETWORK;
2887         prop = 0;
2888         if (ptp)
2889                prop |= FLG_PTP;
2890         if (ptmp && pri)
2891                prop |= FLG_FORCE_PTMP;
2892         mISDNport->ml3 = open_layer3(port-1, protocol, prop , do_dchannel, mISDNport);
2893         if (!mISDNport->ml3)
2894         {
2895                 PERROR_RUNTIME("Cannot get layer(%d) id of port %d\n", nt?2:4, port);
2896                 return(NULL);
2897         }
2898
2899 #if 0
2900         /* if ntmode, establish L1 to send the tei removal during start */
2901         if (mISDNport->ntmode)
2902         {
2903                 iframe_t act;
2904                 /* L1 */
2905                 act.prim = PH_ACTIVATE | REQUEST;
2906                 act.addr = mISDNport->upper_id | FLG_MSG_DOWN;
2907                 printf("UPPER ID 0x%x, addr 0x%x\n",mISDNport->upper_id, act.addr);
2908                 act.dinfo = 0;
2909                 act.len = 0;
2910                 mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
2911                 usleep(10000); /* to be sure, that l1 is up */
2912         }
2913 #endif
2914
2915         SCPY(mISDNport->name, devinfo.name);
2916         mISDNport->b_num = devinfo.nrbchan;
2917 #else
2918         msg_queue_init(&mISDNport->downqueue);
2919         mISDNport->d_stid = stinf->id;
2920         PDEBUG(DEBUG_ISDN, "d_stid = 0x%x.\n", mISDNport->d_stid);
2921         if ((stinf->pid.protocol[2]&ISDN_PID_L2_DF_PTP) || (nt&&ptp) || pri)
2922         {
2923                 PDEBUG(DEBUG_ISDN, "Port is point-to-point.\n");
2924                 ptp = 1;
2925                 if (ptmp && nt)
2926                 {
2927                         PDEBUG(DEBUG_ISDN, "Port is forced to point-to-multipoint.\n");
2928                         ptp = 0;
2929                 }
2930         }
2931
2932         /* create layer intance */
2933         memset(&li, 0, sizeof(li));
2934         UCPY(&li.name[0], (nt)?"net l2":"pbx l4");
2935         li.object_id = -1;
2936         li.extentions = 0;
2937         li.pid.protocol[nt?2:4] = (nt)?ISDN_PID_L2_LAPD_NET:ISDN_PID_L4_CAPI20;
2938         li.pid.layermask = ISDN_LAYER((nt?2:4));
2939         li.st = mISDNport->d_stid;
2940         ret = mISDN_new_layer(mISDNdevice, &li);
2941         if (ret)
2942         {
2943                 PERROR("Cannot add layer %d of port %d (ret %d)\n", nt?2:4, port, ret);
2944                 closeport:
2945                 mISDNport_close(mISDNport);
2946                 return(NULL);
2947         }
2948         mISDNport->upper_id = li.id;
2949         ret = mISDN_register_layer(mISDNdevice, mISDNport->d_stid, mISDNport->upper_id);
2950         if (ret)
2951         {
2952                 PERROR("Cannot register layer %d of port %d\n", nt?2:4, port);
2953                 goto closeport;
2954         }
2955         mISDNport->lower_id = mISDN_get_layerid(mISDNdevice, mISDNport->d_stid, nt?1:3); // id of lower layer (nt=1, te=3)
2956         if (mISDNport->lower_id < 0)
2957         {
2958                 PERROR("Cannot get layer(%d) id of port %d\n", nt?1:3, port);
2959                 goto closeport;
2960         }
2961         mISDNport->upper_id = mISDN_get_layerid(mISDNdevice, mISDNport->d_stid, nt?2:4); // id of uppermost layer (nt=2, te=4)
2962         if (mISDNport->upper_id < 0)
2963         {
2964                 PERROR("Cannot get layer(%d) id of port %d\n", nt?2:4, port);
2965                 goto closeport;
2966         }
2967         PDEBUG(DEBUG_ISDN, "Layer %d of port %d added.\n", nt?2:4, port);
2968
2969         /* if ntmode, establish L1 to send the tei removal during start */
2970         if (mISDNport->ntmode)
2971         {
2972                 iframe_t act;
2973                 /* L1 */
2974                 act.prim = PH_ACTIVATE | REQUEST;
2975                 act.addr = mISDNport->upper_id | FLG_MSG_DOWN;
2976                 printf("UPPER ID 0x%x, addr 0x%x\n",mISDNport->upper_id, act.addr);
2977                 act.dinfo = 0;
2978                 act.len = 0;
2979                 mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
2980                 usleep(10000); /* to be sure, that l1 is up */
2981         }
2982
2983         /* create nst (nt-mode only) */
2984         if (nt)
2985         {
2986                 mgr = &mISDNport->mgr;
2987                 nst = &mISDNport->nst;
2988
2989                 mgr->nst = nst;
2990                 nst->manager = mgr;
2991
2992                 nst->l3_manager = stack2manager_nt; /* messages from nt-mode */
2993                 nst->device = mISDNdevice;
2994                 nst->cardnr = port;
2995                 nst->d_stid = mISDNport->d_stid;
2996
2997                 nst->feature = FEATURE_NET_HOLD;
2998                 if (ptp)
2999                         nst->feature |= FEATURE_NET_PTP;
3000                 if (pri)
3001                         nst->feature |= FEATURE_NET_CRLEN2 | FEATURE_NET_EXTCID;
3002 #if 0
3003                 i = 0;
3004                 while(i < mISDNport->b_num)
3005                 {
3006                         nst->b_stid[i] = mISDNport->b_stid[i];
3007                         i++;
3008                 }
3009 #endif
3010                 nst->l1_id = mISDNport->lower_id;
3011                 nst->l2_id = mISDNport->upper_id;
3012
3013                 /* phd */
3014                 msg_queue_init(&nst->down_queue);
3015
3016                 Isdnl2Init(nst);
3017                 Isdnl3Init(nst);
3018         }
3019
3020         mISDNport->b_num = stinf->childcnt;
3021 #endif
3022         mISDNport->portnum = port;
3023         mISDNport->ntmode = nt;
3024         mISDNport->pri = pri;
3025         mISDNport->ptp = ptp;
3026         PDEBUG(DEBUG_ISDN, "Port has %d b-channels.\n", mISDNport->b_num);
3027         i = 0;
3028         while(i < mISDNport->b_num)
3029         {
3030                 mISDNport->b_state[i] = B_STATE_IDLE;
3031 #ifdef SOCKET_MISDN
3032                 mISDNport->b_socket = -1;
3033 #else
3034                 mISDNport->b_stid[i] = stinf->child[i];
3035                 PDEBUG(DEBUG_ISDN, "b_stid[%d] = 0x%x.\n", i, mISDNport->b_stid[i]);
3036 #endif
3037                 i++;
3038         }
3039
3040         /* if te-mode, query state link */
3041         if (!mISDNport->ntmode)
3042         {
3043                 iframe_t act;
3044                 /* L2 */
3045                 PDEBUG(DEBUG_ISDN, "sending short status request for port %d.\n", port);
3046                 act.prim = MGR_SHORTSTATUS | REQUEST;
3047                 act.addr = mISDNport->upper_id | MSG_BROADCAST;
3048                 act.dinfo = SSTATUS_BROADCAST_BIT | SSTATUS_ALL;
3049                 act.len = 0;
3050                 mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
3051         }
3052         /* if ptp AND te-mode, pull up the link */
3053         if (mISDNport->ptp && !mISDNport->ntmode)
3054         {
3055                 iframe_t act;
3056                 /* L2 */
3057                 act.prim = DL_ESTABLISH | REQUEST;
3058                 act.addr = (mISDNport->upper_id & ~LAYER_ID_MASK) | 4 | FLG_MSG_DOWN;
3059                 act.dinfo = 0;
3060                 act.len = 0;
3061                 mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
3062         }
3063         /* if ptp AND nt-mode, pull up the link */
3064         if (mISDNport->ptp && mISDNport->ntmode)
3065         {
3066                 msg_t *dmsg;
3067                 /* L2 */
3068                 dmsg = create_l2msg(DL_ESTABLISH | REQUEST, 0, 0);
3069                 if (mISDNport->nst.manager_l3(&mISDNport->nst, dmsg))
3070                         free_msg(dmsg);
3071         }
3072         /* initially, we assume that the link is down, exept for nt-ptmp */
3073         mISDNport->l2link = (mISDNport->ntmode && !mISDNport->ptp)?1:0;
3074
3075         PDEBUG(DEBUG_BCHANNEL, "using 'mISDN_dsp.o' module\n");
3076
3077         start_trace(mISDNport->portnum,
3078                     interface,
3079                     NULL,
3080                     NULL,
3081                     DIRECTION_NONE,
3082                     CATEGORY_CH,
3083                     0,
3084                     "PORT (open)");
3085         add_trace("channels", NULL, "%d", mISDNport->b_num);
3086         end_trace();
3087         return(mISDNport);
3088 }
3089
3090
3091 /*
3092  * function to free ALL cards (ports)
3093  */
3094 void mISDNport_close_all(void)
3095 {
3096         /* free all ports */
3097         while(mISDNport_first)
3098                 mISDNport_close(mISDNport_first);
3099 }
3100
3101 /*
3102  * free only one port
3103  */
3104 void mISDNport_close(struct mISDNport *mISDNport)
3105 {
3106         struct mISDNport **mISDNportp;
3107         class Port *port;
3108         class PmISDN *isdnport;
3109         net_stack_t *nst;
3110         unsigned char buf[32];
3111         int i;
3112
3113         /* remove all port instance that are linked to this mISDNport */
3114         port = port_first;
3115         while(port)
3116         {
3117                 if ((port->p_type&PORT_CLASS_MASK) == PORT_CLASS_mISDN)
3118                 {
3119                         isdnport = (class PmISDN *)port;
3120                         if (isdnport->p_m_mISDNport)
3121                         {
3122                                 PDEBUG(DEBUG_ISDN, "port %s uses mISDNport %d, destroying it.\n", isdnport->p_name, mISDNport->portnum);
3123                                 delete isdnport;
3124                         }
3125                 }
3126                 port = port->next;
3127         }
3128
3129         /* only if we are already part of interface */
3130         if (mISDNport->ifport)
3131         {
3132                 start_trace(mISDNport->portnum,
3133                             mISDNport->ifport->interface,
3134                             NULL,
3135                             NULL,
3136                             DIRECTION_NONE,
3137                             CATEGORY_CH,
3138                             0,
3139                             "PORT (close)");
3140                 end_trace();
3141         }
3142
3143         /* free bchannels */
3144         i = 0;
3145         while(i < mISDNport->b_num)
3146         {
3147                 if (mISDNport->b_addr[i])
3148                 {
3149                         _bchannel_destroy(mISDNport, i);
3150                         PDEBUG(DEBUG_BCHANNEL, "freeing %s port %d bchannel (index %d).\n", (mISDNport->ntmode)?"NT":"TE", mISDNport->portnum, i);
3151                 }
3152                 i++;
3153         }
3154
3155 #ifdef SOCKET_MISDN
3156         close_layer3(mISDNport->ml3);
3157 #else
3158         /* free ressources of port */
3159         msg_queue_purge(&mISDNport->downqueue);
3160
3161         /* free stacks */
3162         if (mISDNport->ntmode)
3163         {
3164                 nst = &mISDNport->nst;
3165                 if (nst->manager) /* to see if initialized */
3166                 {
3167                         PDEBUG(DEBUG_STACK, "the following messages are ok: one L3 process always exists (broadcast process) and some L2 instances (broadcast + current telephone's instances)\n");
3168                         cleanup_Isdnl3(nst);
3169                         cleanup_Isdnl2(nst);
3170
3171                         /* phd */
3172                         msg_queue_purge(&nst->down_queue);
3173                         if (nst->phd_down_msg)
3174                                 FREE(nst->phd_down_msg, 0);
3175                 }
3176         }
3177
3178         PDEBUG(DEBUG_BCHANNEL, "freeing d-stack.\n");
3179         if (mISDNport->d_stid)
3180         {
3181                 if (mISDNport->upper_id)
3182                         mISDN_write_frame(mISDNdevice, buf, mISDNport->upper_id | FLG_MSG_DOWN, MGR_DELLAYER | REQUEST, 0, 0, NULL, TIMEOUT_1SEC);
3183         }
3184 #endif
3185
3186         /* remove from list */
3187         mISDNportp = &mISDNport_first;
3188         while(*mISDNportp)
3189         {
3190                 if (*mISDNportp == mISDNport)
3191                 {
3192                         *mISDNportp = (*mISDNportp)->next;
3193                         mISDNportp = NULL;
3194                         break;
3195                 }
3196                 mISDNportp = &((*mISDNportp)->next);
3197         }
3198
3199         if (mISDNportp)
3200                 FATAL("mISDNport not in list\n");
3201
3202         FREE(mISDNport, sizeof(struct mISDNport));
3203         pmemuse--;
3204
3205 }
3206
3207
3208 /*
3209  * global function to show all available isdn ports
3210  */
3211 void mISDN_port_info(void)
3212 {
3213         int ret;
3214         int i, ii, p;
3215         int useable, nt, te, pri, bri, pots;
3216         unsigned char buff[1025];
3217         iframe_t *frm = (iframe_t *)buff;
3218 #ifdef SOCKET_MISDN
3219         struct mISDN_devinfo devinfo;
3220         int socket;
3221
3222         /* open mISDN */
3223         socket = socket(PF_ISDN, SOCK_RAW, ISDN_P_BASE);
3224         if (socket < 0)
3225         {
3226                 fprintf(stderr, "Cannot open mISDN due to %s. (Does your Kernel support socket based mISDN?)\n", strerror(errno));
3227                 exit(EXIT_FAILURE);
3228         }
3229
3230         /* get number of stacks */
3231         i = 1;
3232         ret = ioctl(socket, IMGETCOUNT, &ii);
3233         if (ret < 0)
3234         {
3235                 fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret);
3236                 goto done;
3237         }
3238 #else
3239         stack_info_t *stinf;
3240         int device;
3241
3242         /* open mISDN */
3243         if ((device = mISDN_open()) < 0)
3244         {
3245                 fprintf(stderr, "Cannot open mISDN device ret=%d errno=%d (%s) Check for mISDN modules!\nAlso did you create \"/dev/mISDN\"? Do: \"mknod /dev/mISDN c 46 0\"\n", device, errno, strerror(errno));
3246                 exit(EXIT_FAILURE);
3247         }
3248
3249         /* get number of stacks */
3250         i = 1;
3251         ii = mISDN_get_stack_count(device);
3252 #endif
3253         printf("\n");
3254         if (ii <= 0)
3255         {
3256                 printf("Found no card. Please be sure to load card drivers.\n");
3257                 goto done;
3258         }
3259
3260         /* loop the number of cards and get their info */
3261         while(i <= ii)
3262         {
3263                 nt = te = bri = pri = pots = 0;
3264                 useable = 0;
3265
3266 #ifdef SOCKET_MISDN
3267                 devinfo.id = i - 1;
3268                 ret = ioctl(socket, IMGETDEVINFO, &devinfo);
3269                 if (ret <= 0)
3270                 {
3271                         fprintf(stderr, "Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", i, ret);
3272                         break;
3273                 }
3274
3275                 /* output the port info */
3276                 printf("Port %2d name='%s': ", i, devinfo.name);
3277                 if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0))
3278                 {
3279                         bri = 1;
3280                         te = 1;
3281                 }
3282                 if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0))
3283                 {
3284                         bri = 1;
3285                         nt = 1;
3286                 }
3287 #ifdef ISDN_P_TE_E1
3288                 if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1))
3289                 {
3290                         pri = 1;
3291                         te = 1;
3292                 }
3293 #endif
3294 #ifdef ISDN_P_NT_E1
3295                 if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1))
3296                 {
3297                         pri = 1;
3298                         nt = 1;
3299                 }
3300 #endif
3301 #ifdef ISDN_P_FXS
3302                 if (devinfo.Dprotocols & (1 << ISDN_P_FXS))
3303                 {
3304                         pots = 1;
3305                         te = 1;
3306                 }
3307 #endif
3308 #ifdef ISDN_P_FXO
3309                 if (devinfo.Dprotocols & (1 << ISDN_P_FXO))
3310                 {
3311                         pots = 1;
3312                         nt = 1;
3313                 }
3314 #endif
3315                 if ((te || nt) && (bri || pri || ports))
3316                         usable = 1;
3317
3318                 if (te && bri)
3319                         printf("TE-mode BRI S/T interface line (for phone lines)");
3320                 if (nt && bri)
3321                         printf("NT-mode BRI S/T interface port (for phones)");
3322                 if (te && pri)
3323                         printf("TE-mode PRI E1  interface line (for phone lines)");
3324                 if (nt && pri)
3325                         printf("NT-mode PRI E1  interface port (for E1 terminals)");
3326                 if (te && pots)
3327                         printf("FXS     POTS    interface port (for analog lines)");
3328                 if (nt && pots)
3329                         printf("FXO     POTS    interface port (for analog phones)");
3330                 if (ports)
3331                 {
3332                         usable = 0;
3333                         printf("\n -> Analog interfaces are not supported.");
3334                 } else
3335                 if (!usable)
3336                 {
3337                         printf("unsupported interface protocol bits 0x%016x", devinfo.Dprotocols);
3338                 }
3339                 printf("\n");
3340
3341                 printf("  - %d B-channels\n", devinfo.nfbchan);
3342 #else
3343                 ret = mISDN_get_stack_info(device, i, buff, sizeof(buff));
3344                 if (ret <= 0)
3345                 {
3346                         fprintf(stderr, "mISDN_get_stack_info() failed: port=%d error=%d\n", i, ret);
3347                         break;
3348                 }
3349                 stinf = (stack_info_t *)&frm->data.p;
3350
3351                 /* output the port info */
3352                 printf("Port %2d: ", i);
3353                 switch(stinf->pid.protocol[0] & ~ISDN_PID_FEATURE_MASK)
3354                 {
3355                         case ISDN_PID_L0_TE_S0:
3356                         useable = 1;
3357                         te = 1;
3358                         bri = 1;
3359                         printf("TE-mode BRI S/T interface line (for phone lines)");
3360                         break;
3361                         case ISDN_PID_L0_NT_S0:
3362                         useable = 1;
3363                         nt = 1;
3364                         bri = 1;
3365                         printf("NT-mode BRI S/T interface port (for phones)");
3366                         break;
3367                         case ISDN_PID_L0_TE_E1:
3368                         useable = 1;
3369                         te = 1;
3370                         pri = 1;
3371                         printf("TE-mode PRI E1  interface line (for phone lines)");
3372                         break;
3373                         case ISDN_PID_L0_NT_E1:
3374                         useable = 1;
3375                         nt = 1;
3376                         pri = 1;
3377                         printf("NT-mode PRI E1  interface port (for E1 terminals)");
3378                         break;
3379                         default:
3380                         useable = 0;
3381                         printf("unknown type 0x%08x",stinf->pid.protocol[0]);
3382                 }
3383                 printf("\n");
3384
3385                 if (nt)
3386                 {
3387                         if (stinf->pid.protocol[1] == 0)
3388                         {
3389                                 useable = 0;
3390                                 printf(" -> Missing layer 1 NT-mode protocol.\n");
3391                         }
3392                         p = 2;
3393                         while(p <= MAX_LAYER_NR) {
3394                                 if (stinf->pid.protocol[p])
3395                                 {
3396                                         useable = 0;
3397                                         printf(" -> Layer %d protocol 0x%08x is detected, port already in use by another application.\n", p, stinf->pid.protocol[p]);
3398                                 }
3399                                 p++;
3400                         }
3401                         if (useable)
3402                         {
3403                                 if (pri)
3404                                         printf(" -> Interface is Point-To-Point (PRI).\n");
3405                                 else
3406                                         printf(" -> Interface can be Poin-To-Point/Multipoint.\n");
3407                         }
3408                 }
3409                 if (te)
3410                 {
3411                         if (stinf->pid.protocol[1] == 0)
3412                         {
3413                                 useable = 0;
3414                                 printf(" -> Missing layer 1 protocol.\n");
3415                         }
3416                         if (stinf->pid.protocol[2] == 0)
3417                         {
3418                                 useable = 0;
3419                                 printf(" -> Missing layer 2 protocol.\n");
3420                         }
3421                         if (stinf->pid.protocol[2] & ISDN_PID_L2_DF_PTP)
3422                         {
3423                                 printf(" -> Interface is Poin-To-Point.\n");
3424                         }
3425                         if (stinf->pid.protocol[3] == 0)
3426                         {
3427                                 useable = 0;
3428                                 printf(" -> Missing layer 3 protocol.\n");
3429                         } else
3430                         {
3431                                 printf(" -> Protocol: ");
3432                                 switch(stinf->pid.protocol[3] & ~ISDN_PID_FEATURE_MASK)
3433                                 {
3434                                         case ISDN_PID_L3_DSS1USER:
3435                                         printf("DSS1 (Euro ISDN)");
3436                                         break;
3437
3438                                         default:
3439                                         useable = 0;
3440                                         printf("unknown protocol 0x%08x",stinf->pid.protocol[3]);
3441                                 }
3442                                 printf("\n");
3443                         }
3444                         p = 4;
3445                         while(p <= MAX_LAYER_NR) {
3446                                 if (stinf->pid.protocol[p])
3447                                 {
3448                                         useable = 0;
3449                                         printf(" -> Layer %d protocol 0x%08x is detected, port already in use by another application.\n", p, stinf->pid.protocol[p]);
3450                                 }
3451                                 p++;
3452                         }
3453                 }
3454                 printf("  - %d B-channels\n", stinf->childcnt);
3455 #endif
3456
3457                 if (!useable)
3458                         printf(" * Port NOT useable for LCR\n");
3459
3460                 printf("--------\n");
3461
3462                 i++;
3463         }
3464         printf("\n");
3465
3466 done:
3467 #ifdef SOCKET_MISDN
3468         close(sd);
3469 #else
3470         /* close mISDN */
3471         if ((ret = mISDN_close(device)))
3472                 FATAL("mISDN_close() failed: err=%d '%s'\n", ret, strerror(ret));
3473 #endif
3474 }
3475
3476
3477 /*
3478  * enque data from upper buffer
3479  */
3480 void PmISDN::txfromup(unsigned char *data, int length)
3481 {
3482 #ifdef SOCKET_MISDN
3483         unsigned char buf[MISDN_HEADER_LEN+((length>ISDN_LOAD)?length:ISDN_LOAD)];
3484         struct mISDNhead *frm = (struct mISDNhead *)buf;
3485
3486         if (p_m_b_index < 0)
3487                 return;
3488         if (!p_m_mISDNport->b_socket[p_m_b_index])
3489                 return;
3490 #else
3491         unsigned char buf[mISDN_HEADER_LEN+((length>ISDN_LOAD)?length:ISDN_LOAD)];
3492         iframe_t *frm = (iframe_t *)buf;
3493
3494         if (p_m_b_index < 0)
3495                 return;
3496         if (!p_m_mISDNport->b_addr[p_m_b_index])
3497                 return;
3498 #endif
3499
3500         /* check if high priority tones exist
3501          * ignore data in this case
3502          */
3503         if (p_tone_name[0] || p_m_crypt_msg_loops)
3504                 return;
3505
3506         /* preload procedure
3507          * if transmit buffer in DSP module is empty,
3508          * preload it to DSP_LOAD to prevent jitter gaps.
3509          */
3510         if (p_m_load==0 && ISDN_LOAD>0)
3511         {
3512
3513                 memcpy(buf+mISDN_HEADER_LEN, data, ISDN_LOAD);
3514                 frm->len = ISDN_LOAD;
3515                 mISDN_write(mISDNdevice, frm, mISDN_HEADER_LEN+frm->len, TIMEOUT_1SEC);
3516                 p_m_load += frm->len;
3517         }
3518
3519         /* drop if load would exceed ISDN_MAXLOAD
3520          * this keeps the delay not too high
3521          */
3522         if (p_m_load+length > ISDN_MAXLOAD)
3523                 return;
3524
3525         /* make and send frame */
3526 #ifdef SOCKET_MISDN
3527         frm->prim = DL_DATA_REQ;
3528         frm->id = 0;
3529         memcpy(buf+MISDN_HEADER_LEN, data, length);
3530         ret = sendto(p_m_mISDNport->b_socket[p_m_b_index], buf, MISDN_HEADER_LEN+length, 0, NULL, 0);
3531         if (!ret)
3532                 PERROR("Failed to send to socket %d\n", handle);
3533 #else
3534         frm->prim = DL_DATA | REQUEST;
3535         frm->addr = p_m_mISDNport->b_addr[p_m_b_index] | FLG_MSG_DOWN;
3536         frm->dinfo = 0;
3537         frm->len = length;
3538         memcpy(buf+mISDN_HEADER_LEN, data, length);
3539         mISDN_write(mISDNdevice, frm, mISDN_HEADER_LEN+frm->len, TIMEOUT_1SEC);
3540 #endif
3541         p_m_load += length;
3542 }
3543