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 <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 handle = mISDNport->b_addr[i];
 784 #else
 785         int handle = 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, handle);
 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("stack", "address", "%x", handle);
 811 #else
 812                                 add_trace("socket", "id", "%d", handle);
 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, handle);
 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("stack", "address", "%x", handle);
 866 #else
 867                         add_trace("socket", "id", "%d", handle);
 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, handle);
 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("stack", "address", "%x", handle);
 941 #else
 942                                 add_trace("socket", "id", "%d", handle);
 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, handle);
 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("stack", "address", "%x", handle);
 981 #else
 982                         add_trace("socket", "id", "%d", handle);
 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, handle);
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("stack", "address", "%x", handle);
1018 #else
1019                                         add_trace("socket", "id", "%d", handle);
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, handle);
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("stack", "address", "%x", handle);
1058 #else
1059                                         add_trace("socket", "id", "%d", handle);
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 (mISDNport->b_addr[i] == 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                         case CMX_TX_DATA:
1536                         if (!p_m_txdata)
1537                         {
1538                                 /* if tx is off, it may happen that fifos send us pending informations, we just ignore them */
1539                                 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring tx data, because 'txdata' is turned off\n", p_name);
1540                                 return;
1541                         }
1542                         if (p_record)
1543                                 record((unsigned char *)(cont+1), len - 4, 1); // from up
1544                         break;
1545
1546                         default:
1547                         chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1548                         add_trace("unknown", NULL, "0x%x", cont);
1549                         end_trace();
1550                 }
1551                 return;
1552         }
1553 #ifdef SOCKET_MISDN
1554         if (hh->prim != PH_DATA_IND && hh->prim != DL_DATA_IND)
1555         {
1556                 PERROR("Bchannel received unknown primitve: 0x%x\n", hh->prim);
1557 #else
1558         if (frm->prim != (PH_DATA | INDICATION) && frm->prim != (DL_DATA | INDICATION))
1559         {
1560                 PERROR("Bchannel received unknown primitve: 0x%x\n", frm->prim);
1561 #endif
1562                 return;
1563         }
1564
1565         /* calls will not process any audio data unless
1566          * the call is connected OR interface features audio during call setup.
1567          */
1568 //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);
1569 #ifndef DEBUG_COREBRIDGE
1570         if (p_state!=PORT_STATE_CONNECT
1571          && !p_m_mISDNport->earlyb)
1572                 return;
1573 #endif
1574
1575         /* if rx is off, it may happen that fifos send us pending informations, we just ignore them */
1576         if (p_m_rxoff)
1577         {
1578                 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring data, because rx is turned off\n", p_name);
1579                 return;
1580         }
1581
1582         /* record data */
1583         if (p_record)
1584                 record(data, len, 0); // from down
1585
1586         /* randomize and listen to crypt message if enabled */
1587         if (p_m_crypt_listen)
1588         {
1589                 /* the noisy randomizer */
1590                 p = data;
1591                 l = len;
1592                 while(l--)
1593                         mISDN_rand[mISDN_rand_count & 0xff] += *p++;
1594
1595                 cryptman_listen_bch(data, len);
1596         }
1597
1598         p = data;
1599
1600         /* send data to epoint */
1601         if (p_m_joindata && ACTIVE_EPOINT(p_epointlist)) /* only if we have an epoint object */
1602         {
1603                 length_temp = len;
1604                 data_temp = p;
1605                 while(length_temp)
1606                 {
1607                         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_DATA);
1608                         message->param.data.len = (length_temp>sizeof(message->param.data.data))?sizeof(message->param.data.data):length_temp;
1609                         memcpy(message->param.data.data, data_temp, message->param.data.len);
1610                         message_put(message);
1611                         if (length_temp <= sizeof(message->param.data.data))
1612                                 break;
1613                         data_temp += sizeof(message->param.data.data);
1614                         length_temp -= sizeof(message->param.data.data);
1615                 }
1616         }
1617 }
1618
1619
1620 /*
1621  * set echotest
1622  */
1623 void PmISDN::set_echotest(int echo)
1624 {
1625         if (p_m_echo != echo)
1626         {
1627                 p_m_echo = echo;
1628                 PDEBUG(DEBUG_ISDN, "we set echo to echo=%d.\n", p_m_echo);
1629                 if (p_m_b_channel)
1630                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1631 #ifdef SOCKET_MISDN
1632                                 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);
1633 #else
1634                                 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);
1635 #endif
1636         }
1637 }
1638
1639 /*
1640  * set tone
1641  */
1642 void PmISDN::set_tone(char *dir, char *tone)
1643 {
1644         int id;
1645
1646         if (!tone)
1647                 tone = "";
1648         PDEBUG(DEBUG_ISDN, "isdn port now plays tone:'%s'.\n", tone);
1649         if (!tone[0])
1650         {
1651                 id = TONE_OFF;
1652                 goto setdsp;
1653         }
1654
1655         /* check if we NOT really have to use a dsp-tone */
1656         if (!options.dsptones)
1657         {
1658                 nodsp:
1659                 if (p_m_tone)
1660                 if (p_m_b_index >= 0)
1661                 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1662                 {
1663                         PDEBUG(DEBUG_ISDN, "we reset tone from id=%d to OFF.\n", p_m_tone);
1664 #ifdef SOCKET_MISDN
1665                         ph_control(p_m_mISDNport, this, p_m_mISDNport->b_socket[p_m_b_index], TONE_PATT_OFF, 0, "DSP-TONE", 0);
1666 #else
1667                         ph_control(p_m_mISDNport, this, p_m_mISDNport->b_addr[p_m_b_index], TONE_PATT_OFF, 0, "DSP-TONE", 0);
1668 #endif
1669                 }
1670                 p_m_tone = 0;
1671                 Port::set_tone(dir, tone);
1672                 return;
1673         }
1674         if (p_tone_dir[0])
1675                 goto nodsp;
1676
1677         /* now we USE dsp-tone, convert name */
1678         else if (!strcmp(tone, "dialtone"))
1679         {
1680                 switch(options.dsptones) {
1681                 case DSP_AMERICAN: id = TONE_AMERICAN_DIALTONE; break;
1682                 case DSP_GERMAN: id = TONE_GERMAN_DIALTONE; break;
1683                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALTONE; break;
1684                 }
1685         } else if (!strcmp(tone, "dialpbx"))
1686         {
1687                 switch(options.dsptones) {
1688                 case DSP_AMERICAN: id = TONE_AMERICAN_DIALPBX; break;
1689                 case DSP_GERMAN: id = TONE_GERMAN_DIALPBX; break;
1690                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALPBX; break;
1691                 }
1692         } else if (!strcmp(tone, "ringing"))
1693         {
1694                 switch(options.dsptones) {
1695                 case DSP_AMERICAN: id = TONE_AMERICAN_RINGING; break;
1696                 case DSP_GERMAN: id = TONE_GERMAN_RINGING; break;
1697                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGING; break;
1698                 }
1699         } else if (!strcmp(tone, "ringpbx"))
1700         {
1701                 switch(options.dsptones) {
1702                 case DSP_AMERICAN: id = TONE_AMERICAN_RINGPBX; break;
1703                 case DSP_GERMAN: id = TONE_GERMAN_RINGPBX; break;
1704                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGPBX; break;
1705                 }
1706         } else if (!strcmp(tone, "busy"))
1707         {
1708                 busy:
1709                 switch(options.dsptones) {
1710                 case DSP_AMERICAN: id = TONE_AMERICAN_BUSY; break;
1711                 case DSP_GERMAN: id = TONE_GERMAN_BUSY; break;
1712                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1713                 }
1714         } else if (!strcmp(tone, "release"))
1715         {
1716                 hangup:
1717                 switch(options.dsptones) {
1718                 case DSP_AMERICAN: id = TONE_AMERICAN_HANGUP; break;
1719                 case DSP_GERMAN: id = TONE_GERMAN_HANGUP; break;
1720                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDHANGUP; break;
1721                 }
1722         } else if (!strcmp(tone, "cause_10"))
1723                 goto hangup;
1724         else if (!strcmp(tone, "cause_11"))
1725                 goto busy;
1726         else if (!strcmp(tone, "cause_22"))
1727         {
1728                 switch(options.dsptones) {
1729                 case DSP_AMERICAN: id = TONE_SPECIAL_INFO; break;
1730                 case DSP_GERMAN: id = TONE_GERMAN_GASSENBESETZT; break;
1731                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1732                 }
1733         } else if (!strncmp(tone, "cause_", 6))
1734                 id = TONE_SPECIAL_INFO;
1735         else
1736                 id = TONE_OFF;
1737
1738         /* if we have a tone that is not supported by dsp */
1739         if (id==TONE_OFF && tone[0])
1740                 goto nodsp;
1741
1742         setdsp:
1743         if (p_m_tone != id)
1744         {
1745                 /* set new tone */
1746                 p_m_tone = id;
1747                 PDEBUG(DEBUG_ISDN, "we set tone to id=%d.\n", p_m_tone);
1748                 if (p_m_b_index >= 0)
1749                 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1750 #ifdef SOCKET_MISDN
1751                         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);
1752 #else
1753                         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);
1754 #endif
1755         }
1756         /* turn user-space tones off in cases of no tone OR dsp tone */
1757         Port::set_tone("",NULL);
1758 }
1759
1760
1761 /* MESSAGE_mISDNSIGNAL */
1762 //extern struct message *dddebug;
1763 void PmISDN::message_mISDNsignal(unsigned long epoint_id, int message_id, union parameter *param)
1764 {
1765         switch(param->mISDNsignal.message)
1766         {
1767                 case mISDNSIGNAL_VOLUME:
1768                 if (p_m_txvol != param->mISDNsignal.txvol)
1769                 {
1770                         p_m_txvol = param->mISDNsignal.txvol;
1771                         PDEBUG(DEBUG_BCHANNEL, "we change tx-volume to shift=%d.\n", p_m_txvol);
1772                         if (p_m_b_index >= 0)
1773                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1774 #ifdef SOCKET_MISDN
1775                                 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);
1776 #else
1777                                 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);
1778 #endif
1779                 } else
1780                         PDEBUG(DEBUG_BCHANNEL, "we already have tx-volume shift=%d.\n", p_m_rxvol);
1781                 if (p_m_rxvol != param->mISDNsignal.rxvol)
1782                 {
1783                         p_m_rxvol = param->mISDNsignal.rxvol;
1784                         PDEBUG(DEBUG_BCHANNEL, "we change rx-volume to shift=%d.\n", p_m_rxvol);
1785                         if (p_m_b_index >= 0)
1786                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1787 #ifdef SOCKET_MISDN
1788                                 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);
1789 #else
1790                                 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);
1791 #endif
1792                 } else
1793                         PDEBUG(DEBUG_BCHANNEL, "we already have rx-volume shift=%d.\n", p_m_rxvol);
1794                 break;
1795
1796                 case mISDNSIGNAL_CONF:
1797 //if (dddebug) PDEBUG(DEBUG_ISDN, "dddebug = %d\n", dddebug->type);
1798 //tone          if (!p_m_tone && p_m_conf!=param->mISDNsignal.conf)
1799                 if (p_m_conf != param->mISDNsignal.conf)
1800                 {
1801                         p_m_conf = param->mISDNsignal.conf;
1802                         PDEBUG(DEBUG_BCHANNEL, "we change conference to conf=%d.\n", p_m_conf);
1803                         if (p_m_b_index >= 0)
1804                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1805 #ifdef SOCKET_MISDN
1806                                 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);
1807 #else
1808                                 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);
1809 #endif
1810                 } else
1811                         PDEBUG(DEBUG_BCHANNEL, "we already have conf=%d.\n", p_m_conf);
1812                 /* we must set, even if currently tone forbids conf */
1813                 p_m_conf = param->mISDNsignal.conf;
1814 //if (dddebug) PDEBUG(DEBUG_ISDN, "dddebug = %d\n", dddebug->type);
1815                 break;
1816
1817                 case mISDNSIGNAL_JOINDATA:
1818                 if (p_m_joindata != param->mISDNsignal.joindata)
1819                 {
1820                         p_m_joindata = param->mISDNsignal.joindata;
1821                         PDEBUG(DEBUG_BCHANNEL, "we change to joindata=%d.\n", p_m_joindata);
1822                 } else
1823                         PDEBUG(DEBUG_BCHANNEL, "we already have joindata=%d.\n", p_m_joindata);
1824                 break;
1825
1826                 case mISDNSIGNAL_DELAY:
1827                 if (p_m_delay != param->mISDNsignal.delay)
1828                 {
1829                         p_m_delay = param->mISDNsignal.delay;
1830                         PDEBUG(DEBUG_BCHANNEL, "we change delay mode to delay=%d.\n", p_m_delay);
1831                         if (p_m_b_index >= 0)
1832                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1833 #ifdef SOCKET_MISDN
1834                                 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);
1835 #else
1836                                 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);
1837 #endif
1838                 } else
1839                         PDEBUG(DEBUG_BCHANNEL, "we already have delay=%d.\n", p_m_delay);
1840                 break;
1841
1842                 default:
1843                 PERROR("PmISDN(%s) unsupported signal message %d.\n", p_name, param->mISDNsignal.message);
1844         }
1845 }
1846
1847 /* MESSAGE_CRYPT */
1848 void PmISDN::message_crypt(unsigned long epoint_id, int message_id, union parameter *param)
1849 {
1850         struct message *message;
1851
1852         switch(param->crypt.type)
1853         {
1854                 case CC_ACTBF_REQ:           /* activate blowfish */
1855                 p_m_crypt = 1;
1856                 p_m_crypt_key_len = param->crypt.len;
1857                 if (p_m_crypt_key_len > (int)sizeof(p_m_crypt_key))
1858                 {
1859                         PERROR("PmISDN(%s) key too long %d > %d\n", p_name, p_m_crypt_key_len, sizeof(p_m_crypt_key));
1860                         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1861                         message->param.crypt.type = CC_ERROR_IND;
1862                         message_put(message);
1863                         break;
1864                 }
1865                 memcpy(p_m_crypt_key, param->crypt.data, p_m_crypt_key_len);
1866                 crypt_off:
1867                 PDEBUG(DEBUG_BCHANNEL, "we set encryption to crypt=%d. (0 means OFF)\n", p_m_crypt);
1868                 if (p_m_b_index >= 0)
1869                 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1870 #ifdef SOCKET_MISDN
1871                         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);
1872 #else
1873                         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);
1874 #endif
1875                 break;
1876
1877                 case CC_DACT_REQ:            /* deactivate session encryption */
1878                 p_m_crypt = 0;
1879                 goto crypt_off;
1880                 break;
1881
1882                 case CR_LISTEN_REQ:          /* start listening to messages */
1883                 p_m_crypt_listen = 1;
1884                 p_m_crypt_listen_state = 0;
1885                 break;
1886
1887                 case CR_UNLISTEN_REQ:        /* stop listening to messages */
1888                 p_m_crypt_listen = 0;
1889                 break;
1890
1891                 case CR_MESSAGE_REQ:         /* send message */
1892                 p_m_crypt_msg_len = cryptman_encode_bch(param->crypt.data, param->crypt.len, p_m_crypt_msg, sizeof(p_m_crypt_msg));
1893                 if (!p_m_crypt_msg_len)
1894                 {
1895                         PERROR("PmISDN(%s) message too long %d > %d\n", p_name, param->crypt.len-1, sizeof(p_m_crypt_msg));
1896                         break;
1897                 }
1898                 p_m_crypt_msg_current = 0; /* reset */
1899                 p_m_crypt_msg_loops = 3; /* enable */
1900 #if 0
1901                 /* disable txmix, or we get corrupt data due to audio process */
1902                 if (p_m_txmix && p_m_b_index>=0)
1903                 {
1904                         PDEBUG(DEBUG_BCHANNEL, "for sending CR_MESSAGE_REQ, we reset txmix from txmix=%d.\n", p_m_txmix);
1905 #ifdef SOCKET_MISDN
1906                         ph_control(p_m_mISDNport, this, p_mISDNport->b_socket[p_m_b_index], CMX_MIX_OFF, 0, "DSP-TXMIX", 0);
1907 #else
1908                         ph_control(p_m_mISDNport, this, p_mISDNport->b_addr[p_m_b_index], CMX_MIX_OFF, 0, "DSP-TXMIX", 0);
1909 #endif
1910                 }
1911 #endif
1912                 break;
1913
1914                 default:
1915                 PERROR("PmISDN(%s) unknown crypt message %d\n", p_name, param->crypt.type);
1916         }
1917
1918 }
1919
1920 /*
1921  * endpoint sends messages to the port
1922  */
1923 int PmISDN::message_epoint(unsigned long epoint_id, int message_id, union parameter *param)
1924 {
1925         if (Port::message_epoint(epoint_id, message_id, param))
1926                 return(1);
1927
1928         switch(message_id)
1929         {
1930                 case MESSAGE_DATA: /* tx-data from upper layer */
1931                 txfromup(param->data.data, param->data.len);
1932                 return(1);
1933
1934                 case MESSAGE_mISDNSIGNAL: /* user command */
1935                 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received special ISDN SIGNAL %d.\n", p_name, param->mISDNsignal.message);
1936                 message_mISDNsignal(epoint_id, message_id, param);
1937                 return(1);
1938
1939                 case MESSAGE_CRYPT: /* crypt control command */
1940                 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received encryption command '%d'.\n", p_name, param->crypt.type);
1941                 message_crypt(epoint_id, message_id, param);
1942                 return(1);
1943         }
1944
1945         return(0);
1946 }
1947
1948
1949 /*
1950  * main loop for processing messages from mISDN device
1951  */
1952 int mISDN_handler(void)
1953 {
1954         int ret;
1955         msg_t *msg;
1956         iframe_t *frm;
1957         struct mISDNport *mISDNport;
1958         class PmISDN *isdnport;
1959         net_stack_t *nst;
1960         msg_t *dmsg;
1961         mISDNuser_head_t *hh;
1962         int i;
1963
1964         /* the que avoids loopbacks when replying to stack after receiving
1965          * from stack. */
1966         mISDNport = mISDNport_first;
1967         while(mISDNport)
1968         {
1969                 /* process turning on/off rx */
1970                 i = 0;
1971                 while(i < mISDNport->b_num)
1972                 {
1973                         isdnport=mISDNport->b_port[i];
1974                         if (isdnport)
1975                         {
1976                                 /* call bridges in user space OR crypto OR recording */
1977                                 if (isdnport->p_m_joindata || isdnport->p_m_crypt_msg_loops || isdnport->p_m_crypt_listen || isdnport->p_record)
1978                                 {
1979                                         /* rx IS required */
1980                                         if (isdnport->p_m_rxoff)
1981                                         {
1982                                                 /* turn on RX */
1983                                                 isdnport->p_m_rxoff = 0;
1984                                                 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is required, so we turn them on\n");
1985                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
1986                                                         ph_control(mISDNport, isdnport, mISDNport->b_addr[isdnport->p_m_b_index], CMX_RECEIVE_ON, 0, "DSP-RXOFF", 0);
1987                                                 return(1);
1988                                         }
1989                                 } else
1990                                 {
1991                                         /* rx NOT required */
1992                                         if (!isdnport->p_m_rxoff)
1993                                         {
1994                                                 /* turn off RX */
1995                                                 isdnport->p_m_rxoff = 1;
1996                                                 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is not required, so we turn them off\n");
1997                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
1998                                                         ph_control(mISDNport, isdnport, mISDNport->b_addr[isdnport->p_m_b_index], CMX_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
1999                                                 return(1);
2000                                         }
2001                                 }
2002                                 /* recording */
2003                                 if (isdnport->p_record)
2004                                 {
2005                                         /* txdata IS required */
2006                                         if (!isdnport->p_m_txdata)
2007                                         {
2008                                                 /* turn on RX */
2009                                                 isdnport->p_m_txdata = 1;
2010                                                 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is required, so we turn them on\n");
2011                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
2012                                                         ph_control(mISDNport, isdnport, mISDNport->b_addr[isdnport->p_m_b_index], CMX_TXDATA_ON, 0, "DSP-TXDATA", 1);
2013                                                 return(1);
2014                                         }
2015                                 } else
2016                                 {
2017                                         /* txdata NOT required */
2018                                         if (isdnport->p_m_txdata)
2019                                         {
2020                                                 /* turn off RX */
2021                                                 isdnport->p_m_txdata = 0;
2022                                                 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is not required, so we turn them off\n");
2023                                                 if (mISDNport->b_port[i] && mISDNport->b_state[i] == B_STATE_ACTIVE)
2024                                                         ph_control(mISDNport, isdnport, mISDNport->b_addr[isdnport->p_m_b_index], CMX_TXDATA_OFF, 0, "DSP-TXDATA", 0);
2025                                                 return(1);
2026                                         }
2027                                 }
2028                         }
2029                         i++;
2030                 }
2031 #if 0
2032                 if (mISDNport->l1timeout && now>mISDNport->l1timeout)
2033                 {
2034                         PDEBUG(DEBUG_ISDN, "the L1 establish timer expired, we release all pending messages.\n", mISDNport->portnum);
2035                         mISDNport->l1timeout = 0;
2036 #endif
2037
2038                 if (mISDNport->l2establish)
2039                 {
2040                         if (now-mISDNport->l2establish > 5)
2041                         {
2042                                 if (mISDNport->ntmode)
2043                                 {
2044                                         PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link NT portnum=%d.\n", mISDNport->portnum);
2045                                         time(&mISDNport->l2establish);
2046                                         /* establish */
2047                                         dmsg = create_l2msg(DL_ESTABLISH | REQUEST, 0, 0);
2048                                         if (mISDNport->nst.manager_l3(&mISDNport->nst, dmsg))
2049                                                 free_msg(dmsg);
2050                                 } else {
2051                                         PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link TE portnum=%d.\n", mISDNport->portnum);
2052                                         time(&mISDNport->l2establish);
2053                                         /* establish */
2054                                         iframe_t act;
2055                                         act.prim = DL_ESTABLISH | REQUEST;
2056                                         act.addr = (mISDNport->upper_id & ~LAYER_ID_MASK) | 3 | FLG_MSG_DOWN;
2057                                         act.dinfo = 0;
2058                                         act.len = 0;
2059                                         mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
2060                                 }
2061                                 l1l2l3_trace_header(mISDNport, NULL, DL_ESTABLISH | REQUEST, DIRECTION_OUT);
2062                                 end_trace();
2063                                 return(1);
2064                         }
2065                 }
2066                 if ((dmsg = msg_dequeue(&mISDNport->downqueue)))
2067                 {
2068                         if (mISDNport->ntmode)
2069                         {
2070                                 hh = (mISDNuser_head_t *)dmsg->data;
2071                                 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);
2072                                 if (mISDNport->nst.manager_l3(&mISDNport->nst, dmsg))
2073                                         free_msg(dmsg);
2074                         } else
2075                         {
2076                                 frm = (iframe_t *)dmsg->data;
2077                                 frm->addr = mISDNport->upper_id | FLG_MSG_DOWN;
2078                                 frm->len = (dmsg->len) - mISDN_HEADER_LEN;
2079                                 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);
2080                                 mISDN_write(mISDNdevice, dmsg->data, dmsg->len, TIMEOUT_1SEC);
2081                                 free_msg(dmsg);
2082                         }
2083                         return(1);
2084                 }
2085                 mISDNport = mISDNport->next;
2086         }
2087
2088         /* no device, no read */
2089         if (mISDNdevice < 0)
2090                 return(0);
2091
2092         /* get message from kernel */
2093         if (!(msg = alloc_msg(MAX_MSG_SIZE)))
2094                 return(1);
2095         ret = mISDN_read(mISDNdevice, msg->data, MAX_MSG_SIZE, 0);
2096         if (ret < 0)
2097         {
2098                 free_msg(msg);
2099                 if (errno == EAGAIN)
2100                         return(0);
2101                 FATAL("Failed to do mISDN_read()\n");
2102         }
2103         if (!ret)
2104         {
2105                 free_msg(msg);
2106 //              printf("%s: ERROR: mISDN_read() returns nothing\n");
2107                 return(0);
2108         }
2109         msg->len = ret;
2110         frm = (iframe_t *)msg->data;
2111
2112         /* global prim */
2113         switch(frm->prim)
2114         {
2115                 case MGR_DELLAYER | CONFIRM:
2116                 case MGR_INITTIMER | CONFIRM:
2117                 case MGR_ADDTIMER | CONFIRM:
2118                 case MGR_DELTIMER | CONFIRM:
2119                 case MGR_REMOVETIMER | CONFIRM:
2120                 free_msg(msg);
2121                 return(1);
2122         }
2123
2124         /* handle timer events from mISDN for NT-stack
2125          * note: they do not associate with a stack */
2126         if (frm->prim == (MGR_TIMER | INDICATION))
2127         {
2128                 itimer_t *it;
2129
2130                 /* find mISDNport */
2131                 mISDNport = mISDNport_first;
2132                 while(mISDNport)
2133                 {
2134                         /* nt mode only */
2135                         if (mISDNport->ntmode)
2136                         {
2137                                 it = mISDNport->nst.tlist;
2138                                 /* find timer */
2139                                 while(it)
2140                                 {
2141                                         if (it->id == (int)frm->addr)
2142                                                 break;
2143                                         it = it->next;
2144                                 }
2145                                 if (it)
2146                                         break;
2147                         }
2148                         mISDNport = mISDNport->next;
2149                 }
2150                 if (mISDNport)
2151                 {
2152                         mISDN_write_frame(mISDNdevice, msg->data, mISDNport->upper_id | FLG_MSG_DOWN,
2153                                 MGR_TIMER | RESPONSE, 0, 0, NULL, TIMEOUT_1SEC);
2154
2155                         PDEBUG(DEBUG_ISDN, "timer-indication port %d it=%p\n", mISDNport->portnum, it);
2156                         test_and_clear_bit(FLG_TIMER_RUNING, (long unsigned int *)&it->Flags);
2157                         ret = it->function(it->data);
2158                 } else
2159                 {
2160                         PDEBUG(DEBUG_ISDN, "timer-indication not handled\n");
2161                 }
2162                 goto out;
2163         }
2164
2165         /* find the mISDNport that belongs to the stack */
2166         mISDNport = mISDNport_first;
2167         while(mISDNport)
2168         {
2169                 if ((frm->addr&MASTER_ID_MASK) == (unsigned int)(mISDNport->upper_id&MASTER_ID_MASK))
2170                         break;
2171                 mISDNport = mISDNport->next;
2172         }
2173         if (!mISDNport)
2174         {
2175                 PERROR("message belongs to no mISDNport: prim(0x%x) addr(0x%x) msg->len(%d)\n", frm->prim, frm->addr, msg->len);
2176                 goto out;
2177         }
2178
2179         /* master stack */
2180         if (!(frm->addr&FLG_CHILD_STACK))
2181         {
2182                 /* d-message */
2183                 switch(frm->prim)
2184                 {
2185                         case MGR_SHORTSTATUS | INDICATION:
2186                         case MGR_SHORTSTATUS | CONFIRM:
2187                         switch(frm->dinfo) {
2188                                 case SSTATUS_L1_ACTIVATED:
2189                                 l1l2l3_trace_header(mISDNport, NULL, PH_ACTIVATE | (frm->prim & 0x3), DIRECTION_IN);
2190                                 end_trace();
2191                                 goto ss_act;
2192                                 case SSTATUS_L1_DEACTIVATED:
2193                                 l1l2l3_trace_header(mISDNport, NULL, PH_DEACTIVATE | (frm->prim & 0x3), DIRECTION_IN);
2194                                 end_trace();
2195                                 goto ss_deact;
2196                                 case SSTATUS_L2_ESTABLISHED:
2197                                 l1l2l3_trace_header(mISDNport, NULL, DL_ESTABLISH | (frm->prim & 0x3), DIRECTION_IN);
2198                                 end_trace();
2199                                 goto ss_estab;
2200                                 case SSTATUS_L2_RELEASED:
2201                                 l1l2l3_trace_header(mISDNport, NULL, DL_RELEASE | (frm->prim & 0x3), DIRECTION_IN);
2202                                 end_trace();
2203                                 goto ss_rel;
2204                         }
2205                         break;
2206
2207                         case PH_ACTIVATE | CONFIRM:
2208                         case PH_ACTIVATE | INDICATION:
2209                         l1l2l3_trace_header(mISDNport, NULL, frm->prim, DIRECTION_IN);
2210                         end_trace();
2211                         if (mISDNport->ntmode)
2212                         {
2213                                 mISDNport->l1link = 1;
2214                                 setup_queue(mISDNport, 1);
2215                                 goto l1_msg;
2216                         }
2217                         ss_act:
2218                         mISDNport->l1link = 1;
2219                         setup_queue(mISDNport, 1);
2220                         break;
2221
2222                         case PH_DEACTIVATE | CONFIRM:
2223                         case PH_DEACTIVATE | INDICATION:
2224                         l1l2l3_trace_header(mISDNport, NULL, frm->prim, DIRECTION_IN);
2225                         end_trace();
2226                         if (mISDNport->ntmode)
2227                         {
2228                                 mISDNport->l1link = 0;
2229                                 setup_queue(mISDNport, 0);
2230                                 goto l1_msg;
2231                         }
2232                         ss_deact:
2233                         mISDNport->l1link = 0;
2234                         setup_queue(mISDNport, 0);
2235                         break;
2236
2237                         case PH_CONTROL | CONFIRM:
2238                         case PH_CONTROL | INDICATION:
2239                         PDEBUG(DEBUG_ISDN, "Received PH_CONTROL for port %d (%s).\n", mISDNport->portnum, mISDNport->ifport->interface->name);
2240                         break;
2241
2242                         case DL_ESTABLISH | INDICATION:
2243                         case DL_ESTABLISH | CONFIRM:
2244                         l1l2l3_trace_header(mISDNport, NULL, frm->prim, DIRECTION_IN);
2245                         end_trace();
2246                         if (!mISDNport->ntmode) break; /* !!!!!!!!!!!!!!!! */
2247                         ss_estab:
2248                         if (mISDNport->l2establish)
2249                         {
2250                                 mISDNport->l2establish = 0;
2251                                 PDEBUG(DEBUG_ISDN, "the link became active before l2establish timer expiry.\n");
2252                         }
2253                         mISDNport->l2link = 1;
2254                         break;
2255
2256                         case DL_RELEASE | INDICATION:
2257                         case DL_RELEASE | CONFIRM:
2258                         l1l2l3_trace_header(mISDNport, NULL, frm->prim, DIRECTION_IN);
2259                         end_trace();
2260                         if (!mISDNport->ntmode) break; /* !!!!!!!!!!!!!!!! */
2261                         ss_rel:
2262                         mISDNport->l2link = 0;
2263                         if (mISDNport->ptp)
2264                         {
2265                                 time(&mISDNport->l2establish);
2266                                 PDEBUG(DEBUG_ISDN, "because we are ptp, we set a l2establish timer.\n");
2267                         }
2268                         break;
2269
2270                         default:
2271                         l1_msg:
2272                         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);
2273                         if (frm->dinfo==(signed long)0xffffffff && frm->prim==(PH_DATA|CONFIRM))
2274                         {
2275                                 PERROR("SERIOUS BUG, dinfo == 0xffffffff, prim == PH_DATA | CONFIRM !!!!\n");
2276                         }
2277                         /* d-message */
2278                         if (mISDNport->ntmode)
2279                         {
2280                                 /* l1-data enters the nt-mode library */
2281                                 nst = &mISDNport->nst;
2282                                 if (nst->l1_l2(nst, msg))
2283                                         free_msg(msg);
2284                                 return(1);
2285                         } else
2286                         {
2287                                 /* l3-data is sent to pbx */
2288                                 if (stack2manager_te(mISDNport, msg))
2289                                         free_msg(msg);
2290                                 return(1);
2291                         }
2292                 }
2293         } else
2294         /* child stack */
2295         {
2296                 /* b-message */
2297                 switch(frm->prim)
2298                 {
2299                         /* we don't care about confirms, we use rx data to sync tx */
2300                         case PH_DATA | CONFIRM:
2301                         case DL_DATA | CONFIRM:
2302                         break;
2303
2304                         /* we receive audio data, we respond to it AND we send tones */
2305                         case PH_DATA | INDICATION:
2306                         case DL_DATA | INDICATION:
2307                         case PH_CONTROL | INDICATION:
2308                         i = 0;
2309                         while(i < mISDNport->b_num)
2310                         {
2311                                 if ((unsigned int)(mISDNport->b_addr[i]&STACK_ID_MASK) == (frm->addr&STACK_ID_MASK))
2312                                         break;
2313                                 i++;
2314                         }
2315                         if (i == mISDNport->b_num)
2316                         {
2317                                 PERROR("unhandled b-message (prim 0x%x address 0x%x).\n", frm->prim, frm->addr);
2318                                 break;
2319                         }
2320                         if (mISDNport->b_port[i])
2321                         {
2322 //PERROR("port sech: %s data\n", mISDNport->b_port[i]->p_name);
2323                                 mISDNport->b_port[i]->bchannel_receive(frm);
2324                         } else
2325                                 PDEBUG(DEBUG_BCHANNEL, "b-channel is not associated to an ISDNPort (address 0x%x), ignoring.\n", frm->addr);
2326                         break;
2327
2328                         case PH_ACTIVATE | INDICATION:
2329                         case DL_ESTABLISH | INDICATION:
2330                         case PH_ACTIVATE | CONFIRM:
2331                         case DL_ESTABLISH | CONFIRM:
2332                         PDEBUG(DEBUG_BCHANNEL, "DL_ESTABLISH confirm: bchannel is now activated (address 0x%x).\n", frm->addr);
2333                         i = 0;
2334                         while(i < mISDNport->b_num)
2335                         {
2336                                 if ((unsigned int)(mISDNport->b_addr[i]&STACK_ID_MASK) == (frm->addr&STACK_ID_MASK))
2337                                         break;
2338                                 i++;
2339                         }
2340                         if (i == mISDNport->b_num)
2341                         {
2342                                 PERROR("unhandled b-establish (prim 0x%x address 0x%x).\n", frm->prim, frm->addr);
2343                                 break;
2344                         }
2345                         bchannel_event(mISDNport, i, B_EVENT_ACTIVATED);
2346                         break;
2347
2348                         case PH_DEACTIVATE | INDICATION:
2349                         case DL_RELEASE | INDICATION:
2350                         case PH_DEACTIVATE | CONFIRM:
2351                         case DL_RELEASE | CONFIRM:
2352                         PDEBUG(DEBUG_BCHANNEL, "DL_RELEASE confirm: bchannel is now de-activated (address 0x%x).\n", frm->addr);
2353                         i = 0;
2354                         while(i < mISDNport->b_num)
2355                         {
2356                                 if ((unsigned int)(mISDNport->b_addr[i]&STACK_ID_MASK) == (frm->addr&STACK_ID_MASK))
2357                                         break;
2358                                 i++;
2359                         }
2360                         if (i == mISDNport->b_num)
2361                         {
2362                                 PERROR("unhandled b-release (prim 0x%x address 0x%x).\n", frm->prim, frm->addr);
2363                                 break;
2364                         }
2365                         bchannel_event(mISDNport, i, B_EVENT_DEACTIVATED);
2366                         break;
2367
2368                         default:
2369                         PERROR("child message not handled: prim(0x%x) addr(0x%x) msg->len(%d)\n", frm->prim, frm->addr, msg->len);
2370                 }
2371         }
2372
2373         out:
2374         free_msg(msg);
2375         return(1);
2376 }
2377
2378
2379 /*
2380  * global function to add a new card (port)
2381  */
2382 struct mISDNport *mISDNport_open(int port, int ptp, int ptmp, int force_nt, struct interface *interface)
2383 {
2384         int ret;
2385         unsigned char buff[1025];
2386         iframe_t *frm = (iframe_t *)buff;
2387         struct mISDNport *mISDNport, **mISDNportp;
2388         int i, cnt;
2389         int pri, bri, ports;
2390         int nt, te;
2391 #ifdef SOCKET_MISDN
2392         struct mlayer3 *ml3;
2393         struct mISDN_devinfo devinfo;
2394
2395         ret = ioctl(mISDNsocket, IMGETCOUNT, &cnt);
2396         if (ret < 0)
2397         {
2398                 fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret);
2399                 return(NULL);
2400         }
2401 #else
2402 //      interface_info_t ii;
2403         net_stack_t *nst;
2404         manager_t *mgr;
2405         layer_info_t li;
2406         stack_info_t *stinf;
2407
2408         /* query port's requirements */
2409         cnt = mISDN_get_stack_count(mISDNdevice);
2410 #endif
2411
2412         if (cnt <= 0)
2413         {
2414                 PERROR_RUNTIME("Found no card. Please be sure to load card drivers.\n");
2415                 return(NULL);
2416         }
2417         if (port>cnt || port<1)
2418         {
2419                 PERROR_RUNTIME("Port (%d) given at 'ports' (options.conf) is out of existing port range (%d-%d)\n", port, 1, cnt);
2420                 return(NULL);
2421         }
2422
2423         pri = bri = ports = nt = te = 0;
2424 #ifdef SOCKET_MISDN
2425         devinfo.id = port - 1;
2426         ret = ioctl(socket, IMGETDEVINFO, &devinfo);
2427         if (ret <= 0)
2428         {
2429                 PERROR_RUNTIME("Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", i, ret);
2430                 break;
2431         }
2432         /* output the port info */
2433         if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0))
2434         {
2435                 bri = 1;
2436                 te = 1;
2437         }
2438         if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0))
2439         {
2440                 bri = 1;
2441                 nt = 1;
2442         }
2443 #ifdef ISDN_P_TE_E1
2444         if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1))
2445         {
2446                 pri = 1;
2447                 te = 1;
2448         }
2449 #endif
2450 #ifdef ISDN_P_NT_E1
2451         if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1))
2452         {
2453                 pri = 1;
2454                 nt = 1;
2455         }
2456 #endif
2457 #ifdef ISDN_P_FXS
2458         if (devinfo.Dprotocols & (1 << ISDN_P_FXS))
2459         {
2460                 pots = 1;
2461                 te = 1;
2462         }
2463 #endif
2464 #ifdef ISDN_P_FXO
2465         if (devinfo.Dprotocols & (1 << ISDN_P_FXO))
2466         {
2467                 pots = 1;
2468                 nt = 1;
2469         }
2470 #endif
2471         if (force_nt && !nt)
2472         {
2473                 PERROR_RUNTIME("Port %d does not support NT-mode.\n", port);
2474                 return(NULL);
2475         }
2476         if (bri && pri)
2477         {
2478                 PERROR_RUNTIME("Port %d supports BRI and PRI?? What kind of controller is that?. (Can't use this!)\n", port);
2479                 return(NULL);
2480         }
2481         if (pots && !bri && !pri)
2482         {
2483                 PERROR_RUNTIME("Port %d supports POTS, LCR does not!\n", port);
2484                 return(NULL);
2485         }
2486         if (!bri && !pri)
2487         {
2488                 PERROR_RUNTIME("Port %d does not support BRI nor PRI!\n", port);
2489                 return(NULL);
2490         }
2491         if (!nt && !te)
2492         {
2493                 PERROR_RUNTIME("Port %d does not support NT-mode nor TE-mode!\n", port);
2494                 return(NULL);
2495         }
2496         /* force nt, by turning off TE */
2497         if (force_nt && nt)
2498                 te = 0;
2499         /* if TE an NT is supported (and not forced to NT), turn off NT */
2500         if (te && nt)
2501                 nt = 0;
2502 #else
2503         ret = mISDN_get_stack_info(mISDNdevice, port, buff, sizeof(buff));
2504         if (ret < 0)
2505         {
2506                 PERROR_RUNTIME("Cannot get stack info for port %d (ret=%d)\n", port, ret);
2507                 return(NULL);
2508         }
2509         stinf = (stack_info_t *)&frm->data.p;
2510         switch(stinf->pid.protocol[0] & ~ISDN_PID_FEATURE_MASK)
2511         {
2512                 case ISDN_PID_L0_TE_S0:
2513                 PDEBUG(DEBUG_ISDN, "TE-mode BRI S/T interface line\n");
2514                 break;
2515                 case ISDN_PID_L0_NT_S0:
2516                 PDEBUG(DEBUG_ISDN, "NT-mode BRI S/T interface port\n");
2517                 nt = 1;
2518                 break;
2519                 case ISDN_PID_L0_TE_E1:
2520                 PDEBUG(DEBUG_ISDN, "TE-mode PRI E1  interface line\n");
2521                 pri = 1;
2522                 break;
2523                 case ISDN_PID_L0_NT_E1:
2524                 PDEBUG(DEBUG_ISDN, "LT-mode PRI E1  interface port\n");
2525                 pri = 1;
2526                 nt = 1;
2527                 break;
2528                 default:
2529                 PERROR_RUNTIME("unknown port(%d) type 0x%08x\n", port, stinf->pid.protocol[0]);
2530                 return(NULL);
2531         }
2532         if (nt)
2533         {
2534                 /* NT */
2535                 if (stinf->pid.protocol[1] == 0)
2536                 {
2537                         PERROR_RUNTIME("Given port %d: Missing layer 1 NT-mode protocol.\n", port);
2538                         return(NULL);
2539                 }
2540                 if (stinf->pid.protocol[2])
2541                 {
2542                         PERROR_RUNTIME("Given port %d: Layer 2 protocol 0x%08x is detected, but not allowed for NT lib.\n", port, stinf->pid.protocol[2]);
2543                         return(NULL);
2544                 }
2545         }
2546         if (te)
2547         {
2548                 /* TE */
2549                 if (stinf->pid.protocol[1] == 0)
2550                 {
2551                         PERROR_RUNTIME("Given port %d: Missing layer 1 protocol.\n", port);
2552                         return(NULL);
2553                 }
2554                 if (stinf->pid.protocol[2] == 0)
2555                 {
2556                         PERROR_RUNTIME("Given port %d: Missing layer 2 protocol.\n", port);
2557                         return(NULL);
2558                 }
2559                 if (stinf->pid.protocol[3] == 0)
2560                 {
2561                         PERROR_RUNTIME("Given port %d: Missing layer 3 protocol.\n", port);
2562                         return(NULL);
2563                 } else
2564                 {
2565                         switch(stinf->pid.protocol[3] & ~ISDN_PID_FEATURE_MASK)
2566                         {
2567                                 case ISDN_PID_L3_DSS1USER:
2568                                 break;
2569
2570                                 default:
2571                                 PERROR_RUNTIME("Given port %d: own protocol 0x%08x", port,stinf->pid.protocol[3]);
2572                                 return(NULL);
2573                         }
2574                 }
2575                 if (stinf->pid.protocol[4])
2576                 {
2577                         PERROR_RUNTIME("Given port %d: Layer 4 protocol not allowed.\n", port);
2578                         return(NULL);
2579                 }
2580         }
2581 #endif
2582
2583         /* add mISDNport structure */
2584         mISDNportp = &mISDNport_first;
2585         while(*mISDNportp)
2586                 mISDNportp = &((*mISDNportp)->next);
2587         mISDNport = (struct mISDNport *)MALLOC(sizeof(struct mISDNport));
2588         pmemuse++;
2589         *mISDNportp = mISDNport;
2590
2591         /* allocate ressources of port */
2592 #ifdef SOCKET_MISDN
2593         /* open layer 3 */
2594         protocol = (nt)?L3_PROTOCOL_DSS1_USER:L3_PROTOCOL_DSS1_NETWORK;
2595         prop = 0;
2596         if (ptp)
2597                prop |= FLG_PTP;
2598         if (ptmp && pri)
2599                prop |= FLG_FORCE_PTMP;
2600         mISDNport->ml3 = open_layer3(port-1, protocol, prop , do_dchannel, mISDNport);
2601         if (!mISDNport->ml3)
2602         {
2603                 PERROR_RUNTIME("Cannot get layer(%d) id of port %d\n", nt?2:4, port);
2604                 return(NULL);
2605         }
2606
2607 #if 0
2608         /* if ntmode, establish L1 to send the tei removal during start */
2609         if (mISDNport->ntmode)
2610         {
2611                 iframe_t act;
2612                 /* L1 */
2613                 act.prim = PH_ACTIVATE | REQUEST;
2614                 act.addr = mISDNport->upper_id | FLG_MSG_DOWN;
2615                 printf("UPPER ID 0x%x, addr 0x%x\n",mISDNport->upper_id, act.addr);
2616                 act.dinfo = 0;
2617                 act.len = 0;
2618                 mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
2619                 usleep(10000); /* to be sure, that l1 is up */
2620         }
2621 #endif
2622
2623         SCPY(mISDNport->name, devinfo.name);
2624         mISDNport->b_num = devinfo.nrbchan;
2625 #else
2626         msg_queue_init(&mISDNport->downqueue);
2627         mISDNport->d_stid = stinf->id;
2628         PDEBUG(DEBUG_ISDN, "d_stid = 0x%x.\n", mISDNport->d_stid);
2629         if ((stinf->pid.protocol[2]&ISDN_PID_L2_DF_PTP) || (nt&&ptp) || pri)
2630         {
2631                 PDEBUG(DEBUG_ISDN, "Port is point-to-point.\n");
2632                 ptp = 1;
2633                 if (ptmp && nt)
2634                 {
2635                         PDEBUG(DEBUG_ISDN, "Port is forced to point-to-multipoint.\n");
2636                         ptp = 0;
2637                 }
2638         }
2639
2640         /* create layer intance */
2641         memset(&li, 0, sizeof(li));
2642         UCPY(&li.name[0], (nt)?"net l2":"pbx l4");
2643         li.object_id = -1;
2644         li.extentions = 0;
2645         li.pid.protocol[nt?2:4] = (nt)?ISDN_PID_L2_LAPD_NET:ISDN_PID_L4_CAPI20;
2646         li.pid.layermask = ISDN_LAYER((nt?2:4));
2647         li.st = mISDNport->d_stid;
2648         ret = mISDN_new_layer(mISDNdevice, &li);
2649         if (ret)
2650         {
2651                 PERROR("Cannot add layer %d of port %d (ret %d)\n", nt?2:4, port, ret);
2652                 closeport:
2653                 mISDNport_close(mISDNport);
2654                 return(NULL);
2655         }
2656         mISDNport->upper_id = li.id;
2657         ret = mISDN_register_layer(mISDNdevice, mISDNport->d_stid, mISDNport->upper_id);
2658         if (ret)
2659         {
2660                 PERROR("Cannot register layer %d of port %d\n", nt?2:4, port);
2661                 goto closeport;
2662         }
2663         mISDNport->lower_id = mISDN_get_layerid(mISDNdevice, mISDNport->d_stid, nt?1:3); // id of lower layer (nt=1, te=3)
2664         if (mISDNport->lower_id < 0)
2665         {
2666                 PERROR("Cannot get layer(%d) id of port %d\n", nt?1:3, port);
2667                 goto closeport;
2668         }
2669         mISDNport->upper_id = mISDN_get_layerid(mISDNdevice, mISDNport->d_stid, nt?2:4); // id of uppermost layer (nt=2, te=4)
2670         if (mISDNport->upper_id < 0)
2671         {
2672                 PERROR("Cannot get layer(%d) id of port %d\n", nt?2:4, port);
2673                 goto closeport;
2674         }
2675         PDEBUG(DEBUG_ISDN, "Layer %d of port %d added.\n", nt?2:4, port);
2676
2677         /* if ntmode, establish L1 to send the tei removal during start */
2678         if (mISDNport->ntmode)
2679         {
2680                 iframe_t act;
2681                 /* L1 */
2682                 act.prim = PH_ACTIVATE | REQUEST;
2683                 act.addr = mISDNport->upper_id | FLG_MSG_DOWN;
2684                 printf("UPPER ID 0x%x, addr 0x%x\n",mISDNport->upper_id, act.addr);
2685                 act.dinfo = 0;
2686                 act.len = 0;
2687                 mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
2688                 usleep(10000); /* to be sure, that l1 is up */
2689         }
2690
2691         /* create nst (nt-mode only) */
2692         if (nt)
2693         {
2694                 mgr = &mISDNport->mgr;
2695                 nst = &mISDNport->nst;
2696
2697                 mgr->nst = nst;
2698                 nst->manager = mgr;
2699
2700                 nst->l3_manager = stack2manager_nt; /* messages from nt-mode */
2701                 nst->device = mISDNdevice;
2702                 nst->cardnr = port;
2703                 nst->d_stid = mISDNport->d_stid;
2704
2705                 nst->feature = FEATURE_NET_HOLD;
2706                 if (ptp)
2707                         nst->feature |= FEATURE_NET_PTP;
2708                 if (pri)
2709                         nst->feature |= FEATURE_NET_CRLEN2 | FEATURE_NET_EXTCID;
2710 #if 0
2711                 i = 0;
2712                 while(i < mISDNport->b_num)
2713                 {
2714                         nst->b_stid[i] = mISDNport->b_stid[i];
2715                         i++;
2716                 }
2717 #endif
2718                 nst->l1_id = mISDNport->lower_id;
2719                 nst->l2_id = mISDNport->upper_id;
2720
2721                 /* phd */
2722                 msg_queue_init(&nst->down_queue);
2723
2724                 Isdnl2Init(nst);
2725                 Isdnl3Init(nst);
2726         }
2727
2728         mISDNport->b_num = stinf->childcnt;
2729 #endif
2730         mISDNport->portnum = port;
2731         mISDNport->ntmode = nt;
2732         mISDNport->pri = pri;
2733         mISDNport->ptp = ptp;
2734         PDEBUG(DEBUG_ISDN, "Port has %d b-channels.\n", mISDNport->b_num);
2735         i = 0;
2736         while(i < mISDNport->b_num)
2737         {
2738                 mISDNport->b_state[i] = B_STATE_IDLE;
2739 #ifdef SOCKET_MISDN
2740                 mISDNport->b_socket = -1;
2741 #else
2742                 mISDNport->b_stid[i] = stinf->child[i];
2743                 PDEBUG(DEBUG_ISDN, "b_stid[%d] = 0x%x.\n", i, mISDNport->b_stid[i]);
2744 #endif
2745                 i++;
2746         }
2747
2748         /* if te-mode, query state link */
2749         if (!mISDNport->ntmode)
2750         {
2751                 iframe_t act;
2752                 /* L2 */
2753                 PDEBUG(DEBUG_ISDN, "sending short status request for port %d.\n", port);
2754                 act.prim = MGR_SHORTSTATUS | REQUEST;
2755                 act.addr = mISDNport->upper_id | MSG_BROADCAST;
2756                 act.dinfo = SSTATUS_BROADCAST_BIT | SSTATUS_ALL;
2757                 act.len = 0;
2758                 mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
2759         }
2760         /* if ptp AND te-mode, pull up the link */
2761         if (mISDNport->ptp && !mISDNport->ntmode)
2762         {
2763                 iframe_t act;
2764                 /* L2 */
2765                 act.prim = DL_ESTABLISH | REQUEST;
2766                 act.addr = (mISDNport->upper_id & ~LAYER_ID_MASK) | 4 | FLG_MSG_DOWN;
2767                 act.dinfo = 0;
2768                 act.len = 0;
2769                 mISDN_write(mISDNdevice, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
2770         }
2771         /* if ptp AND nt-mode, pull up the link */
2772         if (mISDNport->ptp && mISDNport->ntmode)
2773         {
2774                 msg_t *dmsg;
2775                 /* L2 */
2776                 dmsg = create_l2msg(DL_ESTABLISH | REQUEST, 0, 0);
2777                 if (mISDNport->nst.manager_l3(&mISDNport->nst, dmsg))
2778                         free_msg(dmsg);
2779         }
2780         /* initially, we assume that the link is down, exept for nt-ptmp */
2781         mISDNport->l2link = (mISDNport->ntmode && !mISDNport->ptp)?1:0;
2782
2783         PDEBUG(DEBUG_BCHANNEL, "using 'mISDN_dsp.o' module\n");
2784
2785         start_trace(mISDNport->portnum,
2786                     interface,
2787                     NULL,
2788                     NULL,
2789                     DIRECTION_NONE,
2790                     CATEGORY_CH,
2791                     0,
2792                     "PORT (open)");
2793         add_trace("channels", NULL, "%d", mISDNport->b_num);
2794         end_trace();
2795         return(mISDNport);
2796 }
2797
2798
2799 /*
2800  * function to free ALL cards (ports)
2801  */
2802 void mISDNport_close_all(void)
2803 {
2804         /* free all ports */
2805         while(mISDNport_first)
2806                 mISDNport_close(mISDNport_first);
2807 }
2808
2809 /*
2810  * free only one port
2811  */
2812 void mISDNport_close(struct mISDNport *mISDNport)
2813 {
2814         struct mISDNport **mISDNportp;
2815         class Port *port;
2816         class PmISDN *isdnport;
2817         net_stack_t *nst;
2818         unsigned char buf[32];
2819         int i;
2820
2821         /* remove all port instance that are linked to this mISDNport */
2822         port = port_first;
2823         while(port)
2824         {
2825                 if ((port->p_type&PORT_CLASS_MASK) == PORT_CLASS_mISDN)
2826                 {
2827                         isdnport = (class PmISDN *)port;
2828                         if (isdnport->p_m_mISDNport)
2829                         {
2830                                 PDEBUG(DEBUG_ISDN, "port %s uses mISDNport %d, destroying it.\n", isdnport->p_name, mISDNport->portnum);
2831                                 delete isdnport;
2832                         }
2833                 }
2834                 port = port->next;
2835         }
2836
2837         /* only if we are already part of interface */
2838         if (mISDNport->ifport)
2839         {
2840                 start_trace(mISDNport->portnum,
2841                             mISDNport->ifport->interface,
2842                             NULL,
2843                             NULL,
2844                             DIRECTION_NONE,
2845                             CATEGORY_CH,
2846                             0,
2847                             "PORT (close)");
2848                 end_trace();
2849         }
2850
2851         /* free bchannels */
2852         i = 0;
2853         while(i < mISDNport->b_num)
2854         {
2855                 if (mISDNport->b_addr[i])
2856                 {
2857                         _bchannel_destroy(mISDNport, i);
2858                         PDEBUG(DEBUG_BCHANNEL, "freeing %s port %d bchannel (index %d).\n", (mISDNport->ntmode)?"NT":"TE", mISDNport->portnum, i);
2859                 }
2860                 i++;
2861         }
2862
2863 #ifdef SOCKET_MISDN
2864         close_layer3(mISDNport->ml3);
2865 #else
2866         /* free ressources of port */
2867         msg_queue_purge(&mISDNport->downqueue);
2868
2869         /* free stacks */
2870         if (mISDNport->ntmode)
2871         {
2872                 nst = &mISDNport->nst;
2873                 if (nst->manager) /* to see if initialized */
2874                 {
2875                         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");
2876                         cleanup_Isdnl3(nst);
2877                         cleanup_Isdnl2(nst);
2878
2879                         /* phd */
2880                         msg_queue_purge(&nst->down_queue);
2881                         if (nst->phd_down_msg)
2882                                 FREE(nst->phd_down_msg, 0);
2883                 }
2884         }
2885
2886         PDEBUG(DEBUG_BCHANNEL, "freeing d-stack.\n");
2887         if (mISDNport->d_stid)
2888         {
2889                 if (mISDNport->upper_id)
2890                         mISDN_write_frame(mISDNdevice, buf, mISDNport->upper_id | FLG_MSG_DOWN, MGR_DELLAYER | REQUEST, 0, 0, NULL, TIMEOUT_1SEC);
2891         }
2892 #endif
2893
2894         /* remove from list */
2895         mISDNportp = &mISDNport_first;
2896         while(*mISDNportp)
2897         {
2898                 if (*mISDNportp == mISDNport)
2899                 {
2900                         *mISDNportp = (*mISDNportp)->next;
2901                         mISDNportp = NULL;
2902                         break;
2903                 }
2904                 mISDNportp = &((*mISDNportp)->next);
2905         }
2906
2907         if (mISDNportp)
2908                 FATAL("mISDNport not in list\n");
2909
2910         FREE(mISDNport, sizeof(struct mISDNport));
2911         pmemuse--;
2912
2913 }
2914
2915
2916 /*
2917  * global function to show all available isdn ports
2918  */
2919 void mISDN_port_info(void)
2920 {
2921         int ret;
2922         int i, ii, p;
2923         int useable, nt, te, pri, bri, pots;
2924         unsigned char buff[1025];
2925         iframe_t *frm = (iframe_t *)buff;
2926 #ifdef SOCKET_MISDN
2927         struct mISDN_devinfo devinfo;
2928         int socket;
2929
2930         /* open mISDN */
2931         socket = socket(PF_ISDN, SOCK_RAW, ISDN_P_BASE);
2932         if (socket < 0)
2933         {
2934                 fprintf(stderr, "Cannot open mISDN due to %s. (Does your Kernel support socket based mISDN?)\n", strerror(errno));
2935                 exit(EXIT_FAILURE);
2936         }
2937
2938         /* get number of stacks */
2939         i = 1;
2940         ret = ioctl(socket, IMGETCOUNT, &ii);
2941         if (ret < 0)
2942         {
2943                 fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret);
2944                 goto done;
2945         }
2946 #else
2947         stack_info_t *stinf;
2948         int device;
2949
2950         /* open mISDN */
2951         if ((device = mISDN_open()) < 0)
2952         {
2953                 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));
2954                 exit(EXIT_FAILURE);
2955         }
2956
2957         /* get number of stacks */
2958         i = 1;
2959         ii = mISDN_get_stack_count(device);
2960 #endif
2961         printf("\n");
2962         if (ii <= 0)
2963         {
2964                 printf("Found no card. Please be sure to load card drivers.\n");
2965                 goto done;
2966         }
2967
2968         /* loop the number of cards and get their info */
2969         while(i <= ii)
2970         {
2971                 nt = te = bri = pri = pots = 0;
2972                 useable = 0;
2973
2974 #ifdef SOCKET_MISDN
2975                 devinfo.id = i - 1;
2976                 ret = ioctl(socket, IMGETDEVINFO, &devinfo);
2977                 if (ret <= 0)
2978                 {
2979                         fprintf(stderr, "Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", i, ret);
2980                         break;
2981                 }
2982
2983                 /* output the port info */
2984                 printf("Port %2d name='%s': ", i, devinfo.name);
2985                 if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0))
2986                 {
2987                         bri = 1;
2988                         te = 1;
2989                 }
2990                 if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0))
2991                 {
2992                         bri = 1;
2993                         nt = 1;
2994                 }
2995 #ifdef ISDN_P_TE_E1
2996                 if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1))
2997                 {
2998                         pri = 1;
2999                         te = 1;
3000                 }
3001 #endif
3002 #ifdef ISDN_P_NT_E1
3003                 if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1))
3004                 {
3005                         pri = 1;
3006                         nt = 1;
3007                 }
3008 #endif
3009 #ifdef ISDN_P_FXS
3010                 if (devinfo.Dprotocols & (1 << ISDN_P_FXS))
3011                 {
3012                         pots = 1;
3013                         te = 1;
3014                 }
3015 #endif
3016 #ifdef ISDN_P_FXO
3017                 if (devinfo.Dprotocols & (1 << ISDN_P_FXO))
3018                 {
3019                         pots = 1;
3020                         nt = 1;
3021                 }
3022 #endif
3023                 if ((te || nt) && (bri || pri || ports))
3024                         usable = 1;
3025
3026                 if (te && bri)
3027                         printf("TE-mode BRI S/T interface line (for phone lines)");
3028                 if (nt && bri)
3029                         printf("NT-mode BRI S/T interface port (for phones)");
3030                 if (te && pri)
3031                         printf("TE-mode PRI E1  interface line (for phone lines)");
3032                 if (nt && pri)
3033                         printf("NT-mode PRI E1  interface port (for E1 terminals)");
3034                 if (te && pots)
3035                         printf("FXS     POTS    interface port (for analog lines)");
3036                 if (nt && pots)
3037                         printf("FXO     POTS    interface port (for analog phones)");
3038                 if (ports)
3039                 {
3040                         usable = 0;
3041                         printf("\n -> Analog interfaces are not supported.");
3042                 } else
3043                 if (!usable)
3044                 {
3045                         printf("unsupported interface protocol bits 0x%016x", devinfo.Dprotocols);
3046                 }
3047                 printf("\n");
3048
3049                 printf("  - %d B-channels\n", devinfo.nfbchan);
3050 #else
3051                 ret = mISDN_get_stack_info(device, i, buff, sizeof(buff));
3052                 if (ret <= 0)
3053                 {
3054                         fprintf(stderr, "mISDN_get_stack_info() failed: port=%d error=%d\n", i, ret);
3055                         break;
3056                 }
3057                 stinf = (stack_info_t *)&frm->data.p;
3058
3059                 /* output the port info */
3060                 printf("Port %2d: ", i);
3061                 switch(stinf->pid.protocol[0] & ~ISDN_PID_FEATURE_MASK)
3062                 {
3063                         case ISDN_PID_L0_TE_S0:
3064                         useable = 1;
3065                         te = 1;
3066                         bri = 1;
3067                         printf("TE-mode BRI S/T interface line (for phone lines)");
3068                         break;
3069                         case ISDN_PID_L0_NT_S0:
3070                         useable = 1;
3071                         nt = 1;
3072                         bri = 1;
3073                         printf("NT-mode BRI S/T interface port (for phones)");
3074                         break;
3075                         case ISDN_PID_L0_TE_E1:
3076                         useable = 1;
3077                         te = 1;
3078                         pri = 1;
3079                         printf("TE-mode PRI E1  interface line (for phone lines)");
3080                         break;
3081                         case ISDN_PID_L0_NT_E1:
3082                         useable = 1;
3083                         nt = 1;
3084                         pri = 1;
3085                         printf("NT-mode PRI E1  interface port (for E1 terminals)");
3086                         break;
3087                         default:
3088                         useable = 0;
3089                         printf("unknown type 0x%08x",stinf->pid.protocol[0]);
3090                 }
3091                 printf("\n");
3092
3093                 if (nt)
3094                 {
3095                         if (stinf->pid.protocol[1] == 0)
3096                         {
3097                                 useable = 0;
3098                                 printf(" -> Missing layer 1 NT-mode protocol.\n");
3099                         }
3100                         p = 2;
3101                         while(p <= MAX_LAYER_NR) {
3102                                 if (stinf->pid.protocol[p])
3103                                 {
3104                                         useable = 0;
3105                                         printf(" -> Layer %d protocol 0x%08x is detected, port already in use by another application.\n", p, stinf->pid.protocol[p]);
3106                                 }
3107                                 p++;
3108                         }
3109                         if (useable)
3110                         {
3111                                 if (pri)
3112                                         printf(" -> Interface is Point-To-Point (PRI).\n");
3113                                 else
3114                                         printf(" -> Interface can be Poin-To-Point/Multipoint.\n");
3115                         }
3116                 }
3117                 if (te)
3118                 {
3119                         if (stinf->pid.protocol[1] == 0)
3120                         {
3121                                 useable = 0;
3122                                 printf(" -> Missing layer 1 protocol.\n");
3123                         }
3124                         if (stinf->pid.protocol[2] == 0)
3125                         {
3126                                 useable = 0;
3127                                 printf(" -> Missing layer 2 protocol.\n");
3128                         }
3129                         if (stinf->pid.protocol[2] & ISDN_PID_L2_DF_PTP)
3130                         {
3131                                 printf(" -> Interface is Poin-To-Point.\n");
3132                         }
3133                         if (stinf->pid.protocol[3] == 0)
3134                         {
3135                                 useable = 0;
3136                                 printf(" -> Missing layer 3 protocol.\n");
3137                         } else
3138                         {
3139                                 printf(" -> Protocol: ");
3140                                 switch(stinf->pid.protocol[3] & ~ISDN_PID_FEATURE_MASK)
3141                                 {
3142                                         case ISDN_PID_L3_DSS1USER:
3143                                         printf("DSS1 (Euro ISDN)");
3144                                         break;
3145
3146                                         default:
3147                                         useable = 0;
3148                                         printf("unknown protocol 0x%08x",stinf->pid.protocol[3]);
3149                                 }
3150                                 printf("\n");
3151                         }
3152                         p = 4;
3153                         while(p <= MAX_LAYER_NR) {
3154                                 if (stinf->pid.protocol[p])
3155                                 {
3156                                         useable = 0;
3157                                         printf(" -> Layer %d protocol 0x%08x is detected, port already in use by another application.\n", p, stinf->pid.protocol[p]);
3158                                 }
3159                                 p++;
3160                         }
3161                 }
3162                 printf("  - %d B-channels\n", stinf->childcnt);
3163 #endif
3164
3165                 if (!useable)
3166                         printf(" * Port NOT useable for LCR\n");
3167
3168                 printf("--------\n");
3169
3170                 i++;
3171         }
3172         printf("\n");
3173
3174 done:
3175 #ifdef SOCKET_MISDN
3176         close(sd);
3177 #else
3178         /* close mISDN */
3179         if ((ret = mISDN_close(device)))
3180                 FATAL("mISDN_close() failed: err=%d '%s'\n", ret, strerror(ret));
3181 #endif
3182 }
3183
3184
3185 /*
3186  * enque data from upper buffer
3187  */
3188 void PmISDN::txfromup(unsigned char *data, int length)
3189 {
3190         unsigned char buf[mISDN_HEADER_LEN+((length>ISDN_LOAD)?length:ISDN_LOAD)];
3191         iframe_t *frm = (iframe_t *)buf;
3192
3193         /* configure frame */
3194         frm->prim = DL_DATA | REQUEST;
3195         frm->addr = p_m_mISDNport->b_addr[p_m_b_index] | FLG_MSG_DOWN;
3196         frm->dinfo = 0;
3197
3198         /* check if high priority tones exist
3199          * ignore data in this case
3200          */
3201         if (p_tone_name[0] || p_m_crypt_msg_loops)
3202                 return;
3203
3204         /* preload procedure
3205          * if transmit buffer in DSP module is empty,
3206          * preload it to DSP_LOAD to prevent jitter gaps.
3207          */
3208         if (p_m_load==0 && ISDN_LOAD>0)
3209         {
3210
3211                 memcpy(buf+mISDN_HEADER_LEN, data, ISDN_LOAD);
3212                 frm->len = ISDN_LOAD;
3213                 mISDN_write(mISDNdevice, frm, mISDN_HEADER_LEN+frm->len, TIMEOUT_1SEC);
3214                 p_m_load += frm->len;
3215         }
3216
3217         /* drop if load would exceed ISDN_MAXLOAD
3218          * this keeps the delay not too high
3219          */
3220         if (p_m_load+length > ISDN_MAXLOAD)
3221                 return;
3222
3223         /* load data to buffer
3224          */
3225         memcpy(buf+mISDN_HEADER_LEN, data, length);
3226         frm->len = length;
3227         mISDN_write(mISDNdevice, frm, mISDN_HEADER_LEN+frm->len, TIMEOUT_1SEC);
3228         p_m_load += frm->len;
3229 }
3230