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