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 static int load_timer(struct lcr_timer *timer, void *instance, int index);
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)
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;
654 b_port->update_load();
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;
664 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
670 FATAL("bchannel must be linked to a Port class\n");
673 /* bchannel is idle due to an error, so we do nothing */
676 case B_STATE_ACTIVATING:
677 /* do nothing because we must wait until bchanenl is active before deactivating */
681 /* bchannel is active, so we deactivate */
682 _bchannel_activate(mISDNport, i, 0, 0);
683 state = B_STATE_DEACTIVATING;
684 timer = B_TIMER_DEACTIVATING;
687 case B_STATE_DEACTIVATING:
688 /* we may have taken an already deactivating bchannel, but do not require it anymore, so we do nothing */
692 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
696 case B_EVENT_DEACTIVATED:
700 /* ignore due to deactivation confirm after unloading */
703 case B_STATE_DEACTIVATING:
704 _bchannel_destroy(mISDNport, i);
705 state = B_STATE_IDLE;
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;
717 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
721 case B_EVENT_TIMEOUT:
725 /* ignore due to deactivation confirm after unloading */
728 case B_STATE_ACTIVATING:
729 _bchannel_activate(mISDNport, i, 1, 1);
730 timer = B_TIMER_ACTIVATING;
733 case B_STATE_DEACTIVATING:
734 _bchannel_activate(mISDNport, i, 0, 1);
735 timer = B_TIMER_DEACTIVATING;
739 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
744 PERROR("Illegal event %d, please correct.\n", event);
747 mISDNport->b_state[i] = state;
749 unsched_timer(&mISDNport->b_timer[i]);
751 schedule_timer(&mISDNport->b_timer[i], timer, 0);
758 * check for available channel and reserve+set it.
759 * give channel number or SEL_CHANNEL_ANY or SEL_CHANNEL_NO
761 * returns -(cause value) or x = channel x or 0 = no channel
762 * NOTE: no activation is done here
764 int PmISDN::seize_bchannel(int channel, int exclusive)
768 /* the channel is what we have */
769 if (p_m_b_channel == channel)
772 /* if channel already in use, release it */
777 if (channel==CHANNEL_NO || channel==0)
780 /* is channel in range ? */
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 */
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 */
794 /* ask for channel */
796 i = channel-1-(channel>16);
797 if (p_m_mISDNport->b_port[i] == NULL)
801 /* search for channel */
803 while(i < p_m_mISDNport->b_num) {
804 if (!p_m_mISDNport->b_port[i]) {
805 channel = i+1+(i>=15);
810 return(-34); /* no free channel */
813 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) seizing bchannel %d (index %d)\n", p_name, channel, i);
815 /* link Port, set parameters */
816 p_m_mISDNport->b_port[i] = this;
818 p_m_b_channel = channel;
819 p_m_b_exclusive = exclusive;
820 p_m_mISDNport->b_mode[i] = p_m_b_mode;
822 /* reserve channel */
823 if (!p_m_b_reserve) {
825 p_m_mISDNport->b_reserved++;
832 * drop reserved channel and unset it.
833 * deactivation is also done
835 void PmISDN::drop_bchannel(void)
837 /* unreserve channel */
839 p_m_mISDNport->b_reserved--;
848 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) dropping bchannel\n", p_name);
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;
863 audio transmission procedure:
864 -----------------------------
867 three sources of audio transmission:
868 - crypto-data high priority
869 - tones high priority (also high)
870 - remote-data low priority
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.
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
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.
888 * procedure for low priority data
889 see txfromup() for procedure
890 in short: remote data is ignored during high priority tones
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.
897 0 p_m_preload ISDN_MAXLOAD
898 +--------------------+----------------------+
900 +--------------------+----------------------+
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 +--------------------+----------------------+
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 +--------------------+----------------------+
915 void PmISDN::update_load(void)
917 /* don't trigger load event if event already active */
918 if (p_m_loadtimer.active)
921 schedule_timer(&p_m_loadtimer, 0, 0); /* no delay the first time */
924 static int load_timer(struct lcr_timer *timer, void *instance, int index)
926 class PmISDN *isdnport = (class PmISDN *)instance;
933 void PmISDN::load_tx(void)
937 struct timeval current_time;
940 gettimeofday(¤t_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);
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;
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)
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 schedule_timer(&p_m_loadtimer, 0, PORT_TRANSMIT * 125);
1021 /* handle timeouts */
1022 static int mISDN_timeout(struct lcr_timer *timer, void *instance, int i)
1024 class PmISDN *isdnport = (class PmISDN *)instance;
1025 struct lcr_msg *message;
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);
1038 * whenever we get audio data from bchannel, we process it here
1040 void PmISDN::bchannel_receive(struct mISDNhead *hh, unsigned char *data, int len)
1042 unsigned int cont = *((unsigned int *)data);
1043 struct lcr_msg *message;
1047 if (hh->prim == PH_CONTROL_IND) {
1049 PERROR("SHORT READ OF PH_CONTROL INDICATION\n");
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);
1056 add_trace("info", NULL, "DTMF is disabled");
1060 if (p_type == PORT_TYPE_POTS_FXS_IN && p_state == PORT_STATE_IN_OVERLAP) {
1061 class Pfxs *pfxs = (class Pfxs *)this;
1062 if (!pfxs->p_m_fxs_allow_dtmf) {
1063 PDEBUG(DEBUG_PORT, "PmISDN(%s) DTMF for FXS currently disabled\n", p_name);
1066 SCCAT(p_dialinginfo.id, cont & DTMF_TONE_MASK);
1067 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_INFORMATION);
1068 message->param.information.id[0] = cont & DTMF_TONE_MASK;
1069 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION INFORMATION digit '%s'\n", p_name, message->param.information.id);
1070 message_put(message);
1072 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_DTMF);
1073 message->param.dtmf = cont & DTMF_TONE_MASK;
1074 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION DTMF digit '%c'\n", p_name, message->param.dtmf);
1075 message_put(message);
1081 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1082 add_trace("DSP-CRYPT", NULL, "error");
1084 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1085 message->param.crypt.type = CC_ERROR_IND;
1086 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION reject of blowfish.\n", p_name);
1087 message_put(message);
1091 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1092 add_trace("DSP-CRYPT", NULL, "ok");
1094 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1095 message->param.crypt.type = CC_ACTBF_CONF;
1096 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION accept of blowfish.\n", p_name);
1097 message_put(message);
1101 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1102 add_trace("unknown", NULL, "0x%x", cont);
1107 if (hh->prim == PH_CONTROL_IND) {
1110 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1111 add_trace("unknown", NULL, "0x%x", hh->id);
1116 if (hh->prim == PH_DATA_REQ || hh->prim == DL_DATA_REQ) {
1118 /* if tx is off, it may happen that fifos send us pending informations, we just ignore them */
1119 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring tx data, because 'txdata' is turned off\n", p_name);
1122 /* see below (same condition) */
1123 if (p_state!=PORT_STATE_CONNECT
1124 && !p_m_mISDNport->tones)
1126 // printf(".");fflush(stdout);return;
1128 record(data, len, 1); // from up
1130 tap(data, len, 1); // from up
1133 if (hh->prim != PH_DATA_IND && hh->prim != DL_DATA_IND) {
1134 PERROR("Bchannel received unknown primitve: 0x%x\n", hh->prim);
1138 /* inband is processed */
1139 if (p_m_inband_receive_on)
1140 inband_receive(data, len);
1142 /* send to remote, if bridged */
1143 bridge_tx(data, len);
1145 /* calls will not process any audio data unless
1146 * the call is connected OR tones feature is enabled.
1148 #ifndef DEBUG_COREBRIDGE
1149 if (p_state!=PORT_STATE_CONNECT
1150 && !p_m_mISDNport->tones)
1155 /* the bearer capability must be audio in order to send and receive
1156 * audio prior or after connect.
1158 if (!(p_bearerinfo.capability&CLASS_CAPABILITY_AUDIO) && p_state!=PORT_STATE_CONNECT)
1162 /* if rx is off, it may happen that fifos send us pending informations, we just ignore them */
1164 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring data, because rx is turned off\n", p_name);
1170 record(data, len, 0); // from down
1172 tap(data, len, 0); // from down
1174 /* randomize and listen to crypt message if enabled */
1175 if (p_m_crypt_listen) {
1176 /* the noisy randomizer */
1180 mISDN_rand[mISDN_rand_count & 0xff] += *p++;
1182 cryptman_listen_bch(data, len);
1190 void PmISDN::set_echotest(int echo)
1192 if (p_m_echo != echo) {
1194 PDEBUG(DEBUG_ISDN, "we set echo to echo=%d.\n", p_m_echo);
1196 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1197 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);
1204 void PmISDN::set_tone(const char *dir, const char *tone)
1209 /* if no directory is given (by extension), we use interface.conf or options.conf */
1210 if (!dir || !dir[0]) {
1211 if (p_m_mISDNport->ifport->tones_dir[0])
1212 dir = p_m_mISDNport->ifport->tones_dir;
1213 else if (options.tones_dir[0])
1214 dir = options.tones_dir;
1219 PDEBUG(DEBUG_ISDN, "isdn port now plays tone:'%s'.\n", tone);
1225 /* check for dsp tones */
1226 if (!strcmp(dir, "american"))
1228 if (!strcmp(dir, "german"))
1230 if (!strcmp(dir, "oldgerman"))
1231 dsp = DSP_OLDGERMAN;
1233 /* check if we NOT really have to use a dsp-tone */
1234 if (dsp == DSP_NONE) {
1237 if (p_m_b_index > -1)
1238 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) {
1239 PDEBUG(DEBUG_ISDN, "we reset tone from id=%d to OFF.\n", p_m_tone);
1240 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TONE_PATT_OFF, 0, "DSP-TONE", 0);
1243 Port::set_tone(dir, tone);
1247 /* now we USE dsp-tone, convert name */
1248 if (!strcmp(tone, "dialtone")) {
1250 case DSP_AMERICAN: id = TONE_AMERICAN_DIALTONE; break;
1251 case DSP_GERMAN: id = TONE_GERMAN_DIALTONE; break;
1252 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALTONE; break;
1254 } else if (!strcmp(tone, "dialpbx")) {
1256 case DSP_AMERICAN: id = TONE_AMERICAN_DIALPBX; break;
1257 case DSP_GERMAN: id = TONE_GERMAN_DIALPBX; break;
1258 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALPBX; break;
1260 } else if (!strcmp(tone, "ringing")) {
1262 case DSP_AMERICAN: id = TONE_AMERICAN_RINGING; break;
1263 case DSP_GERMAN: id = TONE_GERMAN_RINGING; break;
1264 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGING; break;
1266 } else if (!strcmp(tone, "ringpbx")) {
1268 case DSP_AMERICAN: id = TONE_AMERICAN_RINGPBX; break;
1269 case DSP_GERMAN: id = TONE_GERMAN_RINGPBX; break;
1270 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGPBX; break;
1272 } else if (!strcmp(tone, "busy")) {
1275 case DSP_AMERICAN: id = TONE_AMERICAN_BUSY; break;
1276 case DSP_GERMAN: id = TONE_GERMAN_BUSY; break;
1277 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1279 } else if (!strcmp(tone, "release")) {
1282 case DSP_AMERICAN: id = TONE_AMERICAN_HANGUP; break;
1283 case DSP_GERMAN: id = TONE_GERMAN_HANGUP; break;
1284 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDHANGUP; break;
1286 } else if (!strcmp(tone, "cause_10"))
1288 else if (!strcmp(tone, "cause_11"))
1290 else if (!strcmp(tone, "cause_22")) {
1292 case DSP_AMERICAN: id = TONE_SPECIAL_INFO; break;
1293 case DSP_GERMAN: id = TONE_GERMAN_GASSENBESETZT; break;
1294 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1296 } else if (!strncmp(tone, "cause_", 6))
1297 id = TONE_SPECIAL_INFO;
1301 /* if we have a tone that is not supported by dsp */
1302 if (id==TONE_OFF && tone[0])
1306 if (p_m_tone != id) {
1309 PDEBUG(DEBUG_ISDN, "we set tone to id=%d.\n", p_m_tone);
1310 if (p_m_b_index > -1)
1311 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)
1312 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);
1314 /* turn user-space tones off in cases of no tone OR dsp tone */
1315 Port::set_tone("",NULL);
1319 /* MESSAGE_mISDNSIGNAL */
1320 //extern struct lcr_msg *dddebug;
1321 void PmISDN::message_mISDNsignal(unsigned int epoint_id, int message_id, union parameter *param)
1323 int oldconf, newconf;
1324 switch(param->mISDNsignal.message) {
1325 case mISDNSIGNAL_VOLUME:
1326 if (p_m_tx_gain != param->mISDNsignal.tx_gain) {
1327 p_m_tx_gain = param->mISDNsignal.tx_gain;
1328 PDEBUG(DEBUG_BCHANNEL, "we change tx-volume to shift=%d.\n", p_m_tx_gain);
1329 if (p_m_b_index > -1)
1330 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)
1331 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);
1333 PDEBUG(DEBUG_BCHANNEL, "we already have tx-volume shift=%d.\n", p_m_rx_gain);
1334 if (p_m_rx_gain != param->mISDNsignal.rx_gain) {
1335 p_m_rx_gain = param->mISDNsignal.rx_gain;
1336 PDEBUG(DEBUG_BCHANNEL, "we change rx-volume to shift=%d.\n", p_m_rx_gain);
1337 if (p_m_b_index > -1)
1338 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)
1339 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);
1341 PDEBUG(DEBUG_BCHANNEL, "we already have rx-volume shift=%d.\n", p_m_rx_gain);
1344 case mISDNSIGNAL_CONF:
1345 oldconf = p_m_mute?0:p_m_conf;
1346 p_m_conf = param->mISDNsignal.conf;
1347 newconf = p_m_mute?0:p_m_conf;
1348 set_conf(oldconf, newconf);
1351 case mISDNSIGNAL_DELAY:
1352 if (p_m_delay != param->mISDNsignal.delay) {
1353 p_m_delay = param->mISDNsignal.delay;
1354 PDEBUG(DEBUG_BCHANNEL, "we change delay mode to delay=%d.\n", p_m_delay);
1355 if (p_m_b_index > -1)
1356 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)
1357 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);
1359 PDEBUG(DEBUG_BCHANNEL, "we already have delay=%d.\n", p_m_delay);
1363 PERROR("PmISDN(%s) unsupported signal message %d.\n", p_name, param->mISDNsignal.message);
1368 void PmISDN::message_crypt(unsigned int epoint_id, int message_id, union parameter *param)
1370 struct lcr_msg *message;
1372 switch(param->crypt.type) {
1373 case CC_ACTBF_REQ: /* activate blowfish */
1375 p_m_crypt_key_len = param->crypt.len;
1376 if (p_m_crypt_key_len > (int)sizeof(p_m_crypt_key)) {
1377 PERROR("PmISDN(%s) key too long %d > %d\n", p_name, p_m_crypt_key_len, sizeof(p_m_crypt_key));
1378 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1379 message->param.crypt.type = CC_ERROR_IND;
1380 message_put(message);
1383 memcpy(p_m_crypt_key, param->crypt.data, p_m_crypt_key_len);
1385 PDEBUG(DEBUG_BCHANNEL, "we set encryption to crypt=%d. (0 means OFF)\n", p_m_crypt);
1386 if (p_m_b_index > -1)
1387 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)
1388 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);
1391 case CC_DACT_REQ: /* deactivate session encryption */
1396 case CR_LISTEN_REQ: /* start listening to messages */
1397 p_m_crypt_listen = 1;
1399 p_m_crypt_listen_state = 0;
1402 case CR_UNLISTEN_REQ: /* stop listening to messages */
1403 p_m_crypt_listen = 0;
1407 case CR_MESSAGE_REQ: /* send message */
1408 p_m_crypt_msg_len = cryptman_encode_bch(param->crypt.data, param->crypt.len, p_m_crypt_msg, sizeof(p_m_crypt_msg));
1409 if (!p_m_crypt_msg_len) {
1410 PERROR("PmISDN(%s) message too long %d > %d\n", p_name, param->crypt.len-1, sizeof(p_m_crypt_msg));
1413 p_m_crypt_msg_current = 0; /* reset */
1414 p_m_crypt_msg_loops = 6; /* enable */
1417 /* disable txmix, or we get corrupt data due to audio process */
1418 if (p_m_txmix && p_m_b_index>=0 && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT) {
1419 PDEBUG(DEBUG_BCHANNEL, "for sending CR_MESSAGE_REQ, we reset txmix from txmix=%d.\n", p_m_txmix);
1420 ph_control(p_m_mISDNport, this, p_mISDNport->b_sock[p_m_b_index].fd, DSP_MIX_OFF, 0, "DSP-TXMIX", 0);
1426 PERROR("PmISDN(%s) unknown crypt message %d\n", p_name, param->crypt.type);
1432 * endpoint sends messages to the port
1434 int PmISDN::message_epoint(unsigned int epoint_id, int message_id, union parameter *param)
1436 if (Port::message_epoint(epoint_id, message_id, param)) {
1437 if (message_id == MESSAGE_BRIDGE)
1442 switch(message_id) {
1443 case MESSAGE_mISDNSIGNAL: /* user command */
1444 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received special ISDN SIGNAL %d.\n", p_name, param->mISDNsignal.message);
1445 message_mISDNsignal(epoint_id, message_id, param);
1448 case MESSAGE_CRYPT: /* crypt control command */
1449 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received encryption command '%d'.\n", p_name, param->crypt.type);
1450 message_crypt(epoint_id, message_id, param);
1453 case MESSAGE_DISABLE_DEJITTER:
1454 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received de-jitter disable order.\n", p_name);
1455 p_m_disable_dejitter = 1;
1456 p_m_preload = param->queue;
1464 void PmISDN::update_rxoff(void)
1466 int tx_dejitter = 0;
1468 /* call bridges in user space OR crypto OR recording */
1469 if (p_bridge || p_m_crypt_msg_loops || p_m_crypt_listen || p_record || p_tap || p_m_inband_receive_on) {
1470 /* rx IS required */
1474 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is required, so we turn them on\n", __FUNCTION__);
1475 if (p_m_b_index > -1)
1476 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1477 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_RECEIVE_ON, 0, "DSP-RXOFF", 0);
1480 /* rx NOT required */
1484 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is not required, so we turn them off\n", __FUNCTION__);
1485 if (p_m_b_index > -1)
1486 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1487 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
1490 /* recording / tapping */
1491 if (p_record || p_tap) {
1492 /* txdata IS required */
1496 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is required, so we turn them on\n", __FUNCTION__);
1497 if (p_m_b_index > -1)
1498 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1499 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TXDATA_ON, 0, "DSP-TXDATA", 1);
1502 /* txdata NOT required */
1506 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is not required, so we turn them off\n", __FUNCTION__);
1507 if (p_m_b_index > -1)
1508 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1509 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TXDATA_OFF, 0, "DSP-TXDATA", 0);
1512 /* dejitter on bridge */
1513 if (p_bridge && !p_m_disable_dejitter)
1515 if (p_m_tx_dejitter != tx_dejitter) {
1516 p_m_tx_dejitter = tx_dejitter;
1517 PDEBUG(DEBUG_BCHANNEL, "we change dejitter mode to %s.\n", (p_m_tx_dejitter) ? "on" : "off");
1518 if (p_m_b_index > -1)
1519 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)
1520 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);
1524 static int mISDN_upqueue(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1526 struct mISDNport *mISDNport;
1532 /* unset global semaphore */
1534 // with a very small incident, upqueue_avail may be set by mISDN thread and
1535 // another byte may be sent to the pipe, which causes a call to this function
1536 // again with nothing in the upqueue. this is no problem.
1537 ret = read(fd->fd, &byte, 1);
1539 /* process all ports */
1540 mISDNport = mISDNport_first;
1542 /* handle queued up-messages (d-channel) */
1543 while ((mb = mdequeue(&mISDNport->upqueue))) {
1546 case MPH_ACTIVATE_IND:
1547 if (mISDNport->l1link != 1) {
1548 l1l2l3_trace_header(mISDNport, NULL, L1_ACTIVATE_IND, DIRECTION_IN);
1550 mISDNport->l1link = 1;
1554 case MPH_DEACTIVATE_IND:
1555 if (mISDNport->l1link != 0) {
1556 l1l2l3_trace_header(mISDNport, NULL, L1_DEACTIVATE_IND, DIRECTION_IN);
1558 mISDNport->l1link = 0;
1562 case MPH_INFORMATION_IND:
1563 PDEBUG(DEBUG_ISDN, "Received MPH_INFORMATION_IND for port %d (%s).\n", mISDNport->portnum, mISDNport->ifport->interface->name);
1565 case L1_SIGNAL_LOS_ON:
1568 case L1_SIGNAL_LOS_OFF:
1571 case L1_SIGNAL_AIS_ON:
1574 case L1_SIGNAL_AIS_OFF:
1577 case L1_SIGNAL_RDI_ON:
1580 case L1_SIGNAL_RDI_OFF:
1583 case L1_SIGNAL_SLIP_TX:
1584 mISDNport->slip_tx++;
1586 case L1_SIGNAL_SLIP_RX:
1587 mISDNport->slip_rx++;
1592 case MT_L2ESTABLISH:
1593 l1l2l3_trace_header(mISDNport, NULL, L2_ESTABLISH_IND, DIRECTION_IN);
1594 add_trace("tei", NULL, "%d", l3m->pid);
1596 mISDNport->l2link = 1;
1598 mISDNport->l2mask[l3m->pid >> 3] |= (1 << (l3m->pid & 7));
1599 if ((!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127) {
1600 if (mISDNport->l2establish.active) {
1601 unsched_timer(&mISDNport->l2establish);
1602 PDEBUG(DEBUG_ISDN, "the link became active before l2establish timer expiry.\n");
1609 mISDNport->l2mask[l3m->pid >> 3] &= ~(1 << (l3m->pid & 7));
1610 if (!mISDNport->l2establish.active) {
1611 l1l2l3_trace_header(mISDNport, NULL, L2_RELEASE_IND, DIRECTION_IN);
1612 add_trace("tei", NULL, "%d", l3m->pid);
1614 /* down if not nt-ptmp */
1615 if (!mISDNport->ntmode || mISDNport->ptp)
1616 mISDNport->l2link = 0;
1618 if ((!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127) {
1619 if (!mISDNport->l2establish.active && mISDNport->l2hold) {
1620 PDEBUG(DEBUG_ISDN, "set timer and establish.\n");
1621 schedule_timer(&mISDNport->l2establish, 5, 0);
1622 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
1628 /* l3-data is sent to LCR */
1629 stack2manager(mISDNport, l3m->type, l3m->pid, l3m);
1634 mISDNport = mISDNport->next;
1639 /* l2 establish timer fires */
1640 static int l2establish_timeout(struct lcr_timer *timer, void *instance, int i)
1642 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1644 if (mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode)) {
1645 PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link portnum=%d.\n", mISDNport->portnum);
1646 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
1647 schedule_timer(&mISDNport->l2establish, 5, 0); /* 5 seconds */
1653 /* handle frames from bchannel */
1654 static int b_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1656 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1657 unsigned char buffer[2048+MISDN_HEADER_LEN];
1658 struct mISDNhead *hh = (struct mISDNhead *)buffer;
1661 ret = recv(fd->fd, buffer, sizeof(buffer), 0);
1663 PERROR("read error frame, errno %d\n", errno);
1666 if (ret < (int)MISDN_HEADER_LEN) {
1667 PERROR("read short frame, got %d, expected %d\n", ret, (int)MISDN_HEADER_LEN);
1671 /* we don't care about confirms, we use rx data to sync tx */
1675 /* we receive audio data, we respond to it AND we send tones */
1680 case PH_CONTROL_IND:
1681 if (mISDNport->b_port[i])
1682 mISDNport->b_port[i]->bchannel_receive(hh, buffer+MISDN_HEADER_LEN, ret-MISDN_HEADER_LEN);
1684 PDEBUG(DEBUG_BCHANNEL, "b-channel is not associated to an ISDNPort (socket %d), ignoring.\n", fd->fd);
1687 case PH_ACTIVATE_IND:
1688 case DL_ESTABLISH_IND:
1689 case PH_ACTIVATE_CNF:
1690 case DL_ESTABLISH_CNF:
1691 PDEBUG(DEBUG_BCHANNEL, "DL_ESTABLISH confirm: bchannel is now activated (socket %d).\n", fd->fd);
1692 bchannel_event(mISDNport, i, B_EVENT_ACTIVATED);
1695 case PH_DEACTIVATE_IND:
1696 case DL_RELEASE_IND:
1697 case PH_DEACTIVATE_CNF:
1698 case DL_RELEASE_CNF:
1699 PDEBUG(DEBUG_BCHANNEL, "DL_RELEASE confirm: bchannel is now de-activated (socket %d).\n", fd->fd);
1700 bchannel_event(mISDNport, i, B_EVENT_DEACTIVATED);
1704 PERROR("child message not handled: prim(0x%x) socket(%d) msg->len(%d)\n", hh->prim, fd->fd, ret-MISDN_HEADER_LEN);
1710 /* process timer events for bchannel handling */
1711 static int b_timer_timeout(struct lcr_timer *timer, void *instance, int i)
1713 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1715 bchannel_event(mISDNport, i, B_EVENT_TIMEOUT);
1721 int do_layer3(struct mlayer3 *ml3, unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1725 * l3m must be queued, except for MT_ASSIGN
1728 struct mISDNport *mISDNport = (struct mISDNport *)ml3->priv;
1731 #ifdef OLD_MT_ASSIGN
1732 /* special MT_ASSIGN handling:
1734 * if we request a PID from mlayer, we always do it while lcr is locked.
1735 * therefore we must check the MT_ASSIGN reply first before we lock.
1736 * this is because the MT_ASSIGN reply is received with the requesting
1737 * process, not by the mlayer thread!
1738 * this means, that the reply is sent during call of the request.
1739 * we must check if we get a reply and we know that we lcr is currently
1742 if (cmd==MT_ASSIGN && (pid&MISDN_PID_CR_FLAG) && (pid>>16)==MISDN_CES_MASTER) {
1743 /* let's do some checking if someone changes stack behaviour */
1744 if (mt_assign_pid != 0)
1745 FATAL("someone played with the mISDNuser stack. MT_ASSIGN not currently expected.\n");
1746 mt_assign_pid = pid;
1750 /* queue message, create, if required */
1752 l3m = alloc_l3_msg();
1754 FATAL("No memory for layer 3 message\n");
1756 mb = container_of(l3m, struct mbuffer, l3);
1759 mqueue_tail(&mISDNport->upqueue, mb);
1760 if (!upqueue_avail) {
1761 // multiple threads may cause multiple calls of this section, but this
1762 // results only in multiple processing of the upqueue read.
1763 // this is no problem.
1767 ret = write(upqueue_pipe[1], &byte, 1);
1772 int mISDN_getportbyname(int sock, int cnt, char *portname)
1774 struct mISDN_devinfo devinfo;
1778 while (port < cnt) {
1780 ret = ioctl(sock, IMGETDEVINFO, &devinfo);
1783 if (!strcasecmp(devinfo.name, portname))
1793 /* handle frames from pots */
1794 static int pots_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1796 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1797 unsigned char buffer[2048+MISDN_HEADER_LEN];
1798 struct mISDNhead *hh = (struct mISDNhead *)buffer;
1802 ret = recv(fd->fd, buffer, sizeof(buffer), 0);
1804 PERROR("read error frame, errno %d\n", errno);
1807 if (ret < (int)MISDN_HEADER_LEN) {
1808 PERROR("read short frame, got %d, expected %d\n", ret, (int)MISDN_HEADER_LEN);
1812 case PH_CONTROL_IND:
1813 cont = *((unsigned int *)(buffer + MISDN_HEADER_LEN));
1814 /* l1-control is sent to LCR */
1815 if (mISDNport->ntmode)
1816 stack2manager_fxs(mISDNport, cont);
1818 PERROR("FXO not supported!\n");
1820 case PH_ACTIVATE_REQ:
1824 PERROR("child message not handled: prim(0x%x) socket(%d) msg->len(%d)\n", hh->prim, fd->fd, ret-MISDN_HEADER_LEN);
1831 * global function to add a new card (port)
1833 struct mISDNport *mISDNport_open(struct interface_port *ifport)
1836 struct mISDNport *mISDNport, **mISDNportp;
1837 int port = ifport->portnum;
1838 int ptp = ifport->ptp;
1839 int force_nt = ifport->nt;
1840 int l1hold = ifport->l1hold;
1841 int l2hold = ifport->l2hold;
1842 int ss5 = ifport->ss5;
1846 // struct mlayer3 *ml3;
1847 struct mISDN_devinfo devinfo;
1848 unsigned int protocol, prop;
1850 /* check port counts */
1851 ret = ioctl(mISDNsocket, IMGETCOUNT, &cnt);
1853 fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret);
1858 PERROR_RUNTIME("Found no card. Please be sure to load card drivers.\n");
1862 port = mISDN_getportbyname(mISDNsocket, cnt, ifport->portname);
1864 PERROR_RUNTIME("Port name '%s' not found, use 'misdn_info' tool to list all existing ports.\n", ifport->portname);
1867 // note: 'port' has still the port number
1869 if (port>cnt || port<0) {
1870 PERROR_RUNTIME("Port (%d) given at 'ports' (options.conf) is out of existing port range (%d-%d)\n", port, 0, cnt);
1874 /* get port attributes */
1875 pri = bri = pots = nt = te = 0;
1877 ret = ioctl(mISDNsocket, IMGETDEVINFO, &devinfo);
1879 PERROR_RUNTIME("Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", port, ret);
1882 if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0)) {
1886 if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0)) {
1890 if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1)) {
1894 if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1)) {
1898 #ifdef ISDN_P_FXS_POTS
1899 if (devinfo.Dprotocols & (1 << ISDN_P_FXO_POTS)) {
1903 if (devinfo.Dprotocols & (1 << ISDN_P_FXS_POTS)) {
1908 if (force_nt && !nt) {
1910 PERROR_RUNTIME("Port %d does not support NT-mode\n", port);
1912 PERROR_RUNTIME("Port %d does not support FXS-mode\n", port);
1916 PERROR_RUNTIME("Port %d supports BRI and PRI?? What kind of controller is that?. (Can't use this!)\n", port);
1919 if (!bri && !pri && !pots) {
1920 PERROR_RUNTIME("Port %d does not support BRI nor PRI nor POTS!\n", port);
1924 PERROR_RUNTIME("Port %d does not support NT-mode nor TE-mode!\n", port);
1927 /* set NT by turning off TE */
1930 /* if TE an NT is supported (and not forced to NT), turn off NT */
1934 PERROR_RUNTIME("Port %d uses FXO-mode, but not supported by LCR!\n", port);
1938 /* check for double use of port */
1940 mISDNport = mISDNport_first;
1942 if (mISDNport->portnum == port)
1944 mISDNport = mISDNport->next;
1947 PERROR_RUNTIME("Port %d already in use by LCR. You can't use a NT port multiple times.\n", port);
1952 /* check for continous channelmap with no bchannel on slot 16 */
1953 if (test_channelmap(0, devinfo.channelmap)) {
1954 PERROR_RUNTIME("Port %d provides channel 0, but we cannot access it!\n", port);
1958 while(i < (int)devinfo.nrbchan + 1) {
1960 if (test_channelmap(i, devinfo.channelmap)) {
1961 PERROR("Port %d provides bchannel 16. Pleas upgrade mISDN, if this port is mISDN loopback interface.\n", port);
1965 if (!test_channelmap(i, devinfo.channelmap)) {
1966 PERROR_RUNTIME("Port %d has no channel on slot %d!\n", port, i);
1973 /* add mISDNport structure */
1974 mISDNportp = &mISDNport_first;
1976 mISDNportp = &((*mISDNportp)->next);
1977 mISDNport = (struct mISDNport *)MALLOC(sizeof(struct mISDNport));
1978 add_timer(&mISDNport->l2establish, l2establish_timeout, mISDNport, 0);
1980 /* ss5 link is always active */
1981 mISDNport->l1link = 1;
1982 mISDNport->l2link = 1;
1984 mISDNport->l1link = -1;
1985 mISDNport->l2link = -1;
1988 *mISDNportp = mISDNport;
1990 /* if pri, must set PTP */
1994 /* set ss5 params */
1996 /* try to keep interface enabled */
2016 /* allocate ressources of port */
2019 protocol = (nt)?L3_PROTOCOL_DSS1_NET:L3_PROTOCOL_DSS1_USER;
2020 prop = (1 << MISDN_FLG_L2_CLEAN);
2021 if (ptp) // ptp forced
2022 prop |= (1 << MISDN_FLG_PTP);
2023 if (nt) // supports hold/retrieve on nt-mode
2024 prop |= (1 << MISDN_FLG_NET_HOLD);
2025 if (l1hold) // supports layer 1 hold
2026 prop |= (1 << MISDN_FLG_L1_HOLD);
2027 if (l2hold) // supports layer 2 hold
2028 prop |= (1 << MISDN_FLG_L2_HOLD);
2029 /* open layer 3 and init upqueue */
2030 /* queue must be initializes, because l3-thread may send messages during open_layer3() */
2031 mqueue_init(&mISDNport->upqueue);
2032 mISDNport->ml3 = open_layer3(port, protocol, prop , do_layer3, mISDNport);
2033 if (!mISDNport->ml3) {
2034 mqueue_purge(&mISDNport->upqueue);
2035 PERROR_RUNTIME("open_layer3() failed for port %d\n", port);
2043 "PORT (open failed)");
2045 mISDNport_close(mISDNport);
2049 #ifdef ISDN_P_FXS_POTS
2052 struct sockaddr_mISDN addr;
2053 struct mISDNhead act;
2056 /* queue must be initializes, because even pots interfaces are checked at mISDN_upqueue loop */
2057 mqueue_init(&mISDNport->upqueue);
2058 sock = socket(PF_ISDN, SOCK_DGRAM, (nt) ? ISDN_P_FXS_POTS : ISDN_P_FXO_POTS);
2060 PERROR_RUNTIME("Cannot open mISDN due to '%s'.\n", strerror(errno));
2063 /* bind socket to dchannel */
2064 addr.family = AF_ISDN;
2067 ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
2069 PERROR_RUNTIME("Error: Failed to bind pots control channel\n");
2077 "PORT (open failed)");
2081 act.prim = PH_ACTIVATE_REQ;
2083 ret = sendto(sock, &act, MISDN_HEADER_LEN, 0, NULL, 0);
2085 PERROR("Failed to send to socket %d\n", sock);
2086 mISDNport->pots_sock.fd = sock;
2087 register_fd(&mISDNport->pots_sock, LCR_FD_READ, pots_sock_callback, mISDNport, i);
2091 SCPY(mISDNport->name, devinfo.name);
2092 mISDNport->b_num = devinfo.nrbchan;
2093 mISDNport->portnum = port;
2094 mISDNport->ntmode = nt;
2095 mISDNport->pots = pots;
2096 mISDNport->tespecial = ifport->tespecial;
2097 mISDNport->pri = pri;
2098 mISDNport->ptp = ptp;
2099 mISDNport->l1hold = l1hold;
2100 mISDNport->l2hold = l2hold;
2101 mISDNport->ss5 = ss5;
2102 PDEBUG(DEBUG_ISDN, "Port has %d b-channels.\n", mISDNport->b_num);
2104 while(i < mISDNport->b_num) {
2105 mISDNport->b_state[i] = B_STATE_IDLE;
2106 add_timer(&mISDNport->b_timer[i], b_timer_timeout, mISDNport, i);
2110 /* if ptp, pull up the link */
2111 if (!pots && mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode)) {
2112 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
2113 l1l2l3_trace_header(mISDNport, NULL, L2_ESTABLISH_REQ, DIRECTION_OUT);
2114 add_trace("tei", NULL, "%d", 0);
2116 schedule_timer(&mISDNport->l2establish, 5, 0); /* 5 seconds */
2119 /* for POTS or nt-mode ptmp the link is always up */
2120 if (pots || (mISDNport->ntmode && !mISDNport->ptp))
2121 mISDNport->l2link = 1;
2123 PDEBUG(DEBUG_BCHANNEL, "using 'mISDN_dsp.o' module\n");
2125 start_trace(mISDNport->portnum,
2134 add_trace("mode", NULL, (mISDNport->ntmode)?"network":"terminal");
2136 add_trace("mode", NULL, (mISDNport->ntmode)?"FXS":"FXO");
2137 add_trace("channels", NULL, "%d", mISDNport->b_num);
2139 add_trace("ccitt#5", NULL, "enabled");
2147 * load static port instances, if required by mISDNport
2149 void mISDNport_static(struct mISDNport *mISDNport)
2154 while(i < mISDNport->b_num) {
2157 ss5_create_channel(mISDNport, i);
2165 * function to free ALL cards (ports)
2167 void mISDNport_close_all(void)
2169 /* free all ports */
2170 while(mISDNport_first)
2171 mISDNport_close(mISDNport_first);
2175 * free only one port
2177 void mISDNport_close(struct mISDNport *mISDNport)
2179 struct mISDNport **mISDNportp;
2181 class PmISDN *isdnport;
2184 /* remove all port instance that are linked to this mISDNport */
2188 if ((port->p_type&PORT_CLASS_MASK) == PORT_CLASS_mISDN) {
2189 isdnport = (class PmISDN *)port;
2190 if (isdnport->p_m_mISDNport && isdnport->p_m_mISDNport == mISDNport) {
2191 PDEBUG(DEBUG_ISDN, "port %s uses mISDNport %d, destroying it.\n", isdnport->p_name, mISDNport->portnum);
2199 /* only if we are already part of interface */
2200 if (mISDNport->ifport) {
2201 start_trace(mISDNport->portnum,
2202 mISDNport->ifport->interface,
2212 /* free bchannels */
2214 while(i < mISDNport->b_num) {
2215 if (mISDNport->b_sock[i].inuse) {
2216 _bchannel_destroy(mISDNport, i);
2217 PDEBUG(DEBUG_BCHANNEL, "freeing %s port %d bchannel (index %d).\n", (mISDNport->ntmode)?"NT":"TE", mISDNport->portnum, i);
2219 if (mISDNport->b_timer[i].inuse) {
2220 del_timer(&mISDNport->b_timer[i]);
2224 del_timer(&mISDNport->l2establish);
2226 /* close layer 3, if open */
2227 if (mISDNport->ml3) {
2228 close_layer3(mISDNport->ml3);
2231 /* close layer 1, if open */
2232 if (mISDNport->pots_sock.fd) {
2233 unregister_fd(&mISDNport->pots_sock);
2234 close(mISDNport->pots_sock.fd);
2238 mqueue_purge(&mISDNport->upqueue);
2240 /* remove from list */
2241 mISDNportp = &mISDNport_first;
2242 while(*mISDNportp) {
2243 if (*mISDNportp == mISDNport) {
2244 *mISDNportp = (*mISDNportp)->next;
2248 mISDNportp = &((*mISDNportp)->next);
2252 FATAL("mISDNport not in list\n");
2254 FREE(mISDNport, sizeof(struct mISDNport));
2261 * enque data from remote port
2263 int PmISDN::bridge_rx(unsigned char *data, int length)
2265 unsigned char buf[MISDN_HEADER_LEN+((length>p_m_preload)?length:p_m_preload)];
2266 struct mISDNhead *hh = (struct mISDNhead *)buf;
2269 if (p_m_b_index < 0)
2271 if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_ACTIVE)
2274 /* check if high priority tones exist
2275 * ignore data in this case
2277 if (p_tone_name[0] || p_m_crypt_msg_loops || p_m_inband_send_on)
2280 /* preload procedure
2281 * if transmit buffer in DSP module is empty,
2282 * preload it to DSP_LOAD to prevent jitter gaps.
2284 * if load runs empty, preload again.
2286 if (p_m_disable_dejitter && p_m_load == 0 && p_m_preload > 0) {
2287 //printf("preload=%d\n", p_m_preload);
2288 hh->prim = PH_DATA_REQ;
2290 memset(buf+MISDN_HEADER_LEN, silence, p_m_preload);
2291 ret = sendto(p_m_mISDNport->b_sock[p_m_b_index].fd, buf, MISDN_HEADER_LEN+p_m_preload, 0, NULL, 0);
2293 PERROR("Failed to send to socket %d\n", p_m_mISDNport->b_sock[p_m_b_index].fd);
2294 p_m_load += p_m_preload;
2295 schedule_timer(&p_m_loadtimer, 0, PORT_TRANSMIT * 125);
2298 /* drop if load would exceed ISDN_MAXLOAD
2299 * this keeps the delay not too high
2301 //printf("load=%d len=%d 2*preload=%d\n", p_m_load, length, p_m_preload << 1);
2302 if (p_m_disable_dejitter && p_m_preload > 0 && p_m_load+length > (p_m_preload << 1))
2305 /* make and send frame */
2306 hh->prim = PH_DATA_REQ;
2308 memcpy(buf+MISDN_HEADER_LEN, data, length);
2309 ret = sendto(p_m_mISDNport->b_sock[p_m_b_index].fd, buf, MISDN_HEADER_LEN+length, 0, NULL, 0);
2311 PERROR("Failed to send to socket %d\n", p_m_mISDNport->b_sock[p_m_b_index].fd);
2317 int PmISDN::inband_send(unsigned char *buffer, int len)
2319 PERROR("this function must be derived to function!\n");
2323 void PmISDN::inband_send_on(void)
2325 PDEBUG(DEBUG_PORT, "turning inband signalling send on.\n");
2326 p_m_inband_send_on = 1;
2329 void PmISDN::inband_send_off(void)
2331 PDEBUG(DEBUG_PORT, "turning inband signalling send off.\n");
2332 p_m_inband_send_on = 0;
2335 void PmISDN::inband_receive(unsigned char *buffer, int len)
2338 // if (len >= SS5_DECODER_NPOINTS)
2339 // ss5_decode(buffer, SS5_DECODER_NPOINTS);
2340 PERROR("this function must be derived to function!\n");
2343 void PmISDN::inband_receive_on(void)
2345 /* this must work during constructor, see ss5.cpp */
2346 PDEBUG(DEBUG_PORT, "turning inband signalling receive on.\n");
2347 p_m_inband_receive_on = 1;
2351 void PmISDN::inband_receive_off(void)
2353 PDEBUG(DEBUG_PORT, "turning inband signalling receive off.\n");
2354 p_m_inband_receive_on = 0;
2358 void PmISDN::mute_on(void)
2362 PDEBUG(DEBUG_PORT, "turning mute on.\n");
2364 set_conf(p_m_conf, 0);
2367 void PmISDN::mute_off(void)
2371 PDEBUG(DEBUG_PORT, "turning mute off.\n");
2373 set_conf(0, p_m_conf);