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         if (p_m_b_index < 0)
1177                 return;
1178
1179         /* unreserve channel */
1180         if (p_m_b_reserve)
1181                 p_m_mISDNport->b_reserved--;
1182         p_m_b_reserve = 0;
1183
1184         /* if not in use */
1185         if (!p_m_b_channel)
1186                 return;
1187
1188         PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) dropping bchannel\n", p_name);
1189
1190         if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_IDLE)
1191                 bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_DROP);
1192         p_m_mISDNport->b_port[p_m_b_index] = NULL;
1193         p_m_b_index = -1;
1194         p_m_b_channel = 0;
1195         p_m_b_exclusive = 0;
1196 }
1197
1198 /* process bchannel export/import message from join */
1199 void message_bchannel_from_join(class JoinRemote *joinremote, int type, unsigned long handle)
1200 {
1201         class Endpoint *epoint;
1202         class Port *port;
1203         class PmISDN *isdnport;
1204         struct mISDNport *mISDNport;
1205         int i, ii;
1206
1207         switch(type)
1208         {
1209                 case BCHANNEL_REQUEST:
1210                 /* find the port object for the join object ref */
1211                 if (!(epoint = find_epoint_id(joinremote->j_epoint_id)))
1212                 {
1213                         PDEBUG(DEBUG_BCHANNEL, "join %d has no endpoint (anymore)\n", joinremote->j_serial);
1214                         return;
1215                 }
1216                 if (!epoint->ep_portlist)
1217                 {
1218                         PDEBUG(DEBUG_BCHANNEL, "join %d has no port (anymore in portlist)\n", joinremote->j_serial);
1219                         return;
1220                 }
1221                 if (epoint->ep_portlist->next)
1222                 {
1223                         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);
1224                 }
1225                 if (!(port = find_port_id(epoint->ep_portlist->port_id)))
1226                 {
1227                         PDEBUG(DEBUG_BCHANNEL, "join %d has no port (anymore as object)\n", joinremote->j_serial);
1228                         return;
1229                 }
1230                 if (!((port->p_type&PORT_CLASS_MASK) != PORT_CLASS_mISDN))
1231                 {
1232                         PERROR("join %d has port %d not of mISDN type. This shall not happen.\n", joinremote->j_serial, port->p_serial);
1233                 }
1234                 isdnport = (class PmISDN *)port;
1235
1236                 /* assign */
1237                 if (isdnport->p_m_remote_id)
1238                 {
1239                         PERROR("join %d recevied bchannel request from remote, but channel is already assinged.\n", joinremote->j_serial);
1240                         break;
1241                 }
1242                 mISDNport = isdnport->p_m_mISDNport;
1243                 i = isdnport->p_m_b_index;
1244                 chan_trace_header(mISDNport, isdnport, "MESSAGE_BCHANNEL (from remote application)", DIRECTION_NONE);
1245                 add_trace("type", NULL, "export request");
1246                 isdnport->p_m_remote_ref = joinremote->j_serial;
1247                 isdnport->p_m_remote_id = joinremote->j_remote_id;
1248                 if (mISDNport && i>=0)
1249                 {
1250                         bchannel_event(mISDNport, i, B_EVENT_EXPORTREQUEST);
1251                 }
1252                 end_trace();
1253                 break;
1254
1255                 case BCHANNEL_ASSIGN_ACK:
1256                 case BCHANNEL_REMOVE_ACK:
1257                 /* find mISDNport for stack ID */
1258                 mISDNport = mISDNport_first;
1259                 while(mISDNport)
1260                 {
1261                         i = 0;
1262                         ii = mISDNport->b_num;
1263                         while(i < ii)
1264                         {
1265 #ifdef SOCKET_MISDN
1266                                 if (mISDNport->b_socket[i] == handle)
1267 #else
1268                                 if ((unsigned long)(mISDNport->portnum<<8)+i+1+(i>=15) == handle)
1269 #endif
1270                                         break;
1271                                 i++;
1272                         }
1273                         if (i != ii)
1274                                 break;
1275                         mISDNport = mISDNport->next;
1276                 }
1277                 if (!mISDNport)
1278                 {
1279                         PERROR("received assign/remove ack for handle=%x, but handle does not exist in any mISDNport structure.\n", handle);
1280                         break;
1281                 }
1282                 /* mISDNport may now be set or NULL */
1283
1284                 /* set */
1285                 chan_trace_header(mISDNport, mISDNport->b_port[i], "MESSAGE_BCHANNEL (from remote application)", DIRECTION_NONE);
1286                 add_trace("type", NULL, (type==BCHANNEL_ASSIGN_ACK)?"assign_ack":"remove_ack");
1287                 if (mISDNport && i>=0)
1288                         bchannel_event(mISDNport, i, (type==BCHANNEL_ASSIGN_ACK)?B_EVENT_EXPORTED:B_EVENT_IMPORTED);
1289                 end_trace();
1290                 break;
1291                 default:
1292                 PERROR("received wrong bchannel message type %d from remote\n", type);
1293         }
1294 }
1295
1296
1297 /*
1298  * handler
1299
1300 audio transmission procedure:
1301 -----------------------------
1302
1303 * priority
1304 three sources of audio transmission:
1305 - crypto-data high priority
1306 - tones high priority (also high)
1307 - remote-data low priority
1308
1309 * elapsed
1310 a variable that temporarily shows the number of samples elapsed since last transmission process.
1311 p_m_last_tv_* is used to store that last timestamp. this is used to calculate the time elapsed.
1312
1313 * load
1314 a variable that is increased whenever data is transmitted.
1315 it is decreased while time elapses. it stores the number of samples that
1316 are currently loaded to dsp module.
1317 since clock in dsp module is the same clock for user space process, these
1318 times have no skew.
1319
1320 * levels
1321 there are two levels:
1322 ISDN_LOAD will give the load that have to be kept in dsp.
1323 ISDN_MAXLOAD will give the maximum load before dropping.
1324
1325 * procedure for low priority data
1326 see txfromup() for procedure
1327 in short: remote data is ignored during high priority tones
1328
1329 * procedure for high priority data
1330 whenever load is below ISDN_LOAD, load is filled up to ISDN_LOAD
1331 if no more data is available, load becomes empty again.
1332
1333 'load' variable:
1334 0                    ISDN_LOAD           ISDN_MAXLOAD
1335 +--------------------+----------------------+
1336 |                    |                      |
1337 +--------------------+----------------------+
1338
1339 on empty load or on load below ISDN_LOAD, the load is inceased to ISDN_LOAD:
1340 0                    ISDN_LOAD           ISDN_MAXLOAD
1341 +--------------------+----------------------+
1342 |TTTTTTTTTTTTTTTTTTTT|                      |
1343 +--------------------+----------------------+
1344
1345 on empty load, remote-audio causes the load with the remote audio to be increased to ISDN_LOAD.
1346 0                    ISDN_LOAD           ISDN_MAXLOAD
1347 +--------------------+----------------------+
1348 |TTTTTTTTTTTTTTTTTTTTRRRRR                  |
1349 +--------------------+----------------------+
1350
1351  */
1352 int PmISDN::handler(void)
1353 {
1354         struct message *message;
1355         int elapsed = 0;
1356         int ret;
1357
1358         if ((ret = Port::handler()))
1359                 return(ret);
1360
1361         /* get elapsed */
1362         if (p_m_last_tv_sec)
1363         {
1364                 elapsed = 8000 * (now_tv.tv_sec - p_m_last_tv_sec)
1365                         + 8 * (now_tv.tv_usec/1000 - p_m_last_tv_msec);
1366         } else
1367         {
1368                 /* set clock of first process ever in this instance */
1369                 p_m_last_tv_sec = now_tv.tv_sec;
1370                 p_m_last_tv_msec = now_tv.tv_usec/1000;
1371         }
1372         /* process only if we have a minimum of samples, to make packets not too small */
1373         if (elapsed >= ISDN_TRANSMIT)
1374         {
1375                 /* set clock of last process! */
1376                 p_m_last_tv_sec = now_tv.tv_sec;
1377                 p_m_last_tv_msec = now_tv.tv_usec/1000;
1378
1379                 /* update load */
1380                 if (elapsed < p_m_load)
1381                         p_m_load -= elapsed;
1382                 else
1383                         p_m_load = 0;
1384
1385                 /* to send data, tone must be active OR crypt messages must be on */
1386                 if ((p_tone_name[0] || p_m_crypt_msg_loops) && p_m_load < ISDN_LOAD)
1387                 {
1388                         int tosend = ISDN_LOAD - p_m_load, length;
1389 #ifdef SOCKET_MISDN
1390                         unsigned char buf[MISDN_HEADER_LEN+tosend];
1391                         struct mISDNhead *frm = (struct mISDNhead *)buf;
1392                         unsigned long *d = buf+MISDN_HEADER_LEN;
1393 #else
1394                         unsigned char buf[mISDN_HEADER_LEN+tosend];
1395                         iframe_t *frm = (iframe_t *)buf;
1396                         unsigned char *p = buf+mISDN_HEADER_LEN;
1397 #endif
1398
1399                         /* copy crypto loops */
1400                         while (p_m_crypt_msg_loops && tosend)
1401                         {
1402                                 /* how much do we have to send */
1403                                 length = p_m_crypt_msg_len - p_m_crypt_msg_current;
1404
1405                                 /* clip tosend */
1406                                 if (length > tosend)
1407                                         length = tosend;
1408
1409                                 /* copy message (part) to buffer */
1410                                 memcpy(p, p_m_crypt_msg+p_m_crypt_msg_current, length);
1411
1412                                 /* new position */
1413                                 p_m_crypt_msg_current += length;
1414                                 if (p_m_crypt_msg_current == p_m_crypt_msg_len)
1415                                 {
1416                                         /* next loop */
1417                                         p_m_crypt_msg_current = 0;
1418                                         p_m_crypt_msg_loops--;
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 = 3; /* 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;
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                                         switch(hh->prim)
2054                                         {
2055                                                 /* we don't care about confirms, we use rx data to sync tx */
2056                                                 case PH_DATA_CONF:
2057                                                 case DL_DATA_CONF:
2058                                                 break;
2059
2060                                                 /* we receive audio data, we respond to it AND we send tones */
2061                                                 case PH_DATA_IND:
2062                                                 case DL_DATA_IND:
2063                                                 case PH_CONTROL_IND:
2064                                                 if (mISDNport->b_port[i])
2065                                                         mISDNport->b_port[i]->bchannel_receive(hh, buffer+MISDN_HEADER_LEN, ret-MISDN_HEADER_LEN);
2066                                                 else
2067                                                         PDEBUG(DEBUG_BCHANNEL, "b-channel is not associated to an ISDNPort (socket %d), ignoring.\n", mISDNport->b_stack[i]);
2068                                                 break;
2069
2070                                                 case PH_ACTIVATE_IND:
2071                                                 case DL_ESTABLISH_IND:
2072                                                 case PH_ACTIVATE_CONF:
2073                                                 case DL_ESTABLISH_CONF:
2074                                                 PDEBUG(DEBUG_BCHANNEL, "DL_ESTABLISH confirm: bchannel is now activated (socket %d).\n", mISDNport->b_socket[i]);
2075                                                 bchannel_event(mISDNport, i, B_EVENT_ACTIVATED);
2076                                                 break;
2077
2078                                                 case PH_DEACTIVATE_IND:
2079                                                 case DL_RELEASE_IND:
2080                                                 case PH_DEACTIVATE_CONF:
2081                                                 case DL_RELEASE_CONF:
2082                                                 PDEBUG(DEBUG_BCHANNEL, "DL_RELEASE confirm: bchannel is now de-activated (socket %d).\n", mISDNport->b_socket[i]);
2083                                                 bchannel_event(mISDNport, i, B_EVENT_DEACTIVATED);
2084                                                 break;
2085
2086                                                 default:
2087                                                 PERROR("child message not handled: prim(0x%x) socket(%d) msg->len(%d)\n", hh->prim, mISDNport->b_socket[i], msg->len);
2088                                         }
2089                                 } else
2090                                 {
2091                                         if (ret < 0 && errno != EWOULDBLOCK)
2092                                                 PERROR("Read from port %d, index %d failed with return code %d\n", mISDNport->portnum, i, ret);
2093                                 }
2094                         }
2095
2096                         i++;
2097                 }
2098 #if 0
2099                 if (mISDNport->l1timeout && now>mISDNport->l1timeout)
2100                 { ---}
2101                         PDEBUG(DEBUG_ISDN, "the L1 establish timer expired, we release all pending messages.\n", mISDNport->portnum);
2102                         mISDNport->l1timeout = 0;
2103 #endif
2104
2105                 /* layer 2 establish timer */
2106                 if (mISDNport->l2establish)
2107                 {
2108                         if (now-mISDNport->l2establish > 5)
2109                         {
2110
2111                                 PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link portnum=%d.\n", mISDNport->portnum);
2112                                 mISDNport->ml3->to_layer2(mISDNport->ml3, DL_ESTABLISH_REQ);
2113                                 l1l2l3_trace_header(mISDNport, NULL, DL_ESTABLISH_REQ, DIRECTION_OUT);
2114                                 end_trace();
2115                                 return(1);
2116                         }
2117                 }
2118
2119
2120                 mISDNport = mISDNport->next;
2121         }
2122
2123 }
2124 #else
2125 int mISDN_handler(void)
2126 {
2127         int ret;
2128         struct mISDNport *mISDNport;
2129         class PmISDN *isdnport;
2130         int i;
2131         msg_t *msg;
2132         iframe_t *frm;
2133         msg_t *dmsg;
2134         mISDNuser_head_t *hh;
2135         net_stack_t *nst;
2136
2137         /* the que avoids loopbacks when replying to stack after receiving
2138          * from stack. */
2139         mISDNport = mISDNport_first;
2140         while(mISDNport)
2141         {
2142                 /* process turning on/off rx */
2143                 i = 0;
2144                 while(i < mISDNport->b_num)
2145                 {
2146                         isdnport=mISDNport->b_port[i];
2147                         if (isdnport)
2148                         {
2149                                 /* call bridges in user space OR crypto OR recording */
2150                                 if (isdnport->p_m_joindata || isdnport->p_m_crypt_msg_loops || isdnport->p_m_crypt_listen || isdnport->p_record)
2151                                 {
2152                                         /* rx IS required */
2153                                         if (isdnport->p_m_rxoff)
2154                                         {
2155                                                 /* turn on RX */
2156                                                 isdnport->p_m_rxoff = 0;
2157                                                 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is required, so we turn them on\n");
2158                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
2159                                                         ph_control(mISDNport, isdnport, mISDNport->b_addr[isdnport->p_m_b_index], CMX_RECEIVE_ON, 0, "DSP-RXOFF", 0);
2160                                                 return(1);
2161                                         }
2162                                 } else
2163                                 {
2164                                         /* rx NOT required */
2165                                         if (!isdnport->p_m_rxoff)
2166                                         {
2167                                                 /* turn off RX */
2168                                                 isdnport->p_m_rxoff = 1;
2169                                                 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is not required, so we turn them off\n");
2170                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
2171                                                         ph_control(mISDNport, isdnport, mISDNport->b_addr[isdnport->p_m_b_index], CMX_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
2172                                                 return(1);
2173                                         }
2174                                 }
2175                                 /* recording */
2176                                 if (isdnport->p_record)
2177                                 {
2178                                         /* txdata IS required */
2179                                         if (!isdnport->p_m_txdata)
2180                                         {
2181                                                 /* turn on RX */
2182                                                 isdnport->p_m_txdata = 1;
2183                                                 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is required, so we turn them on\n");
2184                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
2185                                                         ph_control(mISDNport, isdnport, mISDNport->b_addr[isdnport->p_m_b_index], CMX_TXDATA_ON, 0, "DSP-TXDATA", 1);
2186                                                 return(1);
2187                                         }
2188                                 } else
2189                                 {
2190                                         /* txdata NOT required */
2191                                         if (isdnport->p_m_txdata)
2192                                         {
2193                                                 /* turn off RX */
2194                                                 isdnport->p_m_txdata = 0;
2195                                                 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is not required, so we turn them off\n");
2196                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
2197                                                         ph_control(mISDNport, isdnport, mISDNport->b_addr[isdnport->p_m_b_index], CMX_TXDATA_OFF, 0, "DSP-TXDATA", 0);
2198                                                 return(1);
2199                                         }
2200                                 }
2201                         }
2202                         i++;
2203                 }
2204 #if 0
2205                 if (mISDNport->l1timeout && now>mISDNport->l1timeout)
2206                 { ---}
2207                         PDEBUG(DEBUG_ISDN, "the L1 establish timer expired, we release all pending messages.\n", mISDNport->portnum);
2208                         mISDNport->l1timeout = 0;
2209 #endif
2210
2211                 if (mISDNport->l2establish)
2212                 {
2213                         if (now-mISDNport->l2establish > 5)
2214                         {
2215                                 if (mISDNport->ntmode)
2216                                 {
2217                                         PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link NT portnum=%d.\n", mISDNport->portnum);
2218                                         time(&mISDNport->l2establish);
2219                                         /* establish */
2220                                         dmsg = create_l2msg(DL_ESTABLISH | REQUEST, 0, 0);
2221                                         if (mISDNport->nst.manager_l3(&mISDNport->nst, dmsg))
2222                                                 free_msg(dmsg);
2223                                 } else {
2224                                         iframe_t act;
2225
2226                                         PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link TE portnum=%d.\n", mISDNport->portnum);
2227                                         time(&mISDNport->l2establish);
2228                                         /* establish */
2229                                         act.prim = DL_ESTABLISH | REQUEST;
2230                                         act.addr = (mISDNport->upper_id & ~LAYER_ID_MASK) | 3 | FLG_MSG_DOWN;
2231                                         act.dinfo = 0;
2232                                         act.len = 0;
2233                                         mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
2234                                 }
2235                                 l1l2l3_trace_header(mISDNport, NULL, DL_ESTABLISH | REQUEST, DIRECTION_OUT);
2236                                 end_trace();
2237                                 return(1);
2238                         }
2239                 }
2240                 if ((dmsg = msg_dequeue(&mISDNport->downqueue)))
2241                 {
2242                         if (mISDNport->ntmode)
2243                         {
2244                                 hh = (mISDNuser_head_t *)dmsg->data;
2245                                 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);
2246                                 if (mISDNport->nst.manager_l3(&mISDNport->nst, dmsg))
2247                                         free_msg(dmsg);
2248                         } else
2249                         {
2250                                 frm = (iframe_t *)dmsg->data;
2251                                 frm->addr = mISDNport->upper_id | FLG_MSG_DOWN;
2252                                 frm->len = (dmsg->len) - mISDN_HEADER_LEN;
2253                                 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);
2254                                 mISDN_write(mISDNdevice, dmsg->data, dmsg->len, TIMEOUT_1SEC);
2255                                 free_msg(dmsg);
2256                         }
2257                         return(1);
2258                 }
2259                 mISDNport = mISDNport->next;
2260         }
2261
2262         /* no device, no read */
2263         if (mISDNdevice < 0)
2264                 return(0);
2265
2266         /* get message from kernel */
2267         if (!(msg = alloc_msg(MAX_MSG_SIZE)))
2268                 return(1);
2269         ret = mISDN_read(mISDNdevice, msg->data, MAX_MSG_SIZE, 0);
2270         if (ret < 0)
2271         {
2272                 free_msg(msg);
2273                 if (errno == EAGAIN)
2274                         return(0);
2275                 FATAL("Failed to do mISDN_read()\n");
2276         }
2277         if (!ret)
2278         {
2279                 free_msg(msg);
2280 //              printf("%s: ERROR: mISDN_read() returns nothing\n");
2281                 return(0);
2282         }
2283         msg->len = ret;
2284         frm = (iframe_t *)msg->data;
2285
2286         /* global prim */
2287         switch(frm->prim)
2288         {
2289                 case MGR_DELLAYER | CONFIRM:
2290                 case MGR_INITTIMER | CONFIRM:
2291                 case MGR_ADDTIMER | CONFIRM:
2292                 case MGR_DELTIMER | CONFIRM:
2293                 case MGR_REMOVETIMER | CONFIRM:
2294                 free_msg(msg);
2295                 return(1);
2296         }
2297
2298         /* handle timer events from mISDN for NT-stack
2299          * note: they do not associate with a stack */
2300         if (frm->prim == (MGR_TIMER | INDICATION))
2301         {
2302                 itimer_t *it;
2303
2304                 /* find mISDNport */
2305                 mISDNport = mISDNport_first;
2306                 while(mISDNport)
2307                 {
2308                         /* nt mode only */
2309                         if (mISDNport->ntmode)
2310                         {
2311                                 it = mISDNport->nst.tlist;
2312                                 /* find timer */
2313                                 while(it)
2314                                 {
2315                                         if (it->id == (int)frm->addr)
2316                                                 break;
2317                                         it = it->next;
2318                                 }
2319                                 if (it)
2320                                         break;
2321                         }
2322                         mISDNport = mISDNport->next;
2323                 }
2324                 if (mISDNport)
2325                 {
2326                         mISDN_write_frame(mISDNdevice, msg->data, mISDNport->upper_id | FLG_MSG_DOWN,
2327                                 MGR_TIMER | RESPONSE, 0, 0, NULL, TIMEOUT_1SEC);
2328
2329                         PDEBUG(DEBUG_ISDN, "timer-indication port %d it=%p\n", mISDNport->portnum, it);
2330                         test_and_clear_bit(FLG_TIMER_RUNING, (long unsigned int *)&it->Flags);
2331                         ret = it->function(it->data);
2332                 } else
2333                 {
2334                         PDEBUG(DEBUG_ISDN, "timer-indication not handled\n");
2335                 }
2336                 goto out;
2337         }
2338
2339         /* find the mISDNport that belongs to the stack */
2340         mISDNport = mISDNport_first;
2341         while(mISDNport)
2342         {
2343                 if ((frm->addr&MASTER_ID_MASK) == (unsigned int)(mISDNport->upper_id&MASTER_ID_MASK))
2344                         break;
2345                 mISDNport = mISDNport->next;
2346         }
2347         if (!mISDNport)
2348         {
2349                 PERROR("message belongs to no mISDNport: prim(0x%x) addr(0x%x) msg->len(%d)\n", frm->prim, frm->addr, msg->len);
2350                 goto out;
2351         }
2352
2353         /* master stack */
2354         if (!(frm->addr&FLG_CHILD_STACK))
2355         {
2356                 /* d-message */
2357                 switch(frm->prim)
2358                 {
2359                         case MGR_SHORTSTATUS | INDICATION:
2360                         case MGR_SHORTSTATUS | CONFIRM:
2361                         switch(frm->dinfo) {
2362                                 case SSTATUS_L1_ACTIVATED:
2363                                 l1l2l3_trace_header(mISDNport, NULL, PH_ACTIVATE | (frm->prim & 0x3), DIRECTION_IN);
2364                                 end_trace();
2365                                 goto ss_act;
2366                                 case SSTATUS_L1_DEACTIVATED:
2367                                 l1l2l3_trace_header(mISDNport, NULL, PH_DEACTIVATE | (frm->prim & 0x3), DIRECTION_IN);
2368                                 end_trace();
2369                                 goto ss_deact;
2370                                 case SSTATUS_L2_ESTABLISHED:
2371                                 l1l2l3_trace_header(mISDNport, NULL, DL_ESTABLISH | (frm->prim & 0x3), DIRECTION_IN);
2372                                 end_trace();
2373                                 goto ss_estab;
2374                                 case SSTATUS_L2_RELEASED:
2375                                 l1l2l3_trace_header(mISDNport, NULL, DL_RELEASE | (frm->prim & 0x3), DIRECTION_IN);
2376                                 end_trace();
2377                                 goto ss_rel;
2378                         }
2379                         break;
2380
2381                         case PH_ACTIVATE | CONFIRM:
2382                         case PH_ACTIVATE | INDICATION:
2383                         l1l2l3_trace_header(mISDNport, NULL, frm->prim, DIRECTION_IN);
2384                         end_trace();
2385                         if (mISDNport->ntmode)
2386                         {
2387                                 mISDNport->l1link = 1;
2388                                 setup_queue(mISDNport, 1);
2389                                 goto l1_msg;
2390                         }
2391                         ss_act:
2392                         mISDNport->l1link = 1;
2393                         setup_queue(mISDNport, 1);
2394                         break;
2395
2396                         case PH_DEACTIVATE | CONFIRM:
2397                         case PH_DEACTIVATE | INDICATION:
2398                         l1l2l3_trace_header(mISDNport, NULL, frm->prim, DIRECTION_IN);
2399                         end_trace();
2400                         if (mISDNport->ntmode)
2401                         {
2402                                 mISDNport->l1link = 0;
2403                                 setup_queue(mISDNport, 0);
2404                                 goto l1_msg;
2405                         }
2406                         ss_deact:
2407                         mISDNport->l1link = 0;
2408                         setup_queue(mISDNport, 0);
2409                         break;
2410
2411                         case PH_CONTROL | CONFIRM:
2412                         case PH_CONTROL | INDICATION:
2413                         PDEBUG(DEBUG_ISDN, "Received PH_CONTROL for port %d (%s).\n", mISDNport->portnum, mISDNport->ifport->interface->name);
2414                         break;
2415
2416                         case DL_ESTABLISH | INDICATION:
2417                         case DL_ESTABLISH | CONFIRM:
2418                         l1l2l3_trace_header(mISDNport, NULL, frm->prim, DIRECTION_IN);
2419                         end_trace();
2420                         if (!mISDNport->ntmode) break; /* !!!!!!!!!!!!!!!! */
2421                         ss_estab:
2422                         if (mISDNport->l2establish)
2423                         {
2424                                 mISDNport->l2establish = 0;
2425                                 PDEBUG(DEBUG_ISDN, "the link became active before l2establish timer expiry.\n");
2426                         }
2427                         mISDNport->l2link = 1;
2428                         break;
2429
2430                         case DL_RELEASE | INDICATION:
2431                         case DL_RELEASE | CONFIRM:
2432                         l1l2l3_trace_header(mISDNport, NULL, frm->prim, DIRECTION_IN);
2433                         end_trace();
2434                         if (!mISDNport->ntmode) break; /* !!!!!!!!!!!!!!!! */
2435                         ss_rel:
2436                         mISDNport->l2link = 0;
2437                         if (mISDNport->ptp)
2438                         {
2439                                 time(&mISDNport->l2establish);
2440                                 PDEBUG(DEBUG_ISDN, "because we are ptp, we set a l2establish timer.\n");
2441                         }
2442                         break;
2443
2444                         default:
2445                         l1_msg:
2446                         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);
2447                         if (frm->dinfo==(signed long)0xffffffff && frm->prim==(PH_DATA|CONFIRM))
2448                         {
2449                                 PERROR("SERIOUS BUG, dinfo == 0xffffffff, prim == PH_DATA | CONFIRM !!!!\n");
2450                         }
2451                         /* d-message */
2452                         if (mISDNport->ntmode)
2453                         {
2454                                 /* l1-data enters the nt-mode library */
2455                                 nst = &mISDNport->nst;
2456                                 if (nst->l1_l2(nst, msg))
2457                                         free_msg(msg);
2458                                 return(1);
2459                         } else
2460                         {
2461                                 /* l3-data is sent to pbx */
2462                                 if (stack2manager_te(mISDNport, msg))
2463                                         free_msg(msg);
2464                                 return(1);
2465                         }
2466                 }
2467         } else
2468         /* child stack */
2469         {
2470                 /* b-message */
2471                 switch(frm->prim)
2472                 {
2473                         /* we don't care about confirms, we use rx data to sync tx */
2474                         case PH_DATA | CONFIRM:
2475                         case DL_DATA | CONFIRM:
2476                         break;
2477
2478                         /* we receive audio data, we respond to it AND we send tones */
2479                         case PH_DATA | INDICATION:
2480                         case DL_DATA | INDICATION:
2481                         case PH_CONTROL | INDICATION:
2482                         case PH_SIGNAL | INDICATION:
2483                         i = 0;
2484                         while(i < mISDNport->b_num)
2485                         {
2486                                 if ((unsigned int)(mISDNport->b_addr[i]&STACK_ID_MASK) == (frm->addr&STACK_ID_MASK))
2487                                         break;
2488                                 i++;
2489                         }
2490                         if (i == mISDNport->b_num)
2491                         {
2492                                 PERROR("unhandled b-message (prim 0x%x address 0x%x).\n", frm->prim, frm->addr);
2493                                 break;
2494                         }
2495                         if (mISDNport->b_port[i])
2496                         {
2497 //PERROR("port sech: %s data\n", mISDNport->b_port[i]->p_name);
2498                                 mISDNport->b_port[i]->bchannel_receive(frm);
2499                         } else
2500                                 PDEBUG(DEBUG_BCHANNEL, "b-channel is not associated to an ISDNPort (address 0x%x), ignoring.\n", frm->addr);
2501                         break;
2502
2503                         case PH_ACTIVATE | INDICATION:
2504                         case DL_ESTABLISH | INDICATION:
2505                         case PH_ACTIVATE | CONFIRM:
2506                         case DL_ESTABLISH | CONFIRM:
2507                         PDEBUG(DEBUG_BCHANNEL, "DL_ESTABLISH confirm: bchannel is now activated (address 0x%x).\n", frm->addr);
2508                         i = 0;
2509                         while(i < mISDNport->b_num)
2510                         {
2511                                 if ((unsigned int)(mISDNport->b_addr[i]&STACK_ID_MASK) == (frm->addr&STACK_ID_MASK))
2512                                         break;
2513                                 i++;
2514                         }
2515                         if (i == mISDNport->b_num)
2516                         {
2517                                 PERROR("unhandled b-establish (prim 0x%x address 0x%x).\n", frm->prim, frm->addr);
2518                                 break;
2519                         }
2520                         bchannel_event(mISDNport, i, B_EVENT_ACTIVATED);
2521                         break;
2522
2523                         case PH_DEACTIVATE | INDICATION:
2524                         case DL_RELEASE | INDICATION:
2525                         case PH_DEACTIVATE | CONFIRM:
2526                         case DL_RELEASE | CONFIRM:
2527                         PDEBUG(DEBUG_BCHANNEL, "DL_RELEASE confirm: bchannel is now de-activated (address 0x%x).\n", frm->addr);
2528                         i = 0;
2529                         while(i < mISDNport->b_num)
2530                         {
2531                                 if ((unsigned int)(mISDNport->b_addr[i]&STACK_ID_MASK) == (frm->addr&STACK_ID_MASK))
2532                                         break;
2533                                 i++;
2534                         }
2535                         if (i == mISDNport->b_num)
2536                         {
2537                                 PERROR("unhandled b-release (prim 0x%x address 0x%x).\n", frm->prim, frm->addr);
2538                                 break;
2539                         }
2540                         bchannel_event(mISDNport, i, B_EVENT_DEACTIVATED);
2541                         break;
2542
2543                         default:
2544                         PERROR("child message not handled: prim(0x%x) addr(0x%x) msg->len(%d)\n", frm->prim, frm->addr, msg->len);
2545                 }
2546         }
2547
2548         out:
2549         free_msg(msg);
2550         return(1);
2551 }
2552 #endif
2553
2554 #ifdef SOCKET_MISDN
2555 int do_layer3(struct mlayer3 *ml3, unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
2556 {
2557         struct mISDNport *mISDNport = ml3->private;
2558
2559         if (cmd == MT_ASSIGN)
2560         {
2561                 ueberdenken!!!
2562         }
2563
2564         /* lock LCR */
2565         achtung MT_ASSIGN kommt hier an
2566         lock it baby
2567
2568         /* d-message */
2569         switch(cmd)
2570         {
2571                 case MGR_SHORTSTATUS_IND:
2572                 case MGR_SHORTSTATUS_CONF:
2573                 switch(frm->dinfo) {
2574                         case SSTATUS_L1_ACTIVATED:
2575                         l1l2l3_trace_header(mISDNport, NULL, PH_ACTIVATE_IND, DIRECTION_IN);
2576                         end_trace();
2577                         goto ss_act;
2578                         case SSTATUS_L1_DEACTIVATED:
2579                         l1l2l3_trace_header(mISDNport, NULL, PH_DEACTIVATE_IND, DIRECTION_IN);
2580                         end_trace();
2581                         goto ss_deact;
2582                         case SSTATUS_L2_ESTABLISHED:
2583                         l1l2l3_trace_header(mISDNport, NULL, DL_ESTABLISH_IND, DIRECTION_IN);
2584                         end_trace();
2585                         goto ss_estab;
2586                         case SSTATUS_L2_RELEASED:
2587                         l1l2l3_trace_header(mISDNport, NULL, DL_RELEASE_IND, DIRECTION_IN);
2588                         end_trace();
2589                         goto ss_rel;
2590                 }
2591                 break;
2592
2593                 case PH_ACTIVATE_CONF:
2594                 case PH_ACTIVATE_IND:
2595                 l1l2l3_trace_header(mISDNport, NULL, cmd, DIRECTION_IN);
2596                 end_trace();
2597                 ss_act:
2598                 mISDNport->l1link = 1;
2599 #if 0
2600                 if (mISDNport->ntmode)
2601                         setup_queue(mISDNport, 1);
2602 #endif
2603                 break;
2604
2605                 case PH_DEACTIVATE | CONFIRM:
2606                 case PH_DEACTIVATE | INDICATION:
2607                 l1l2l3_trace_header(mISDNport, NULL, cmd, DIRECTION_IN);
2608                 end_trace();
2609                 ss_deact:
2610                 mISDNport->l1link = 0;
2611 raus mit der setup-queue, da dies im stack geschieht
2612 #if 0
2613                 if (mISDNport->ntmode)
2614                         setup_queue(mISDNport, 0);
2615 #endif
2616                 break;
2617
2618                 case PH_CONTROL_CONFIRM:
2619                 case PH_CONTROL_INDICATION:
2620                 PDEBUG(DEBUG_ISDN, "Received PH_CONTROL for port %d (%s).\n", mISDNport->portnum, mISDNport->ifport->interface->name);
2621                 break;
2622
2623                 case DL_ESTABLISH_IND:
2624                 case DL_ESTABLISH_CONF:
2625                 l1l2l3_trace_header(mISDNport, NULL, cmd, DIRECTION_IN);
2626                 end_trace();
2627                 if (!mISDNport->ntmode) break; /* !!!!!!!!!!!!!!!! */
2628                 ss_estab:
2629                 if (mISDNport->l2establish)
2630                 {
2631                         mISDNport->l2establish = 0;
2632                         PDEBUG(DEBUG_ISDN, "the link became active before l2establish timer expiry.\n");
2633                 }
2634                 mISDNport->l2link = 1;
2635                 break;
2636
2637                 case DL_RELEASE_IND:
2638                 case DL_RELEASE_CONF:
2639                 l1l2l3_trace_header(mISDNport, NULL, cmd, DIRECTION_IN);
2640                 end_trace();
2641                 ss_rel:
2642                 mISDNport->l2link = 0;
2643                 if (mISDNport->ptp)
2644                 {
2645                         time(&mISDNport->l2establish);
2646                         PDEBUG(DEBUG_ISDN, "because we are ptp, we set a l2establish timer.\n");
2647                 }
2648                 break;
2649
2650                 default:
2651                 /* l3-data is sent to LCR */
2652                 message_from_mlayer3(mISDNport, cmd, pid, l3m);
2653         }
2654
2655         /* unlock LCR */
2656         unlock it baby
2657
2658         /* free message */
2659         if (l3m)
2660                 free_l3_msg(l3m);
2661         return(0);
2662
2663 }
2664 #endif
2665
2666
2667 /*
2668  * global function to add a new card (port)
2669  */
2670 struct mISDNport *mISDNport_open(int port, int ptp, int ptmp, int force_nt, struct interface *interface)
2671 {
2672         int ret;
2673         unsigned char buff[1025];
2674         iframe_t *frm = (iframe_t *)buff;
2675         struct mISDNport *mISDNport, **mISDNportp;
2676         int i, cnt;
2677         int pri, bri, ports;
2678         int nt, te;
2679 #ifdef SOCKET_MISDN
2680         struct mlayer3 *ml3;
2681         struct mISDN_devinfo devinfo;
2682
2683         ret = ioctl(mISDNsocket, IMGETCOUNT, &cnt);
2684         if (ret < 0)
2685         {
2686                 fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret);
2687                 return(NULL);
2688         }
2689 #else
2690 //      interface_info_t ii;
2691         net_stack_t *nst;
2692         manager_t *mgr;
2693         layer_info_t li;
2694         stack_info_t *stinf;
2695
2696         /* query port's requirements */
2697         cnt = mISDN_get_stack_count(mISDNdevice);
2698 #endif
2699
2700         if (cnt <= 0)
2701         {
2702                 PERROR_RUNTIME("Found no card. Please be sure to load card drivers.\n");
2703                 return(NULL);
2704         }
2705         if (port>cnt || port<1)
2706         {
2707                 PERROR_RUNTIME("Port (%d) given at 'ports' (options.conf) is out of existing port range (%d-%d)\n", port, 1, cnt);
2708                 return(NULL);
2709         }
2710
2711         pri = bri = ports = nt = te = 0;
2712 #ifdef SOCKET_MISDN
2713         devinfo.id = port - 1;
2714         ret = ioctl(socket, IMGETDEVINFO, &devinfo);
2715         if (ret <= 0)
2716         {
2717                 PERROR_RUNTIME("Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", i, ret);
2718                 break;
2719         }
2720         /* output the port info */
2721         if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0))
2722         {
2723                 bri = 1;
2724                 te = 1;
2725         }
2726         if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0))
2727         {
2728                 bri = 1;
2729                 nt = 1;
2730         }
2731 #ifdef ISDN_P_TE_E1
2732         if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1))
2733         {
2734                 pri = 1;
2735                 te = 1;
2736         }
2737 #endif
2738 #ifdef ISDN_P_NT_E1
2739         if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1))
2740         {
2741                 pri = 1;
2742                 nt = 1;
2743         }
2744 #endif
2745 #ifdef ISDN_P_FXS
2746         if (devinfo.Dprotocols & (1 << ISDN_P_FXS))
2747         {
2748                 pots = 1;
2749                 te = 1;
2750         }
2751 #endif
2752 #ifdef ISDN_P_FXO
2753         if (devinfo.Dprotocols & (1 << ISDN_P_FXO))
2754         {
2755                 pots = 1;
2756                 nt = 1;
2757         }
2758 #endif
2759         if (force_nt && !nt)
2760         {
2761                 PERROR_RUNTIME("Port %d does not support NT-mode.\n", port);
2762                 return(NULL);
2763         }
2764         if (bri && pri)
2765         {
2766                 PERROR_RUNTIME("Port %d supports BRI and PRI?? What kind of controller is that?. (Can't use this!)\n", port);
2767                 return(NULL);
2768         }
2769         if (pots && !bri && !pri)
2770         {
2771                 PERROR_RUNTIME("Port %d supports POTS, LCR does not!\n", port);
2772                 return(NULL);
2773         }
2774         if (!bri && !pri)
2775         {
2776                 PERROR_RUNTIME("Port %d does not support BRI nor PRI!\n", port);
2777                 return(NULL);
2778         }
2779         if (!nt && !te)
2780         {
2781                 PERROR_RUNTIME("Port %d does not support NT-mode nor TE-mode!\n", port);
2782                 return(NULL);
2783         }
2784         /* force nt, by turning off TE */
2785         if (force_nt && nt)
2786                 te = 0;
2787         /* if TE an NT is supported (and not forced to NT), turn off NT */
2788         if (te && nt)
2789                 nt = 0;
2790 #else
2791         ret = mISDN_get_stack_info(mISDNdevice, port, buff, sizeof(buff));
2792         if (ret < 0)
2793         {
2794                 PERROR_RUNTIME("Cannot get stack info for port %d (ret=%d)\n", port, ret);
2795                 return(NULL);
2796         }
2797         stinf = (stack_info_t *)&frm->data.p;
2798         switch(stinf->pid.protocol[0] & ~ISDN_PID_FEATURE_MASK)
2799         {
2800                 case ISDN_PID_L0_TE_S0:
2801                 PDEBUG(DEBUG_ISDN, "TE-mode BRI S/T interface line\n");
2802                 break;
2803                 case ISDN_PID_L0_NT_S0:
2804                 PDEBUG(DEBUG_ISDN, "NT-mode BRI S/T interface port\n");
2805                 nt = 1;
2806                 break;
2807                 case ISDN_PID_L0_TE_E1:
2808                 PDEBUG(DEBUG_ISDN, "TE-mode PRI E1  interface line\n");
2809                 pri = 1;
2810                 break;
2811                 case ISDN_PID_L0_NT_E1:
2812                 PDEBUG(DEBUG_ISDN, "LT-mode PRI E1  interface port\n");
2813                 pri = 1;
2814                 nt = 1;
2815                 break;
2816                 default:
2817                 PERROR_RUNTIME("unknown port(%d) type 0x%08x\n", port, stinf->pid.protocol[0]);
2818                 return(NULL);
2819         }
2820         if (nt)
2821         {
2822                 /* NT */
2823                 if (stinf->pid.protocol[1] == 0)
2824                 {
2825                         PERROR_RUNTIME("Given port %d: Missing layer 1 NT-mode protocol.\n", port);
2826                         return(NULL);
2827                 }
2828                 if (stinf->pid.protocol[2])
2829                 {
2830                         PERROR_RUNTIME("Given port %d: Layer 2 protocol 0x%08x is detected, but not allowed for NT lib.\n", port, stinf->pid.protocol[2]);
2831                         return(NULL);
2832                 }
2833         }
2834         if (te)
2835         {
2836                 /* TE */
2837                 if (stinf->pid.protocol[1] == 0)
2838                 {
2839                         PERROR_RUNTIME("Given port %d: Missing layer 1 protocol.\n", port);
2840                         return(NULL);
2841                 }
2842                 if (stinf->pid.protocol[2] == 0)
2843                 {
2844                         PERROR_RUNTIME("Given port %d: Missing layer 2 protocol.\n", port);
2845                         return(NULL);
2846                 }
2847                 if (stinf->pid.protocol[3] == 0)
2848                 {
2849                         PERROR_RUNTIME("Given port %d: Missing layer 3 protocol.\n", port);
2850                         return(NULL);
2851                 } else
2852                 {
2853                         switch(stinf->pid.protocol[3] & ~ISDN_PID_FEATURE_MASK)
2854                         {
2855                                 case ISDN_PID_L3_DSS1USER:
2856                                 break;
2857
2858                                 default:
2859                                 PERROR_RUNTIME("Given port %d: own protocol 0x%08x", port,stinf->pid.protocol[3]);
2860                                 return(NULL);
2861                         }
2862                 }
2863                 if (stinf->pid.protocol[4])
2864                 {
2865                         PERROR_RUNTIME("Given port %d: Layer 4 protocol not allowed.\n", port);
2866                         return(NULL);
2867                 }
2868         }
2869 #endif
2870
2871         /* add mISDNport structure */
2872         mISDNportp = &mISDNport_first;
2873         while(*mISDNportp)
2874                 mISDNportp = &((*mISDNportp)->next);
2875         mISDNport = (struct mISDNport *)MALLOC(sizeof(struct mISDNport));
2876         pmemuse++;
2877         *mISDNportp = mISDNport;
2878
2879         /* allocate ressources of port */
2880 #ifdef SOCKET_MISDN
2881         /* open layer 3 */
2882         protocol = (nt)?L3_PROTOCOL_DSS1_USER:L3_PROTOCOL_DSS1_NETWORK;
2883         prop = 0;
2884         if (ptp)
2885                prop |= FLG_PTP;
2886         if (ptmp && pri)
2887                prop |= FLG_FORCE_PTMP;
2888         mISDNport->ml3 = open_layer3(port-1, protocol, prop , do_dchannel, mISDNport);
2889         if (!mISDNport->ml3)
2890         {
2891                 PERROR_RUNTIME("Cannot get layer(%d) id of port %d\n", nt?2:4, port);
2892                 return(NULL);
2893         }
2894
2895 #if 0
2896         /* if ntmode, establish L1 to send the tei removal during start */
2897         if (mISDNport->ntmode)
2898         {
2899                 iframe_t act;
2900                 /* L1 */
2901                 act.prim = PH_ACTIVATE | REQUEST;
2902                 act.addr = mISDNport->upper_id | FLG_MSG_DOWN;
2903                 printf("UPPER ID 0x%x, addr 0x%x\n",mISDNport->upper_id, act.addr);
2904                 act.dinfo = 0;
2905                 act.len = 0;
2906                 mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
2907                 usleep(10000); /* to be sure, that l1 is up */
2908         }
2909 #endif
2910
2911         SCPY(mISDNport->name, devinfo.name);
2912         mISDNport->b_num = devinfo.nrbchan;
2913 #else
2914         msg_queue_init(&mISDNport->downqueue);
2915         mISDNport->d_stid = stinf->id;
2916         PDEBUG(DEBUG_ISDN, "d_stid = 0x%x.\n", mISDNport->d_stid);
2917         if ((stinf->pid.protocol[2]&ISDN_PID_L2_DF_PTP) || (nt&&ptp) || pri)
2918         {
2919                 PDEBUG(DEBUG_ISDN, "Port is point-to-point.\n");
2920                 ptp = 1;
2921                 if (ptmp && nt)
2922                 {
2923                         PDEBUG(DEBUG_ISDN, "Port is forced to point-to-multipoint.\n");
2924                         ptp = 0;
2925                 }
2926         }
2927
2928         /* create layer intance */
2929         memset(&li, 0, sizeof(li));
2930         UCPY(&li.name[0], (nt)?"net l2":"pbx l4");
2931         li.object_id = -1;
2932         li.extentions = 0;
2933         li.pid.protocol[nt?2:4] = (nt)?ISDN_PID_L2_LAPD_NET:ISDN_PID_L4_CAPI20;
2934         li.pid.layermask = ISDN_LAYER((nt?2:4));
2935         li.st = mISDNport->d_stid;
2936         ret = mISDN_new_layer(mISDNdevice, &li);
2937         if (ret)
2938         {
2939                 PERROR("Cannot add layer %d of port %d (ret %d)\n", nt?2:4, port, ret);
2940                 closeport:
2941                 mISDNport_close(mISDNport);
2942                 return(NULL);
2943         }
2944         mISDNport->upper_id = li.id;
2945         ret = mISDN_register_layer(mISDNdevice, mISDNport->d_stid, mISDNport->upper_id);
2946         if (ret)
2947         {
2948                 PERROR("Cannot register layer %d of port %d\n", nt?2:4, port);
2949                 goto closeport;
2950         }
2951         mISDNport->lower_id = mISDN_get_layerid(mISDNdevice, mISDNport->d_stid, nt?1:3); // id of lower layer (nt=1, te=3)
2952         if (mISDNport->lower_id < 0)
2953         {
2954                 PERROR("Cannot get layer(%d) id of port %d\n", nt?1:3, port);
2955                 goto closeport;
2956         }
2957         mISDNport->upper_id = mISDN_get_layerid(mISDNdevice, mISDNport->d_stid, nt?2:4); // id of uppermost layer (nt=2, te=4)
2958         if (mISDNport->upper_id < 0)
2959         {
2960                 PERROR("Cannot get layer(%d) id of port %d\n", nt?2:4, port);
2961                 goto closeport;
2962         }
2963         PDEBUG(DEBUG_ISDN, "Layer %d of port %d added.\n", nt?2:4, port);
2964
2965         /* if ntmode, establish L1 to send the tei removal during start */
2966         if (mISDNport->ntmode)
2967         {
2968                 iframe_t act;
2969                 /* L1 */
2970                 act.prim = PH_ACTIVATE | REQUEST;
2971                 act.addr = mISDNport->upper_id | FLG_MSG_DOWN;
2972                 printf("UPPER ID 0x%x, addr 0x%x\n",mISDNport->upper_id, act.addr);
2973                 act.dinfo = 0;
2974                 act.len = 0;
2975                 mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
2976                 usleep(10000); /* to be sure, that l1 is up */
2977         }
2978
2979         /* create nst (nt-mode only) */
2980         if (nt)
2981         {
2982                 mgr = &mISDNport->mgr;
2983                 nst = &mISDNport->nst;
2984
2985                 mgr->nst = nst;
2986                 nst->manager = mgr;
2987
2988                 nst->l3_manager = stack2manager_nt; /* messages from nt-mode */
2989                 nst->device = mISDNdevice;
2990                 nst->cardnr = port;
2991                 nst->d_stid = mISDNport->d_stid;
2992
2993                 nst->feature = FEATURE_NET_HOLD;
2994                 if (ptp)
2995                         nst->feature |= FEATURE_NET_PTP;
2996                 if (pri)
2997                         nst->feature |= FEATURE_NET_CRLEN2 | FEATURE_NET_EXTCID;
2998 #if 0
2999                 i = 0;
3000                 while(i < mISDNport->b_num)
3001                 {
3002                         nst->b_stid[i] = mISDNport->b_stid[i];
3003                         i++;
3004                 }
3005 #endif
3006                 nst->l1_id = mISDNport->lower_id;
3007                 nst->l2_id = mISDNport->upper_id;
3008
3009                 /* phd */
3010                 msg_queue_init(&nst->down_queue);
3011
3012                 Isdnl2Init(nst);
3013                 Isdnl3Init(nst);
3014         }
3015
3016         mISDNport->b_num = stinf->childcnt;
3017 #endif
3018         mISDNport->portnum = port;
3019         mISDNport->ntmode = nt;
3020         mISDNport->pri = pri;
3021         mISDNport->ptp = ptp;
3022         PDEBUG(DEBUG_ISDN, "Port has %d b-channels.\n", mISDNport->b_num);
3023         i = 0;
3024         while(i < mISDNport->b_num)
3025         {
3026                 mISDNport->b_state[i] = B_STATE_IDLE;
3027 #ifdef SOCKET_MISDN
3028                 mISDNport->b_socket = -1;
3029 #else
3030                 mISDNport->b_stid[i] = stinf->child[i];
3031                 PDEBUG(DEBUG_ISDN, "b_stid[%d] = 0x%x.\n", i, mISDNport->b_stid[i]);
3032 #endif
3033                 i++;
3034         }
3035
3036         /* if te-mode, query state link */
3037         if (!mISDNport->ntmode)
3038         {
3039                 iframe_t act;
3040                 /* L2 */
3041                 PDEBUG(DEBUG_ISDN, "sending short status request for port %d.\n", port);
3042                 act.prim = MGR_SHORTSTATUS | REQUEST;
3043                 act.addr = mISDNport->upper_id | MSG_BROADCAST;
3044                 act.dinfo = SSTATUS_BROADCAST_BIT | SSTATUS_ALL;
3045                 act.len = 0;
3046                 mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
3047         }
3048         /* if ptp AND te-mode, pull up the link */
3049         if (mISDNport->ptp && !mISDNport->ntmode)
3050         {
3051                 iframe_t act;
3052                 /* L2 */
3053                 act.prim = DL_ESTABLISH | REQUEST;
3054                 act.addr = (mISDNport->upper_id & ~LAYER_ID_MASK) | 4 | FLG_MSG_DOWN;
3055                 act.dinfo = 0;
3056                 act.len = 0;
3057                 mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
3058         }
3059         /* if ptp AND nt-mode, pull up the link */
3060         if (mISDNport->ptp && mISDNport->ntmode)
3061         {
3062                 msg_t *dmsg;
3063                 /* L2 */
3064                 dmsg = create_l2msg(DL_ESTABLISH | REQUEST, 0, 0);
3065                 if (mISDNport->nst.manager_l3(&mISDNport->nst, dmsg))
3066                         free_msg(dmsg);
3067         }
3068         /* initially, we assume that the link is down, exept for nt-ptmp */
3069         mISDNport->l2link = (mISDNport->ntmode && !mISDNport->ptp)?1:0;
3070
3071         PDEBUG(DEBUG_BCHANNEL, "using 'mISDN_dsp.o' module\n");
3072
3073         start_trace(mISDNport->portnum,
3074                     interface,
3075                     NULL,
3076                     NULL,
3077                     DIRECTION_NONE,
3078                     CATEGORY_CH,
3079                     0,
3080                     "PORT (open)");
3081         add_trace("channels", NULL, "%d", mISDNport->b_num);
3082         end_trace();
3083         return(mISDNport);
3084 }
3085
3086
3087 /*
3088  * function to free ALL cards (ports)
3089  */
3090 void mISDNport_close_all(void)
3091 {
3092         /* free all ports */
3093         while(mISDNport_first)
3094                 mISDNport_close(mISDNport_first);
3095 }
3096
3097 /*
3098  * free only one port
3099  */
3100 void mISDNport_close(struct mISDNport *mISDNport)
3101 {
3102         struct mISDNport **mISDNportp;
3103         class Port *port;
3104         class PmISDN *isdnport;
3105         net_stack_t *nst;
3106         unsigned char buf[32];
3107         int i;
3108
3109         /* remove all port instance that are linked to this mISDNport */
3110         port = port_first;
3111         while(port)
3112         {
3113                 if ((port->p_type&PORT_CLASS_MASK) == PORT_CLASS_mISDN)
3114                 {
3115                         isdnport = (class PmISDN *)port;
3116                         if (isdnport->p_m_mISDNport)
3117                         {
3118                                 PDEBUG(DEBUG_ISDN, "port %s uses mISDNport %d, destroying it.\n", isdnport->p_name, mISDNport->portnum);
3119                                 delete isdnport;
3120                         }
3121                 }
3122                 port = port->next;
3123         }
3124
3125         /* only if we are already part of interface */
3126         if (mISDNport->ifport)
3127         {
3128                 start_trace(mISDNport->portnum,
3129                             mISDNport->ifport->interface,
3130                             NULL,
3131                             NULL,
3132                             DIRECTION_NONE,
3133                             CATEGORY_CH,
3134                             0,
3135                             "PORT (close)");
3136                 end_trace();
3137         }
3138
3139         /* free bchannels */
3140         i = 0;
3141         while(i < mISDNport->b_num)
3142         {
3143                 if (mISDNport->b_addr[i])
3144                 {
3145                         _bchannel_destroy(mISDNport, i);
3146                         PDEBUG(DEBUG_BCHANNEL, "freeing %s port %d bchannel (index %d).\n", (mISDNport->ntmode)?"NT":"TE", mISDNport->portnum, i);
3147                 }
3148                 i++;
3149         }
3150
3151 #ifdef SOCKET_MISDN
3152         close_layer3(mISDNport->ml3);
3153 #else
3154         /* free ressources of port */
3155         msg_queue_purge(&mISDNport->downqueue);
3156
3157         /* free stacks */
3158         if (mISDNport->ntmode)
3159         {
3160                 nst = &mISDNport->nst;
3161                 if (nst->manager) /* to see if initialized */
3162                 {
3163                         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");
3164                         cleanup_Isdnl3(nst);
3165                         cleanup_Isdnl2(nst);
3166
3167                         /* phd */
3168                         msg_queue_purge(&nst->down_queue);
3169                         if (nst->phd_down_msg)
3170                                 FREE(nst->phd_down_msg, 0);
3171                 }
3172         }
3173
3174         PDEBUG(DEBUG_BCHANNEL, "freeing d-stack.\n");
3175         if (mISDNport->d_stid)
3176         {
3177                 if (mISDNport->upper_id)
3178                         mISDN_write_frame(mISDNdevice, buf, mISDNport->upper_id | FLG_MSG_DOWN, MGR_DELLAYER | REQUEST, 0, 0, NULL, TIMEOUT_1SEC);
3179         }
3180 #endif
3181
3182         /* remove from list */
3183         mISDNportp = &mISDNport_first;
3184         while(*mISDNportp)
3185         {
3186                 if (*mISDNportp == mISDNport)
3187                 {
3188                         *mISDNportp = (*mISDNportp)->next;
3189                         mISDNportp = NULL;
3190                         break;
3191                 }
3192                 mISDNportp = &((*mISDNportp)->next);
3193         }
3194
3195         if (mISDNportp)
3196                 FATAL("mISDNport not in list\n");
3197
3198         FREE(mISDNport, sizeof(struct mISDNport));
3199         pmemuse--;
3200
3201 }
3202
3203
3204 /*
3205  * global function to show all available isdn ports
3206  */
3207 void mISDN_port_info(void)
3208 {
3209         int ret;
3210         int i, ii, p;
3211         int useable, nt, te, pri, bri, pots;
3212         unsigned char buff[1025];
3213         iframe_t *frm = (iframe_t *)buff;
3214 #ifdef SOCKET_MISDN
3215         struct mISDN_devinfo devinfo;
3216         int socket;
3217
3218         /* open mISDN */
3219         socket = socket(PF_ISDN, SOCK_RAW, ISDN_P_BASE);
3220         if (socket < 0)
3221         {
3222                 fprintf(stderr, "Cannot open mISDN due to %s. (Does your Kernel support socket based mISDN?)\n", strerror(errno));
3223                 exit(EXIT_FAILURE);
3224         }
3225
3226         /* get number of stacks */
3227         i = 1;
3228         ret = ioctl(socket, IMGETCOUNT, &ii);
3229         if (ret < 0)
3230         {
3231                 fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret);
3232                 goto done;
3233         }
3234 #else
3235         stack_info_t *stinf;
3236         int device;
3237
3238         /* open mISDN */
3239         if ((device = mISDN_open()) < 0)
3240         {
3241                 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));
3242                 exit(EXIT_FAILURE);
3243         }
3244
3245         /* get number of stacks */
3246         i = 1;
3247         ii = mISDN_get_stack_count(device);
3248 #endif
3249         printf("\n");
3250         if (ii <= 0)
3251         {
3252                 printf("Found no card. Please be sure to load card drivers.\n");
3253                 goto done;
3254         }
3255
3256         /* loop the number of cards and get their info */
3257         while(i <= ii)
3258         {
3259                 nt = te = bri = pri = pots = 0;
3260                 useable = 0;
3261
3262 #ifdef SOCKET_MISDN
3263                 devinfo.id = i - 1;
3264                 ret = ioctl(socket, IMGETDEVINFO, &devinfo);
3265                 if (ret <= 0)
3266                 {
3267                         fprintf(stderr, "Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", i, ret);
3268                         break;
3269                 }
3270
3271                 /* output the port info */
3272                 printf("Port %2d name='%s': ", i, devinfo.name);
3273                 if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0))
3274                 {
3275                         bri = 1;
3276                         te = 1;
3277                 }
3278                 if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0))
3279                 {
3280                         bri = 1;
3281                         nt = 1;
3282                 }
3283 #ifdef ISDN_P_TE_E1
3284                 if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1))
3285                 {
3286                         pri = 1;
3287                         te = 1;
3288                 }
3289 #endif
3290 #ifdef ISDN_P_NT_E1
3291                 if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1))
3292                 {
3293                         pri = 1;
3294                         nt = 1;
3295                 }
3296 #endif
3297 #ifdef ISDN_P_FXS
3298                 if (devinfo.Dprotocols & (1 << ISDN_P_FXS))
3299                 {
3300                         pots = 1;
3301                         te = 1;
3302                 }
3303 #endif
3304 #ifdef ISDN_P_FXO
3305                 if (devinfo.Dprotocols & (1 << ISDN_P_FXO))
3306                 {
3307                         pots = 1;
3308                         nt = 1;
3309                 }
3310 #endif
3311                 if ((te || nt) && (bri || pri || ports))
3312                         usable = 1;
3313
3314                 if (te && bri)
3315                         printf("TE-mode BRI S/T interface line (for phone lines)");
3316                 if (nt && bri)
3317                         printf("NT-mode BRI S/T interface port (for phones)");
3318                 if (te && pri)
3319                         printf("TE-mode PRI E1  interface line (for phone lines)");
3320                 if (nt && pri)
3321                         printf("NT-mode PRI E1  interface port (for E1 terminals)");
3322                 if (te && pots)
3323                         printf("FXS     POTS    interface port (for analog lines)");
3324                 if (nt && pots)
3325                         printf("FXO     POTS    interface port (for analog phones)");
3326                 if (ports)
3327                 {
3328                         usable = 0;
3329                         printf("\n -> Analog interfaces are not supported.");
3330                 } else
3331                 if (!usable)
3332                 {
3333                         printf("unsupported interface protocol bits 0x%016x", devinfo.Dprotocols);
3334                 }
3335                 printf("\n");
3336
3337                 printf("  - %d B-channels\n", devinfo.nfbchan);
3338 #else
3339                 ret = mISDN_get_stack_info(device, i, buff, sizeof(buff));
3340                 if (ret <= 0)
3341                 {
3342                         fprintf(stderr, "mISDN_get_stack_info() failed: port=%d error=%d\n", i, ret);
3343                         break;
3344                 }
3345                 stinf = (stack_info_t *)&frm->data.p;
3346
3347                 /* output the port info */
3348                 printf("Port %2d: ", i);
3349                 switch(stinf->pid.protocol[0] & ~ISDN_PID_FEATURE_MASK)
3350                 {
3351                         case ISDN_PID_L0_TE_S0:
3352                         useable = 1;
3353                         te = 1;
3354                         bri = 1;
3355                         printf("TE-mode BRI S/T interface line (for phone lines)");
3356                         break;
3357                         case ISDN_PID_L0_NT_S0:
3358                         useable = 1;
3359                         nt = 1;
3360                         bri = 1;
3361                         printf("NT-mode BRI S/T interface port (for phones)");
3362                         break;
3363                         case ISDN_PID_L0_TE_E1:
3364                         useable = 1;
3365                         te = 1;
3366                         pri = 1;
3367                         printf("TE-mode PRI E1  interface line (for phone lines)");
3368                         break;
3369                         case ISDN_PID_L0_NT_E1:
3370                         useable = 1;
3371                         nt = 1;
3372                         pri = 1;
3373                         printf("NT-mode PRI E1  interface port (for E1 terminals)");
3374                         break;
3375                         default:
3376                         useable = 0;
3377                         printf("unknown type 0x%08x",stinf->pid.protocol[0]);
3378                 }
3379                 printf("\n");
3380
3381                 if (nt)
3382                 {
3383                         if (stinf->pid.protocol[1] == 0)
3384                         {
3385                                 useable = 0;
3386                                 printf(" -> Missing layer 1 NT-mode protocol.\n");
3387                         }
3388                         p = 2;
3389                         while(p <= MAX_LAYER_NR) {
3390                                 if (stinf->pid.protocol[p])
3391                                 {
3392                                         useable = 0;
3393                                         printf(" -> Layer %d protocol 0x%08x is detected, port already in use by another application.\n", p, stinf->pid.protocol[p]);
3394                                 }
3395                                 p++;
3396                         }
3397                         if (useable)
3398                         {
3399                                 if (pri)
3400                                         printf(" -> Interface is Point-To-Point (PRI).\n");
3401                                 else
3402                                         printf(" -> Interface can be Poin-To-Point/Multipoint.\n");
3403                         }
3404                 }
3405                 if (te)
3406                 {
3407                         if (stinf->pid.protocol[1] == 0)
3408                         {
3409                                 useable = 0;
3410                                 printf(" -> Missing layer 1 protocol.\n");
3411                         }
3412                         if (stinf->pid.protocol[2] == 0)
3413                         {
3414                                 useable = 0;
3415                                 printf(" -> Missing layer 2 protocol.\n");
3416                         }
3417                         if (stinf->pid.protocol[2] & ISDN_PID_L2_DF_PTP)
3418                         {
3419                                 printf(" -> Interface is Poin-To-Point.\n");
3420                         }
3421                         if (stinf->pid.protocol[3] == 0)
3422                         {
3423                                 useable = 0;
3424                                 printf(" -> Missing layer 3 protocol.\n");
3425                         } else
3426                         {
3427                                 printf(" -> Protocol: ");
3428                                 switch(stinf->pid.protocol[3] & ~ISDN_PID_FEATURE_MASK)
3429                                 {
3430                                         case ISDN_PID_L3_DSS1USER:
3431                                         printf("DSS1 (Euro ISDN)");
3432                                         break;
3433
3434                                         default:
3435                                         useable = 0;
3436                                         printf("unknown protocol 0x%08x",stinf->pid.protocol[3]);
3437                                 }
3438                                 printf("\n");
3439                         }
3440                         p = 4;
3441                         while(p <= MAX_LAYER_NR) {
3442                                 if (stinf->pid.protocol[p])
3443                                 {
3444                                         useable = 0;
3445                                         printf(" -> Layer %d protocol 0x%08x is detected, port already in use by another application.\n", p, stinf->pid.protocol[p]);
3446                                 }
3447                                 p++;
3448                         }
3449                 }
3450                 printf("  - %d B-channels\n", stinf->childcnt);
3451 #endif
3452
3453                 if (!useable)
3454                         printf(" * Port NOT useable for LCR\n");
3455
3456                 printf("--------\n");
3457
3458                 i++;
3459         }
3460         printf("\n");
3461
3462 done:
3463 #ifdef SOCKET_MISDN
3464         close(sd);
3465 #else
3466         /* close mISDN */
3467         if ((ret = mISDN_close(device)))
3468                 FATAL("mISDN_close() failed: err=%d '%s'\n", ret, strerror(ret));
3469 #endif
3470 }
3471
3472
3473 /*
3474  * enque data from upper buffer
3475  */
3476 void PmISDN::txfromup(unsigned char *data, int length)
3477 {
3478 #ifdef SOCKET_MISDN
3479         unsigned char buf[MISDN_HEADER_LEN+((length>ISDN_LOAD)?length:ISDN_LOAD)];
3480         struct mISDNhead *frm = (struct mISDNhead *)buf;
3481
3482         if (p_m_b_index < 0)
3483                 return;
3484         if (!p_m_mISDNport->b_socket[p_m_b_index])
3485                 return;
3486 #else
3487         unsigned char buf[mISDN_HEADER_LEN+((length>ISDN_LOAD)?length:ISDN_LOAD)];
3488         iframe_t *frm = (iframe_t *)buf;
3489
3490         if (p_m_b_index < 0)
3491                 return;
3492         if (!p_m_mISDNport->b_addr[p_m_b_index])
3493                 return;
3494 #endif
3495
3496         /* check if high priority tones exist
3497          * ignore data in this case
3498          */
3499         if (p_tone_name[0] || p_m_crypt_msg_loops)
3500                 return;
3501
3502         /* preload procedure
3503          * if transmit buffer in DSP module is empty,
3504          * preload it to DSP_LOAD to prevent jitter gaps.
3505          */
3506         if (p_m_load==0 && ISDN_LOAD>0)
3507         {
3508
3509                 memcpy(buf+mISDN_HEADER_LEN, data, ISDN_LOAD);
3510                 frm->len = ISDN_LOAD;
3511                 mISDN_write(mISDNdevice, frm, mISDN_HEADER_LEN+frm->len, TIMEOUT_1SEC);
3512                 p_m_load += frm->len;
3513         }
3514
3515         /* drop if load would exceed ISDN_MAXLOAD
3516          * this keeps the delay not too high
3517          */
3518         if (p_m_load+length > ISDN_MAXLOAD)
3519                 return;
3520
3521         /* make and send frame */
3522 #ifdef SOCKET_MISDN
3523         frm->prim = DL_DATA_REQ;
3524         frm->id = 0;
3525         memcpy(buf+MISDN_HEADER_LEN, data, length);
3526         ret = sendto(p_m_mISDNport->b_socket[p_m_b_index], buf, MISDN_HEADER_LEN+length, 0, NULL, 0);
3527         if (!ret)
3528                 PERROR("Failed to send to socket %d\n", handle);
3529 #else
3530         frm->prim = DL_DATA | REQUEST;
3531         frm->addr = p_m_mISDNport->b_addr[p_m_b_index] | FLG_MSG_DOWN;
3532         frm->dinfo = 0;
3533         frm->len = length;
3534         memcpy(buf+mISDN_HEADER_LEN, data, length);
3535         mISDN_write(mISDNdevice, frm, mISDN_HEADER_LEN+frm->len, TIMEOUT_1SEC);
3536 #endif
3537         p_m_load += length;
3538 }
3539