1 /*****************************************************************************\
3 ** Linux Call Router **
5 **---------------------------------------------------------------------------**
6 ** Copyright: Andreas Eversberg **
8 ** mISDN port abstraction for dss1 **
10 \*****************************************************************************/
14 #include <mISDN/q931.h>
17 #ifdef __compiler_offsetof
18 #define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
20 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
24 #define container_of(ptr, type, member) ({ \
25 const typeof( ((type *)0)->member ) *__mptr = (ptr); \
26 (type *)( (char *)__mptr - offsetof(type,member) );})
29 // timeouts if activating/deactivating response from mISDN got lost
30 #define B_TIMER_ACTIVATING 1 // seconds
31 #define B_TIMER_DEACTIVATING 1 // seconds
33 /* list of mISDN ports */
34 struct mISDNport *mISDNport_first;
36 /* noise randomizer */
37 unsigned char mISDN_rand[256];
38 int mISDN_rand_count = 0;
41 unsigned int mt_assign_pid = ~0;
45 static int upqueue_pipe[2];
46 static struct lcr_fd upqueue_fd;
47 int upqueue_avail = 0;
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);
52 static int my_mISDNlib_debug(const char *file, int line, const char *func, int level, const char *fmt, va_list va)
57 ret = vfprintf(debug_fp, fmt, va);
61 static struct mi_ext_fn_s myfn;
63 int mISDN_initialize(void)
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);
76 // set debug printout function
77 myfn.prt_debug = my_mISDNlib_debug;
79 ver = init_layer3(4, &myfn); // buffer of 4
81 /* open debug, if enabled and not only stack debugging */
83 SPRINT(filename, "%s/debug.log", LOG_DIR);
84 debug_fp = fopen(filename, "a");
87 if (options.deb & DEBUG_STACK)
88 mISDN_set_debug_level(0xfffffeff);
90 mISDN_set_debug_level(0);
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);
101 void mISDN_deinitialize(void)
109 if (mISDNsocket > -1)
112 if (upqueue_fd.inuse) {
113 unregister_fd(&upqueue_fd);
114 close(upqueue_pipe[0]);
115 close(upqueue_pipe[1]);
120 int load_timer(struct lcr_timer *timer, void *instance, int index);
125 PmISDN::PmISDN(int type, mISDNport *mISDNport, char *portname, struct port_settings *settings, int channel, int exclusive, int mode) : Port(type, portname, settings)
127 p_m_mISDNport = mISDNport;
128 p_m_portnum = mISDNport->portnum;
135 p_m_tx_gain = mISDNport->ifport->interface->tx_gain;
136 p_m_rx_gain = mISDNport->ifport->interface->rx_gain;
142 p_m_preload = ISDN_LOAD;
143 p_m_disable_dejitter = 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);
155 memset(&p_m_loadtimer, 0, sizeof(p_m_loadtimer));
156 add_timer(&p_m_loadtimer, load_timer, this, 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;
180 /* if any channel requested by constructor */
181 if (channel == CHANNEL_ANY) {
182 /* reserve channel */
184 mISDNport->b_reserved++;
187 /* reserve channel */
188 if (channel > 0) // only if constructor was called with a channel resevation
189 seize_bchannel(channel, exclusive);
191 /* we increase the number of objects: */
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();
203 struct lcr_msg *message;
205 del_timer(&p_m_timeout);
206 del_timer(&p_m_loadtimer);
208 /* remove bchannel relation */
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);
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);
231 void chan_trace_header(struct mISDNport *mISDNport, class PmISDN *port, const char *msgtext, int direction)
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,
240 port?port->p_serial:0,
248 static struct 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},
289 static const char *isdn_prim[4] = {
295 void l1l2l3_trace_header(struct mISDNport *mISDNport, class PmISDN *port, unsigned int msg, int direction)
300 SCPY(msgtext, "<<UNKNOWN MESSAGE>>");
301 /* select message and primitive text */
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);
311 SCAT(msgtext, isdn_prim[msg&0x00000003]);
314 if (direction && (msg&0xffffff00)!=L3_NEW_L3ID_REQ && (msg&0xffffff00)!=L3_RELEASE_L3ID_REQ) {
316 if (mISDNport->ntmode) {
317 if (direction == DIRECTION_OUT)
318 SCAT(msgtext, " N->U");
320 SCAT(msgtext, " N<-U");
322 if (direction == DIRECTION_OUT)
323 SCAT(msgtext, " U->N");
325 SCAT(msgtext, " U<-N");
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,
337 port?port->p_serial:0,
343 * send control information to the channel (dsp-module)
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)
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);
355 ctrl->prim = PH_CONTROL_REQ;
359 ret = sendto(sock, buffer, MISDN_HEADER_LEN+sizeof(int)*2, 0, NULL, 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);
366 add_trace(trace_name, NULL, "%d", trace_value);
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)
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);
380 ctrl->prim = PH_CONTROL_REQ;
383 memcpy(d, c2, c2_len);
384 ret = sendto(sock, buffer, MISDN_HEADER_LEN+sizeof(int)+c2_len, 0, NULL, 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);
392 static int b_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i);
395 * subfunction for bchannel_event
398 static int _bchannel_create(struct mISDNport *mISDNport, int i)
401 struct sockaddr_mISDN addr;
403 if (mISDNport->b_sock[i].inuse) {
404 PERROR("Error: Socket already created for index %d\n", i);
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);
417 /* register callback for read */
418 register_fd(&mISDNport->b_sock[i], LCR_FD_READ, b_sock_callback, mISDNport, i);
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));
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]);
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);
442 * subfunction for bchannel_event
443 * activate / deactivate request
445 static void _bchannel_activate(struct mISDNport *mISDNport, int i, int activate, int timeout)
447 struct mISDNhead act;
450 if (!mISDNport->b_sock[i].inuse)
452 act.prim = (activate)?PH_ACTIVATE_REQ:PH_DEACTIVATE_REQ;
454 ret = sendto(mISDNport->b_sock[i].fd, &act, MISDN_HEADER_LEN, 0, NULL, 0);
456 PERROR("Failed to send to socket %d\n", mISDNport->b_sock[i].fd);
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));
462 add_trace("event", NULL, "timeout recovery");
468 * subfunction for bchannel_event
471 static void _bchannel_configure(struct mISDNport *mISDNport, int i)
476 if (!mISDNport->b_sock[i].inuse)
478 handle = mISDNport->b_sock[i].fd;
479 port = mISDNport->b_port[i];
480 mode = mISDNport->b_mode[i];
482 PERROR("bchannel index i=%d not associated with a port object\n", i);
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);
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);
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);
516 void PmISDN::set_conf(int oldconf, int newconf)
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);
524 PDEBUG(DEBUG_BCHANNEL, "we already have conf=%d.\n", newconf);
529 * subfunction for bchannel_event
532 static void _bchannel_destroy(struct mISDNport *mISDNport, int i)
534 if (!mISDNport->b_sock[i].inuse)
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);
540 close(mISDNport->b_sock[i].fd);
541 unregister_fd(&mISDNport->b_sock[i]);
549 A bchannel goes through the following states in this order:
552 No one is using the bchannel.
553 It is available and not linked to Port class, nor reserved.
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.
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.
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.
569 After deactivating bchannel, and if not used, the bchannel becomes idle again.
571 A bchannel can have the following events:
574 A bchannel is required by a Port class.
577 The bchannel beomes active.
580 The bchannel is not required by Port class anymore
582 - B_EVENT_DEACTIVATED
583 The bchannel becomes inactive.
585 All actions taken on these events depend on the current bchannel's state and if it is linked to a Port class.
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
596 void bchannel_event(struct mISDNport *mISDNport, int i, int event)
598 class PmISDN *b_port = mISDNport->b_port[i];
599 int state = mISDNport->b_state[i];
600 int timer = -1; // no change
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;
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;
619 /* port must be linked in order to allow activation */
621 FATAL("bchannel must be linked to a Port class\n");
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;
632 case B_STATE_ACTIVATING:
633 /* do nothing, because it is already activating */
637 /* problems that might ocurr:
638 * B_EVENT_USE is received when channel already in use.
640 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
645 case B_EVENT_ACTIVATED:
648 case B_STATE_ACTIVATING:
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;
655 /* bchannel is active, but not used anymore (or has wrong stack config), so we deactivate */
656 _bchannel_activate(mISDNport, i, 0, 0);
657 state = B_STATE_DEACTIVATING;
658 timer = B_TIMER_DEACTIVATING;
663 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
669 FATAL("bchannel must be linked to a Port class\n");
672 /* bchannel is idle due to an error, so we do nothing */
675 case B_STATE_ACTIVATING:
676 /* do nothing because we must wait until bchanenl is active before deactivating */
680 /* bchannel is active, so we deactivate */
681 _bchannel_activate(mISDNport, i, 0, 0);
682 state = B_STATE_DEACTIVATING;
683 timer = B_TIMER_DEACTIVATING;
686 case B_STATE_DEACTIVATING:
687 /* we may have taken an already deactivating bchannel, but do not require it anymore, so we do nothing */
691 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
695 case B_EVENT_DEACTIVATED:
699 /* ignore due to deactivation confirm after unloading */
702 case B_STATE_DEACTIVATING:
703 _bchannel_destroy(mISDNport, i);
704 state = B_STATE_IDLE;
706 /* bchannel is now deactivate, but is requied by Port class, so we reactivate */
707 if (_bchannel_create(mISDNport, i)) {
708 _bchannel_activate(mISDNport, i, 1, 0);
709 state = B_STATE_ACTIVATING;
710 timer = B_TIMER_ACTIVATING;
716 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
720 case B_EVENT_TIMEOUT:
724 /* ignore due to deactivation confirm after unloading */
727 case B_STATE_ACTIVATING:
728 _bchannel_activate(mISDNport, i, 1, 1);
729 timer = B_TIMER_ACTIVATING;
732 case B_STATE_DEACTIVATING:
733 _bchannel_activate(mISDNport, i, 0, 1);
734 timer = B_TIMER_DEACTIVATING;
738 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
743 PERROR("Illegal event %d, please correct.\n", event);
746 mISDNport->b_state[i] = state;
748 unsched_timer(&mISDNport->b_timer[i]);
750 schedule_timer(&mISDNport->b_timer[i], timer, 0);
757 * check for available channel and reserve+set it.
758 * give channel number or SEL_CHANNEL_ANY or SEL_CHANNEL_NO
760 * returns -(cause value) or x = channel x or 0 = no channel
761 * NOTE: no activation is done here
763 int PmISDN::seize_bchannel(int channel, int exclusive)
767 /* the channel is what we have */
768 if (p_m_b_channel == channel)
771 /* if channel already in use, release it */
776 if (channel==CHANNEL_NO || channel==0)
779 /* is channel in range ? */
781 || (channel>p_m_mISDNport->b_num && channel<16)
782 || ((channel-1)>p_m_mISDNport->b_num && channel>16)) /* channel-1 because channel 16 is not counted */
783 return(-6); /* channel unacceptable */
785 /* request exclusive channel */
786 if (exclusive && channel>0) {
787 i = channel-1-(channel>16);
788 if (p_m_mISDNport->b_port[i])
789 return(-44); /* requested channel not available */
793 /* ask for channel */
795 i = channel-1-(channel>16);
796 if (p_m_mISDNport->b_port[i] == NULL)
800 /* search for channel */
802 while(i < p_m_mISDNport->b_num) {
803 if (!p_m_mISDNport->b_port[i]) {
804 channel = i+1+(i>=15);
809 return(-34); /* no free channel */
812 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) seizing bchannel %d (index %d)\n", p_name, channel, i);
814 /* link Port, set parameters */
815 p_m_mISDNport->b_port[i] = this;
817 p_m_b_channel = channel;
818 p_m_b_exclusive = exclusive;
819 p_m_mISDNport->b_mode[i] = p_m_b_mode;
821 /* reserve channel */
822 if (!p_m_b_reserve) {
824 p_m_mISDNport->b_reserved++;
831 * drop reserved channel and unset it.
832 * deactivation is also done
834 void PmISDN::drop_bchannel(void)
836 /* unreserve channel */
838 p_m_mISDNport->b_reserved--;
847 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) dropping bchannel\n", p_name);
849 if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_IDLE)
850 bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_DROP);
851 p_m_mISDNport->b_port[p_m_b_index] = NULL;
852 p_m_mISDNport->b_mode[p_m_b_index] = 0;
862 audio transmission procedure:
863 -----------------------------
866 three sources of audio transmission:
867 - crypto-data high priority
868 - tones high priority (also high)
869 - remote-data low priority
872 a variable that temporarily shows the number of samples elapsed since last transmission process.
873 p_m_last_tv_* is used to store that last timestamp. this is used to calculate the time elapsed.
876 a variable that is increased whenever data is transmitted.
877 it is decreased while time elapses. it stores the number of samples that
878 are currently loaded to dsp module.
879 since clock in dsp module is the same clock for user space process, these
883 there are two levels:
884 p_m_preload will give the load that have to be kept in dsp.
885 ISDN_MAXLOAD (2*p_m_preload) will give the maximum load before dropping.
887 * procedure for low priority data
888 see txfromup() for procedure
889 in short: remote data is ignored during high priority tones
891 * procedure for high priority data
892 whenever load is below p_m_preload, load is filled up to p_m_preload
893 if no more data is available, load becomes empty again.
896 0 p_m_preload ISDN_MAXLOAD
897 +--------------------+----------------------+
899 +--------------------+----------------------+
901 on empty load or on load below p_m_preload, the load is inceased to p_m_preload:
902 0 p_m_preload ISDN_MAXLOAD
903 +--------------------+----------------------+
904 |TTTTTTTTTTTTTTTTTTTT| |
905 +--------------------+----------------------+
907 on empty load, remote-audio causes the load with the remote audio to be increased to p_m_preload.
908 0 p_m_preload ISDN_MAXLOAD
909 +--------------------+----------------------+
910 |TTTTTTTTTTTTTTTTTTTTRRRRR |
911 +--------------------+----------------------+
914 void PmISDN::update_load(void)
916 /* don't trigger load event if: */
917 if (!p_tone_name[0] && !p_m_crypt_msg_loops && !p_m_inband_send_on && !(p_bridge && p_m_disable_dejitter && p_m_preload > 0))
920 /* don't trigger load event if event already active */
921 if (p_m_loadtimer.active)
924 schedule_timer(&p_m_loadtimer, 0, 0); /* no delay the first time */
927 int load_timer(struct lcr_timer *timer, void *instance, int index)
929 class PmISDN *isdnport = (class PmISDN *)instance;
936 void PmISDN::load_tx(void)
940 struct timeval current_time;
943 gettimeofday(¤t_time, NULL);
944 if (p_m_last_tv_sec) {
945 elapsed = 8000 * (current_time.tv_sec - p_m_last_tv_sec)
946 + 8 * (current_time.tv_usec/1000 - p_m_last_tv_msec);
948 /* set clock of last process! */
949 p_m_last_tv_sec = current_time.tv_sec;
950 p_m_last_tv_msec = current_time.tv_usec/1000;
952 /* process only if we have samples and we are active */
953 if (elapsed && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE) {
955 if (elapsed < p_m_load)
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;
969 /* copy inband signalling (e.g. used by ss5) */
970 if (p_m_inband_send_on && tosend) {
971 tosend -= inband_send(p, tosend);
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;
983 /* copy message (part) to buffer */
984 memcpy(p, p_m_crypt_msg+p_m_crypt_msg_current, length);
987 p_m_crypt_msg_current += length;
988 if (p_m_crypt_msg_current == p_m_crypt_msg_len) {
990 p_m_crypt_msg_current = 0;
991 p_m_crypt_msg_loops--;
992 if (!p_m_crypt_msg_loops)
994 // puts("eine loop weniger");
1002 if (p_tone_name[0] && tosend) {
1003 tosend -= read_audio(p, tosend);
1007 if (p_m_preload - p_m_load - tosend > 0) {
1008 frm->prim = PH_DATA_REQ;
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);
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;
1018 if (p_tone_name[0] || p_m_crypt_msg_loops || p_m_inband_send_on || p_m_load) {
1019 schedule_timer(&p_m_loadtimer, 0, PORT_TRANSMIT * 125);
1023 /* handle timeouts */
1024 static int mISDN_timeout(struct lcr_timer *timer, void *instance, int i)
1026 class PmISDN *isdnport = (class PmISDN *)instance;
1027 struct lcr_msg *message;
1029 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);
1030 /* send timeout to endpoint */
1031 message = message_create(isdnport->p_serial, ACTIVE_EPOINT(isdnport->p_epointlist), PORT_TO_EPOINT, MESSAGE_TIMEOUT);
1032 message->param.state = isdnport->p_state;
1033 message_put(message);
1040 * whenever we get audio data from bchannel, we process it here
1042 void PmISDN::bchannel_receive(struct mISDNhead *hh, unsigned char *data, int len)
1044 unsigned int cont = *((unsigned int *)data);
1045 struct lcr_msg *message;
1049 if (hh->prim == PH_CONTROL_IND) {
1051 PERROR("SHORT READ OF PH_CONTROL INDICATION\n");
1054 if ((cont&(~DTMF_TONE_MASK)) == DTMF_TONE_VAL) {
1055 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1056 add_trace("DTMF", NULL, "%c", cont & DTMF_TONE_MASK);
1058 add_trace("info", NULL, "DTMF is disabled");
1062 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_DTMF);
1063 message->param.dtmf = cont & DTMF_TONE_MASK;
1064 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION DTMF digit '%c'\n", p_name, message->param.dtmf);
1065 message_put(message);
1070 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1071 add_trace("DSP-CRYPT", NULL, "error");
1073 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1074 message->param.crypt.type = CC_ERROR_IND;
1075 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION reject of blowfish.\n", p_name);
1076 message_put(message);
1080 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1081 add_trace("DSP-CRYPT", NULL, "ok");
1083 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1084 message->param.crypt.type = CC_ACTBF_CONF;
1085 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION accept of blowfish.\n", p_name);
1086 message_put(message);
1090 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1091 add_trace("unknown", NULL, "0x%x", cont);
1096 if (hh->prim == PH_CONTROL_IND) {
1099 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1100 add_trace("unknown", NULL, "0x%x", hh->id);
1105 if (hh->prim == PH_DATA_REQ || hh->prim == DL_DATA_REQ) {
1107 /* if tx is off, it may happen that fifos send us pending informations, we just ignore them */
1108 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring tx data, because 'txdata' is turned off\n", p_name);
1111 /* see below (same condition) */
1112 if (p_state!=PORT_STATE_CONNECT
1113 && !p_m_mISDNport->tones)
1115 // printf(".");fflush(stdout);return;
1117 record(data, len, 1); // from up
1120 if (hh->prim != PH_DATA_IND && hh->prim != DL_DATA_IND) {
1121 PERROR("Bchannel received unknown primitve: 0x%x\n", hh->prim);
1125 /* inband is processed */
1126 if (p_m_inband_receive_on)
1127 inband_receive(data, len);
1129 /* send to remote, if bridged */
1130 bridge_tx(data, len);
1132 /* calls will not process any audio data unless
1133 * the call is connected OR tones feature is enabled.
1135 #ifndef DEBUG_COREBRIDGE
1136 if (p_state!=PORT_STATE_CONNECT
1137 && !p_m_mISDNport->tones)
1142 /* the bearer capability must be audio in order to send and receive
1143 * audio prior or after connect.
1145 if (!(p_bearerinfo.capability&CLASS_CAPABILITY_AUDIO) && p_state!=PORT_STATE_CONNECT)
1149 /* if rx is off, it may happen that fifos send us pending informations, we just ignore them */
1151 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring data, because rx is turned off\n", p_name);
1157 record(data, len, 0); // from down
1159 /* randomize and listen to crypt message if enabled */
1160 if (p_m_crypt_listen) {
1161 /* the noisy randomizer */
1165 mISDN_rand[mISDN_rand_count & 0xff] += *p++;
1167 cryptman_listen_bch(data, len);
1175 void PmISDN::set_echotest(int echo)
1177 if (p_m_echo != echo) {
1179 PDEBUG(DEBUG_ISDN, "we set echo to echo=%d.\n", p_m_echo);
1181 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1182 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);
1189 void PmISDN::set_tone(const char *dir, const char *tone)
1194 /* if no directory is given (by extension), we use interface.conf or options.conf */
1195 if (!dir || !dir[0]) {
1196 if (p_m_mISDNport->ifport->tones_dir[0])
1197 dir = p_m_mISDNport->ifport->tones_dir;
1198 else if (options.tones_dir[0])
1199 dir = options.tones_dir;
1204 PDEBUG(DEBUG_ISDN, "isdn port now plays tone:'%s'.\n", tone);
1210 /* check for dsp tones */
1211 if (!strcmp(dir, "american"))
1213 if (!strcmp(dir, "german"))
1215 if (!strcmp(dir, "oldgerman"))
1216 dsp = DSP_OLDGERMAN;
1218 /* check if we NOT really have to use a dsp-tone */
1219 if (dsp == DSP_NONE) {
1222 if (p_m_b_index > -1)
1223 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) {
1224 PDEBUG(DEBUG_ISDN, "we reset tone from id=%d to OFF.\n", p_m_tone);
1225 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 Port::set_tone(dir, tone);
1232 /* now we USE dsp-tone, convert name */
1233 if (!strcmp(tone, "dialtone")) {
1235 case DSP_AMERICAN: id = TONE_AMERICAN_DIALTONE; break;
1236 case DSP_GERMAN: id = TONE_GERMAN_DIALTONE; break;
1237 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALTONE; break;
1239 } else if (!strcmp(tone, "dialpbx")) {
1241 case DSP_AMERICAN: id = TONE_AMERICAN_DIALPBX; break;
1242 case DSP_GERMAN: id = TONE_GERMAN_DIALPBX; break;
1243 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALPBX; break;
1245 } else if (!strcmp(tone, "ringing")) {
1247 case DSP_AMERICAN: id = TONE_AMERICAN_RINGING; break;
1248 case DSP_GERMAN: id = TONE_GERMAN_RINGING; break;
1249 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGING; break;
1251 } else if (!strcmp(tone, "ringpbx")) {
1253 case DSP_AMERICAN: id = TONE_AMERICAN_RINGPBX; break;
1254 case DSP_GERMAN: id = TONE_GERMAN_RINGPBX; break;
1255 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGPBX; break;
1257 } else if (!strcmp(tone, "busy")) {
1260 case DSP_AMERICAN: id = TONE_AMERICAN_BUSY; break;
1261 case DSP_GERMAN: id = TONE_GERMAN_BUSY; break;
1262 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1264 } else if (!strcmp(tone, "release")) {
1267 case DSP_AMERICAN: id = TONE_AMERICAN_HANGUP; break;
1268 case DSP_GERMAN: id = TONE_GERMAN_HANGUP; break;
1269 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDHANGUP; break;
1271 } else if (!strcmp(tone, "cause_10"))
1273 else if (!strcmp(tone, "cause_11"))
1275 else if (!strcmp(tone, "cause_22")) {
1277 case DSP_AMERICAN: id = TONE_SPECIAL_INFO; break;
1278 case DSP_GERMAN: id = TONE_GERMAN_GASSENBESETZT; break;
1279 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1281 } else if (!strncmp(tone, "cause_", 6))
1282 id = TONE_SPECIAL_INFO;
1286 /* if we have a tone that is not supported by dsp */
1287 if (id==TONE_OFF && tone[0])
1291 if (p_m_tone != id) {
1294 PDEBUG(DEBUG_ISDN, "we set tone to id=%d.\n", p_m_tone);
1295 if (p_m_b_index > -1)
1296 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)
1297 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);
1299 /* turn user-space tones off in cases of no tone OR dsp tone */
1300 Port::set_tone("",NULL);
1304 /* MESSAGE_mISDNSIGNAL */
1305 //extern struct lcr_msg *dddebug;
1306 void PmISDN::message_mISDNsignal(unsigned int epoint_id, int message_id, union parameter *param)
1308 int oldconf, newconf;
1309 switch(param->mISDNsignal.message) {
1310 case mISDNSIGNAL_VOLUME:
1311 if (p_m_tx_gain != param->mISDNsignal.tx_gain) {
1312 p_m_tx_gain = param->mISDNsignal.tx_gain;
1313 PDEBUG(DEBUG_BCHANNEL, "we change tx-volume to shift=%d.\n", p_m_tx_gain);
1314 if (p_m_b_index > -1)
1315 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)
1316 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);
1318 PDEBUG(DEBUG_BCHANNEL, "we already have tx-volume shift=%d.\n", p_m_rx_gain);
1319 if (p_m_rx_gain != param->mISDNsignal.rx_gain) {
1320 p_m_rx_gain = param->mISDNsignal.rx_gain;
1321 PDEBUG(DEBUG_BCHANNEL, "we change rx-volume to shift=%d.\n", p_m_rx_gain);
1322 if (p_m_b_index > -1)
1323 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)
1324 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);
1326 PDEBUG(DEBUG_BCHANNEL, "we already have rx-volume shift=%d.\n", p_m_rx_gain);
1329 case mISDNSIGNAL_CONF:
1330 oldconf = p_m_mute?0:p_m_conf;
1331 p_m_conf = param->mISDNsignal.conf;
1332 newconf = p_m_mute?0:p_m_conf;
1333 set_conf(oldconf, newconf);
1336 case mISDNSIGNAL_DELAY:
1337 if (p_m_delay != param->mISDNsignal.delay) {
1338 p_m_delay = param->mISDNsignal.delay;
1339 PDEBUG(DEBUG_BCHANNEL, "we change delay mode to delay=%d.\n", p_m_delay);
1340 if (p_m_b_index > -1)
1341 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)
1342 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);
1344 PDEBUG(DEBUG_BCHANNEL, "we already have delay=%d.\n", p_m_delay);
1348 PERROR("PmISDN(%s) unsupported signal message %d.\n", p_name, param->mISDNsignal.message);
1353 void PmISDN::message_crypt(unsigned int epoint_id, int message_id, union parameter *param)
1355 struct lcr_msg *message;
1357 switch(param->crypt.type) {
1358 case CC_ACTBF_REQ: /* activate blowfish */
1360 p_m_crypt_key_len = param->crypt.len;
1361 if (p_m_crypt_key_len > (int)sizeof(p_m_crypt_key)) {
1362 PERROR("PmISDN(%s) key too long %d > %d\n", p_name, p_m_crypt_key_len, sizeof(p_m_crypt_key));
1363 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1364 message->param.crypt.type = CC_ERROR_IND;
1365 message_put(message);
1368 memcpy(p_m_crypt_key, param->crypt.data, p_m_crypt_key_len);
1370 PDEBUG(DEBUG_BCHANNEL, "we set encryption to crypt=%d. (0 means OFF)\n", p_m_crypt);
1371 if (p_m_b_index > -1)
1372 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)
1373 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 case CC_DACT_REQ: /* deactivate session encryption */
1381 case CR_LISTEN_REQ: /* start listening to messages */
1382 p_m_crypt_listen = 1;
1384 p_m_crypt_listen_state = 0;
1387 case CR_UNLISTEN_REQ: /* stop listening to messages */
1388 p_m_crypt_listen = 0;
1392 case CR_MESSAGE_REQ: /* send message */
1393 p_m_crypt_msg_len = cryptman_encode_bch(param->crypt.data, param->crypt.len, p_m_crypt_msg, sizeof(p_m_crypt_msg));
1394 if (!p_m_crypt_msg_len) {
1395 PERROR("PmISDN(%s) message too long %d > %d\n", p_name, param->crypt.len-1, sizeof(p_m_crypt_msg));
1398 p_m_crypt_msg_current = 0; /* reset */
1399 p_m_crypt_msg_loops = 6; /* enable */
1403 /* disable txmix, or we get corrupt data due to audio process */
1404 if (p_m_txmix && p_m_b_index>=0 && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT) {
1405 PDEBUG(DEBUG_BCHANNEL, "for sending CR_MESSAGE_REQ, we reset txmix from txmix=%d.\n", p_m_txmix);
1406 ph_control(p_m_mISDNport, this, p_mISDNport->b_sock[p_m_b_index].fd, DSP_MIX_OFF, 0, "DSP-TXMIX", 0);
1412 PERROR("PmISDN(%s) unknown crypt message %d\n", p_name, param->crypt.type);
1418 * endpoint sends messages to the port
1420 int PmISDN::message_epoint(unsigned int epoint_id, int message_id, union parameter *param)
1422 if (Port::message_epoint(epoint_id, message_id, param)) {
1423 if (message_id == MESSAGE_BRIDGE)
1428 switch(message_id) {
1429 case MESSAGE_mISDNSIGNAL: /* user command */
1430 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received special ISDN SIGNAL %d.\n", p_name, param->mISDNsignal.message);
1431 message_mISDNsignal(epoint_id, message_id, param);
1434 case MESSAGE_CRYPT: /* crypt control command */
1435 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received encryption command '%d'.\n", p_name, param->crypt.type);
1436 message_crypt(epoint_id, message_id, param);
1439 case MESSAGE_DISABLE_DEJITTER:
1440 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received de-jitter disable order.\n", p_name);
1441 p_m_disable_dejitter = 1;
1442 p_m_preload = param->queue;
1450 void PmISDN::update_rxoff(void)
1452 int tx_dejitter = 0;
1454 /* call bridges in user space OR crypto OR recording */
1455 if (p_bridge || p_m_crypt_msg_loops || p_m_crypt_listen || p_record || p_m_inband_receive_on) {
1456 /* rx IS required */
1460 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is required, so we turn them on\n", __FUNCTION__);
1461 if (p_m_b_index > -1)
1462 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1463 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_RECEIVE_ON, 0, "DSP-RXOFF", 0);
1466 /* rx NOT required */
1470 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is not required, so we turn them off\n", __FUNCTION__);
1471 if (p_m_b_index > -1)
1472 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1473 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
1478 /* txdata IS required */
1482 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is required, so we turn them on\n", __FUNCTION__);
1483 if (p_m_b_index > -1)
1484 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1485 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TXDATA_ON, 0, "DSP-TXDATA", 1);
1488 /* txdata NOT required */
1492 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is not required, so we turn them off\n", __FUNCTION__);
1493 if (p_m_b_index > -1)
1494 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1495 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TXDATA_OFF, 0, "DSP-TXDATA", 0);
1498 /* dejitter on bridge */
1499 if (p_bridge && !p_m_disable_dejitter)
1501 if (p_m_tx_dejitter != tx_dejitter) {
1502 p_m_tx_dejitter = tx_dejitter;
1503 PDEBUG(DEBUG_BCHANNEL, "we change dejitter mode to delay=%d.\n", p_m_tx_dejitter);
1504 if (p_m_b_index > -1)
1505 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)
1506 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);
1510 static int mISDN_upqueue(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1512 struct mISDNport *mISDNport;
1518 /* unset global semaphore */
1520 // with a very small incident, upqueue_avail may be set by mISDN thread and
1521 // another byte may be sent to the pipe, which causes a call to this function
1522 // again with nothing in the upqueue. this is no problem.
1523 ret = read(fd->fd, &byte, 1);
1525 /* process all ports */
1526 mISDNport = mISDNport_first;
1528 /* handle queued up-messages (d-channel) */
1529 while ((mb = mdequeue(&mISDNport->upqueue))) {
1532 case MPH_ACTIVATE_IND:
1533 if (mISDNport->l1link != 1) {
1534 l1l2l3_trace_header(mISDNport, NULL, L1_ACTIVATE_IND, DIRECTION_IN);
1536 mISDNport->l1link = 1;
1540 case MPH_DEACTIVATE_IND:
1541 if (mISDNport->l1link != 0) {
1542 l1l2l3_trace_header(mISDNport, NULL, L1_DEACTIVATE_IND, DIRECTION_IN);
1544 mISDNport->l1link = 0;
1548 case MPH_INFORMATION_IND:
1549 PDEBUG(DEBUG_ISDN, "Received MPH_INFORMATION_IND for port %d (%s).\n", mISDNport->portnum, mISDNport->ifport->interface->name);
1551 case L1_SIGNAL_LOS_ON:
1554 case L1_SIGNAL_LOS_OFF:
1557 case L1_SIGNAL_AIS_ON:
1560 case L1_SIGNAL_AIS_OFF:
1563 case L1_SIGNAL_RDI_ON:
1566 case L1_SIGNAL_RDI_OFF:
1569 case L1_SIGNAL_SLIP_TX:
1570 mISDNport->slip_tx++;
1572 case L1_SIGNAL_SLIP_RX:
1573 mISDNport->slip_rx++;
1578 case MT_L2ESTABLISH:
1579 l1l2l3_trace_header(mISDNport, NULL, L2_ESTABLISH_IND, DIRECTION_IN);
1580 add_trace("tei", NULL, "%d", l3m->pid);
1582 mISDNport->l2link = 1;
1584 mISDNport->l2mask[l3m->pid >> 3] |= (1 << (l3m->pid & 7));
1585 if ((!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127) {
1586 if (mISDNport->l2establish.active) {
1587 unsched_timer(&mISDNport->l2establish);
1588 PDEBUG(DEBUG_ISDN, "the link became active before l2establish timer expiry.\n");
1595 mISDNport->l2mask[l3m->pid >> 3] &= ~(1 << (l3m->pid & 7));
1596 if (!mISDNport->l2establish.active) {
1597 l1l2l3_trace_header(mISDNport, NULL, L2_RELEASE_IND, DIRECTION_IN);
1598 add_trace("tei", NULL, "%d", l3m->pid);
1600 /* down if not nt-ptmp */
1601 if (!mISDNport->ntmode || mISDNport->ptp)
1602 mISDNport->l2link = 0;
1604 if ((!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127) {
1605 if (!mISDNport->l2establish.active && mISDNport->l2hold) {
1606 PDEBUG(DEBUG_ISDN, "set timer and establish.\n");
1607 schedule_timer(&mISDNport->l2establish, 5, 0);
1608 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
1614 /* l3-data is sent to LCR */
1615 stack2manager(mISDNport, l3m->type, l3m->pid, l3m);
1620 mISDNport = mISDNport->next;
1625 /* l2 establish timer fires */
1626 static int l2establish_timeout(struct lcr_timer *timer, void *instance, int i)
1628 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1630 if (mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode)) {
1631 PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link portnum=%d.\n", mISDNport->portnum);
1632 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
1633 schedule_timer(&mISDNport->l2establish, 5, 0); /* 5 seconds */
1639 /* handle frames from bchannel */
1640 static int b_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1642 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1643 unsigned char buffer[2048+MISDN_HEADER_LEN];
1644 struct mISDNhead *hh = (struct mISDNhead *)buffer;
1647 ret = recv(fd->fd, buffer, sizeof(buffer), 0);
1649 PERROR("read error frame, errno %d\n", errno);
1652 if (ret < (int)MISDN_HEADER_LEN) {
1653 PERROR("read short frame, got %d, expected %d\n", ret, (int)MISDN_HEADER_LEN);
1657 /* we don't care about confirms, we use rx data to sync tx */
1661 /* we receive audio data, we respond to it AND we send tones */
1666 case PH_CONTROL_IND:
1667 if (mISDNport->b_port[i])
1668 mISDNport->b_port[i]->bchannel_receive(hh, buffer+MISDN_HEADER_LEN, ret-MISDN_HEADER_LEN);
1670 PDEBUG(DEBUG_BCHANNEL, "b-channel is not associated to an ISDNPort (socket %d), ignoring.\n", fd->fd);
1673 case PH_ACTIVATE_IND:
1674 case DL_ESTABLISH_IND:
1675 case PH_ACTIVATE_CNF:
1676 case DL_ESTABLISH_CNF:
1677 PDEBUG(DEBUG_BCHANNEL, "DL_ESTABLISH confirm: bchannel is now activated (socket %d).\n", fd->fd);
1678 bchannel_event(mISDNport, i, B_EVENT_ACTIVATED);
1681 case PH_DEACTIVATE_IND:
1682 case DL_RELEASE_IND:
1683 case PH_DEACTIVATE_CNF:
1684 case DL_RELEASE_CNF:
1685 PDEBUG(DEBUG_BCHANNEL, "DL_RELEASE confirm: bchannel is now de-activated (socket %d).\n", fd->fd);
1686 bchannel_event(mISDNport, i, B_EVENT_DEACTIVATED);
1690 PERROR("child message not handled: prim(0x%x) socket(%d) msg->len(%d)\n", hh->prim, fd->fd, ret-MISDN_HEADER_LEN);
1696 /* process timer events for bchannel handling */
1697 static int b_timer_timeout(struct lcr_timer *timer, void *instance, int i)
1699 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1701 bchannel_event(mISDNport, i, B_EVENT_TIMEOUT);
1707 int do_layer3(struct mlayer3 *ml3, unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1711 * l3m must be queued, except for MT_ASSIGN
1714 struct mISDNport *mISDNport = (struct mISDNport *)ml3->priv;
1717 #ifdef OLD_MT_ASSIGN
1718 /* special MT_ASSIGN handling:
1720 * if we request a PID from mlayer, we always do it while lcr is locked.
1721 * therefore we must check the MT_ASSIGN reply first before we lock.
1722 * this is because the MT_ASSIGN reply is received with the requesting
1723 * process, not by the mlayer thread!
1724 * this means, that the reply is sent during call of the request.
1725 * we must check if we get a reply and we know that we lcr is currently
1728 if (cmd==MT_ASSIGN && (pid&MISDN_PID_CR_FLAG) && (pid>>16)==MISDN_CES_MASTER) {
1729 /* let's do some checking if someone changes stack behaviour */
1730 if (mt_assign_pid != 0)
1731 FATAL("someone played with the mISDNuser stack. MT_ASSIGN not currently expected.\n");
1732 mt_assign_pid = pid;
1736 /* queue message, create, if required */
1738 l3m = alloc_l3_msg();
1740 FATAL("No memory for layer 3 message\n");
1742 mb = container_of(l3m, struct mbuffer, l3);
1745 mqueue_tail(&mISDNport->upqueue, mb);
1746 if (!upqueue_avail) {
1747 // multiple threads may cause multiple calls of this section, but this
1748 // results only in multiple processing of the upqueue read.
1749 // this is no problem.
1753 ret = write(upqueue_pipe[1], &byte, 1);
1758 int mISDN_getportbyname(int sock, int cnt, char *portname)
1760 struct mISDN_devinfo devinfo;
1764 while (port < cnt) {
1766 ret = ioctl(sock, IMGETDEVINFO, &devinfo);
1769 if (!strcasecmp(devinfo.name, portname))
1780 * global function to add a new card (port)
1782 struct mISDNport *mISDNport_open(struct interface_port *ifport)
1785 struct mISDNport *mISDNport, **mISDNportp;
1786 int port = ifport->portnum;
1787 int ptp = ifport->ptp;
1788 int force_nt = ifport->nt;
1789 int l1hold = ifport->l1hold;
1790 int l2hold = ifport->l2hold;
1791 int ss5 = ifport->ss5;
1795 // struct mlayer3 *ml3;
1796 struct mISDN_devinfo devinfo;
1797 unsigned int protocol, prop;
1799 /* check port counts */
1800 ret = ioctl(mISDNsocket, IMGETCOUNT, &cnt);
1802 fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret);
1807 PERROR_RUNTIME("Found no card. Please be sure to load card drivers.\n");
1811 port = mISDN_getportbyname(mISDNsocket, cnt, ifport->portname);
1813 PERROR_RUNTIME("Port name '%s' not found, use 'misdn_info' tool to list all existing ports.\n", ifport->portname);
1816 // note: 'port' has still the port number
1818 if (port>cnt || port<0) {
1819 PERROR_RUNTIME("Port (%d) given at 'ports' (options.conf) is out of existing port range (%d-%d)\n", port, 0, cnt);
1823 /* get port attributes */
1824 pri = bri = pots = nt = te = 0;
1826 ret = ioctl(mISDNsocket, IMGETDEVINFO, &devinfo);
1828 PERROR_RUNTIME("Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", port, ret);
1831 if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0)) {
1835 if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0)) {
1839 if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1)) {
1843 if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1)) {
1848 if (devinfo.Dprotocols & (1 << ISDN_P_FXS)) {
1854 if (devinfo.Dprotocols & (1 << ISDN_P_FXO)) {
1859 if (force_nt && !nt) {
1860 PERROR_RUNTIME("Port %d does not support NT-mode\n", port);
1864 PERROR_RUNTIME("Port %d supports BRI and PRI?? What kind of controller is that?. (Can't use this!)\n", port);
1867 if (pots && !bri && !pri) {
1868 PERROR_RUNTIME("Port %d supports POTS, LCR does not!\n", port);
1872 PERROR_RUNTIME("Port %d does not support BRI nor PRI!\n", port);
1876 PERROR_RUNTIME("Port %d does not support NT-mode nor TE-mode!\n", port);
1879 /* set NT by turning off TE */
1882 /* if TE an NT is supported (and not forced to NT), turn off NT */
1886 /* check for double use of port */
1888 mISDNport = mISDNport_first;
1890 if (mISDNport->portnum == port)
1892 mISDNport = mISDNport->next;
1895 PERROR_RUNTIME("Port %d already in use by LCR. You can't use a NT port multiple times.\n", port);
1900 /* check for continous channelmap with no bchannel on slot 16 */
1901 if (test_channelmap(0, devinfo.channelmap)) {
1902 PERROR_RUNTIME("Port %d provides channel 0, but we cannot access it!\n", port);
1906 while(i < (int)devinfo.nrbchan + 1) {
1908 if (test_channelmap(i, devinfo.channelmap)) {
1909 PERROR("Port %d provides bchannel 16. Pleas upgrade mISDN, if this port is mISDN loopback interface.\n", port);
1913 if (!test_channelmap(i, devinfo.channelmap)) {
1914 PERROR_RUNTIME("Port %d has no channel on slot %d!\n", port, i);
1921 /* add mISDNport structure */
1922 mISDNportp = &mISDNport_first;
1924 mISDNportp = &((*mISDNportp)->next);
1925 mISDNport = (struct mISDNport *)MALLOC(sizeof(struct mISDNport));
1926 add_timer(&mISDNport->l2establish, l2establish_timeout, mISDNport, 0);
1928 /* ss5 link is always active */
1929 mISDNport->l1link = 1;
1930 mISDNport->l2link = 1;
1932 mISDNport->l1link = -1;
1933 mISDNport->l2link = -1;
1936 *mISDNportp = mISDNport;
1938 /* if pri, must set PTP */
1942 /* set ss5 params */
1944 /* try to keep interface enabled */
1964 /* allocate ressources of port */
1965 protocol = (nt)?L3_PROTOCOL_DSS1_NET:L3_PROTOCOL_DSS1_USER;
1966 prop = (1 << MISDN_FLG_L2_CLEAN);
1967 if (ptp) // ptp forced
1968 prop |= (1 << MISDN_FLG_PTP);
1969 if (nt) // supports hold/retrieve on nt-mode
1970 prop |= (1 << MISDN_FLG_NET_HOLD);
1971 if (l1hold) // supports layer 1 hold
1972 prop |= (1 << MISDN_FLG_L1_HOLD);
1973 if (l2hold) // supports layer 2 hold
1974 prop |= (1 << MISDN_FLG_L2_HOLD);
1975 /* open layer 3 and init upqueue */
1976 /* queue must be initializes, because l3-thread may send messages during open_layer3() */
1977 mqueue_init(&mISDNport->upqueue);
1978 mISDNport->ml3 = open_layer3(port, protocol, prop , do_layer3, mISDNport);
1979 if (!mISDNport->ml3) {
1980 mqueue_purge(&mISDNport->upqueue);
1981 PERROR_RUNTIME("open_layer3() failed for port %d\n", port);
1989 "PORT (open failed)");
1991 mISDNport_close(mISDNport);
1995 SCPY(mISDNport->name, devinfo.name);
1996 mISDNport->b_num = devinfo.nrbchan;
1997 mISDNport->portnum = port;
1998 mISDNport->ntmode = nt;
1999 mISDNport->tespecial = ifport->tespecial;
2000 mISDNport->pri = pri;
2001 mISDNport->ptp = ptp;
2002 mISDNport->l1hold = l1hold;
2003 mISDNport->l2hold = l2hold;
2004 mISDNport->ss5 = ss5;
2005 PDEBUG(DEBUG_ISDN, "Port has %d b-channels.\n", mISDNport->b_num);
2007 while(i < mISDNport->b_num) {
2008 mISDNport->b_state[i] = B_STATE_IDLE;
2009 add_timer(&mISDNport->b_timer[i], b_timer_timeout, mISDNport, i);
2013 /* if ptp, pull up the link */
2014 if (mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode)) {
2015 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
2016 l1l2l3_trace_header(mISDNport, NULL, L2_ESTABLISH_REQ, DIRECTION_OUT);
2017 add_trace("tei", NULL, "%d", 0);
2019 schedule_timer(&mISDNport->l2establish, 5, 0); /* 5 seconds */
2022 /* for nt-mode ptmp the link is always up */
2023 if (mISDNport->ntmode && !mISDNport->ptp)
2024 mISDNport->l2link = 1;
2026 PDEBUG(DEBUG_BCHANNEL, "using 'mISDN_dsp.o' module\n");
2028 start_trace(mISDNport->portnum,
2036 add_trace("mode", NULL, (mISDNport->ntmode)?"network":"terminal");
2037 add_trace("channels", NULL, "%d", mISDNport->b_num);
2039 add_trace("ccitt#5", NULL, "enabled");
2047 * load static port instances, if required by mISDNport
2049 void mISDNport_static(struct mISDNport *mISDNport)
2054 while(i < mISDNport->b_num) {
2057 ss5_create_channel(mISDNport, i);
2065 * function to free ALL cards (ports)
2067 void mISDNport_close_all(void)
2069 /* free all ports */
2070 while(mISDNport_first)
2071 mISDNport_close(mISDNport_first);
2075 * free only one port
2077 void mISDNport_close(struct mISDNport *mISDNport)
2079 struct mISDNport **mISDNportp;
2081 class PmISDN *isdnport;
2084 /* remove all port instance that are linked to this mISDNport */
2088 if ((port->p_type&PORT_CLASS_MASK) == PORT_CLASS_mISDN) {
2089 isdnport = (class PmISDN *)port;
2090 if (isdnport->p_m_mISDNport && isdnport->p_m_mISDNport == mISDNport) {
2091 PDEBUG(DEBUG_ISDN, "port %s uses mISDNport %d, destroying it.\n", isdnport->p_name, mISDNport->portnum);
2099 /* only if we are already part of interface */
2100 if (mISDNport->ifport) {
2101 start_trace(mISDNport->portnum,
2102 mISDNport->ifport->interface,
2112 /* free bchannels */
2114 while(i < mISDNport->b_num) {
2115 if (mISDNport->b_sock[i].inuse) {
2116 _bchannel_destroy(mISDNport, i);
2117 PDEBUG(DEBUG_BCHANNEL, "freeing %s port %d bchannel (index %d).\n", (mISDNport->ntmode)?"NT":"TE", mISDNport->portnum, i);
2119 if (mISDNport->b_timer[i].inuse) {
2120 del_timer(&mISDNport->b_timer[i]);
2124 del_timer(&mISDNport->l2establish);
2126 /* close layer 3, if open */
2127 if (mISDNport->ml3) {
2128 close_layer3(mISDNport->ml3);
2132 mqueue_purge(&mISDNport->upqueue);
2134 /* remove from list */
2135 mISDNportp = &mISDNport_first;
2136 while(*mISDNportp) {
2137 if (*mISDNportp == mISDNport) {
2138 *mISDNportp = (*mISDNportp)->next;
2142 mISDNportp = &((*mISDNportp)->next);
2146 FATAL("mISDNport not in list\n");
2148 FREE(mISDNport, sizeof(struct mISDNport));
2155 * enque data from remote port
2157 int PmISDN::bridge_rx(unsigned char *data, int length)
2159 unsigned char buf[MISDN_HEADER_LEN+((length>p_m_preload)?length:p_m_preload)];
2160 struct mISDNhead *hh = (struct mISDNhead *)buf;
2163 if (p_m_b_index < 0)
2165 if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_ACTIVE)
2168 /* run load-timer when bridged and dejitter is disabled */
2169 if (!p_m_loadtimer.active && p_m_disable_dejitter && p_m_preload > 0)
2172 /* check if high priority tones exist
2173 * ignore data in this case
2175 if (p_tone_name[0] || p_m_crypt_msg_loops || p_m_inband_send_on)
2178 /* preload procedure
2179 * if transmit buffer in DSP module is empty,
2180 * preload it to DSP_LOAD to prevent jitter gaps.
2182 * if load runs empty, preload again.
2184 if (p_m_disable_dejitter && p_m_load == 0 && p_m_preload > 0) {
2185 //printf("preload=%d\n", p_m_preload);
2186 hh->prim = PH_DATA_REQ;
2188 memset(buf+MISDN_HEADER_LEN, silence, p_m_preload);
2189 ret = sendto(p_m_mISDNport->b_sock[p_m_b_index].fd, buf, MISDN_HEADER_LEN+p_m_preload, 0, NULL, 0);
2191 PERROR("Failed to send to socket %d\n", p_m_mISDNport->b_sock[p_m_b_index].fd);
2192 p_m_load += p_m_preload;
2193 schedule_timer(&p_m_loadtimer, 0, PORT_TRANSMIT * 125);
2196 /* drop if load would exceed ISDN_MAXLOAD
2197 * this keeps the delay not too high
2199 //printf("load=%d len=%d 2*preload=%d\n", p_m_load, length, p_m_preload << 1);
2200 if (p_m_disable_dejitter && p_m_preload > 0 && p_m_load+length > (p_m_preload << 1))
2203 /* make and send frame */
2204 hh->prim = PH_DATA_REQ;
2206 memcpy(buf+MISDN_HEADER_LEN, data, length);
2207 ret = sendto(p_m_mISDNport->b_sock[p_m_b_index].fd, buf, MISDN_HEADER_LEN+length, 0, NULL, 0);
2209 PERROR("Failed to send to socket %d\n", p_m_mISDNport->b_sock[p_m_b_index].fd);
2215 int PmISDN::inband_send(unsigned char *buffer, int len)
2217 PERROR("this function must be derived to function!\n");
2221 void PmISDN::inband_send_on(void)
2223 PDEBUG(DEBUG_PORT, "turning inband signalling send on.\n");
2224 p_m_inband_send_on = 1;
2225 /* trigger inband transmit */
2229 void PmISDN::inband_send_off(void)
2231 PDEBUG(DEBUG_PORT, "turning inband signalling send off.\n");
2232 p_m_inband_send_on = 0;
2235 void PmISDN::inband_receive(unsigned char *buffer, int len)
2238 // if (len >= SS5_DECODER_NPOINTS)
2239 // ss5_decode(buffer, SS5_DECODER_NPOINTS);
2240 PERROR("this function must be derived to function!\n");
2243 void PmISDN::inband_receive_on(void)
2245 /* this must work during constructor, see ss5.cpp */
2246 PDEBUG(DEBUG_PORT, "turning inband signalling receive on.\n");
2247 p_m_inband_receive_on = 1;
2251 void PmISDN::inband_receive_off(void)
2253 PDEBUG(DEBUG_PORT, "turning inband signalling receive off.\n");
2254 p_m_inband_receive_on = 0;
2258 void PmISDN::mute_on(void)
2262 PDEBUG(DEBUG_PORT, "turning mute on.\n");
2264 set_conf(p_m_conf, 0);
2267 void PmISDN::mute_off(void)
2271 PDEBUG(DEBUG_PORT, "turning mute off.\n");
2273 set_conf(0, p_m_conf);