mISDN.cpp

   1 /*****************************************************************************\
   2 **                                                                           **
   3 ** Linux Call Router                                                         **
   4 **                                                                           **
   5 **---------------------------------------------------------------------------**
   6 ** Copyright: Andreas Eversberg                                              **
   7 **                                                                           **
   8 ** mISDN port abstraction for dss1                                           **
   9 **                                                                           **
  10 \*****************************************************************************/
  11
  12 #include "main.h"
  13 #include "myisdn.h"
  14 #include <mISDN/q931.h>
  15
  16 #undef offsetof
  17 #ifdef __compiler_offsetof
  18 #define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
  19 #else
  20 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
  21 #endif
  22
  23 #ifndef container_of
  24 #define container_of(ptr, type, member) ({                      \
  25         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
  26         (type *)( (char *)__mptr - offsetof(type,member) );})
  27 #endif
  28
  29 // timeouts if activating/deactivating response from mISDN got lost
  30 #define B_TIMER_ACTIVATING 1 // seconds
  31 #define B_TIMER_DEACTIVATING 1 // seconds
  32
  33 /* list of mISDN ports */
  34 struct mISDNport *mISDNport_first;
  35
  36 /* noise randomizer */
  37 unsigned char mISDN_rand[256];
  38 int mISDN_rand_count = 0;
  39
  40 #ifdef OLD_MT_ASSIGN
  41 unsigned int mt_assign_pid = ~0;
  42 #endif
  43
  44 int mISDNsocket = -1;
  45 static int upqueue_pipe[2];
  46 static struct lcr_fd upqueue_fd;
  47 int upqueue_avail = 0;
  48
  49 static int mISDN_upqueue(struct lcr_fd *fd, unsigned int what, void *instance, int i);
  50 static int mISDN_timeout(struct lcr_timer *timer, void *instance, int i);
  51
  52 static int my_mISDNlib_debug(const char *file, int line, const char *func, int level, const char *fmt, va_list va)
  53 {
  54         int ret = 0;
  55
  56         if (debug_fp > 0)
  57                 ret = vfprintf(debug_fp, fmt, va);
  58         return ret;
  59 }
  60
  61 static struct mi_ext_fn_s myfn;
  62
  63 int mISDN_initialize(void)
  64 {
  65         char filename[256];
  66
  67         /* try to open raw socket to check kernel */
  68         mISDNsocket = socket(PF_ISDN, SOCK_RAW, ISDN_P_BASE);
  69         if (mISDNsocket < 0) {
  70                 fprintf(stderr, "Cannot open mISDN due to '%s'. (Does your Kernel support socket based mISDN? Protocol family is %d.)\n", strerror(errno), PF_ISDN);
  71                 return(-1);
  72         }
  73
  74         /* init mlayer3 */
  75         // set debug printout function
  76         myfn.prt_debug = my_mISDNlib_debug;
  77
  78         init_layer3(4, &myfn); // buffer of 4
  79
  80         /* open debug, if enabled and not only stack debugging */
  81         if (options.deb) {
  82                 SPRINT(filename, "%s/debug.log", LOG_DIR);
  83                 debug_fp = fopen(filename, "a");
  84         }
  85
  86         if (options.deb & DEBUG_STACK)
  87                 mISDN_set_debug_level(0xfffffeff);
  88         else
  89                 mISDN_set_debug_level(0);
  90
  91         if (pipe(upqueue_pipe) < 0)
  92                 FATAL("Failed to open pipe\n");
  93         memset(&upqueue_fd, 0, sizeof(upqueue_fd));
  94         upqueue_fd.fd = upqueue_pipe[0];
  95         register_fd(&upqueue_fd, LCR_FD_READ, mISDN_upqueue, NULL, 0);
  96
  97         return(0);
  98 }
  99
 100 void mISDN_deinitialize(void)
 101 {
 102         cleanup_layer3();
 103
 104         if (debug_fp)
 105                 fclose(debug_fp);
 106         debug_fp = NULL;
 107
 108         if (mISDNsocket > -1)
 109                 close(mISDNsocket);
 110
 111         if (upqueue_fd.inuse) {
 112                 unregister_fd(&upqueue_fd);
 113                 close(upqueue_pipe[0]);
 114                 close(upqueue_pipe[1]);
 115         }
 116         upqueue_avail = 0;
 117 }
 118
 119 static int load_timer(struct lcr_timer *timer, void *instance, int index);
 120
 121 /*
 122  * constructor
 123  */
 124 PmISDN::PmISDN(int type, mISDNport *mISDNport, char *portname, struct port_settings *settings, struct interface *interface, int channel, int exclusive, int mode) : Port(type, portname, settings, interface)
 125 {
 126         p_m_mISDNport = mISDNport;
 127         p_m_portnum = mISDNport->portnum;
 128         p_m_b_index = -1;
 129         p_m_b_channel = 0;
 130         p_m_b_exclusive = 0;
 131         p_m_b_reserve = 0;
 132         p_m_b_mode = mode;
 133         p_m_hold = 0;
 134         p_m_tx_gain = mISDNport->ifport->interface->tx_gain;
 135         p_m_rx_gain = mISDNport->ifport->interface->rx_gain;
 136         p_m_conf = 0;
 137         p_m_mute = 0;
 138         p_m_txdata = 0;
 139         p_m_delay = 0;
 140         p_m_tx_dejitter = 0;
 141         p_m_preload = ISDN_LOAD;
 142         p_m_disable_dejitter = 0;
 143         p_m_echo = 0;
 144         p_m_tone = 0;
 145         p_m_rxoff = 0;
 146         p_m_inband_send_on = 0;
 147         p_m_inband_receive_on = 0;
 148         p_m_dtmf = !mISDNport->ifport->nodtmf;
 149         p_m_dtmf_threshold = mISDNport->ifport->dtmf_threshold;
 150         memset(&p_m_timeout, 0, sizeof(p_m_timeout));
 151         add_timer(&p_m_timeout, mISDN_timeout, this, 0);
 152         SCPY(p_m_pipeline, mISDNport->ifport->interface->pipeline);
 153
 154         /* audio */
 155         memset(&p_m_loadtimer, 0, sizeof(p_m_loadtimer));
 156         add_timer(&p_m_loadtimer, load_timer, this, 0);
 157         p_m_load = 0;
 158         p_m_last_tv_sec = 0;
 159
 160         /* crypt */
 161         p_m_crypt = 0;
 162         p_m_crypt_listen = 0;
 163         p_m_crypt_msg_loops = 0;
 164         p_m_crypt_msg_loops = 0;
 165         p_m_crypt_msg_len = 0;
 166         p_m_crypt_msg[0] = '\0';
 167         p_m_crypt_msg_current = 0;
 168         p_m_crypt_key_len = 0;
 169         p_m_crypt_listen = 0;
 170         p_m_crypt_listen_state = 0;
 171         p_m_crypt_listen_len = 0;
 172         p_m_crypt_listen_msg[0] = '\0';
 173         p_m_crypt_listen_crc = 0;
 174         if (mISDNport->ifport->interface->bf_len >= 4 && mISDNport->ifport->interface->bf_len <= 56) {
 175                 memcpy(p_m_crypt_key, mISDNport->ifport->interface->bf_key, p_m_crypt_key_len);
 176                 p_m_crypt_key_len = mISDNport->ifport->interface->bf_len;
 177                 p_m_crypt = 1;
 178         }
 179
 180         /* if any channel requested by constructor */
 181         if (channel == CHANNEL_ANY) {
 182                 /* reserve channel */
 183                 p_m_b_reserve = 1;
 184                 mISDNport->b_reserved++;
 185         }
 186
 187         /* reserve channel */
 188         if (channel > 0) // only if constructor was called with a channel resevation
 189                 seize_bchannel(channel, exclusive);
 190
 191         /* we increase the number of objects: */
 192         mISDNport->use++;
 193         PDEBUG(DEBUG_ISDN, "Created new mISDNPort(%s). Currently %d objects use, port #%d\n", portname, mISDNport->use, p_m_portnum);
 194 //inband_receive_on();
 195 }
 196
 197
 198 /*
 199  * destructor
 200  */
 201 PmISDN::~PmISDN()
 202 {
 203         struct lcr_msg *message;
 204
 205         del_timer(&p_m_timeout);
 206         del_timer(&p_m_loadtimer);
 207
 208         /* remove bchannel relation */
 209         drop_bchannel();
 210
 211         /* release epoint */
 212         while (p_epointlist) {
 213                 PDEBUG(DEBUG_ISDN, "destroy mISDNPort(%s). endpoint still exists, releaseing.\n", p_name);
 214                 message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
 215                 message->param.disconnectinfo.cause = 16;
 216                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
 217                 message_put(message);
 218                 /* remove from list */
 219                 free_epointlist(p_epointlist);
 220         }
 221
 222         /* we decrease the number of objects: */
 223         p_m_mISDNport->use--;
 224         PDEBUG(DEBUG_ISDN, "destroyed mISDNPort(%s). Currently %d objects\n", p_name, p_m_mISDNport->use);
 225 }
 226
 227
 228 /*
 229  * trace
 230  */
 231 void chan_trace_header(struct mISDNport *mISDNport, class PmISDN *port, const char *msgtext, int direction)
 232 {
 233         /* init trace with given values */
 234         start_trace(mISDNport?mISDNport->portnum:-1,
 235                     (mISDNport)?((mISDNport->ifport)?mISDNport->ifport->interface:NULL):NULL,
 236                     port?numberrize_callerinfo(port->p_callerinfo.id, port->p_callerinfo.ntype, options.national, options.international):NULL,
 237                     port?port->p_dialinginfo.id:NULL,
 238                     direction,
 239                     CATEGORY_CH,
 240                     port?port->p_serial:0,
 241                     msgtext);
 242 }
 243
 244
 245 /*
 246  * layer trace header
 247  */
 248 static struct isdn_message {
 249         const char *name;
 250         unsigned int value;
 251 } isdn_message[] = {
 252         {"PH_ACTIVATE", L1_ACTIVATE_REQ},
 253         {"PH_DEACTIVATE", L1_DEACTIVATE_REQ},
 254         {"DL_ESTABLISH", L2_ESTABLISH_REQ},
 255         {"DL_RELEASE", L2_RELEASE_REQ},
 256         {"UNKNOWN", L3_UNKNOWN_REQ},
 257         {"MT_TIMEOUT", L3_TIMEOUT_REQ},
 258         {"MT_SETUP", L3_SETUP_REQ},
 259         {"MT_SETUP_ACK", L3_SETUP_ACKNOWLEDGE_REQ},
 260         {"MT_PROCEEDING", L3_PROCEEDING_REQ},
 261         {"MT_ALERTING", L3_ALERTING_REQ},
 262         {"MT_CONNECT", L3_CONNECT_REQ},
 263         {"MT_CONNECT_ACK", L3_CONNECT_ACKNOWLEDGE_REQ},
 264         {"MT_DISCONNECT", L3_DISCONNECT_REQ},
 265         {"MT_RELEASE", L3_RELEASE_REQ},
 266         {"MT_RELEASE_COMP", L3_RELEASE_COMPLETE_REQ},
 267         {"MT_INFORMATION", L3_INFORMATION_REQ},
 268         {"MT_PROGRESS", L3_PROGRESS_REQ},
 269         {"MT_NOTIFY", L3_NOTIFY_REQ},
 270         {"MT_SUSPEND", L3_SUSPEND_REQ},
 271         {"MT_SUSPEND_ACK", L3_SUSPEND_ACKNOWLEDGE_REQ},
 272         {"MT_SUSPEND_REJ", L3_SUSPEND_REJECT_REQ},
 273         {"MT_RESUME", L3_RESUME_REQ},
 274         {"MT_RESUME_ACK", L3_RESUME_ACKNOWLEDGE_REQ},
 275         {"MT_RESUME_REJ", L3_RESUME_REJECT_REQ},
 276         {"MT_HOLD", L3_HOLD_REQ},
 277         {"MT_HOLD_ACK", L3_HOLD_ACKNOWLEDGE_REQ},
 278         {"MT_HOLD_REJ", L3_HOLD_REJECT_REQ},
 279         {"MT_RETRIEVE", L3_RETRIEVE_REQ},
 280         {"MT_RETRIEVE_ACK", L3_RETRIEVE_ACKNOWLEDGE_REQ},
 281         {"MT_RETRIEVE_REJ", L3_RETRIEVE_REJECT_REQ},
 282         {"MT_FACILITY", L3_FACILITY_REQ},
 283         {"MT_STATUS", L3_STATUS_REQ},
 284         {"MT_RESTART", L3_RESTART_REQ},
 285         {"MT_NEW_L3ID", L3_NEW_L3ID_REQ},
 286         {"MT_RELEASE_L3ID", L3_RELEASE_L3ID_REQ},
 287         {NULL, 0},
 288 };
 289 static const char *isdn_prim[4] = {
 290         " REQUEST",
 291         " CONFIRM",
 292         " INDICATION",
 293         " RESPONSE",
 294 };
 295 void l1l2l3_trace_header(struct mISDNport *mISDNport, class PmISDN *port, unsigned int msg, int direction)
 296 {
 297         int i;
 298         char msgtext[64];
 299
 300         SCPY(msgtext, "<<UNKNOWN MESSAGE>>");
 301         /* select message and primitive text */
 302         i = 0;
 303         while(isdn_message[i].name) {
 304 //              if (msg == L3_NOTIFY_REQ) printf("val = %x %s\n", isdn_message[i].value, isdn_message[i].name);
 305                 if (isdn_message[i].value == (msg&0xffffff00)) {
 306                         SCPY(msgtext, isdn_message[i].name);
 307                         break;
 308                 }
 309                 i++;
 310         }
 311         SCAT(msgtext, isdn_prim[msg&0x00000003]);
 312
 313         /* add direction */
 314         if (direction && (msg&0xffffff00)!=L3_NEW_L3ID_REQ && (msg&0xffffff00)!=L3_RELEASE_L3ID_REQ) {
 315                 if (mISDNport) {
 316                         if (mISDNport->ntmode) {
 317                                 if (direction == DIRECTION_OUT)
 318                                         SCAT(msgtext, " N->U");
 319                                 else
 320                                         SCAT(msgtext, " N<-U");
 321                         } else {
 322                                 if (direction == DIRECTION_OUT)
 323                                         SCAT(msgtext, " U->N");
 324                                 else
 325                                         SCAT(msgtext, " U<-N");
 326                         }
 327                 }
 328         }
 329
 330         /* init trace with given values */
 331         start_trace(mISDNport?mISDNport->portnum:-1,
 332                     mISDNport?(mISDNport->ifport?mISDNport->ifport->interface:NULL):NULL,
 333                     port?numberrize_callerinfo(port->p_callerinfo.id, port->p_callerinfo.ntype, options.national, options.international):NULL,
 334                     port?port->p_dialinginfo.id:NULL,
 335                     direction,
 336                     CATEGORY_CH,
 337                     port?port->p_serial:0,
 338                     msgtext);
 339 }
 340
 341
 342 /*
 343  * send control information to the channel (dsp-module)
 344  */
 345 void ph_control(struct mISDNport *mISDNport, class PmISDN *isdnport, int sock, unsigned int c1, unsigned int c2, const char *trace_name, int trace_value)
 346 {
 347         unsigned char buffer[MISDN_HEADER_LEN+sizeof(int)+sizeof(int)];
 348         struct mISDNhead *ctrl = (struct mISDNhead *)buffer;
 349         unsigned int *d = (unsigned int *)(buffer+MISDN_HEADER_LEN);
 350         int ret;
 351         int len = 8;
 352
 353         if (sock < 0)
 354                 return;
 355
 356         if (c1 == DTMF_TONE_START && c2 == 0) {
 357                 len = 4;
 358         }
 359
 360         ctrl->prim = PH_CONTROL_REQ;
 361         ctrl->id = 0;
 362         *d++ = c1;
 363         *d++ = c2;
 364         ret = sendto(sock, buffer, MISDN_HEADER_LEN+len, 0, NULL, 0);
 365         if (ret <= 0)
 366                 PERROR("Failed to send to socket %d\n", sock);
 367         chan_trace_header(mISDNport, isdnport, "BCHANNEL control", DIRECTION_OUT);
 368         if (c1 == DSP_CONF_JOIN)
 369                 add_trace(trace_name, NULL, "0x%08x", trace_value);
 370         else
 371                 add_trace(trace_name, NULL, "%d", trace_value);
 372         end_trace();
 373 }
 374
 375 void ph_control_block(struct mISDNport *mISDNport, class PmISDN *isdnport, int sock, unsigned int c1, void *c2, int c2_len, const char *trace_name, int trace_value)
 376 {
 377         unsigned char buffer[MISDN_HEADER_LEN+sizeof(int)+c2_len];
 378         struct mISDNhead *ctrl = (struct mISDNhead *)buffer;
 379         unsigned int *d = (unsigned int *)(buffer+MISDN_HEADER_LEN);
 380         int ret;
 381
 382         if (sock < 0)
 383                 return;
 384
 385         ctrl->prim = PH_CONTROL_REQ;
 386         ctrl->id = 0;
 387         *d++ = c1;
 388         memcpy(d, c2, c2_len);
 389         ret = sendto(sock, buffer, MISDN_HEADER_LEN+sizeof(int)+c2_len, 0, NULL, 0);
 390         if (ret <= 0)
 391                 PERROR("Failed to send to socket %d\n", sock);
 392         chan_trace_header(mISDNport, isdnport, "BCHANNEL control", DIRECTION_OUT);
 393         add_trace(trace_name, NULL, "%d", trace_value);
 394         end_trace();
 395 }
 396
 397 static int b_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i);
 398
 399 /*
 400  * subfunction for bchannel_event
 401  * create stack
 402  */
 403 static int _bchannel_create(struct mISDNport *mISDNport, int i)
 404 {
 405         int ret;
 406         struct sockaddr_mISDN addr;
 407
 408         if (mISDNport->b_sock[i].inuse) {
 409                 PERROR("Error: Socket already created for index %d\n", i);
 410                 return(0);
 411         }
 412
 413         /* open socket */
 414 //#warning testing without DSP
 415 //      mISDNport->b_sock[i].fd = socket(PF_ISDN, SOCK_DGRAM, (mISDNport->b_mode[i]==B_MODE_HDLC)?ISDN_P_B_HDLC:ISDN_P_B_RAW);
 416         mISDNport->b_sock[i].fd = socket(PF_ISDN, SOCK_DGRAM, (mISDNport->b_mode[i]==B_MODE_HDLC)?ISDN_P_B_L2DSPHDLC:ISDN_P_B_L2DSP);
 417         if (mISDNport->b_sock[i].fd < 0) {
 418                 PERROR("Error: Failed to open bchannel-socket for index %d with mISDN-DSP layer. Did you load mISDN_dsp.ko?\n", i);
 419                 return(0);
 420         }
 421
 422         /* register callback for read */
 423         register_fd(&mISDNport->b_sock[i], LCR_FD_READ, b_sock_callback, mISDNport, i);
 424
 425         /* bind socket to bchannel */
 426         addr.family = AF_ISDN;
 427         addr.dev = mISDNport->portnum;
 428         addr.channel = i+1+(i>=15);
 429         ret = bind(mISDNport->b_sock[i].fd, (struct sockaddr *)&addr, sizeof(addr));
 430         if (ret < 0) {
 431                 PERROR("Error: Failed to bind bchannel-socket for index %d with mISDN-DSP layer (errno=%d). Did you load mISDN_dsp.ko?\n", i, errno);
 432                 close(mISDNport->b_sock[i].fd);
 433                 unregister_fd(&mISDNport->b_sock[i]);
 434                 return(0);
 435         }
 436
 437         chan_trace_header(mISDNport, mISDNport->b_port[i], "BCHANNEL create socket", DIRECTION_OUT);
 438         add_trace("channel", NULL, "%d", i+1+(i>=15));
 439         add_trace("socket", NULL, "%d", mISDNport->b_sock[i].fd);
 440         end_trace();
 441
 442         return(1);
 443 }
 444
 445
 446 /*
 447  * subfunction for bchannel_event
 448  * activate / deactivate request
 449  */
 450 static void _bchannel_activate(struct mISDNport *mISDNport, int i, int activate, int timeout)
 451 {
 452         struct mISDNhead act;
 453         int ret;
 454
 455         if (!mISDNport->b_sock[i].inuse)
 456                 return;
 457         act.prim = (activate)?PH_ACTIVATE_REQ:PH_DEACTIVATE_REQ;
 458         act.id = 0;
 459         ret = sendto(mISDNport->b_sock[i].fd, &act, MISDN_HEADER_LEN, 0, NULL, 0);
 460         if (ret <= 0)
 461                 PERROR("Failed to send to socket %d\n", mISDNport->b_sock[i].fd);
 462
 463         /* trace */
 464         chan_trace_header(mISDNport, mISDNport->b_port[i], activate ? "BCHANNEL activate" : "BCHANNEL deactivate", DIRECTION_OUT);
 465         add_trace("channel", NULL, "%d", i+1+(i>=15));
 466         if (timeout)
 467                 add_trace("event", NULL, "timeout recovery");
 468         end_trace();
 469 }
 470
 471
 472 /*
 473  * subfunction for bchannel_event
 474  * set features
 475  */
 476 static void _bchannel_configure(struct mISDNport *mISDNport, int i)
 477 {
 478         struct PmISDN *port;
 479         int handle, mode;
 480
 481         if (!mISDNport->b_sock[i].inuse)
 482                 return;
 483         handle = mISDNport->b_sock[i].fd;
 484         port = mISDNport->b_port[i];
 485         mode = mISDNport->b_mode[i];
 486         if (!port) {
 487                 PERROR("bchannel index i=%d not associated with a port object\n", i);
 488                 return;
 489         }
 490
 491         /* set dsp features */
 492         if (port->p_m_txdata)
 493                 ph_control(mISDNport, port, handle, (port->p_m_txdata)?DSP_TXDATA_ON:DSP_TXDATA_OFF, 0, "DSP-TXDATA", port->p_m_txdata);
 494         if (port->p_m_delay && mode == B_MODE_TRANSPARENT)
 495                 ph_control(mISDNport, port, handle, DSP_DELAY, port->p_m_delay, "DSP-DELAY", port->p_m_delay);
 496         if (port->p_m_tx_dejitter && mode == B_MODE_TRANSPARENT)
 497                 ph_control(mISDNport, port, handle, DSP_TX_DEJITTER, port->p_m_tx_dejitter, "DSP-TX_DEJITTER", port->p_m_tx_dejitter);
 498         if (port->p_m_tx_gain && mode == B_MODE_TRANSPARENT)
 499                 ph_control(mISDNport, port, handle, DSP_VOL_CHANGE_TX, port->p_m_tx_gain, "DSP-TX_GAIN", port->p_m_tx_gain);
 500         if (port->p_m_rx_gain && mode == B_MODE_TRANSPARENT)
 501                 ph_control(mISDNport, port, handle, DSP_VOL_CHANGE_RX, port->p_m_rx_gain, "DSP-RX_GAIN", port->p_m_rx_gain);
 502         if (port->p_m_pipeline[0] && mode == B_MODE_TRANSPARENT)
 503                 ph_control_block(mISDNport, port, handle, DSP_PIPELINE_CFG, port->p_m_pipeline, strlen(port->p_m_pipeline)+1, "DSP-PIPELINE", 0);
 504         if (port->p_m_conf && !port->p_m_mute)
 505                 ph_control(mISDNport, port, handle, DSP_CONF_JOIN, port->p_m_conf, "DSP-CONF", port->p_m_conf);
 506         if (port->p_m_echo)
 507                 ph_control(mISDNport, port, handle, DSP_ECHO_ON, 0, "DSP-ECHO", 1);
 508         if (port->p_m_tone && mode == B_MODE_TRANSPARENT)
 509                 ph_control(mISDNport, port, handle, DSP_TONE_PATT_ON, port->p_m_tone, "DSP-TONE", port->p_m_tone);
 510         if (port->p_m_rxoff)
 511                 ph_control(mISDNport, port, handle, DSP_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
 512 //      if (port->p_m_txmix && mode == B_MODE_TRANSPARENT)
 513 //              ph_control(mISDNport, port, handle, DSP_MIX_ON, 0, "DSP-MIX", 1);
 514         if (port->p_m_dtmf && mode == B_MODE_TRANSPARENT)
 515                 ph_control(mISDNport, port, handle, DTMF_TONE_START, port->p_m_dtmf_threshold, "DSP-DTMF", 1);
 516         if (port->p_m_crypt && mode == B_MODE_TRANSPARENT)
 517                 ph_control_block(mISDNport, port, handle, DSP_BF_ENABLE_KEY, port->p_m_crypt_key, port->p_m_crypt_key_len, "DSP-CRYPT", port->p_m_crypt_key_len);
 518 }
 519
 520
 521 void PmISDN::set_conf(int oldconf, int newconf)
 522 {
 523                 if (oldconf != newconf) {
 524                         PDEBUG(DEBUG_BCHANNEL, "we change conference from conf=%d to conf=%d.\n", oldconf, newconf);
 525                         if (p_m_b_index > -1)
 526                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
 527                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, (newconf)?DSP_CONF_JOIN:DSP_CONF_SPLIT, newconf, "DSP-CONF", newconf);
 528                 } else
 529                         PDEBUG(DEBUG_BCHANNEL, "we already have conf=%d.\n", newconf);
 530 }
 531
 532
 533 /*
 534  * subfunction for bchannel_event
 535  * destroy stack
 536  */
 537 static void _bchannel_destroy(struct mISDNport *mISDNport, int i)
 538 {
 539         if (!mISDNport->b_sock[i].inuse)
 540                 return;
 541         chan_trace_header(mISDNport, mISDNport->b_port[i], "BCHANNEL remove socket", DIRECTION_OUT);
 542         add_trace("channel", NULL, "%d", i+1+(i>=15));
 543         add_trace("socket", NULL, "%d", mISDNport->b_sock[i].fd);
 544         end_trace();
 545         close(mISDNport->b_sock[i].fd);
 546         unregister_fd(&mISDNport->b_sock[i]);
 547 }
 548
 549
 550 /*
 551 bchannel procedure
 552 ------------------
 553
 554 A bchannel goes through the following states in this order:
 555
 556 - B_STATE_IDLE
 557 No one is using the bchannel.
 558 It is available and not linked to Port class, nor reserved.
 559
 560 - B_STATE_ACTIVATING
 561 The bchannel stack is created and an activation request is sent.
 562 It MAY be linked to Port class, but already unlinked due to Port class removal.
 563
 564 - B_STATE_ACTIVE
 565 The bchannel is active and cofigured to the Port class needs.
 566 Also it is linked to a Port class, otherwhise it would be deactivated.
 567
 568 - B_STATE_DEACTIVATING
 569 The bchannel is in deactivating state, due to deactivation request.
 570 It may be linked to a Port class, that likes to reactivate it.
 571
 572 - B_STATE_IDLE
 573 See above.
 574 After deactivating bchannel, and if not used, the bchannel becomes idle again.
 575
 576 A bchannel can have the following events:
 577
 578 - B_EVENT_USE
 579 A bchannel is required by a Port class.
 580
 581 - B_EVENT_ACTIVATED
 582 The bchannel beomes active.
 583
 584 - B_EVENT_DROP
 585 The bchannel is not required by Port class anymore
 586
 587 - B_EVENT_DEACTIVATED
 588 The bchannel becomes inactive.
 589
 590 All actions taken on these events depend on the current bchannel's state and if it is linked to a Port class.
 591
 592 */
 593
 594 /*
 595  * process bchannel events
 596  * - mISDNport is a pointer to the port's structure
 597  * - i is the index of the bchannel
 598  * - event is the B_EVENT_* value
 599  * - port is the PmISDN class pointer
 600  */
 601 void bchannel_event(struct mISDNport *mISDNport, int i, int event)
 602 {
 603         class PmISDN *b_port = mISDNport->b_port[i];
 604         int state = mISDNport->b_state[i];
 605         int timer = -1; // no change
 606 #if 0
 607         int p_m_tx_gain = 0;
 608         int p_m_rx_gain = 0;
 609         char *p_m_pipeline = NULL;
 610         unsigned char *p_m_crypt_key = NULL;
 611         int p_m_crypt_key_len = 0;
 612         int p_m_crypt_key_type = 0;
 613
 614         if (b_port) {
 615                 p_m_tx_gain = b_port->p_m_tx_gain;
 616                 p_m_rx_gain = b_port->p_m_rx_gain;
 617                 p_m_pipeline = b_port->p_m_pipeline;
 618                 p_m_crypt_key = b_port->p_m_crypt_key;
 619                 p_m_crypt_key_len = b_port->p_m_crypt_key_len;
 620                 p_m_crypt_key_type = /*b_port->p_m_crypt_key_type*/1;
 621         }
 622 #endif
 623
 624         switch(event) {
 625                 case B_EVENT_USE:
 626                 /* port must be linked in order to allow activation */
 627                 if (!b_port)
 628                         FATAL("bchannel must be linked to a Port class\n");
 629                 switch(state) {
 630                         case B_STATE_IDLE:
 631                         /* create stack and send activation request */
 632                         if (_bchannel_create(mISDNport, i)) {
 633                                 _bchannel_activate(mISDNport, i, 1, 0);
 634                                 state = B_STATE_ACTIVATING;
 635                                 timer = B_TIMER_ACTIVATING;
 636                         }
 637                         break;
 638
 639                         case B_STATE_ACTIVATING:
 640                         /* do nothing, because it is already activating */
 641                         break;
 642
 643                         default:
 644                         /* problems that might ocurr:
 645                          * B_EVENT_USE is received when channel already in use.
 646                          */
 647                         PERROR("Illegal event %d at state %d, please correct.\n", event, state);
 648                 }
 649                 break;
 650
 651
 652                 case B_EVENT_ACTIVATED:
 653                 timer = 0;
 654                 switch(state) {
 655                         case B_STATE_ACTIVATING:
 656                         if (b_port) {
 657                                 /* bchannel is active and used by Port class, so we configure bchannel */
 658                                 _bchannel_configure(mISDNport, i);
 659                                 state = B_STATE_ACTIVE;
 660                                 b_port->p_m_load = 0;
 661                                 b_port->update_load();
 662                         } else {
 663                                 /* bchannel is active, but not used anymore (or has wrong stack config), so we deactivate */
 664                                 _bchannel_activate(mISDNport, i, 0, 0);
 665                                 state = B_STATE_DEACTIVATING;
 666                                 timer = B_TIMER_DEACTIVATING;
 667                         }
 668                         break;
 669
 670                         default:
 671                         PERROR("Illegal event %d at state %d, please correct.\n", event, state);
 672                 }
 673                 break;
 674
 675                 case B_EVENT_DROP:
 676                 if (!b_port)
 677                         FATAL("bchannel must be linked to a Port class\n");
 678                 switch(state) {
 679                         case B_STATE_IDLE:
 680                         /* bchannel is idle due to an error, so we do nothing */
 681                         break;
 682
 683                         case B_STATE_ACTIVATING:
 684                         /* do nothing because we must wait until bchanenl is active before deactivating */
 685                         break;
 686
 687                         case B_STATE_ACTIVE:
 688                         /* bchannel is active, so we deactivate */
 689                         _bchannel_activate(mISDNport, i, 0, 0);
 690                         state = B_STATE_DEACTIVATING;
 691                         timer = B_TIMER_DEACTIVATING;
 692                         break;
 693
 694                         case B_STATE_DEACTIVATING:
 695                         /* we may have taken an already deactivating bchannel, but do not require it anymore, so we do nothing */
 696                         break;
 697
 698                         default:
 699                         PERROR("Illegal event %d at state %d, please correct.\n", event, state);
 700                 }
 701                 break;
 702
 703                 case B_EVENT_DEACTIVATED:
 704                 timer = 0;
 705                 switch(state) {
 706                         case B_STATE_IDLE:
 707                         /* ignore due to deactivation confirm after unloading */
 708                         break;
 709
 710                         case B_STATE_DEACTIVATING:
 711                         _bchannel_destroy(mISDNport, i);
 712                         state = B_STATE_IDLE;
 713                         if (b_port) {
 714                                 /* bchannel is now deactivate, but is requied by Port class, so we reactivate */
 715                                 if (_bchannel_create(mISDNport, i)) {
 716                                         _bchannel_activate(mISDNport, i, 1, 0);
 717                                         state = B_STATE_ACTIVATING;
 718                                         timer = B_TIMER_ACTIVATING;
 719                                 }
 720                         }
 721                         break;
 722
 723                         default:
 724                         PERROR("Illegal event %d at state %d, please correct.\n", event, state);
 725                 }
 726                 break;
 727
 728                 case B_EVENT_TIMEOUT:
 729                 timer = 0;
 730                 switch(state) {
 731                         case B_STATE_IDLE:
 732                         /* ignore due to deactivation confirm after unloading */
 733                         break;
 734
 735                         case B_STATE_ACTIVATING:
 736                         _bchannel_activate(mISDNport, i, 1, 1);
 737                         timer = B_TIMER_ACTIVATING;
 738                         break;
 739
 740                         case B_STATE_DEACTIVATING:
 741                         _bchannel_activate(mISDNport, i, 0, 1);
 742                         timer = B_TIMER_DEACTIVATING;
 743                         break;
 744
 745                         default:
 746                         PERROR("Illegal event %d at state %d, please correct.\n", event, state);
 747                 }
 748                 break;
 749
 750                 default:
 751                 PERROR("Illegal event %d, please correct.\n", event);
 752         }
 753
 754         mISDNport->b_state[i] = state;
 755         if (timer == 0)
 756                 unsched_timer(&mISDNport->b_timer[i]);
 757         else if (timer > 0)
 758                 schedule_timer(&mISDNport->b_timer[i], timer, 0);
 759 }
 760
 761
 762
 763
 764 /*
 765  * check for available channel and reserve+set it.
 766  * give channel number or SEL_CHANNEL_ANY or SEL_CHANNEL_NO
 767  * give exclusiv flag
 768  * returns -(cause value) or x = channel x or 0 = no channel
 769  * NOTE: no activation is done here
 770  */
 771 int PmISDN::seize_bchannel(int channel, int exclusive)
 772 {
 773         int i;
 774
 775         /* the channel is what we have */
 776         if (p_m_b_channel == channel)
 777                 return(channel);
 778
 779         /* if channel already in use, release it */
 780         if (p_m_b_channel)
 781                 drop_bchannel();
 782
 783         /* if CHANNEL_NO */
 784         if (channel==CHANNEL_NO || channel==0)
 785                 return(0);
 786
 787         /* is channel in range ? */
 788         if (channel==16
 789          || (channel>p_m_mISDNport->b_num && channel<16)
 790          || ((channel-1)>p_m_mISDNport->b_num && channel>16)) /* channel-1 because channel 16 is not counted */
 791                 return(-6); /* channel unacceptable */
 792
 793         /* request exclusive channel */
 794         if (exclusive && channel>0) {
 795                 i = channel-1-(channel>16);
 796                 if (p_m_mISDNport->b_port[i])
 797                         return(-44); /* requested channel not available */
 798                 goto seize;
 799         }
 800
 801         /* ask for channel */
 802         if (channel>0) {
 803                 i = channel-1-(channel>16);
 804                 if (p_m_mISDNport->b_port[i] == NULL)
 805                         goto seize;
 806         }
 807
 808         /* search for channel */
 809         i = 0;
 810         while(i < p_m_mISDNport->b_num) {
 811                 if (!p_m_mISDNport->b_port[i]) {
 812                         channel = i+1+(i>=15);
 813                         goto seize;
 814                 }
 815                 i++;
 816         }
 817         return(-34); /* no free channel */
 818
 819 seize:
 820         PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) seizing bchannel %d (index %d)\n", p_name, channel, i);
 821
 822         /* link Port, set parameters */
 823         p_m_mISDNport->b_port[i] = this;
 824         p_m_b_index = i;
 825         p_m_b_channel = channel;
 826         p_m_b_exclusive = exclusive;
 827         p_m_mISDNport->b_mode[i] = p_m_b_mode;
 828
 829         /* reserve channel */
 830         if (!p_m_b_reserve) {
 831                 p_m_b_reserve = 1;
 832                 p_m_mISDNport->b_reserved++;
 833         }
 834
 835         return(channel);
 836 }
 837
 838 /*
 839  * drop reserved channel and unset it.
 840  * deactivation is also done
 841  */
 842 void PmISDN::drop_bchannel(void)
 843 {
 844         /* unreserve channel */
 845         if (p_m_b_reserve)
 846                 p_m_mISDNport->b_reserved--;
 847         p_m_b_reserve = 0;
 848
 849         /* if not in use */
 850         if (p_m_b_index < 0)
 851                 return;
 852         if (!p_m_b_channel)
 853                 return;
 854
 855         PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) dropping bchannel\n", p_name);
 856
 857         if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_IDLE)
 858                 bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_DROP);
 859         p_m_mISDNport->b_port[p_m_b_index] = NULL;
 860         p_m_mISDNport->b_mode[p_m_b_index] = 0;
 861         p_m_b_index = -1;
 862         p_m_b_channel = 0;
 863         p_m_b_exclusive = 0;
 864 }
 865
 866
 867 /*
 868  * handler
 869
 870 audio transmission procedure:
 871 -----------------------------
 872
 873 * priority
 874 three sources of audio transmission:
 875 - crypto-data high priority
 876 - tones high priority (also high)
 877 - remote-data low priority
 878
 879 * elapsed
 880 a variable that temporarily shows the number of samples elapsed since last transmission process.
 881 p_m_last_tv_* is used to store that last timestamp. this is used to calculate the time elapsed.
 882
 883 * load
 884 a variable that is increased whenever data is transmitted.
 885 it is decreased while time elapses. it stores the number of samples that
 886 are currently loaded to dsp module.
 887 since clock in dsp module is the same clock for user space process, these
 888 times have no skew.
 889
 890 * levels
 891 there are two levels:
 892 p_m_preload will give the load that have to be kept in dsp.
 893 ISDN_MAXLOAD (2*p_m_preload) will give the maximum load before dropping.
 894
 895 * procedure for low priority data
 896 see txfromup() for procedure
 897 in short: remote data is ignored during high priority tones
 898
 899 * procedure for high priority data
 900 whenever load is below p_m_preload, load is filled up to p_m_preload
 901 if no more data is available, load becomes empty again.
 902
 903 'load' variable:
 904 0                    p_m_preload           ISDN_MAXLOAD
 905 +--------------------+----------------------+
 906 |                    |                      |
 907 +--------------------+----------------------+
 908
 909 on empty load or on load below p_m_preload, the load is inceased to p_m_preload:
 910 0                    p_m_preload           ISDN_MAXLOAD
 911 +--------------------+----------------------+
 912 |TTTTTTTTTTTTTTTTTTTT|                      |
 913 +--------------------+----------------------+
 914
 915 on empty load, remote-audio causes the load with the remote audio to be increased to p_m_preload.
 916 0                    p_m_preload           ISDN_MAXLOAD
 917 +--------------------+----------------------+
 918 |TTTTTTTTTTTTTTTTTTTTRRRRR                  |
 919 +--------------------+----------------------+
 920
 921  */
 922 void PmISDN::update_load(void)
 923 {
 924         /* don't trigger load event if event already active */
 925         if (p_m_loadtimer.active)
 926                 return;
 927
 928         schedule_timer(&p_m_loadtimer, 0, 0); /* no delay the first time */
 929 }
 930
 931 static int load_timer(struct lcr_timer *timer, void *instance, int index)
 932 {
 933         class PmISDN *isdnport = (class PmISDN *)instance;
 934
 935         isdnport->load_tx();
 936
 937         return 0;
 938 }
 939
 940 void PmISDN::load_tx(void)
 941 {
 942         int elapsed = 0;
 943         int ret;
 944         struct timeval current_time;
 945
 946         /* get elapsed */
 947         gettimeofday(&current_time, NULL);
 948         if (p_m_last_tv_sec) {
 949                 elapsed = 8000 * (current_time.tv_sec - p_m_last_tv_sec)
 950                         + 8 * (current_time.tv_usec/1000 - p_m_last_tv_msec);
 951         }
 952         /* set clock of last process! */
 953         p_m_last_tv_sec = current_time.tv_sec;
 954         p_m_last_tv_msec = current_time.tv_usec/1000;
 955
 956         /* process only if we have samples and we are active */
 957         if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_ACTIVE)
 958                 return;
 959
 960         if (elapsed) {
 961                 /* update load */
 962                 if (elapsed < p_m_load)
 963                         p_m_load -= elapsed;
 964                 else
 965                         p_m_load = 0;
 966
 967                 /* to send data, tone must be on */
 968                 if ((p_tone_name[0] || p_m_crypt_msg_loops || p_m_inband_send_on) /* what tones? */
 969                  && (p_m_load < p_m_preload) /* not too much load? */
 970                  && (p_state==PORT_STATE_CONNECT || p_m_mISDNport->tones || p_m_inband_send_on)) { /* connected or inband-tones? */
 971                         int tosend = p_m_preload - p_m_load, length;
 972                         unsigned char buf[MISDN_HEADER_LEN+tosend];
 973                         struct mISDNhead *frm = (struct mISDNhead *)buf;
 974                         unsigned char *p = buf+MISDN_HEADER_LEN;
 975
 976                         /* copy inband signalling (e.g. used by ss5) */
 977                         if (p_m_inband_send_on && tosend) {
 978                                 tosend -= inband_send(p, tosend);
 979                         }
 980
 981                         /* copy crypto loops */
 982                         while (p_m_crypt_msg_loops && tosend) {
 983                                 /* how much do we have to send */
 984                                 length = p_m_crypt_msg_len - p_m_crypt_msg_current;
 985
 986                                 /* clip tosend */
 987                                 if (length > tosend)
 988                                         length = tosend;
 989
 990                                 /* copy message (part) to buffer */
 991                                 memcpy(p, p_m_crypt_msg+p_m_crypt_msg_current, length);
 992
 993                                 /* new position */
 994                                 p_m_crypt_msg_current += length;
 995                                 if (p_m_crypt_msg_current == p_m_crypt_msg_len) {
 996                                         /* next loop */
 997                                         p_m_crypt_msg_current = 0;
 998                                         p_m_crypt_msg_loops--;
 999                                         if (!p_m_crypt_msg_loops)
1000                                                 update_rxoff();
1001 //                                      puts("eine loop weniger");
1002                                 }
1003
1004                                 /* new length */
1005                                 tosend -= length;
1006                         }
1007
1008                         /* copy tones */
1009                         if (p_tone_name[0] && tosend) {
1010                                 tosend -= read_audio(p, tosend);
1011                         }
1012
1013                         /* send data */
1014                         if (p_m_preload - p_m_load - tosend > 0) {
1015                                 frm->prim = PH_DATA_REQ;
1016                                 frm->id = 0;
1017                                 ret = sendto(p_m_mISDNport->b_sock[p_m_b_index].fd, buf, MISDN_HEADER_LEN+p_m_preload-p_m_load-tosend, 0, NULL, 0);
1018                                 if (ret <= 0)
1019                                         PERROR("Failed to send to socket %d (samples = %d)\n", p_m_mISDNport->b_sock[p_m_b_index].fd, p_m_preload-p_m_load-tosend);
1020                                 p_m_load += p_m_preload - p_m_load - tosend;
1021                         }
1022                 }
1023         }
1024
1025         schedule_timer(&p_m_loadtimer, 0, PORT_TRANSMIT * 125);
1026 }
1027
1028 /* handle timeouts */
1029 static int mISDN_timeout(struct lcr_timer *timer, void *instance, int i)
1030 {
1031         class PmISDN *isdnport = (class PmISDN *)instance;
1032         struct lcr_msg *message;
1033
1034         PDEBUG(DEBUG_ISDN, "(%s) timeout after %d seconds detected (state=%d).\n", isdnport->p_name, isdnport->p_m_timeout.timeout.tv_sec, isdnport->p_state);
1035         /* send timeout to endpoint */
1036         message = message_create(isdnport->p_serial, ACTIVE_EPOINT(isdnport->p_epointlist), PORT_TO_EPOINT, MESSAGE_TIMEOUT);
1037         message->param.state = isdnport->p_state;
1038         message_put(message);
1039
1040         return 0;
1041 }
1042
1043
1044 /*
1045  * whenever we get audio data from bchannel, we process it here
1046  */
1047 void PmISDN::bchannel_receive(struct mISDNhead *hh, unsigned char *data, int len)
1048 {
1049         unsigned int cont = *((unsigned int *)data);
1050         struct lcr_msg *message;
1051         unsigned char *p;
1052         int l;
1053
1054         if (hh->prim == PH_CONTROL_IND) {
1055                 if (len < 4) {
1056                         PERROR("SHORT READ OF PH_CONTROL INDICATION\n");
1057                         return;
1058                 }
1059                 if ((cont&(~DTMF_TONE_MASK)) == DTMF_TONE_VAL) {
1060                         chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1061                         add_trace("DTMF", NULL, "%c", cont & DTMF_TONE_MASK);
1062                         if (!p_m_dtmf)
1063                                 add_trace("info", NULL, "DTMF is disabled");
1064                         end_trace();
1065                         if (!p_m_dtmf)
1066                                 return;
1067                         if (p_type == PORT_TYPE_POTS_FXS_IN && p_state == PORT_STATE_IN_OVERLAP) {
1068                                 class Pfxs *pfxs = (class Pfxs *)this;
1069                                 if (!pfxs->p_m_fxs_allow_dtmf) {
1070                                         PDEBUG(DEBUG_PORT, "PmISDN(%s) DTMF for FXS currently disabled\n", p_name);
1071                                         return;
1072                                 }
1073                                 SCCAT(p_dialinginfo.id, cont & DTMF_TONE_MASK);
1074                                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_INFORMATION);
1075                                 message->param.information.id[0] = cont & DTMF_TONE_MASK;
1076                                 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION  INFORMATION digit '%s'\n", p_name, message->param.information.id);
1077                                 message_put(message);
1078                         } else {
1079                                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_DTMF);
1080                                 message->param.dtmf = cont & DTMF_TONE_MASK;
1081                                 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION  DTMF digit '%c'\n", p_name, message->param.dtmf);
1082                                 message_put(message);
1083                         }
1084                         return;
1085                 }
1086                 switch(cont) {
1087                         case DSP_BF_REJECT:
1088                         chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1089                         add_trace("DSP-CRYPT", NULL, "error");
1090                         end_trace();
1091                         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1092                         message->param.crypt.type = CC_ERROR_IND;
1093                         PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION  reject of blowfish.\n", p_name);
1094                         message_put(message);
1095                         break;
1096
1097                         case DSP_BF_ACCEPT:
1098                         chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1099                         add_trace("DSP-CRYPT", NULL, "ok");
1100                         end_trace();
1101                         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1102                         message->param.crypt.type = CC_ACTBF_CONF;
1103                         PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION  accept of blowfish.\n", p_name);
1104                         message_put(message);
1105                         break;
1106
1107                         default:
1108                         chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1109                         add_trace("unknown", NULL, "0x%x", cont);
1110                         end_trace();
1111                 }
1112                 return;
1113         }
1114         if (hh->prim == PH_CONTROL_IND) {
1115                 switch(hh->id) {
1116                         default:
1117                         chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1118                         add_trace("unknown", NULL, "0x%x", hh->id);
1119                         end_trace();
1120                 }
1121                 return;
1122         }
1123         if (hh->prim == PH_DATA_REQ || hh->prim == DL_DATA_REQ) {
1124                 if (!p_m_txdata) {
1125                         /* if tx is off, it may happen that fifos send us pending informations, we just ignore them */
1126                         PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring tx data, because 'txdata' is turned off\n", p_name);
1127                         return;
1128                 }
1129                 /* see below (same condition) */
1130                 if (p_state!=PORT_STATE_CONNECT
1131                          && !p_m_mISDNport->tones)
1132                         return;
1133 //              printf(".");fflush(stdout);return;
1134                 if (p_record)
1135                         record(data, len, 1); // from up
1136                 if (p_tap)
1137                         tap(data, len, 1); // from up
1138                 return;
1139         }
1140         if (hh->prim != PH_DATA_IND && hh->prim != DL_DATA_IND) {
1141                 PERROR("Bchannel received unknown primitve: 0x%x\n", hh->prim);
1142                 return;
1143         }
1144
1145         /* inband is processed */
1146         if (p_m_inband_receive_on)
1147                 inband_receive(data, len);
1148
1149         /* send to remote, if bridged */
1150         bridge_tx(data, len);
1151
1152         /* calls will not process any audio data unless
1153          * the call is connected OR tones feature is enabled.
1154          */
1155 #ifndef DEBUG_COREBRIDGE
1156         if (p_state!=PORT_STATE_CONNECT
1157          && !p_m_mISDNport->tones)
1158                 return;
1159 #endif
1160
1161 #if 0
1162         /* the bearer capability must be audio in order to send and receive
1163          * audio prior or after connect.
1164          */
1165         if (!(p_bearerinfo.capability&CLASS_CAPABILITY_AUDIO) && p_state!=PORT_STATE_CONNECT)
1166                 return;
1167 #endif
1168
1169         /* if rx is off, it may happen that fifos send us pending informations, we just ignore them */
1170         if (p_m_rxoff) {
1171                 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring data, because rx is turned off\n", p_name);
1172                 return;
1173         }
1174
1175         /* record data */
1176         if (p_record)
1177                 record(data, len, 0); // from down
1178         if (p_tap)
1179                 tap(data, len, 0); // from down
1180
1181         /* randomize and listen to crypt message if enabled */
1182         if (p_m_crypt_listen) {
1183                 /* the noisy randomizer */
1184                 p = data;
1185                 l = len;
1186                 while(l--)
1187                         mISDN_rand[mISDN_rand_count & 0xff] += *p++;
1188
1189                 cryptman_listen_bch(data, len);
1190         }
1191 }
1192
1193
1194 /*
1195  * set echotest
1196  */
1197 void PmISDN::set_echotest(int echo)
1198 {
1199         if (p_m_echo != echo) {
1200                 p_m_echo = echo;
1201                 PDEBUG(DEBUG_ISDN, "we set echo to echo=%d.\n", p_m_echo);
1202                 if (p_m_b_channel)
1203                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1204                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, p_m_echo?DSP_ECHO_ON:DSP_ECHO_OFF, 0, "DSP-ECHO", p_m_echo);
1205         }
1206 }
1207
1208 /*
1209  * set tone
1210  */
1211 void PmISDN::set_tone(const char *dir, const char *tone)
1212 {
1213         int id = TONE_OFF;
1214         int dsp = DSP_NONE;
1215
1216         /* if no directory is given (by extension), we use interface.conf or options.conf */
1217         if (!dir || !dir[0]) {
1218                 if (p_m_mISDNport->ifport->tones_dir[0])
1219                         dir = p_m_mISDNport->ifport->tones_dir;
1220                 else if (options.tones_dir[0])
1221                         dir = options.tones_dir;
1222         }
1223
1224         if (!tone)
1225                 tone = "";
1226         PDEBUG(DEBUG_ISDN, "isdn port now plays tone:'%s'.\n", tone);
1227         if (!tone[0]) {
1228                 id = TONE_OFF;
1229                 goto setdsp;
1230         }
1231
1232         /* check for dsp tones */
1233         if (!strcmp(dir, "american"))
1234                 dsp = DSP_AMERICAN;
1235         if (!strcmp(dir, "german"))
1236                 dsp = DSP_GERMAN;
1237         if (!strcmp(dir, "oldgerman"))
1238                 dsp = DSP_OLDGERMAN;
1239
1240         /* check if we NOT really have to use a dsp-tone */
1241         if (dsp == DSP_NONE) {
1242                 nodsp:
1243                 if (p_m_tone)
1244                 if (p_m_b_index > -1)
1245                 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT) {
1246                         PDEBUG(DEBUG_ISDN, "we reset tone from id=%d to OFF.\n", p_m_tone);
1247                         ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TONE_PATT_OFF, 0, "DSP-TONE", 0);
1248                 }
1249                 p_m_tone = 0;
1250                 Port::set_tone(dir, tone);
1251                 return;
1252         }
1253
1254         /* now we USE dsp-tone, convert name */
1255         if (!strcmp(tone, "dialtone")) {
1256                 switch(dsp) {
1257                 case DSP_AMERICAN: id = TONE_AMERICAN_DIALTONE; break;
1258                 case DSP_GERMAN: id = TONE_GERMAN_DIALTONE; break;
1259                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALTONE; break;
1260                 }
1261         } else if (!strcmp(tone, "dialpbx")) {
1262                 switch(dsp) {
1263                 case DSP_AMERICAN: id = TONE_AMERICAN_DIALPBX; break;
1264                 case DSP_GERMAN: id = TONE_GERMAN_DIALPBX; break;
1265                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALPBX; break;
1266                 }
1267         } else if (!strcmp(tone, "ringing")) {
1268                 switch(dsp) {
1269                 case DSP_AMERICAN: id = TONE_AMERICAN_RINGING; break;
1270                 case DSP_GERMAN: id = TONE_GERMAN_RINGING; break;
1271                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGING; break;
1272                 }
1273         } else if (!strcmp(tone, "ringpbx")) {
1274                 switch(dsp) {
1275                 case DSP_AMERICAN: id = TONE_AMERICAN_RINGPBX; break;
1276                 case DSP_GERMAN: id = TONE_GERMAN_RINGPBX; break;
1277                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGPBX; break;
1278                 }
1279         } else if (!strcmp(tone, "busy")) {
1280                 busy:
1281                 switch(dsp) {
1282                 case DSP_AMERICAN: id = TONE_AMERICAN_BUSY; break;
1283                 case DSP_GERMAN: id = TONE_GERMAN_BUSY; break;
1284                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1285                 }
1286         } else if (!strcmp(tone, "release")) {
1287                 hangup:
1288                 switch(dsp) {
1289                 case DSP_AMERICAN: id = TONE_AMERICAN_HANGUP; break;
1290                 case DSP_GERMAN: id = TONE_GERMAN_HANGUP; break;
1291                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDHANGUP; break;
1292                 }
1293         } else if (!strcmp(tone, "cause_10"))
1294                 goto hangup;
1295         else if (!strcmp(tone, "cause_11"))
1296                 goto busy;
1297         else if (!strcmp(tone, "cause_22")) {
1298                 switch(dsp) {
1299                 case DSP_AMERICAN: id = TONE_SPECIAL_INFO; break;
1300                 case DSP_GERMAN: id = TONE_GERMAN_GASSENBESETZT; break;
1301                 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1302                 }
1303         } else if (!strncmp(tone, "cause_", 6))
1304                 id = TONE_SPECIAL_INFO;
1305         else
1306                 id = TONE_OFF;
1307
1308         /* if we have a tone that is not supported by dsp */
1309         if (id==TONE_OFF && tone[0])
1310                 goto nodsp;
1311
1312         setdsp:
1313         if (p_m_tone != id) {
1314                 /* set new tone */
1315                 p_m_tone = id;
1316                 PDEBUG(DEBUG_ISDN, "we set tone to id=%d.\n", p_m_tone);
1317                 if (p_m_b_index > -1)
1318                 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT)
1319                         ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, p_m_tone?DSP_TONE_PATT_ON:DSP_TONE_PATT_OFF, p_m_tone, "DSP-TONE", p_m_tone);
1320         }
1321         /* turn user-space tones off in cases of no tone OR dsp tone */
1322         Port::set_tone("",NULL);
1323 }
1324
1325
1326 /* MESSAGE_mISDNSIGNAL */
1327 //extern struct lcr_msg *dddebug;
1328 void PmISDN::message_mISDNsignal(unsigned int epoint_id, int message_id, union parameter *param)
1329 {
1330         int oldconf, newconf;
1331         switch(param->mISDNsignal.message) {
1332                 case mISDNSIGNAL_VOLUME:
1333                 if (p_m_tx_gain != param->mISDNsignal.tx_gain) {
1334                         p_m_tx_gain = param->mISDNsignal.tx_gain;
1335                         PDEBUG(DEBUG_BCHANNEL, "we change tx-volume to shift=%d.\n", p_m_tx_gain);
1336                         if (p_m_b_index > -1)
1337                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT)
1338                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_VOL_CHANGE_TX, p_m_tx_gain, "DSP-TX_GAIN", p_m_tx_gain);
1339                 } else
1340                         PDEBUG(DEBUG_BCHANNEL, "we already have tx-volume shift=%d.\n", p_m_rx_gain);
1341                 if (p_m_rx_gain != param->mISDNsignal.rx_gain) {
1342                         p_m_rx_gain = param->mISDNsignal.rx_gain;
1343                         PDEBUG(DEBUG_BCHANNEL, "we change rx-volume to shift=%d.\n", p_m_rx_gain);
1344                         if (p_m_b_index > -1)
1345                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT)
1346                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_VOL_CHANGE_RX, p_m_rx_gain, "DSP-RX_GAIN", p_m_rx_gain);
1347                 } else
1348                         PDEBUG(DEBUG_BCHANNEL, "we already have rx-volume shift=%d.\n", p_m_rx_gain);
1349                 break;
1350
1351                 case mISDNSIGNAL_CONF:
1352                 oldconf = p_m_mute?0:p_m_conf;
1353                 p_m_conf = param->mISDNsignal.conf;
1354                 newconf = p_m_mute?0:p_m_conf;
1355                 set_conf(oldconf, newconf);
1356                 break;
1357
1358                 case mISDNSIGNAL_DELAY:
1359                 if (p_m_delay != param->mISDNsignal.delay) {
1360                         p_m_delay = param->mISDNsignal.delay;
1361                         PDEBUG(DEBUG_BCHANNEL, "we change delay mode to delay=%d.\n", p_m_delay);
1362                         if (p_m_b_index > -1)
1363                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT)
1364                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, p_m_delay?DSP_DELAY:DSP_JITTER, p_m_delay, "DSP-DELAY", p_m_delay);
1365                 } else
1366                         PDEBUG(DEBUG_BCHANNEL, "we already have delay=%d.\n", p_m_delay);
1367                 break;
1368
1369                 default:
1370                 PERROR("PmISDN(%s) unsupported signal message %d.\n", p_name, param->mISDNsignal.message);
1371         }
1372 }
1373
1374 /* MESSAGE_CRYPT */
1375 void PmISDN::message_crypt(unsigned int epoint_id, int message_id, union parameter *param)
1376 {
1377         struct lcr_msg *message;
1378
1379         switch(param->crypt.type) {
1380                 case CC_ACTBF_REQ:           /* activate blowfish */
1381                 p_m_crypt = 1;
1382                 p_m_crypt_key_len = param->crypt.len;
1383                 if (p_m_crypt_key_len > (int)sizeof(p_m_crypt_key)) {
1384                         PERROR("PmISDN(%s) key too long %d > %d\n", p_name, p_m_crypt_key_len, sizeof(p_m_crypt_key));
1385                         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1386                         message->param.crypt.type = CC_ERROR_IND;
1387                         message_put(message);
1388                         break;
1389                 }
1390                 memcpy(p_m_crypt_key, param->crypt.data, p_m_crypt_key_len);
1391                 crypt_off:
1392                 PDEBUG(DEBUG_BCHANNEL, "we set encryption to crypt=%d. (0 means OFF)\n", p_m_crypt);
1393                 if (p_m_b_index > -1)
1394                 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT)
1395                         ph_control_block(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, p_m_crypt?DSP_BF_ENABLE_KEY:DSP_BF_DISABLE, p_m_crypt_key, p_m_crypt_key_len, "DSP-CRYPT", p_m_crypt_key_len);
1396                 break;
1397
1398                 case CC_DACT_REQ:            /* deactivate session encryption */
1399                 p_m_crypt = 0;
1400                 goto crypt_off;
1401                 break;
1402
1403                 case CR_LISTEN_REQ:          /* start listening to messages */
1404                 p_m_crypt_listen = 1;
1405                 update_rxoff();
1406                 p_m_crypt_listen_state = 0;
1407                 break;
1408
1409                 case CR_UNLISTEN_REQ:        /* stop listening to messages */
1410                 p_m_crypt_listen = 0;
1411                 update_rxoff();
1412                 break;
1413
1414                 case CR_MESSAGE_REQ:         /* send message */
1415                 p_m_crypt_msg_len = cryptman_encode_bch(param->crypt.data, param->crypt.len, p_m_crypt_msg, sizeof(p_m_crypt_msg));
1416                 if (!p_m_crypt_msg_len) {
1417                         PERROR("PmISDN(%s) message too long %d > %d\n", p_name, param->crypt.len-1, sizeof(p_m_crypt_msg));
1418                         break;
1419                 }
1420                 p_m_crypt_msg_current = 0; /* reset */
1421                 p_m_crypt_msg_loops = 6; /* enable */
1422                 update_rxoff();
1423 #if 0
1424                 /* disable txmix, or we get corrupt data due to audio process */
1425                 if (p_m_txmix && p_m_b_index>=0 && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT) {
1426                         PDEBUG(DEBUG_BCHANNEL, "for sending CR_MESSAGE_REQ, we reset txmix from txmix=%d.\n", p_m_txmix);
1427                         ph_control(p_m_mISDNport, this, p_mISDNport->b_sock[p_m_b_index].fd, DSP_MIX_OFF, 0, "DSP-TXMIX", 0);
1428                 }
1429 #endif
1430                 break;
1431
1432                 default:
1433                 PERROR("PmISDN(%s) unknown crypt message %d\n", p_name, param->crypt.type);
1434         }
1435
1436 }
1437
1438 /* MESSAGE_VOOTP */
1439 void PmISDN::message_vootp(unsigned int epoint_id, int message_id, union parameter *param)
1440 {
1441         struct lcr_msg *message;
1442
1443         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_UPDATEBRIDGE);
1444         message_put(message);
1445
1446 #if 0
1447 does not make sense, since remote port may dejitter
1448         if (param->vootp.enable) {
1449                 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received vootp enable order, so we disable de-jitter.\n", p_name);
1450                 p_m_disable_dejitter = 1;
1451         }
1452 #endif
1453         update_rxoff();
1454 }
1455
1456 /*
1457  * endpoint sends messages to the port
1458  */
1459 int PmISDN::message_epoint(unsigned int epoint_id, int message_id, union parameter *param)
1460 {
1461         /* messages also handled by base class */
1462         switch(message_id) {
1463                 case MESSAGE_VOOTP: /* crypt control command */
1464                 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received VoOTP encryption\n", p_name);
1465                 message_vootp(epoint_id, message_id, param);
1466                 break;
1467         }
1468
1469         if (Port::message_epoint(epoint_id, message_id, param)) {
1470                 if (message_id == MESSAGE_BRIDGE)
1471                         update_rxoff();
1472                 return 1;
1473         }
1474
1475         /* messages not handled by base class */
1476         switch(message_id) {
1477                 case MESSAGE_mISDNSIGNAL: /* user command */
1478                 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received special ISDN SIGNAL %d.\n", p_name, param->mISDNsignal.message);
1479                 message_mISDNsignal(epoint_id, message_id, param);
1480                 return 1;
1481
1482                 case MESSAGE_CRYPT: /* crypt control command */
1483                 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received encryption command '%d'.\n", p_name, param->crypt.type);
1484                 message_crypt(epoint_id, message_id, param);
1485                 return 1;
1486
1487                 case MESSAGE_DISABLE_DEJITTER:
1488                 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received de-jitter disable order.\n", p_name);
1489                 p_m_disable_dejitter = 1;
1490                 p_m_preload = param->queue;
1491                 update_rxoff();
1492                 return 1;
1493         }
1494
1495         return 0;
1496 }
1497
1498 void PmISDN::update_rxoff(void)
1499 {
1500         int tx_dejitter = 0;
1501
1502         /* call bridges in user space OR crypto OR recording */
1503         if (p_bridge || p_m_crypt_msg_loops || p_m_crypt_listen || p_record || p_tap || p_m_inband_receive_on) {
1504                 /* rx IS required */
1505                 if (p_m_rxoff) {
1506                         /* turn on RX */
1507                         p_m_rxoff = 0;
1508                         PDEBUG(DEBUG_BCHANNEL, "%s: receive data is required, so we turn them on\n", __FUNCTION__);
1509                         if (p_m_b_index > -1)
1510                                 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1511                                         ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_RECEIVE_ON, 0, "DSP-RXOFF", 0);
1512                 }
1513         } else {
1514                 /* rx NOT required */
1515                 if (!p_m_rxoff) {
1516                         /* turn off RX */
1517                         p_m_rxoff = 1;
1518                         PDEBUG(DEBUG_BCHANNEL, "%s: receive data is not required, so we turn them off\n", __FUNCTION__);
1519                         if (p_m_b_index > -1)
1520                                 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1521                                         ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
1522                 }
1523         }
1524         /* recording / tapping */
1525         if (p_record || p_tap) {
1526                 /* txdata IS required */
1527                 if (!p_m_txdata) {
1528                         /* turn on RX */
1529                         p_m_txdata = 1;
1530                         PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is required, so we turn them on\n", __FUNCTION__);
1531                         if (p_m_b_index > -1)
1532                                 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1533                                         ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TXDATA_ON, 0, "DSP-TXDATA", 1);
1534                 }
1535         } else {
1536                 /* txdata NOT required */
1537                 if (p_m_txdata) {
1538                         /* turn off RX */
1539                         p_m_txdata = 0;
1540                         PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is not required, so we turn them off\n", __FUNCTION__);
1541                         if (p_m_b_index > -1)
1542                                 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1543                                         ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TXDATA_OFF, 0, "DSP-TXDATA", 0);
1544                 }
1545         }
1546         /* dejitter on bridge */
1547         if (p_bridge && !p_m_disable_dejitter)
1548                 tx_dejitter = 1;
1549         if (p_m_tx_dejitter != tx_dejitter) {
1550                 p_m_tx_dejitter = tx_dejitter;
1551                 PDEBUG(DEBUG_BCHANNEL, "we change dejitter mode to %s.\n", (p_m_tx_dejitter) ? "on" : "off");
1552                 if (p_m_b_index > -1)
1553                         if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT)
1554                                 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TX_DEJITTER, p_m_tx_dejitter, "DSP-TX_DEJITTER", p_m_tx_dejitter);
1555         }
1556 }
1557
1558 static int mISDN_upqueue(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1559 {
1560         struct mISDNport *mISDNport;
1561         struct mbuffer *mb;
1562         struct l3_msg *l3m;
1563         char byte;
1564         int __attribute__((__unused__)) ret;
1565
1566         /* unset global semaphore */
1567         upqueue_avail = 0;
1568         // with a very small incident, upqueue_avail may be set by mISDN thread and
1569         // another byte may be sent to the pipe, which causes a call to this function
1570         // again with nothing in the upqueue. this is no problem.
1571         ret = read(fd->fd, &byte, 1);
1572
1573         /* process all ports */
1574         mISDNport = mISDNport_first;
1575         while(mISDNport) {
1576                 /* handle queued up-messages (d-channel) */
1577                 while ((mb = mdequeue(&mISDNport->upqueue))) {
1578                         l3m = &mb->l3;
1579                         switch(l3m->type) {
1580                                 case MPH_ACTIVATE_IND:
1581                                 if (mISDNport->l1link != 1) {
1582                                         l1l2l3_trace_header(mISDNport, NULL, L1_ACTIVATE_IND, DIRECTION_IN);
1583                                         end_trace();
1584                                         mISDNport->l1link = 1;
1585                                 }
1586                                 break;
1587
1588                                 case MPH_DEACTIVATE_IND:
1589                                 if (mISDNport->l1link != 0) {
1590                                         l1l2l3_trace_header(mISDNport, NULL, L1_DEACTIVATE_IND, DIRECTION_IN);
1591                                         end_trace();
1592                                         mISDNport->l1link = 0;
1593                                 }
1594                                 break;
1595
1596                                 case MPH_INFORMATION_IND:
1597                                 PDEBUG(DEBUG_ISDN, "Received MPH_INFORMATION_IND for port %d (%s).\n", mISDNport->portnum, mISDNport->ifport->interface->name);
1598                                 switch (l3m->pid) {
1599                                         case L1_SIGNAL_LOS_ON:
1600                                         mISDNport->los = 1;
1601                                         break;
1602                                         case L1_SIGNAL_LOS_OFF:
1603                                         mISDNport->los = 0;
1604                                         break;
1605                                         case L1_SIGNAL_AIS_ON:
1606                                         mISDNport->ais = 1;
1607                                         break;
1608                                         case L1_SIGNAL_AIS_OFF:
1609                                         mISDNport->ais = 0;
1610                                         break;
1611                                         case L1_SIGNAL_RDI_ON:
1612                                         mISDNport->rdi = 1;
1613                                         break;
1614                                         case L1_SIGNAL_RDI_OFF:
1615                                         mISDNport->rdi = 0;
1616                                         break;
1617                                         case L1_SIGNAL_SLIP_TX:
1618                                         mISDNport->slip_tx++;
1619                                         break;
1620                                         case L1_SIGNAL_SLIP_RX:
1621                                         mISDNport->slip_rx++;
1622                                         break;
1623                                 }
1624                                 break;
1625
1626                                 case MT_L2ESTABLISH:
1627                                 l1l2l3_trace_header(mISDNport, NULL, L2_ESTABLISH_IND, DIRECTION_IN);
1628                                 add_trace("tei", NULL, "%d", l3m->pid);
1629                                 end_trace();
1630                                 mISDNport->l2link = 1;
1631                                 if (l3m->pid < 128)
1632                                         mISDNport->l2mask[l3m->pid >> 3] |= (1 << (l3m->pid & 7));
1633                                 if ((!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127) {
1634                                         if (mISDNport->l2establish.active) {
1635                                                 unsched_timer(&mISDNport->l2establish);
1636                                                 PDEBUG(DEBUG_ISDN, "the link became active before l2establish timer expiry.\n");
1637                                         }
1638                                 }
1639                                 break;
1640
1641                                 case MT_L2RELEASE:
1642                                 if (l3m->pid < 128)
1643                                         mISDNport->l2mask[l3m->pid >> 3] &= ~(1 << (l3m->pid & 7));
1644                                 if (!mISDNport->l2establish.active) {
1645                                         l1l2l3_trace_header(mISDNport, NULL, L2_RELEASE_IND, DIRECTION_IN);
1646                                         add_trace("tei", NULL, "%d", l3m->pid);
1647                                         end_trace();
1648                                         /* down if not nt-ptmp */
1649                                         if (!mISDNport->ntmode || mISDNport->ptp)
1650                                                 mISDNport->l2link = 0;
1651                                 }
1652                                 if ((!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127) {
1653                                         if (!mISDNport->l2establish.active && mISDNport->l2hold) {
1654                                                 PDEBUG(DEBUG_ISDN, "set timer and establish.\n");
1655                                                 schedule_timer(&mISDNport->l2establish, 5, 0);
1656                                                 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
1657                                         }
1658                                 }
1659                                 break;
1660
1661                                 default:
1662                                 /* l3-data is sent to LCR */
1663                                 stack2manager(mISDNport, l3m->type, l3m->pid, l3m);
1664                         }
1665                         /* free message */
1666                         free_l3_msg(l3m);
1667                 }
1668                 mISDNport = mISDNport->next;
1669         }
1670         return 0;
1671 }
1672
1673 /* l2 establish timer fires */
1674 static int l2establish_timeout(struct lcr_timer *timer, void *instance, int i)
1675 {
1676         struct mISDNport *mISDNport = (struct mISDNport *)instance;
1677
1678         if (mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode)) {
1679                 PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link portnum=%d.\n", mISDNport->portnum);
1680                 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
1681                 schedule_timer(&mISDNport->l2establish, 5, 0); /* 5 seconds */
1682         }
1683
1684         return 0;
1685 }
1686
1687 /* handle frames from bchannel */
1688 static int b_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1689 {
1690         struct mISDNport *mISDNport = (struct mISDNport *)instance;
1691         unsigned char buffer[2048+MISDN_HEADER_LEN];
1692         struct mISDNhead *hh = (struct mISDNhead *)buffer;
1693         int ret;
1694
1695         ret = recv(fd->fd, buffer, sizeof(buffer), 0);
1696         if (ret < 0) {
1697                 PERROR("read error frame, errno %d\n", errno);
1698                 return 0;
1699         }
1700         if (ret < (int)MISDN_HEADER_LEN) {
1701                 PERROR("read short frame, got %d, expected %d\n", ret, (int)MISDN_HEADER_LEN);
1702                 return 0;
1703         }
1704         switch(hh->prim) {
1705                 /* we don't care about confirms, we use rx data to sync tx */
1706                 case PH_DATA_CNF:
1707                 break;
1708
1709                 /* we receive audio data, we respond to it AND we send tones */
1710                 case PH_DATA_IND:
1711                 case DL_DATA_IND:
1712                 case PH_DATA_REQ:
1713                 case DL_DATA_REQ:
1714                 case PH_CONTROL_IND:
1715                 if (mISDNport->b_port[i])
1716                         mISDNport->b_port[i]->bchannel_receive(hh, buffer+MISDN_HEADER_LEN, ret-MISDN_HEADER_LEN);
1717                 else
1718                         PDEBUG(DEBUG_BCHANNEL, "b-channel is not associated to an ISDNPort (socket %d), ignoring.\n", fd->fd);
1719                 break;
1720
1721                 case PH_ACTIVATE_IND:
1722                 case DL_ESTABLISH_IND:
1723                 case PH_ACTIVATE_CNF:
1724                 case DL_ESTABLISH_CNF:
1725                 PDEBUG(DEBUG_BCHANNEL, "DL_ESTABLISH confirm: bchannel is now activated (socket %d).\n", fd->fd);
1726                 bchannel_event(mISDNport, i, B_EVENT_ACTIVATED);
1727                 break;
1728
1729                 case PH_DEACTIVATE_IND:
1730                 case DL_RELEASE_IND:
1731                 case PH_DEACTIVATE_CNF:
1732                 case DL_RELEASE_CNF:
1733                 PDEBUG(DEBUG_BCHANNEL, "DL_RELEASE confirm: bchannel is now de-activated (socket %d).\n", fd->fd);
1734                 bchannel_event(mISDNport, i, B_EVENT_DEACTIVATED);
1735                 break;
1736
1737                 default:
1738                 PERROR("child message not handled: prim(0x%x) socket(%d) msg->len(%d)\n", hh->prim, fd->fd, ret-MISDN_HEADER_LEN);
1739         }
1740
1741         return 0;
1742 }
1743
1744 /* process timer events for bchannel handling */
1745 static int b_timer_timeout(struct lcr_timer *timer, void *instance, int i)
1746 {
1747         struct mISDNport *mISDNport = (struct mISDNport *)instance;
1748
1749         bchannel_event(mISDNport, i, B_EVENT_TIMEOUT);
1750
1751         return 0;
1752 }
1753
1754
1755 int do_layer3(struct mlayer3 *ml3, unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1756 {
1757         /* IMPORTAINT:
1758          *
1759          * l3m must be queued, except for MT_ASSIGN
1760          *
1761          */
1762         struct mISDNport *mISDNport = (struct mISDNport *)ml3->priv;
1763         struct mbuffer *mb;
1764
1765 #ifdef OLD_MT_ASSIGN
1766         /* special MT_ASSIGN handling:
1767          *
1768          * if we request a PID from mlayer, we always do it while lcr is locked.
1769          * therefore we must check the MT_ASSIGN reply first before we lock.
1770          * this is because the MT_ASSIGN reply is received with the requesting
1771          * process, not by the mlayer thread!
1772          * this means, that the reply is sent during call of the request.
1773          * we must check if we get a reply and we know that we lcr is currently
1774          * locked.
1775          */
1776         if (cmd==MT_ASSIGN && (pid&MISDN_PID_CR_FLAG) && (pid>>16)==MISDN_CES_MASTER) {
1777                 /* let's do some checking if someone changes stack behaviour */
1778                 if (mt_assign_pid != 0)
1779                         FATAL("someone played with the mISDNuser stack. MT_ASSIGN not currently expected.\n");
1780                 mt_assign_pid = pid;
1781                 return(0);
1782         }
1783 #endif
1784         /* queue message, create, if required */
1785         if (!l3m) {
1786                 l3m = alloc_l3_msg();
1787                 if (!l3m)
1788                         FATAL("No memory for layer 3 message\n");
1789         }
1790         mb = container_of(l3m, struct mbuffer, l3);
1791         l3m->type = cmd;
1792         l3m->pid = pid;
1793         mqueue_tail(&mISDNport->upqueue, mb);
1794         if (!upqueue_avail) {
1795                 // multiple threads may cause multiple calls of this section, but this
1796                 // results only in multiple processing of the upqueue read.
1797                 // this is no problem.
1798                 upqueue_avail = 1;
1799                 char byte = 0;
1800                 int __attribute__((__unused__)) ret;
1801                 ret = write(upqueue_pipe[1], &byte, 1);
1802         }
1803         return 0;
1804 }
1805
1806 int mISDN_getportbyname(int sock, int cnt, char *portname)
1807 {
1808         struct mISDN_devinfo devinfo;
1809         int port = 0, ret;
1810
1811         /* resolve name */
1812         while (port < cnt) {
1813                 devinfo.id = port;
1814                 ret = ioctl(sock, IMGETDEVINFO, &devinfo);
1815                 if (ret < 0)
1816                         return ret;
1817                 if (!strcasecmp(devinfo.name, portname))
1818                         break;
1819                 port++;
1820         }
1821         if (port == cnt)
1822                 return -EIO;
1823
1824         return (port);
1825 }
1826
1827 #ifdef ISDN_P_FXS_POTS
1828 /* handle frames from pots */
1829 static int pots_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1830 {
1831         struct mISDNport *mISDNport = (struct mISDNport *)instance;
1832         unsigned char buffer[2048+MISDN_HEADER_LEN];
1833         struct mISDNhead *hh = (struct mISDNhead *)buffer;
1834         unsigned int cont;
1835         int ret;
1836
1837         ret = recv(fd->fd, buffer, sizeof(buffer), 0);
1838         if (ret < 0) {
1839                 PERROR("read error frame, errno %d\n", errno);
1840                 return 0;
1841         }
1842         if (ret < (int)MISDN_HEADER_LEN) {
1843                 PERROR("read short frame, got %d, expected %d\n", ret, (int)MISDN_HEADER_LEN);
1844                 return 0;
1845         }
1846         switch(hh->prim) {
1847         case PH_CONTROL_IND:
1848                 cont = *((unsigned int *)(buffer + MISDN_HEADER_LEN));
1849                 /* l1-control is sent to LCR */
1850                 if (mISDNport->ntmode)
1851                         stack2manager_fxs(mISDNport, cont);
1852                 else
1853                         PERROR("FXO not supported!\n");
1854                 break;
1855         case PH_ACTIVATE_REQ:
1856                 break;
1857
1858         default:
1859                 PERROR("child message not handled: prim(0x%x) socket(%d) msg->len(%d)\n", hh->prim, fd->fd, ret-MISDN_HEADER_LEN);
1860         }
1861
1862         return 0;
1863 }
1864 #endif
1865
1866 /*
1867  * global function to add a new card (port)
1868  */
1869 struct mISDNport *mISDNport_open(struct interface_port *ifport)
1870 {
1871         int ret;
1872         struct mISDNport *mISDNport, **mISDNportp;
1873         int port = ifport->portnum;
1874         int ptp = ifport->ptp;
1875         int force_nt = ifport->nt;
1876         int l1hold = ifport->l1hold;
1877         int l2hold = ifport->l2hold;
1878         int ss5 = ifport->ss5;
1879         int i, cnt;
1880         int pri, bri, pots;
1881         int nt, te;
1882 //      struct mlayer3 *ml3;
1883         struct mISDN_devinfo devinfo;
1884         unsigned int protocol, prop;
1885
1886         /* check port counts */
1887         ret = ioctl(mISDNsocket, IMGETCOUNT, &cnt);
1888         if (ret < 0) {
1889                 fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret);
1890                 return(NULL);
1891         }
1892
1893         if (cnt <= 0) {
1894                 PERROR_RUNTIME("Found no card. Please be sure to load card drivers.\n");
1895                 return(NULL);
1896         }
1897         if (port < 0) {
1898                 port = mISDN_getportbyname(mISDNsocket, cnt, ifport->portname);
1899                 if (port < 0) {
1900                         PERROR_RUNTIME("Port name '%s' not found, use 'misdn_info' tool to list all existing ports.\n", ifport->portname);
1901                         return(NULL);
1902                 }
1903                 // note: 'port' has still the port number
1904         }
1905         if (port>cnt || port<0) {
1906                 PERROR_RUNTIME("Port (%d) given at 'ports' (options.conf) is out of existing port range (%d-%d)\n", port, 0, cnt);
1907                 return(NULL);
1908         }
1909
1910         /* get port attributes */
1911         pri = bri = pots = nt = te = 0;
1912         devinfo.id = port;
1913         ret = ioctl(mISDNsocket, IMGETDEVINFO, &devinfo);
1914         if (ret < 0) {
1915                 PERROR_RUNTIME("Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", port, ret);
1916                 return(NULL);
1917         }
1918         if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0)) {
1919                 bri = 1;
1920                 te = 1;
1921         }
1922         if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0)) {
1923                 bri = 1;
1924                 nt = 1;
1925         }
1926         if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1)) {
1927                 pri = 1;
1928                 te = 1;
1929         }
1930         if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1)) {
1931                 pri = 1;
1932                 nt = 1;
1933         }
1934 #ifdef ISDN_P_FXS_POTS
1935         if (devinfo.Dprotocols & (1 << ISDN_P_FXO_POTS)) {
1936                 pots = 1;
1937                 te = 1;
1938         }
1939         if (devinfo.Dprotocols & (1 << ISDN_P_FXS_POTS)) {
1940                 pots = 1;
1941                 nt = 1;
1942         }
1943 #endif
1944         if (force_nt && !nt) {
1945                 if (!pots)
1946                         PERROR_RUNTIME("Port %d does not support NT-mode\n", port);
1947                 else
1948                         PERROR_RUNTIME("Port %d does not support FXS-mode\n", port);
1949                 return(NULL);
1950         }
1951         if (bri && pri) {
1952                 PERROR_RUNTIME("Port %d supports BRI and PRI?? What kind of controller is that?. (Can't use this!)\n", port);
1953                 return(NULL);
1954         }
1955         if (!bri && !pri && !pots) {
1956                 PERROR_RUNTIME("Port %d does not support BRI nor PRI nor POTS!\n", port);
1957                 return(NULL);
1958         }
1959         if (!nt && !te) {
1960                 PERROR_RUNTIME("Port %d does not support NT-mode nor TE-mode!\n", port);
1961                 return(NULL);
1962         }
1963         /* set NT by turning off TE */
1964         if (force_nt && nt)
1965                 te = 0;
1966         /* if TE an NT is supported (and not forced to NT), turn off NT */
1967         if (te && nt)
1968                 nt = 0;
1969         if (pots && te) {
1970                 PERROR_RUNTIME("Port %d uses FXO-mode, but not supported by LCR!\n", port);
1971                 return(NULL);
1972         }
1973
1974         /* check for double use of port */
1975         if (nt) {
1976                 mISDNport = mISDNport_first;
1977                 while(mISDNport) {
1978                         if (mISDNport->portnum == port)
1979                                 break;
1980                         mISDNport = mISDNport->next;
1981                 }
1982                 if (mISDNport) {
1983                         PERROR_RUNTIME("Port %d already in use by LCR. You can't use a NT port multiple times.\n", port);
1984                         return(NULL);
1985                 }
1986         }
1987
1988         /* check for continous channelmap with no bchannel on slot 16 */
1989         if (test_channelmap(0, devinfo.channelmap)) {
1990                 PERROR_RUNTIME("Port %d provides channel 0, but we cannot access it!\n", port);
1991                 return(NULL);
1992         }
1993         i = 1;
1994         while(i < (int)devinfo.nrbchan + 1) {
1995                 if (i == 16) {
1996                         if (test_channelmap(i, devinfo.channelmap)) {
1997                                 PERROR("Port %d provides bchannel 16. Pleas upgrade mISDN, if this port is mISDN loopback interface.\n", port);
1998                                 return(NULL);
1999                         }
2000                 } else {
2001                         if (!test_channelmap(i, devinfo.channelmap)) {
2002                                 PERROR_RUNTIME("Port %d has no channel on slot %d!\n", port, i);
2003                                 return(NULL);
2004                         }
2005                 }
2006                 i++;
2007         }
2008
2009         /* add mISDNport structure */
2010         mISDNportp = &mISDNport_first;
2011         while(*mISDNportp)
2012                 mISDNportp = &((*mISDNportp)->next);
2013         mISDNport = (struct mISDNport *)MALLOC(sizeof(struct mISDNport));
2014         add_timer(&mISDNport->l2establish, l2establish_timeout, mISDNport, 0);
2015         if (ss5) {
2016                 /* ss5 link is always active */
2017                 mISDNport->l1link = 1;
2018                 mISDNport->l2link = 1;
2019         } else {
2020                 mISDNport->l1link = -1;
2021                 mISDNport->l2link = -1;
2022         }
2023         pmemuse++;
2024         *mISDNportp = mISDNport;
2025
2026         /* if pri, must set PTP */
2027         if (pri)
2028                 ptp = 1;
2029
2030         /* set ss5 params */
2031         if (ss5) {
2032                 /* try to keep interface enabled */
2033                 l1hold = 1;
2034                 l2hold = 0;
2035         }
2036         /* set l2hold */
2037         switch (l2hold) {
2038                 case -1: // off
2039                 l2hold = 0;
2040                 break;
2041                 case 1: // on
2042                 l2hold = 1;
2043                 break;
2044                 default:
2045                 if (ptp)
2046                         l2hold = 1;
2047                 else
2048                         l2hold = 0;
2049                 break;
2050         }
2051
2052         /* allocate ressources of port */
2053         if (!pots) {
2054                 /* ISDN */
2055                 protocol = (nt)?L3_PROTOCOL_DSS1_NET:L3_PROTOCOL_DSS1_USER;
2056                 prop = (1 << MISDN_FLG_L2_CLEAN);
2057                 if (ptp) // ptp forced
2058                        prop |= (1 << MISDN_FLG_PTP);
2059                 if (nt) // supports hold/retrieve on nt-mode
2060                        prop |= (1 << MISDN_FLG_NET_HOLD);
2061                 if (l1hold) // supports layer 1 hold
2062                        prop |= (1 << MISDN_FLG_L1_HOLD);
2063                 if (l2hold) // supports layer 2 hold
2064                        prop |= (1 << MISDN_FLG_L2_HOLD);
2065                 /* open layer 3 and init upqueue */
2066                 /* queue must be initializes, because l3-thread may send messages during open_layer3() */
2067                 mqueue_init(&mISDNport->upqueue);
2068                 mISDNport->ml3 = open_layer3(port, protocol, prop , do_layer3, mISDNport);
2069                 if (!mISDNport->ml3) {
2070                         mqueue_purge(&mISDNport->upqueue);
2071                         PERROR_RUNTIME("open_layer3() failed for port %d\n", port);
2072                         start_trace(port,
2073                                 ifport->interface,
2074                                 NULL,
2075                                 NULL,
2076                                 DIRECTION_NONE,
2077                                 CATEGORY_CH,
2078                                 0,
2079                                 "PORT (open failed)");
2080                         end_trace();
2081                         mISDNport_close(mISDNport);
2082                         return(NULL);
2083                 }
2084         } else {
2085 #ifdef ISDN_P_FXS_POTS
2086                 /* POTS */
2087                 int sock, ret;
2088                 struct sockaddr_mISDN addr;
2089                 struct mISDNhead act;
2090
2091                 /* open socket */
2092                 /* queue must be initializes, because even pots interfaces are checked at mISDN_upqueue loop */
2093                 mqueue_init(&mISDNport->upqueue);
2094                 sock = socket(PF_ISDN, SOCK_DGRAM, (nt) ? ISDN_P_FXS_POTS : ISDN_P_FXO_POTS);
2095                 if (sock < 0) {
2096                         PERROR_RUNTIME("Cannot open mISDN due to '%s'.\n", strerror(errno));
2097                         return NULL;
2098                 }
2099                 /* bind socket to dchannel */
2100                 addr.family = AF_ISDN;
2101                 addr.dev = port;
2102                 addr.channel = 0;
2103                 ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
2104                 if (ret < 0) {
2105                         PERROR_RUNTIME("Error: Failed to bind pots control channel\n");
2106                         start_trace(port,
2107                                 ifport->interface,
2108                                 NULL,
2109                                 NULL,
2110                                 DIRECTION_NONE,
2111                                 CATEGORY_CH,
2112                                 0,
2113                                 "PORT (open failed)");
2114                         end_trace();
2115                         return(NULL);
2116                 }
2117                 act.prim = PH_ACTIVATE_REQ;
2118                 act.id = 0;
2119                 ret = sendto(sock, &act, MISDN_HEADER_LEN, 0, NULL, 0);
2120                 if (ret <= 0)
2121                         PERROR("Failed to send to socket %d\n", sock);
2122                 mISDNport->pots_sock.fd = sock;
2123                 register_fd(&mISDNport->pots_sock, LCR_FD_READ, pots_sock_callback, mISDNport, i);
2124 #endif
2125         }
2126
2127         SCPY(mISDNport->name, devinfo.name);
2128         mISDNport->b_num = devinfo.nrbchan;
2129         mISDNport->portnum = port;
2130         mISDNport->ntmode = nt;
2131         mISDNport->pots = pots;
2132         mISDNport->tespecial = ifport->tespecial;
2133         mISDNport->pri = pri;
2134         mISDNport->ptp = ptp;
2135         mISDNport->l1hold = l1hold;
2136         mISDNport->l2hold = l2hold;
2137         mISDNport->ss5 = ss5;
2138         PDEBUG(DEBUG_ISDN, "Port has %d b-channels.\n", mISDNport->b_num);
2139         i = 0;
2140         while(i < mISDNport->b_num) {
2141                 mISDNport->b_state[i] = B_STATE_IDLE;
2142                 add_timer(&mISDNport->b_timer[i], b_timer_timeout, mISDNport, i);
2143                 i++;
2144         }
2145
2146         /* if ptp, pull up the link */
2147         if (!pots && mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode)) {
2148                 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
2149                 l1l2l3_trace_header(mISDNport, NULL, L2_ESTABLISH_REQ, DIRECTION_OUT);
2150                 add_trace("tei", NULL, "%d", 0);
2151                 end_trace();
2152                 schedule_timer(&mISDNport->l2establish, 5, 0); /* 5 seconds */
2153         }
2154
2155         /* for POTS or nt-mode ptmp the link is always up */
2156         if (pots || (mISDNport->ntmode && !mISDNport->ptp))
2157                 mISDNport->l2link = 1;
2158
2159         PDEBUG(DEBUG_BCHANNEL, "using 'mISDN_dsp.o' module\n");
2160
2161         start_trace(mISDNport->portnum,
2162                     ifport->interface,
2163                     NULL,
2164                     NULL,
2165                     DIRECTION_NONE,
2166                     CATEGORY_CH,
2167                     0,
2168                     "PORT (open)");
2169         if (!pots)
2170                 add_trace("mode", NULL, (mISDNport->ntmode)?"network":"terminal");
2171         else
2172                 add_trace("mode", NULL, (mISDNport->ntmode)?"FXS":"FXO");
2173         add_trace("channels", NULL, "%d", mISDNport->b_num);
2174         if (mISDNport->ss5)
2175                 add_trace("ccitt#5", NULL, "enabled");
2176         end_trace();
2177
2178         return(mISDNport);
2179 }
2180
2181
2182 /*
2183  * load static port instances, if required by mISDNport
2184  */
2185 void mISDNport_static(struct mISDNport *mISDNport)
2186 {
2187         int i;
2188
2189         i = 0;
2190         while(i < mISDNport->b_num) {
2191 #ifdef WITH_SS5
2192                 if (mISDNport->ss5)
2193                         ss5_create_channel(mISDNport, i);
2194 #endif
2195                 i++;
2196         }
2197 }
2198
2199
2200 /*
2201  * function to free ALL cards (ports)
2202  */
2203 void mISDNport_close_all(void)
2204 {
2205         /* free all ports */
2206         while(mISDNport_first)
2207                 mISDNport_close(mISDNport_first);
2208 }
2209
2210 /*
2211  * free only one port
2212  */
2213 void mISDNport_close(struct mISDNport *mISDNport)
2214 {
2215         struct mISDNport **mISDNportp;
2216         class Port *port;
2217         class PmISDN *isdnport;
2218         int i;
2219
2220         /* remove all port instance that are linked to this mISDNport */
2221         again:
2222         port = port_first;
2223         while(port) {
2224                 if ((port->p_type&PORT_CLASS_MASK) == PORT_CLASS_mISDN) {
2225                         isdnport = (class PmISDN *)port;
2226                         if (isdnport->p_m_mISDNport && isdnport->p_m_mISDNport == mISDNport) {
2227                                 PDEBUG(DEBUG_ISDN, "port %s uses mISDNport %d, destroying it.\n", isdnport->p_name, mISDNport->portnum);
2228                                 delete isdnport;
2229                                 goto again;
2230                         }
2231                 }
2232                 port = port->next;
2233         }
2234
2235         /* only if we are already part of interface */
2236         if (mISDNport->ifport) {
2237                 start_trace(mISDNport->portnum,
2238                             mISDNport->ifport->interface,
2239                             NULL,
2240                             NULL,
2241                             DIRECTION_NONE,
2242                             CATEGORY_CH,
2243                             0,
2244                             "PORT (close)");
2245                 end_trace();
2246         }
2247
2248         /* free bchannels */
2249         i = 0;
2250         while(i < mISDNport->b_num) {
2251                 if (mISDNport->b_sock[i].inuse) {
2252                         _bchannel_destroy(mISDNport, i);
2253                         PDEBUG(DEBUG_BCHANNEL, "freeing %s port %d bchannel (index %d).\n", (mISDNport->ntmode)?"NT":"TE", mISDNport->portnum, i);
2254                 }
2255                 if (mISDNport->b_timer[i].inuse) {
2256                         del_timer(&mISDNport->b_timer[i]);
2257                 }
2258                 i++;
2259         }
2260         del_timer(&mISDNport->l2establish);
2261
2262         /* close layer 3, if open */
2263         if (mISDNport->ml3) {
2264                 close_layer3(mISDNport->ml3);
2265         }
2266
2267         /* close layer 1, if open */
2268         if (mISDNport->pots_sock.fd) {
2269                 unregister_fd(&mISDNport->pots_sock);
2270                 close(mISDNport->pots_sock.fd);
2271         }
2272
2273         /* purge upqueue */
2274         mqueue_purge(&mISDNport->upqueue);
2275
2276         /* remove from list */
2277         mISDNportp = &mISDNport_first;
2278         while(*mISDNportp) {
2279                 if (*mISDNportp == mISDNport) {
2280                         *mISDNportp = (*mISDNportp)->next;
2281                         mISDNportp = NULL;
2282                         break;
2283                 }
2284                 mISDNportp = &((*mISDNportp)->next);
2285         }
2286
2287         if (mISDNportp)
2288                 FATAL("mISDNport not in list\n");
2289
2290         FREE(mISDNport, sizeof(struct mISDNport));
2291         pmemuse--;
2292
2293 }
2294
2295
2296 /*
2297  * enque data from remote port
2298  */
2299 int PmISDN::bridge_rx(unsigned char *data, int length)
2300 {
2301         unsigned char buf[MISDN_HEADER_LEN+((length>p_m_preload)?length:p_m_preload)];
2302         struct mISDNhead *hh = (struct mISDNhead *)buf;
2303         int ret;
2304
2305         if ((ret = Port::bridge_rx(data, length)))
2306                 return ret;
2307
2308         if (p_m_b_index < 0)
2309                 return -EIO;
2310         if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_ACTIVE)
2311                 return -EINVAL;
2312
2313         /* check if high priority tones exist
2314          * ignore data in this case
2315          */
2316         if (p_tone_name[0] || p_m_crypt_msg_loops || p_m_inband_send_on)
2317                 return -EBUSY;
2318
2319         /* preload procedure
2320          * if transmit buffer in DSP module is empty,
2321          * preload it to DSP_LOAD to prevent jitter gaps.
2322          *
2323          * if load runs empty, preload again.
2324          */
2325         if (p_m_disable_dejitter && p_m_load == 0 && p_m_preload > 0) {
2326 //printf("preload=%d\n", p_m_preload);
2327                 hh->prim = PH_DATA_REQ;
2328                 hh->id = 0;
2329                 memset(buf+MISDN_HEADER_LEN, silence, p_m_preload);
2330                 ret = sendto(p_m_mISDNport->b_sock[p_m_b_index].fd, buf, MISDN_HEADER_LEN+p_m_preload, 0, NULL, 0);
2331                 if (ret <= 0)
2332                         PERROR("Failed to send to socket %d\n", p_m_mISDNport->b_sock[p_m_b_index].fd);
2333                 p_m_load += p_m_preload;
2334                 schedule_timer(&p_m_loadtimer, 0, PORT_TRANSMIT * 125);
2335         }
2336
2337         /* drop if load would exceed ISDN_MAXLOAD
2338          * this keeps the delay not too high
2339          */
2340 //printf("load=%d len=%d 2*preload=%d\n", p_m_load, length, p_m_preload << 1);
2341         if (p_m_disable_dejitter && p_m_preload > 0 && p_m_load+length > (p_m_preload << 1))
2342                 return -EINVAL;
2343
2344         /* make and send frame */
2345         hh->prim = PH_DATA_REQ;
2346         hh->id = 0;
2347         memcpy(buf+MISDN_HEADER_LEN, data, length);
2348         ret = sendto(p_m_mISDNport->b_sock[p_m_b_index].fd, buf, MISDN_HEADER_LEN+length, 0, NULL, 0);
2349         if (ret <= 0)
2350                 PERROR("Failed to send to socket %d\n", p_m_mISDNport->b_sock[p_m_b_index].fd);
2351         p_m_load += length;
2352
2353         return 0;
2354 }
2355
2356 int PmISDN::inband_send(unsigned char *buffer, int len)
2357 {
2358         PERROR("this function must be derived to function!\n");
2359         return 0;
2360 }
2361
2362 void PmISDN::inband_send_on(void)
2363 {
2364         PDEBUG(DEBUG_PORT, "turning inband signalling send on.\n");
2365         p_m_inband_send_on = 1;
2366 }
2367
2368 void PmISDN::inband_send_off(void)
2369 {
2370         PDEBUG(DEBUG_PORT, "turning inband signalling send off.\n");
2371         p_m_inband_send_on = 0;
2372 }
2373
2374 void PmISDN::inband_receive(unsigned char *buffer, int len)
2375 {
2376 //
2377 //      if (len >= SS5_DECODER_NPOINTS)
2378 //              ss5_decode(buffer, SS5_DECODER_NPOINTS);
2379         PERROR("this function must be derived to function!\n");
2380 }
2381
2382 void PmISDN::inband_receive_on(void)
2383 {
2384         /* this must work during constructor, see ss5.cpp */
2385         PDEBUG(DEBUG_PORT, "turning inband signalling receive on.\n");
2386         p_m_inband_receive_on = 1;
2387         update_rxoff();
2388 }
2389
2390 void PmISDN::inband_receive_off(void)
2391 {
2392         PDEBUG(DEBUG_PORT, "turning inband signalling receive off.\n");
2393         p_m_inband_receive_on = 0;
2394         update_rxoff();
2395 }
2396
2397 void PmISDN::mute_on(void)
2398 {
2399         if (p_m_mute)
2400                 return;
2401         PDEBUG(DEBUG_PORT, "turning mute on.\n");
2402         p_m_mute = 1;
2403         set_conf(p_m_conf, 0);
2404 }
2405
2406 void PmISDN::mute_off(void)
2407 {
2408         if (!p_m_mute)
2409                 return;
2410         PDEBUG(DEBUG_PORT, "turning mute off.\n");
2411         p_m_mute = 0;
2412         set_conf(0, p_m_conf);
2413 }
2414
2415