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)
67 /* try to open raw socket to check kernel */
68 mISDNsocket = socket(PF_ISDN, SOCK_RAW, ISDN_P_BASE);
69 if (mISDNsocket < 0) {
70 fprintf(stderr, "Cannot open mISDN due to '%s'. (Does your Kernel support socket based mISDN? Protocol family is %d.)\n", strerror(errno), PF_ISDN);
75 // set debug printout function
76 myfn.prt_debug = my_mISDNlib_debug;
78 init_layer3(4, &myfn); // buffer of 4
80 /* open debug, if enabled and not only stack debugging */
82 SPRINT(filename, "%s/debug.log", LOG_DIR);
83 debug_fp = fopen(filename, "a");
86 if (options.deb & DEBUG_STACK)
87 mISDN_set_debug_level(0xfffffeff);
89 mISDN_set_debug_level(0);
91 if (pipe(upqueue_pipe) < 0)
92 FATAL("Failed to open pipe\n");
93 memset(&upqueue_fd, 0, sizeof(upqueue_fd));
94 upqueue_fd.fd = upqueue_pipe[0];
95 register_fd(&upqueue_fd, LCR_FD_READ, mISDN_upqueue, NULL, 0);
100 void mISDN_deinitialize(void)
108 if (mISDNsocket > -1)
111 if (upqueue_fd.inuse) {
112 unregister_fd(&upqueue_fd);
113 close(upqueue_pipe[0]);
114 close(upqueue_pipe[1]);
119 static int load_timer(struct lcr_timer *timer, void *instance, int index);
124 PmISDN::PmISDN(int type, mISDNport *mISDNport, char *portname, struct port_settings *settings, struct interface *interface, int channel, int exclusive, int mode) : Port(type, portname, settings, interface)
126 p_m_mISDNport = mISDNport;
127 p_m_portnum = mISDNport->portnum;
134 p_m_tx_gain = mISDNport->ifport->interface->tx_gain;
135 p_m_rx_gain = mISDNport->ifport->interface->rx_gain;
141 p_m_preload = ISDN_LOAD;
142 p_m_disable_dejitter = 0;
146 p_m_inband_send_on = 0;
147 p_m_inband_receive_on = 0;
148 p_m_dtmf = !mISDNport->ifport->nodtmf;
149 p_m_dtmf_threshold = mISDNport->ifport->dtmf_threshold;
150 memset(&p_m_timeout, 0, sizeof(p_m_timeout));
151 add_timer(&p_m_timeout, mISDN_timeout, this, 0);
152 SCPY(p_m_pipeline, mISDNport->ifport->interface->pipeline);
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);
356 if (c1 == DTMF_TONE_START && c2 == 0) {
360 ctrl->prim = PH_CONTROL_REQ;
364 ret = sendto(sock, buffer, MISDN_HEADER_LEN+len, 0, NULL, 0);
366 PERROR("Failed to send to socket %d\n", sock);
367 chan_trace_header(mISDNport, isdnport, "BCHANNEL control", DIRECTION_OUT);
368 if (c1 == DSP_CONF_JOIN)
369 add_trace(trace_name, NULL, "0x%08x", trace_value);
371 add_trace(trace_name, NULL, "%d", trace_value);
375 void ph_control_block(struct mISDNport *mISDNport, class PmISDN *isdnport, int sock, unsigned int c1, void *c2, int c2_len, const char *trace_name, int trace_value)
377 unsigned char buffer[MISDN_HEADER_LEN+sizeof(int)+c2_len];
378 struct mISDNhead *ctrl = (struct mISDNhead *)buffer;
379 unsigned int *d = (unsigned int *)(buffer+MISDN_HEADER_LEN);
385 ctrl->prim = PH_CONTROL_REQ;
388 memcpy(d, c2, c2_len);
389 ret = sendto(sock, buffer, MISDN_HEADER_LEN+sizeof(int)+c2_len, 0, NULL, 0);
391 PERROR("Failed to send to socket %d\n", sock);
392 chan_trace_header(mISDNport, isdnport, "BCHANNEL control", DIRECTION_OUT);
393 add_trace(trace_name, NULL, "%d", trace_value);
397 static int b_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i);
400 * subfunction for bchannel_event
403 static int _bchannel_create(struct mISDNport *mISDNport, int i)
406 struct sockaddr_mISDN addr;
408 if (mISDNport->b_sock[i].inuse) {
409 PERROR("Error: Socket already created for index %d\n", i);
414 //#warning testing without DSP
415 // mISDNport->b_sock[i].fd = socket(PF_ISDN, SOCK_DGRAM, (mISDNport->b_mode[i]==B_MODE_HDLC)?ISDN_P_B_HDLC:ISDN_P_B_RAW);
416 mISDNport->b_sock[i].fd = socket(PF_ISDN, SOCK_DGRAM, (mISDNport->b_mode[i]==B_MODE_HDLC)?ISDN_P_B_L2DSPHDLC:ISDN_P_B_L2DSP);
417 if (mISDNport->b_sock[i].fd < 0) {
418 PERROR("Error: Failed to open bchannel-socket for index %d with mISDN-DSP layer. Did you load mISDN_dsp.ko?\n", i);
422 /* register callback for read */
423 register_fd(&mISDNport->b_sock[i], LCR_FD_READ, b_sock_callback, mISDNport, i);
425 /* bind socket to bchannel */
426 addr.family = AF_ISDN;
427 addr.dev = mISDNport->portnum;
428 addr.channel = i+1+(i>=15);
429 ret = bind(mISDNport->b_sock[i].fd, (struct sockaddr *)&addr, sizeof(addr));
431 PERROR("Error: Failed to bind bchannel-socket for index %d with mISDN-DSP layer (errno=%d). Did you load mISDN_dsp.ko?\n", i, errno);
432 close(mISDNport->b_sock[i].fd);
433 unregister_fd(&mISDNport->b_sock[i]);
437 chan_trace_header(mISDNport, mISDNport->b_port[i], "BCHANNEL create socket", DIRECTION_OUT);
438 add_trace("channel", NULL, "%d", i+1+(i>=15));
439 add_trace("socket", NULL, "%d", mISDNport->b_sock[i].fd);
447 * subfunction for bchannel_event
448 * activate / deactivate request
450 static void _bchannel_activate(struct mISDNport *mISDNport, int i, int activate, int timeout)
452 struct mISDNhead act;
455 if (!mISDNport->b_sock[i].inuse)
457 act.prim = (activate)?PH_ACTIVATE_REQ:PH_DEACTIVATE_REQ;
459 ret = sendto(mISDNport->b_sock[i].fd, &act, MISDN_HEADER_LEN, 0, NULL, 0);
461 PERROR("Failed to send to socket %d\n", mISDNport->b_sock[i].fd);
464 chan_trace_header(mISDNport, mISDNport->b_port[i], activate ? "BCHANNEL activate" : "BCHANNEL deactivate", DIRECTION_OUT);
465 add_trace("channel", NULL, "%d", i+1+(i>=15));
467 add_trace("event", NULL, "timeout recovery");
473 * subfunction for bchannel_event
476 static void _bchannel_configure(struct mISDNport *mISDNport, int i)
481 if (!mISDNport->b_sock[i].inuse)
483 handle = mISDNport->b_sock[i].fd;
484 port = mISDNport->b_port[i];
485 mode = mISDNport->b_mode[i];
487 PERROR("bchannel index i=%d not associated with a port object\n", i);
491 /* set dsp features */
492 if (port->p_m_txdata)
493 ph_control(mISDNport, port, handle, (port->p_m_txdata)?DSP_TXDATA_ON:DSP_TXDATA_OFF, 0, "DSP-TXDATA", port->p_m_txdata);
494 if (port->p_m_delay && mode == B_MODE_TRANSPARENT)
495 ph_control(mISDNport, port, handle, DSP_DELAY, port->p_m_delay, "DSP-DELAY", port->p_m_delay);
496 if (port->p_m_tx_dejitter && mode == B_MODE_TRANSPARENT)
497 ph_control(mISDNport, port, handle, DSP_TX_DEJITTER, port->p_m_tx_dejitter, "DSP-TX_DEJITTER", port->p_m_tx_dejitter);
498 if (port->p_m_tx_gain && mode == B_MODE_TRANSPARENT)
499 ph_control(mISDNport, port, handle, DSP_VOL_CHANGE_TX, port->p_m_tx_gain, "DSP-TX_GAIN", port->p_m_tx_gain);
500 if (port->p_m_rx_gain && mode == B_MODE_TRANSPARENT)
501 ph_control(mISDNport, port, handle, DSP_VOL_CHANGE_RX, port->p_m_rx_gain, "DSP-RX_GAIN", port->p_m_rx_gain);
502 if (port->p_m_pipeline[0] && mode == B_MODE_TRANSPARENT)
503 ph_control_block(mISDNport, port, handle, DSP_PIPELINE_CFG, port->p_m_pipeline, strlen(port->p_m_pipeline)+1, "DSP-PIPELINE", 0);
504 if (port->p_m_conf && !port->p_m_mute)
505 ph_control(mISDNport, port, handle, DSP_CONF_JOIN, port->p_m_conf, "DSP-CONF", port->p_m_conf);
507 ph_control(mISDNport, port, handle, DSP_ECHO_ON, 0, "DSP-ECHO", 1);
508 if (port->p_m_tone && mode == B_MODE_TRANSPARENT)
509 ph_control(mISDNport, port, handle, DSP_TONE_PATT_ON, port->p_m_tone, "DSP-TONE", port->p_m_tone);
511 ph_control(mISDNport, port, handle, DSP_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
512 // if (port->p_m_txmix && mode == B_MODE_TRANSPARENT)
513 // ph_control(mISDNport, port, handle, DSP_MIX_ON, 0, "DSP-MIX", 1);
514 if (port->p_m_dtmf && mode == B_MODE_TRANSPARENT)
515 ph_control(mISDNport, port, handle, DTMF_TONE_START, port->p_m_dtmf_threshold, "DSP-DTMF", 1);
516 if (port->p_m_crypt && mode == B_MODE_TRANSPARENT)
517 ph_control_block(mISDNport, port, handle, DSP_BF_ENABLE_KEY, port->p_m_crypt_key, port->p_m_crypt_key_len, "DSP-CRYPT", port->p_m_crypt_key_len);
521 void PmISDN::set_conf(int oldconf, int newconf)
523 if (oldconf != newconf) {
524 PDEBUG(DEBUG_BCHANNEL, "we change conference from conf=%d to conf=%d.\n", oldconf, newconf);
525 if (p_m_b_index > -1)
526 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
527 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, (newconf)?DSP_CONF_JOIN:DSP_CONF_SPLIT, newconf, "DSP-CONF", newconf);
529 PDEBUG(DEBUG_BCHANNEL, "we already have conf=%d.\n", newconf);
534 * subfunction for bchannel_event
537 static void _bchannel_destroy(struct mISDNport *mISDNport, int i)
539 if (!mISDNport->b_sock[i].inuse)
541 chan_trace_header(mISDNport, mISDNport->b_port[i], "BCHANNEL remove socket", DIRECTION_OUT);
542 add_trace("channel", NULL, "%d", i+1+(i>=15));
543 add_trace("socket", NULL, "%d", mISDNport->b_sock[i].fd);
545 close(mISDNport->b_sock[i].fd);
546 unregister_fd(&mISDNport->b_sock[i]);
554 A bchannel goes through the following states in this order:
557 No one is using the bchannel.
558 It is available and not linked to Port class, nor reserved.
561 The bchannel stack is created and an activation request is sent.
562 It MAY be linked to Port class, but already unlinked due to Port class removal.
565 The bchannel is active and cofigured to the Port class needs.
566 Also it is linked to a Port class, otherwhise it would be deactivated.
568 - B_STATE_DEACTIVATING
569 The bchannel is in deactivating state, due to deactivation request.
570 It may be linked to a Port class, that likes to reactivate it.
574 After deactivating bchannel, and if not used, the bchannel becomes idle again.
576 A bchannel can have the following events:
579 A bchannel is required by a Port class.
582 The bchannel beomes active.
585 The bchannel is not required by Port class anymore
587 - B_EVENT_DEACTIVATED
588 The bchannel becomes inactive.
590 All actions taken on these events depend on the current bchannel's state and if it is linked to a Port class.
595 * process bchannel events
596 * - mISDNport is a pointer to the port's structure
597 * - i is the index of the bchannel
598 * - event is the B_EVENT_* value
599 * - port is the PmISDN class pointer
601 void bchannel_event(struct mISDNport *mISDNport, int i, int event)
603 class PmISDN *b_port = mISDNport->b_port[i];
604 int state = mISDNport->b_state[i];
605 int timer = -1; // no change
609 char *p_m_pipeline = NULL;
610 unsigned char *p_m_crypt_key = NULL;
611 int p_m_crypt_key_len = 0;
612 int p_m_crypt_key_type = 0;
615 p_m_tx_gain = b_port->p_m_tx_gain;
616 p_m_rx_gain = b_port->p_m_rx_gain;
617 p_m_pipeline = b_port->p_m_pipeline;
618 p_m_crypt_key = b_port->p_m_crypt_key;
619 p_m_crypt_key_len = b_port->p_m_crypt_key_len;
620 p_m_crypt_key_type = /*b_port->p_m_crypt_key_type*/1;
626 /* port must be linked in order to allow activation */
628 FATAL("bchannel must be linked to a Port class\n");
631 /* create stack and send activation request */
632 if (_bchannel_create(mISDNport, i)) {
633 _bchannel_activate(mISDNport, i, 1, 0);
634 state = B_STATE_ACTIVATING;
635 timer = B_TIMER_ACTIVATING;
639 case B_STATE_ACTIVATING:
640 /* do nothing, because it is already activating */
644 /* problems that might ocurr:
645 * B_EVENT_USE is received when channel already in use.
647 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
652 case B_EVENT_ACTIVATED:
655 case B_STATE_ACTIVATING:
657 /* bchannel is active and used by Port class, so we configure bchannel */
658 _bchannel_configure(mISDNport, i);
659 state = B_STATE_ACTIVE;
660 b_port->p_m_load = 0;
661 b_port->update_load();
663 /* bchannel is active, but not used anymore (or has wrong stack config), so we deactivate */
664 _bchannel_activate(mISDNport, i, 0, 0);
665 state = B_STATE_DEACTIVATING;
666 timer = B_TIMER_DEACTIVATING;
671 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
677 FATAL("bchannel must be linked to a Port class\n");
680 /* bchannel is idle due to an error, so we do nothing */
683 case B_STATE_ACTIVATING:
684 /* do nothing because we must wait until bchanenl is active before deactivating */
688 /* bchannel is active, so we deactivate */
689 _bchannel_activate(mISDNport, i, 0, 0);
690 state = B_STATE_DEACTIVATING;
691 timer = B_TIMER_DEACTIVATING;
694 case B_STATE_DEACTIVATING:
695 /* we may have taken an already deactivating bchannel, but do not require it anymore, so we do nothing */
699 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
703 case B_EVENT_DEACTIVATED:
707 /* ignore due to deactivation confirm after unloading */
710 case B_STATE_DEACTIVATING:
711 _bchannel_destroy(mISDNport, i);
712 state = B_STATE_IDLE;
714 /* bchannel is now deactivate, but is requied by Port class, so we reactivate */
715 if (_bchannel_create(mISDNport, i)) {
716 _bchannel_activate(mISDNport, i, 1, 0);
717 state = B_STATE_ACTIVATING;
718 timer = B_TIMER_ACTIVATING;
724 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
728 case B_EVENT_TIMEOUT:
732 /* ignore due to deactivation confirm after unloading */
735 case B_STATE_ACTIVATING:
736 _bchannel_activate(mISDNport, i, 1, 1);
737 timer = B_TIMER_ACTIVATING;
740 case B_STATE_DEACTIVATING:
741 _bchannel_activate(mISDNport, i, 0, 1);
742 timer = B_TIMER_DEACTIVATING;
746 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
751 PERROR("Illegal event %d, please correct.\n", event);
754 mISDNport->b_state[i] = state;
756 unsched_timer(&mISDNport->b_timer[i]);
758 schedule_timer(&mISDNport->b_timer[i], timer, 0);
765 * check for available channel and reserve+set it.
766 * give channel number or SEL_CHANNEL_ANY or SEL_CHANNEL_NO
768 * returns -(cause value) or x = channel x or 0 = no channel
769 * NOTE: no activation is done here
771 int PmISDN::seize_bchannel(int channel, int exclusive)
775 /* the channel is what we have */
776 if (p_m_b_channel == channel)
779 /* if channel already in use, release it */
784 if (channel==CHANNEL_NO || channel==0)
787 /* is channel in range ? */
789 || (channel>p_m_mISDNport->b_num && channel<16)
790 || ((channel-1)>p_m_mISDNport->b_num && channel>16)) /* channel-1 because channel 16 is not counted */
791 return(-6); /* channel unacceptable */
793 /* request exclusive channel */
794 if (exclusive && channel>0) {
795 i = channel-1-(channel>16);
796 if (p_m_mISDNport->b_port[i])
797 return(-44); /* requested channel not available */
801 /* ask for channel */
803 i = channel-1-(channel>16);
804 if (p_m_mISDNport->b_port[i] == NULL)
808 /* search for channel */
810 while(i < p_m_mISDNport->b_num) {
811 if (!p_m_mISDNport->b_port[i]) {
812 channel = i+1+(i>=15);
817 return(-34); /* no free channel */
820 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) seizing bchannel %d (index %d)\n", p_name, channel, i);
822 /* link Port, set parameters */
823 p_m_mISDNport->b_port[i] = this;
825 p_m_b_channel = channel;
826 p_m_b_exclusive = exclusive;
827 p_m_mISDNport->b_mode[i] = p_m_b_mode;
829 /* reserve channel */
830 if (!p_m_b_reserve) {
832 p_m_mISDNport->b_reserved++;
839 * drop reserved channel and unset it.
840 * deactivation is also done
842 void PmISDN::drop_bchannel(void)
844 /* unreserve channel */
846 p_m_mISDNport->b_reserved--;
855 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) dropping bchannel\n", p_name);
857 if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_IDLE)
858 bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_DROP);
859 p_m_mISDNport->b_port[p_m_b_index] = NULL;
860 p_m_mISDNport->b_mode[p_m_b_index] = 0;
870 audio transmission procedure:
871 -----------------------------
874 three sources of audio transmission:
875 - crypto-data high priority
876 - tones high priority (also high)
877 - remote-data low priority
880 a variable that temporarily shows the number of samples elapsed since last transmission process.
881 p_m_last_tv_* is used to store that last timestamp. this is used to calculate the time elapsed.
884 a variable that is increased whenever data is transmitted.
885 it is decreased while time elapses. it stores the number of samples that
886 are currently loaded to dsp module.
887 since clock in dsp module is the same clock for user space process, these
891 there are two levels:
892 p_m_preload will give the load that have to be kept in dsp.
893 ISDN_MAXLOAD (2*p_m_preload) will give the maximum load before dropping.
895 * procedure for low priority data
896 see txfromup() for procedure
897 in short: remote data is ignored during high priority tones
899 * procedure for high priority data
900 whenever load is below p_m_preload, load is filled up to p_m_preload
901 if no more data is available, load becomes empty again.
904 0 p_m_preload ISDN_MAXLOAD
905 +--------------------+----------------------+
907 +--------------------+----------------------+
909 on empty load or on load below p_m_preload, the load is inceased to p_m_preload:
910 0 p_m_preload ISDN_MAXLOAD
911 +--------------------+----------------------+
912 |TTTTTTTTTTTTTTTTTTTT| |
913 +--------------------+----------------------+
915 on empty load, remote-audio causes the load with the remote audio to be increased to p_m_preload.
916 0 p_m_preload ISDN_MAXLOAD
917 +--------------------+----------------------+
918 |TTTTTTTTTTTTTTTTTTTTRRRRR |
919 +--------------------+----------------------+
922 void PmISDN::update_load(void)
924 /* don't trigger load event if event already active */
925 if (p_m_loadtimer.active)
928 schedule_timer(&p_m_loadtimer, 0, 0); /* no delay the first time */
931 static int load_timer(struct lcr_timer *timer, void *instance, int index)
933 class PmISDN *isdnport = (class PmISDN *)instance;
940 void PmISDN::load_tx(void)
944 struct timeval current_time;
947 gettimeofday(¤t_time, NULL);
948 if (p_m_last_tv_sec) {
949 elapsed = 8000 * (current_time.tv_sec - p_m_last_tv_sec)
950 + 8 * (current_time.tv_usec/1000 - p_m_last_tv_msec);
952 /* set clock of last process! */
953 p_m_last_tv_sec = current_time.tv_sec;
954 p_m_last_tv_msec = current_time.tv_usec/1000;
956 /* process only if we have samples and we are active */
957 if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_ACTIVE)
962 if (elapsed < p_m_load)
967 /* to send data, tone must be on */
968 if ((p_tone_name[0] || p_dov_tx || p_m_crypt_msg_loops || p_m_inband_send_on) /* what tones? */
969 && (p_m_load < p_m_preload) /* not too much load? */
970 && (p_state==PORT_STATE_CONNECT || p_m_mISDNport->tones || p_m_inband_send_on)) { /* connected or inband-tones? */
971 int tosend = p_m_preload - p_m_load, length;
972 unsigned char buf[MISDN_HEADER_LEN+tosend];
973 struct mISDNhead *frm = (struct mISDNhead *)buf;
974 unsigned char *p = buf+MISDN_HEADER_LEN;
976 /* copy inband signalling (e.g. used by ss5) */
977 if (p_m_inband_send_on && tosend) {
978 tosend -= inband_send(p, tosend);
981 /* copy crypto loops */
982 while (p_m_crypt_msg_loops && tosend) {
983 /* how much do we have to send */
984 length = p_m_crypt_msg_len - p_m_crypt_msg_current;
990 /* copy message (part) to buffer */
991 memcpy(p, p_m_crypt_msg+p_m_crypt_msg_current, length);
994 p_m_crypt_msg_current += length;
995 if (p_m_crypt_msg_current == p_m_crypt_msg_len) {
997 p_m_crypt_msg_current = 0;
998 p_m_crypt_msg_loops--;
999 if (!p_m_crypt_msg_loops)
1001 // puts("eine loop weniger");
1010 tosend -= dov_tx(p, tosend);
1014 if (p_tone_name[0] && tosend) {
1015 tosend -= read_audio(p, tosend);
1019 if (p_m_preload - p_m_load - tosend > 0) {
1020 frm->prim = PH_DATA_REQ;
1022 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);
1024 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);
1025 p_m_load += p_m_preload - p_m_load - tosend;
1030 schedule_timer(&p_m_loadtimer, 0, PORT_TRANSMIT * 125);
1033 /* handle timeouts */
1034 static int mISDN_timeout(struct lcr_timer *timer, void *instance, int i)
1036 class PmISDN *isdnport = (class PmISDN *)instance;
1037 struct lcr_msg *message;
1039 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);
1040 /* send timeout to endpoint */
1041 message = message_create(isdnport->p_serial, ACTIVE_EPOINT(isdnport->p_epointlist), PORT_TO_EPOINT, MESSAGE_TIMEOUT);
1042 message->param.state = isdnport->p_state;
1043 message_put(message);
1050 * whenever we get audio data from bchannel, we process it here
1052 void PmISDN::bchannel_receive(struct mISDNhead *hh, unsigned char *data, int len)
1054 unsigned int cont = *((unsigned int *)data);
1055 struct lcr_msg *message;
1059 if (hh->prim == PH_CONTROL_IND) {
1061 PERROR("SHORT READ OF PH_CONTROL INDICATION\n");
1064 if ((cont&(~DTMF_TONE_MASK)) == DTMF_TONE_VAL) {
1065 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1066 add_trace("DTMF", NULL, "%c", cont & DTMF_TONE_MASK);
1068 add_trace("info", NULL, "DTMF is disabled");
1072 if (p_type == PORT_TYPE_POTS_FXS_IN && p_state == PORT_STATE_IN_OVERLAP) {
1073 class Pfxs *pfxs = (class Pfxs *)this;
1074 if (!pfxs->p_m_fxs_allow_dtmf) {
1075 PDEBUG(DEBUG_PORT, "PmISDN(%s) DTMF for FXS currently disabled\n", p_name);
1078 SCCAT(p_dialinginfo.id, cont & DTMF_TONE_MASK);
1079 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_INFORMATION);
1080 message->param.information.id[0] = cont & DTMF_TONE_MASK;
1081 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION INFORMATION digit '%s'\n", p_name, message->param.information.id);
1082 message_put(message);
1084 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_DTMF);
1085 message->param.dtmf = cont & DTMF_TONE_MASK;
1086 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION DTMF digit '%c'\n", p_name, message->param.dtmf);
1087 message_put(message);
1093 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1094 add_trace("DSP-CRYPT", NULL, "error");
1096 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1097 message->param.crypt.type = CC_ERROR_IND;
1098 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION reject of blowfish.\n", p_name);
1099 message_put(message);
1103 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1104 add_trace("DSP-CRYPT", NULL, "ok");
1106 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1107 message->param.crypt.type = CC_ACTBF_CONF;
1108 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION accept of blowfish.\n", p_name);
1109 message_put(message);
1113 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1114 add_trace("unknown", NULL, "0x%x", cont);
1119 if (hh->prim == PH_CONTROL_IND) {
1122 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1123 add_trace("unknown", NULL, "0x%x", hh->id);
1128 if (hh->prim == PH_DATA_REQ || hh->prim == DL_DATA_REQ) {
1130 /* if tx is off, it may happen that fifos send us pending informations, we just ignore them */
1131 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring tx data, because 'txdata' is turned off\n", p_name);
1134 /* see below (same condition) */
1135 if (p_state!=PORT_STATE_CONNECT
1136 && !p_m_mISDNport->tones)
1138 // printf(".");fflush(stdout);return;
1140 record(data, len, 1); // from up
1142 tap(data, len, 1); // from up
1145 if (hh->prim != PH_DATA_IND && hh->prim != DL_DATA_IND) {
1146 PERROR("Bchannel received unknown primitve: 0x%x\n", hh->prim);
1150 /* dov is processed */
1154 /* inband is processed */
1155 if (p_m_inband_receive_on)
1156 inband_receive(data, len);
1158 /* send to remote, if bridged */
1159 bridge_tx(data, len);
1161 /* calls will not process any audio data unless
1162 * the call is connected OR tones feature is enabled.
1164 #ifndef DEBUG_COREBRIDGE
1165 if (p_state!=PORT_STATE_CONNECT
1166 && !p_m_mISDNport->tones)
1171 /* the bearer capability must be audio in order to send and receive
1172 * audio prior or after connect.
1174 if (!(p_bearerinfo.capability&CLASS_CAPABILITY_AUDIO) && p_state!=PORT_STATE_CONNECT)
1178 /* if rx is off, it may happen that fifos send us pending informations, we just ignore them */
1180 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring data, because rx is turned off\n", p_name);
1186 record(data, len, 0); // from down
1188 tap(data, len, 0); // from down
1190 /* randomize and listen to crypt message if enabled */
1191 if (p_m_crypt_listen) {
1192 /* the noisy randomizer */
1196 mISDN_rand[mISDN_rand_count & 0xff] += *p++;
1198 cryptman_listen_bch(data, len);
1206 void PmISDN::set_echotest(int echo)
1208 if (p_m_echo != echo) {
1210 PDEBUG(DEBUG_ISDN, "we set echo to echo=%d.\n", p_m_echo);
1212 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1213 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);
1220 void PmISDN::set_tone(const char *dir, const char *tone)
1225 /* if no directory is given (by extension), we use interface.conf or options.conf */
1226 if (!dir || !dir[0]) {
1227 if (p_m_mISDNport->ifport->tones_dir[0])
1228 dir = p_m_mISDNport->ifport->tones_dir;
1229 else if (options.tones_dir[0])
1230 dir = options.tones_dir;
1235 PDEBUG(DEBUG_ISDN, "isdn port now plays tone:'%s'.\n", tone);
1241 /* check for dsp tones */
1242 if (!strcmp(dir, "american"))
1244 if (!strcmp(dir, "german"))
1246 if (!strcmp(dir, "oldgerman"))
1247 dsp = DSP_OLDGERMAN;
1249 /* check if we NOT really have to use a dsp-tone */
1250 if (dsp == DSP_NONE) {
1253 if (p_m_b_index > -1)
1254 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) {
1255 PDEBUG(DEBUG_ISDN, "we reset tone from id=%d to OFF.\n", p_m_tone);
1256 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TONE_PATT_OFF, 0, "DSP-TONE", 0);
1259 Port::set_tone(dir, tone);
1263 /* now we USE dsp-tone, convert name */
1264 if (!strcmp(tone, "dialtone")) {
1266 case DSP_AMERICAN: id = TONE_AMERICAN_DIALTONE; break;
1267 case DSP_GERMAN: id = TONE_GERMAN_DIALTONE; break;
1268 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALTONE; break;
1270 } else if (!strcmp(tone, "dialpbx")) {
1272 case DSP_AMERICAN: id = TONE_AMERICAN_DIALPBX; break;
1273 case DSP_GERMAN: id = TONE_GERMAN_DIALPBX; break;
1274 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALPBX; break;
1276 } else if (!strcmp(tone, "ringing")) {
1278 case DSP_AMERICAN: id = TONE_AMERICAN_RINGING; break;
1279 case DSP_GERMAN: id = TONE_GERMAN_RINGING; break;
1280 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGING; break;
1282 } else if (!strcmp(tone, "ringpbx")) {
1284 case DSP_AMERICAN: id = TONE_AMERICAN_RINGPBX; break;
1285 case DSP_GERMAN: id = TONE_GERMAN_RINGPBX; break;
1286 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGPBX; break;
1288 } else if (!strcmp(tone, "busy")) {
1291 case DSP_AMERICAN: id = TONE_AMERICAN_BUSY; break;
1292 case DSP_GERMAN: id = TONE_GERMAN_BUSY; break;
1293 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1295 } else if (!strcmp(tone, "release")) {
1298 case DSP_AMERICAN: id = TONE_AMERICAN_HANGUP; break;
1299 case DSP_GERMAN: id = TONE_GERMAN_HANGUP; break;
1300 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDHANGUP; break;
1302 } else if (!strcmp(tone, "cause_10"))
1304 else if (!strcmp(tone, "cause_11"))
1306 else if (!strcmp(tone, "cause_22")) {
1308 case DSP_AMERICAN: id = TONE_SPECIAL_INFO; break;
1309 case DSP_GERMAN: id = TONE_GERMAN_GASSENBESETZT; break;
1310 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1312 } else if (!strncmp(tone, "cause_", 6))
1313 id = TONE_SPECIAL_INFO;
1317 /* if we have a tone that is not supported by dsp */
1318 if (id==TONE_OFF && tone[0])
1322 if (p_m_tone != id) {
1325 PDEBUG(DEBUG_ISDN, "we set tone to id=%d.\n", p_m_tone);
1326 if (p_m_b_index > -1)
1327 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)
1328 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);
1330 /* turn user-space tones off in cases of no tone OR dsp tone */
1331 Port::set_tone("",NULL);
1335 /* MESSAGE_mISDNSIGNAL */
1336 //extern struct lcr_msg *dddebug;
1337 void PmISDN::message_mISDNsignal(unsigned int epoint_id, int message_id, union parameter *param)
1339 int oldconf, newconf;
1340 switch(param->mISDNsignal.message) {
1341 case mISDNSIGNAL_VOLUME:
1342 if (p_m_tx_gain != param->mISDNsignal.tx_gain) {
1343 p_m_tx_gain = param->mISDNsignal.tx_gain;
1344 PDEBUG(DEBUG_BCHANNEL, "we change tx-volume to shift=%d.\n", p_m_tx_gain);
1345 if (p_m_b_index > -1)
1346 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)
1347 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);
1349 PDEBUG(DEBUG_BCHANNEL, "we already have tx-volume shift=%d.\n", p_m_rx_gain);
1350 if (p_m_rx_gain != param->mISDNsignal.rx_gain) {
1351 p_m_rx_gain = param->mISDNsignal.rx_gain;
1352 PDEBUG(DEBUG_BCHANNEL, "we change rx-volume to shift=%d.\n", p_m_rx_gain);
1353 if (p_m_b_index > -1)
1354 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)
1355 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);
1357 PDEBUG(DEBUG_BCHANNEL, "we already have rx-volume shift=%d.\n", p_m_rx_gain);
1360 case mISDNSIGNAL_CONF:
1361 oldconf = p_m_mute?0:p_m_conf;
1362 p_m_conf = param->mISDNsignal.conf;
1363 newconf = p_m_mute?0:p_m_conf;
1364 set_conf(oldconf, newconf);
1367 case mISDNSIGNAL_DELAY:
1368 if (p_m_delay != param->mISDNsignal.delay) {
1369 p_m_delay = param->mISDNsignal.delay;
1370 PDEBUG(DEBUG_BCHANNEL, "we change delay mode to delay=%d.\n", p_m_delay);
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(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);
1375 PDEBUG(DEBUG_BCHANNEL, "we already have delay=%d.\n", p_m_delay);
1379 PERROR("PmISDN(%s) unsupported signal message %d.\n", p_name, param->mISDNsignal.message);
1384 void PmISDN::message_crypt(unsigned int epoint_id, int message_id, union parameter *param)
1386 struct lcr_msg *message;
1388 switch(param->crypt.type) {
1389 case CC_ACTBF_REQ: /* activate blowfish */
1391 p_m_crypt_key_len = param->crypt.len;
1392 if (p_m_crypt_key_len > (int)sizeof(p_m_crypt_key)) {
1393 PERROR("PmISDN(%s) key too long %d > %d\n", p_name, p_m_crypt_key_len, sizeof(p_m_crypt_key));
1394 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1395 message->param.crypt.type = CC_ERROR_IND;
1396 message_put(message);
1399 memcpy(p_m_crypt_key, param->crypt.data, p_m_crypt_key_len);
1401 PDEBUG(DEBUG_BCHANNEL, "we set encryption to crypt=%d. (0 means OFF)\n", p_m_crypt);
1402 if (p_m_b_index > -1)
1403 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)
1404 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);
1407 case CC_DACT_REQ: /* deactivate session encryption */
1412 case CR_LISTEN_REQ: /* start listening to messages */
1413 p_m_crypt_listen = 1;
1415 p_m_crypt_listen_state = 0;
1418 case CR_UNLISTEN_REQ: /* stop listening to messages */
1419 p_m_crypt_listen = 0;
1423 case CR_MESSAGE_REQ: /* send message */
1424 p_m_crypt_msg_len = cryptman_encode_bch(param->crypt.data, param->crypt.len, p_m_crypt_msg, sizeof(p_m_crypt_msg));
1425 if (!p_m_crypt_msg_len) {
1426 PERROR("PmISDN(%s) message too long %d > %d\n", p_name, param->crypt.len-1, sizeof(p_m_crypt_msg));
1429 p_m_crypt_msg_current = 0; /* reset */
1430 p_m_crypt_msg_loops = 6; /* enable */
1433 /* disable txmix, or we get corrupt data due to audio process */
1434 if (p_m_txmix && p_m_b_index>=0 && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT) {
1435 PDEBUG(DEBUG_BCHANNEL, "for sending CR_MESSAGE_REQ, we reset txmix from txmix=%d.\n", p_m_txmix);
1436 ph_control(p_m_mISDNport, this, p_mISDNport->b_sock[p_m_b_index].fd, DSP_MIX_OFF, 0, "DSP-TXMIX", 0);
1442 PERROR("PmISDN(%s) unknown crypt message %d\n", p_name, param->crypt.type);
1448 void PmISDN::message_vootp(unsigned int epoint_id, int message_id, union parameter *param)
1450 struct lcr_msg *message;
1452 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_UPDATEBRIDGE);
1453 message_put(message);
1456 does not make sense, since remote port may dejitter
1457 if (param->vootp.enable) {
1458 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received vootp enable order, so we disable de-jitter.\n", p_name);
1459 p_m_disable_dejitter = 1;
1466 * endpoint sends messages to the port
1468 int PmISDN::message_epoint(unsigned int epoint_id, int message_id, union parameter *param)
1470 /* messages also handled by base class */
1471 switch(message_id) {
1472 case MESSAGE_VOOTP: /* crypt control command */
1473 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received VoOTP encryption\n", p_name);
1474 message_vootp(epoint_id, message_id, param);
1478 if (Port::message_epoint(epoint_id, message_id, param)) {
1479 if (message_id == MESSAGE_BRIDGE)
1484 /* messages not handled by base class */
1485 switch(message_id) {
1486 case MESSAGE_mISDNSIGNAL: /* user command */
1487 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received special ISDN SIGNAL %d.\n", p_name, param->mISDNsignal.message);
1488 message_mISDNsignal(epoint_id, message_id, param);
1491 case MESSAGE_CRYPT: /* crypt control command */
1492 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received encryption command '%d'.\n", p_name, param->crypt.type);
1493 message_crypt(epoint_id, message_id, param);
1496 case MESSAGE_DISABLE_DEJITTER:
1497 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received de-jitter disable order.\n", p_name);
1498 p_m_disable_dejitter = 1;
1499 p_m_preload = param->queue;
1507 void PmISDN::update_rxoff(void)
1509 int tx_dejitter = 0;
1511 /* call bridges in user space OR crypto OR recording */
1512 if (p_bridge || p_m_crypt_msg_loops || p_m_crypt_listen || p_record || p_tap || p_m_inband_receive_on || p_dov_rx) {
1513 /* rx IS required */
1517 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is required, so we turn them on\n", __FUNCTION__);
1518 if (p_m_b_index > -1)
1519 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1520 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_RECEIVE_ON, 0, "DSP-RXOFF", 0);
1523 /* rx NOT required */
1527 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is not required, so we turn them off\n", __FUNCTION__);
1528 if (p_m_b_index > -1)
1529 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1530 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
1533 /* recording / tapping */
1534 if (p_record || p_tap) {
1535 /* txdata IS required */
1539 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is required, so we turn them on\n", __FUNCTION__);
1540 if (p_m_b_index > -1)
1541 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1542 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TXDATA_ON, 0, "DSP-TXDATA", 1);
1545 /* txdata NOT required */
1549 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is not required, so we turn them off\n", __FUNCTION__);
1550 if (p_m_b_index > -1)
1551 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1552 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TXDATA_OFF, 0, "DSP-TXDATA", 0);
1555 /* dejitter on bridge */
1556 if (p_bridge && !p_m_disable_dejitter)
1558 if (p_m_tx_dejitter != tx_dejitter) {
1559 p_m_tx_dejitter = tx_dejitter;
1560 PDEBUG(DEBUG_BCHANNEL, "we change dejitter mode to %s.\n", (p_m_tx_dejitter) ? "on" : "off");
1561 if (p_m_b_index > -1)
1562 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)
1563 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);
1567 static int mISDN_upqueue(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1569 struct mISDNport *mISDNport;
1573 int __attribute__((__unused__)) ret;
1575 /* unset global semaphore */
1577 // with a very small incident, upqueue_avail may be set by mISDN thread and
1578 // another byte may be sent to the pipe, which causes a call to this function
1579 // again with nothing in the upqueue. this is no problem.
1580 ret = read(fd->fd, &byte, 1);
1582 /* process all ports */
1583 mISDNport = mISDNport_first;
1585 /* handle queued up-messages (d-channel) */
1586 while ((mb = mdequeue(&mISDNport->upqueue))) {
1589 case MPH_ACTIVATE_IND:
1590 if (mISDNport->l1link != 1) {
1591 l1l2l3_trace_header(mISDNport, NULL, L1_ACTIVATE_IND, DIRECTION_IN);
1593 mISDNport->l1link = 1;
1597 case MPH_DEACTIVATE_IND:
1598 if (mISDNport->l1link != 0) {
1599 l1l2l3_trace_header(mISDNport, NULL, L1_DEACTIVATE_IND, DIRECTION_IN);
1601 mISDNport->l1link = 0;
1605 case MPH_INFORMATION_IND:
1606 PDEBUG(DEBUG_ISDN, "Received MPH_INFORMATION_IND for port %d (%s).\n", mISDNport->portnum, mISDNport->ifport->interface->name);
1608 case L1_SIGNAL_LOS_ON:
1611 case L1_SIGNAL_LOS_OFF:
1614 case L1_SIGNAL_AIS_ON:
1617 case L1_SIGNAL_AIS_OFF:
1620 case L1_SIGNAL_RDI_ON:
1623 case L1_SIGNAL_RDI_OFF:
1626 case L1_SIGNAL_SLIP_TX:
1627 mISDNport->slip_tx++;
1629 case L1_SIGNAL_SLIP_RX:
1630 mISDNport->slip_rx++;
1635 case MT_L2ESTABLISH:
1636 l1l2l3_trace_header(mISDNport, NULL, L2_ESTABLISH_IND, DIRECTION_IN);
1637 add_trace("tei", NULL, "%d", l3m->pid);
1639 mISDNport->l2link = 1;
1641 mISDNport->l2mask[l3m->pid >> 3] |= (1 << (l3m->pid & 7));
1642 if ((!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127) {
1643 if (mISDNport->l2establish.active) {
1644 unsched_timer(&mISDNport->l2establish);
1645 PDEBUG(DEBUG_ISDN, "the link became active before l2establish timer expiry.\n");
1652 mISDNport->l2mask[l3m->pid >> 3] &= ~(1 << (l3m->pid & 7));
1653 if (!mISDNport->l2establish.active) {
1654 l1l2l3_trace_header(mISDNport, NULL, L2_RELEASE_IND, DIRECTION_IN);
1655 add_trace("tei", NULL, "%d", l3m->pid);
1657 /* down if not nt-ptmp */
1658 if (!mISDNport->ntmode || mISDNport->ptp)
1659 mISDNport->l2link = 0;
1661 if ((!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127) {
1662 if (!mISDNport->l2establish.active && mISDNport->l2hold) {
1663 PDEBUG(DEBUG_ISDN, "set timer and establish.\n");
1664 schedule_timer(&mISDNport->l2establish, 5, 0);
1665 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
1671 /* l3-data is sent to LCR */
1672 stack2manager(mISDNport, l3m->type, l3m->pid, l3m);
1677 mISDNport = mISDNport->next;
1682 /* l2 establish timer fires */
1683 static int l2establish_timeout(struct lcr_timer *timer, void *instance, int i)
1685 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1687 if (mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode)) {
1688 PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link portnum=%d.\n", mISDNport->portnum);
1689 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
1690 schedule_timer(&mISDNport->l2establish, 5, 0); /* 5 seconds */
1696 /* handle frames from bchannel */
1697 static int b_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1699 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1700 unsigned char buffer[2048+MISDN_HEADER_LEN];
1701 struct mISDNhead *hh = (struct mISDNhead *)buffer;
1704 ret = recv(fd->fd, buffer, sizeof(buffer), 0);
1706 PERROR("read error frame, errno %d\n", errno);
1709 if (ret < (int)MISDN_HEADER_LEN) {
1710 PERROR("read short frame, got %d, expected %d\n", ret, (int)MISDN_HEADER_LEN);
1714 /* we don't care about confirms, we use rx data to sync tx */
1718 /* we receive audio data, we respond to it AND we send tones */
1723 case PH_CONTROL_IND:
1724 if (mISDNport->b_port[i])
1725 mISDNport->b_port[i]->bchannel_receive(hh, buffer+MISDN_HEADER_LEN, ret-MISDN_HEADER_LEN);
1727 PDEBUG(DEBUG_BCHANNEL, "b-channel is not associated to an ISDNPort (socket %d), ignoring.\n", fd->fd);
1730 case PH_ACTIVATE_IND:
1731 case DL_ESTABLISH_IND:
1732 case PH_ACTIVATE_CNF:
1733 case DL_ESTABLISH_CNF:
1734 PDEBUG(DEBUG_BCHANNEL, "DL_ESTABLISH confirm: bchannel is now activated (socket %d).\n", fd->fd);
1735 bchannel_event(mISDNport, i, B_EVENT_ACTIVATED);
1738 case PH_DEACTIVATE_IND:
1739 case DL_RELEASE_IND:
1740 case PH_DEACTIVATE_CNF:
1741 case DL_RELEASE_CNF:
1742 PDEBUG(DEBUG_BCHANNEL, "DL_RELEASE confirm: bchannel is now de-activated (socket %d).\n", fd->fd);
1743 bchannel_event(mISDNport, i, B_EVENT_DEACTIVATED);
1747 PERROR("child message not handled: prim(0x%x) socket(%d) msg->len(%d)\n", hh->prim, fd->fd, ret-MISDN_HEADER_LEN);
1753 /* process timer events for bchannel handling */
1754 static int b_timer_timeout(struct lcr_timer *timer, void *instance, int i)
1756 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1758 bchannel_event(mISDNport, i, B_EVENT_TIMEOUT);
1764 int do_layer3(struct mlayer3 *ml3, unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1768 * l3m must be queued, except for MT_ASSIGN
1771 struct mISDNport *mISDNport = (struct mISDNport *)ml3->priv;
1774 #ifdef OLD_MT_ASSIGN
1775 /* special MT_ASSIGN handling:
1777 * if we request a PID from mlayer, we always do it while lcr is locked.
1778 * therefore we must check the MT_ASSIGN reply first before we lock.
1779 * this is because the MT_ASSIGN reply is received with the requesting
1780 * process, not by the mlayer thread!
1781 * this means, that the reply is sent during call of the request.
1782 * we must check if we get a reply and we know that we lcr is currently
1785 if (cmd==MT_ASSIGN && (pid&MISDN_PID_CR_FLAG) && (pid>>16)==MISDN_CES_MASTER) {
1786 /* let's do some checking if someone changes stack behaviour */
1787 if (mt_assign_pid != 0)
1788 FATAL("someone played with the mISDNuser stack. MT_ASSIGN not currently expected.\n");
1789 mt_assign_pid = pid;
1793 /* queue message, create, if required */
1795 l3m = alloc_l3_msg();
1797 FATAL("No memory for layer 3 message\n");
1799 mb = container_of(l3m, struct mbuffer, l3);
1802 mqueue_tail(&mISDNport->upqueue, mb);
1803 if (!upqueue_avail) {
1804 // multiple threads may cause multiple calls of this section, but this
1805 // results only in multiple processing of the upqueue read.
1806 // this is no problem.
1809 int __attribute__((__unused__)) ret;
1810 ret = write(upqueue_pipe[1], &byte, 1);
1815 int mISDN_getportbyname(int sock, int cnt, char *portname)
1817 struct mISDN_devinfo devinfo;
1821 while (port < cnt) {
1823 ret = ioctl(sock, IMGETDEVINFO, &devinfo);
1826 if (!strcasecmp(devinfo.name, portname))
1836 #ifdef ISDN_P_FXS_POTS
1837 /* handle frames from pots */
1838 static int pots_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1840 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1841 unsigned char buffer[2048+MISDN_HEADER_LEN];
1842 struct mISDNhead *hh = (struct mISDNhead *)buffer;
1846 ret = recv(fd->fd, buffer, sizeof(buffer), 0);
1848 PERROR("read error frame, errno %d\n", errno);
1851 if (ret < (int)MISDN_HEADER_LEN) {
1852 PERROR("read short frame, got %d, expected %d\n", ret, (int)MISDN_HEADER_LEN);
1856 case PH_CONTROL_IND:
1857 cont = *((unsigned int *)(buffer + MISDN_HEADER_LEN));
1858 /* l1-control is sent to LCR */
1859 if (mISDNport->ntmode)
1860 stack2manager_fxs(mISDNport, cont);
1862 PERROR("FXO not supported!\n");
1864 case PH_ACTIVATE_REQ:
1868 PERROR("child message not handled: prim(0x%x) socket(%d) msg->len(%d)\n", hh->prim, fd->fd, ret-MISDN_HEADER_LEN);
1876 * global function to add a new card (port)
1878 struct mISDNport *mISDNport_open(struct interface_port *ifport)
1881 struct mISDNport *mISDNport, **mISDNportp;
1882 int port = ifport->portnum;
1883 int ptp = ifport->ptp;
1884 int force_nt = ifport->nt;
1885 int l1hold = ifport->l1hold;
1886 int l2hold = ifport->l2hold;
1887 int ss5 = ifport->ss5;
1891 // struct mlayer3 *ml3;
1892 struct mISDN_devinfo devinfo;
1893 unsigned int protocol, prop;
1895 /* check port counts */
1896 ret = ioctl(mISDNsocket, IMGETCOUNT, &cnt);
1898 fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret);
1903 PERROR_RUNTIME("Found no card. Please be sure to load card drivers.\n");
1907 port = mISDN_getportbyname(mISDNsocket, cnt, ifport->portname);
1909 PERROR_RUNTIME("Port name '%s' not found, use 'misdn_info' tool to list all existing ports.\n", ifport->portname);
1912 // note: 'port' has still the port number
1914 if (port>cnt || port<0) {
1915 PERROR_RUNTIME("Port (%d) given at 'ports' (options.conf) is out of existing port range (%d-%d)\n", port, 0, cnt);
1919 /* get port attributes */
1920 pri = bri = pots = nt = te = 0;
1922 ret = ioctl(mISDNsocket, IMGETDEVINFO, &devinfo);
1924 PERROR_RUNTIME("Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", port, ret);
1927 if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0)) {
1931 if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0)) {
1935 if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1)) {
1939 if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1)) {
1943 #ifdef ISDN_P_FXS_POTS
1944 if (devinfo.Dprotocols & (1 << ISDN_P_FXO_POTS)) {
1948 if (devinfo.Dprotocols & (1 << ISDN_P_FXS_POTS)) {
1953 if (force_nt && !nt) {
1955 PERROR_RUNTIME("Port %d does not support NT-mode\n", port);
1957 PERROR_RUNTIME("Port %d does not support FXS-mode\n", port);
1961 PERROR_RUNTIME("Port %d supports BRI and PRI?? What kind of controller is that?. (Can't use this!)\n", port);
1964 if (!bri && !pri && !pots) {
1965 PERROR_RUNTIME("Port %d does not support BRI nor PRI nor POTS!\n", port);
1969 PERROR_RUNTIME("Port %d does not support NT-mode nor TE-mode!\n", port);
1972 /* set NT by turning off TE */
1975 /* if TE an NT is supported (and not forced to NT), turn off NT */
1979 PERROR_RUNTIME("Port %d uses FXO-mode, but not supported by LCR!\n", port);
1983 /* check for double use of port */
1985 mISDNport = mISDNport_first;
1987 if (mISDNport->portnum == port)
1989 mISDNport = mISDNport->next;
1992 PERROR_RUNTIME("Port %d already in use by LCR. You can't use a NT port multiple times.\n", port);
1997 /* check for continous channelmap with no bchannel on slot 16 */
1998 if (test_channelmap(0, devinfo.channelmap)) {
1999 PERROR_RUNTIME("Port %d provides channel 0, but we cannot access it!\n", port);
2003 while(i < (int)devinfo.nrbchan + 1) {
2005 if (test_channelmap(i, devinfo.channelmap)) {
2006 PERROR("Port %d provides bchannel 16. Pleas upgrade mISDN, if this port is mISDN loopback interface.\n", port);
2010 if (!test_channelmap(i, devinfo.channelmap)) {
2011 PERROR_RUNTIME("Port %d has no channel on slot %d!\n", port, i);
2018 /* add mISDNport structure */
2019 mISDNportp = &mISDNport_first;
2021 mISDNportp = &((*mISDNportp)->next);
2022 mISDNport = (struct mISDNport *)MALLOC(sizeof(struct mISDNport));
2023 add_timer(&mISDNport->l2establish, l2establish_timeout, mISDNport, 0);
2025 /* ss5 link is always active */
2026 mISDNport->l1link = 1;
2027 mISDNport->l2link = 1;
2029 mISDNport->l1link = -1;
2030 mISDNport->l2link = -1;
2033 *mISDNportp = mISDNport;
2035 /* if pri, must set PTP */
2039 /* set ss5 params */
2041 /* try to keep interface enabled */
2061 /* allocate ressources of port */
2064 protocol = (nt)?L3_PROTOCOL_DSS1_NET:L3_PROTOCOL_DSS1_USER;
2065 prop = (1 << MISDN_FLG_L2_CLEAN);
2066 if (ptp) // ptp forced
2067 prop |= (1 << MISDN_FLG_PTP);
2068 if (nt) // supports hold/retrieve on nt-mode
2069 prop |= (1 << MISDN_FLG_NET_HOLD);
2070 if (l1hold) // supports layer 1 hold
2071 prop |= (1 << MISDN_FLG_L1_HOLD);
2072 if (l2hold) // supports layer 2 hold
2073 prop |= (1 << MISDN_FLG_L2_HOLD);
2074 /* open layer 3 and init upqueue */
2075 /* queue must be initializes, because l3-thread may send messages during open_layer3() */
2076 mqueue_init(&mISDNport->upqueue);
2077 mISDNport->ml3 = open_layer3(port, protocol, prop , do_layer3, mISDNport);
2078 if (!mISDNport->ml3) {
2079 mqueue_purge(&mISDNport->upqueue);
2080 PERROR_RUNTIME("open_layer3() failed for port %d\n", port);
2088 "PORT (open failed)");
2090 mISDNport_close(mISDNport);
2094 #ifdef ISDN_P_FXS_POTS
2097 struct sockaddr_mISDN addr;
2098 struct mISDNhead act;
2101 /* queue must be initializes, because even pots interfaces are checked at mISDN_upqueue loop */
2102 mqueue_init(&mISDNport->upqueue);
2103 sock = socket(PF_ISDN, SOCK_DGRAM, (nt) ? ISDN_P_FXS_POTS : ISDN_P_FXO_POTS);
2105 PERROR_RUNTIME("Cannot open mISDN due to '%s'.\n", strerror(errno));
2108 /* bind socket to dchannel */
2109 addr.family = AF_ISDN;
2112 ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
2114 PERROR_RUNTIME("Error: Failed to bind pots control channel\n");
2122 "PORT (open failed)");
2126 act.prim = PH_ACTIVATE_REQ;
2128 ret = sendto(sock, &act, MISDN_HEADER_LEN, 0, NULL, 0);
2130 PERROR("Failed to send to socket %d\n", sock);
2131 mISDNport->pots_sock.fd = sock;
2132 register_fd(&mISDNport->pots_sock, LCR_FD_READ, pots_sock_callback, mISDNport, i);
2136 SCPY(mISDNport->name, devinfo.name);
2137 mISDNport->b_num = devinfo.nrbchan;
2138 mISDNport->portnum = port;
2139 mISDNport->ntmode = nt;
2140 mISDNport->pots = pots;
2141 mISDNport->tespecial = ifport->tespecial;
2142 mISDNport->pri = pri;
2143 mISDNport->ptp = ptp;
2144 mISDNport->l1hold = l1hold;
2145 mISDNport->l2hold = l2hold;
2146 mISDNport->ss5 = ss5;
2147 PDEBUG(DEBUG_ISDN, "Port has %d b-channels.\n", mISDNport->b_num);
2149 while(i < mISDNport->b_num) {
2150 mISDNport->b_state[i] = B_STATE_IDLE;
2151 add_timer(&mISDNport->b_timer[i], b_timer_timeout, mISDNport, i);
2155 /* if ptp, pull up the link */
2156 if (!pots && mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode)) {
2157 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
2158 l1l2l3_trace_header(mISDNport, NULL, L2_ESTABLISH_REQ, DIRECTION_OUT);
2159 add_trace("tei", NULL, "%d", 0);
2161 schedule_timer(&mISDNport->l2establish, 5, 0); /* 5 seconds */
2164 /* for POTS or nt-mode ptmp the link is always up */
2165 if (pots || (mISDNport->ntmode && !mISDNport->ptp))
2166 mISDNport->l2link = 1;
2168 PDEBUG(DEBUG_BCHANNEL, "using 'mISDN_dsp.o' module\n");
2170 start_trace(mISDNport->portnum,
2179 add_trace("mode", NULL, (mISDNport->ntmode)?"network":"terminal");
2181 add_trace("mode", NULL, (mISDNport->ntmode)?"FXS":"FXO");
2182 add_trace("channels", NULL, "%d", mISDNport->b_num);
2184 add_trace("ccitt#5", NULL, "enabled");
2192 * load static port instances, if required by mISDNport
2194 void mISDNport_static(struct mISDNport *mISDNport)
2199 while(i < mISDNport->b_num) {
2202 ss5_create_channel(mISDNport, i);
2210 * function to free ALL cards (ports)
2212 void mISDNport_close_all(void)
2214 /* free all ports */
2215 while(mISDNport_first)
2216 mISDNport_close(mISDNport_first);
2220 * free only one port
2222 void mISDNport_close(struct mISDNport *mISDNport)
2224 struct mISDNport **mISDNportp;
2226 class PmISDN *isdnport;
2229 /* remove all port instance that are linked to this mISDNport */
2233 if ((port->p_type&PORT_CLASS_MASK) == PORT_CLASS_mISDN) {
2234 isdnport = (class PmISDN *)port;
2235 if (isdnport->p_m_mISDNport && isdnport->p_m_mISDNport == mISDNport) {
2236 PDEBUG(DEBUG_ISDN, "port %s uses mISDNport %d, destroying it.\n", isdnport->p_name, mISDNport->portnum);
2244 /* only if we are already part of interface */
2245 if (mISDNport->ifport) {
2246 start_trace(mISDNport->portnum,
2247 mISDNport->ifport->interface,
2257 /* free bchannels */
2259 while(i < mISDNport->b_num) {
2260 if (mISDNport->b_sock[i].inuse) {
2261 _bchannel_destroy(mISDNport, i);
2262 PDEBUG(DEBUG_BCHANNEL, "freeing %s port %d bchannel (index %d).\n", (mISDNport->ntmode)?"NT":"TE", mISDNport->portnum, i);
2264 if (mISDNport->b_timer[i].inuse) {
2265 del_timer(&mISDNport->b_timer[i]);
2269 del_timer(&mISDNport->l2establish);
2271 /* close layer 3, if open */
2272 if (mISDNport->ml3) {
2273 close_layer3(mISDNport->ml3);
2276 /* close layer 1, if open */
2277 if (mISDNport->pots_sock.fd) {
2278 unregister_fd(&mISDNport->pots_sock);
2279 close(mISDNport->pots_sock.fd);
2283 mqueue_purge(&mISDNport->upqueue);
2285 /* remove from list */
2286 mISDNportp = &mISDNport_first;
2287 while(*mISDNportp) {
2288 if (*mISDNportp == mISDNport) {
2289 *mISDNportp = (*mISDNportp)->next;
2293 mISDNportp = &((*mISDNportp)->next);
2297 FATAL("mISDNport not in list\n");
2299 FREE(mISDNport, sizeof(struct mISDNport));
2306 * enque data from remote port
2308 int PmISDN::bridge_rx(unsigned char *data, int length)
2310 unsigned char buf[MISDN_HEADER_LEN+((length>p_m_preload)?length:p_m_preload)];
2311 struct mISDNhead *hh = (struct mISDNhead *)buf;
2314 if ((ret = Port::bridge_rx(data, length)))
2317 if (p_m_b_index < 0)
2319 if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_ACTIVE)
2322 /* check if high priority tones exist
2323 * ignore data in this case
2325 if (p_tone_name[0] || p_dov_tx || p_m_crypt_msg_loops || p_m_inband_send_on)
2328 /* preload procedure
2329 * if transmit buffer in DSP module is empty,
2330 * preload it to DSP_LOAD to prevent jitter gaps.
2332 * if load runs empty, preload again.
2334 if (p_m_disable_dejitter && p_m_load == 0 && p_m_preload > 0) {
2335 //printf("preload=%d\n", p_m_preload);
2336 hh->prim = PH_DATA_REQ;
2338 memset(buf+MISDN_HEADER_LEN, silence, p_m_preload);
2339 ret = sendto(p_m_mISDNport->b_sock[p_m_b_index].fd, buf, MISDN_HEADER_LEN+p_m_preload, 0, NULL, 0);
2341 PERROR("Failed to send to socket %d\n", p_m_mISDNport->b_sock[p_m_b_index].fd);
2342 p_m_load += p_m_preload;
2343 schedule_timer(&p_m_loadtimer, 0, PORT_TRANSMIT * 125);
2346 /* drop if load would exceed ISDN_MAXLOAD
2347 * this keeps the delay not too high
2349 //printf("load=%d len=%d 2*preload=%d\n", p_m_load, length, p_m_preload << 1);
2350 if (p_m_disable_dejitter && p_m_preload > 0 && p_m_load+length > (p_m_preload << 1))
2353 /* make and send frame */
2354 hh->prim = PH_DATA_REQ;
2356 memcpy(buf+MISDN_HEADER_LEN, data, length);
2357 ret = sendto(p_m_mISDNport->b_sock[p_m_b_index].fd, buf, MISDN_HEADER_LEN+length, 0, NULL, 0);
2359 PERROR("Failed to send to socket %d\n", p_m_mISDNport->b_sock[p_m_b_index].fd);
2365 int PmISDN::inband_send(unsigned char *buffer, int len)
2367 PERROR("this function must be derived to function!\n");
2371 void PmISDN::inband_send_on(void)
2373 PDEBUG(DEBUG_PORT, "turning inband signalling send on.\n");
2374 p_m_inband_send_on = 1;
2377 void PmISDN::inband_send_off(void)
2379 PDEBUG(DEBUG_PORT, "turning inband signalling send off.\n");
2380 p_m_inband_send_on = 0;
2383 void PmISDN::inband_receive(unsigned char *buffer, int len)
2386 // if (len >= SS5_DECODER_NPOINTS)
2387 // ss5_decode(buffer, SS5_DECODER_NPOINTS);
2388 PERROR("this function must be derived to function!\n");
2391 void PmISDN::inband_receive_on(void)
2393 /* this must work during constructor, see ss5.cpp */
2394 PDEBUG(DEBUG_PORT, "turning inband signalling receive on.\n");
2395 p_m_inband_receive_on = 1;
2399 void PmISDN::inband_receive_off(void)
2401 PDEBUG(DEBUG_PORT, "turning inband signalling receive off.\n");
2402 p_m_inband_receive_on = 0;
2406 void PmISDN::mute_on(void)
2410 PDEBUG(DEBUG_PORT, "turning mute on.\n");
2412 set_conf(p_m_conf, 0);
2415 void PmISDN::mute_off(void)
2419 PDEBUG(DEBUG_PORT, "turning mute off.\n");
2421 set_conf(0, p_m_conf);