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;
133 p_m_tx_gain = mISDNport->ifport->interface->tx_gain;
134 p_m_rx_gain = mISDNport->ifport->interface->rx_gain;
140 p_m_preload = ISDN_LOAD;
141 p_m_disable_dejitter = 0;
145 p_m_inband_send_on = 0;
146 p_m_inband_receive_on = 0;
147 p_m_dtmf = !mISDNport->ifport->nodtmf;
148 p_m_dtmf_threshold = mISDNport->ifport->dtmf_threshold;
149 memset(&p_m_timeout, 0, sizeof(p_m_timeout));
150 add_timer(&p_m_timeout, mISDN_timeout, this, 0);
151 SCPY(p_m_pipeline, mISDNport->ifport->interface->pipeline);
154 memset(&p_m_loadtimer, 0, sizeof(p_m_loadtimer));
155 add_timer(&p_m_loadtimer, load_timer, this, 0);
161 p_m_crypt_listen = 0;
162 p_m_crypt_msg_loops = 0;
163 p_m_crypt_msg_loops = 0;
164 p_m_crypt_msg_len = 0;
165 p_m_crypt_msg[0] = '\0';
166 p_m_crypt_msg_current = 0;
167 p_m_crypt_key_len = 0;
168 p_m_crypt_listen = 0;
169 p_m_crypt_listen_state = 0;
170 p_m_crypt_listen_len = 0;
171 p_m_crypt_listen_msg[0] = '\0';
172 p_m_crypt_listen_crc = 0;
173 if (mISDNport->ifport->interface->bf_len >= 4 && mISDNport->ifport->interface->bf_len <= 56) {
174 memcpy(p_m_crypt_key, mISDNport->ifport->interface->bf_key, p_m_crypt_key_len);
175 p_m_crypt_key_len = mISDNport->ifport->interface->bf_len;
179 /* if any channel requested by constructor */
180 if (channel == CHANNEL_ANY) {
181 /* reserve channel */
183 mISDNport->b_reserved++;
186 /* reserve channel */
187 if (channel > 0) // only if constructor was called with a channel resevation
188 seize_bchannel(channel, exclusive);
190 /* we increase the number of objects: */
192 PDEBUG(DEBUG_ISDN, "Created new mISDNPort(%s). Currently %d objects use, port #%d\n", portname, mISDNport->use, p_m_portnum);
193 //inband_receive_on();
202 struct lcr_msg *message;
204 del_timer(&p_m_timeout);
205 del_timer(&p_m_loadtimer);
207 /* remove bchannel relation */
211 while (p_epointlist) {
212 PDEBUG(DEBUG_ISDN, "destroy mISDNPort(%s). endpoint still exists, releaseing.\n", p_name);
213 message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
214 message->param.disconnectinfo.cause = 16;
215 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
216 message_put(message);
217 /* remove from list */
218 free_epointlist(p_epointlist);
221 /* we decrease the number of objects: */
222 p_m_mISDNport->use--;
223 PDEBUG(DEBUG_ISDN, "destroyed mISDNPort(%s). Currently %d objects\n", p_name, p_m_mISDNport->use);
230 void chan_trace_header(struct mISDNport *mISDNport, class PmISDN *port, const char *msgtext, int direction)
232 /* init trace with given values */
233 start_trace(mISDNport?mISDNport->portnum:-1,
234 (mISDNport)?((mISDNport->ifport)?mISDNport->ifport->interface:NULL):NULL,
235 port?numberrize_callerinfo(port->p_callerinfo.id, port->p_callerinfo.ntype, options.national, options.international):NULL,
236 port?port->p_dialinginfo.id:NULL,
239 port?port->p_serial:0,
247 static struct isdn_message {
251 {"PH_ACTIVATE", L1_ACTIVATE_REQ},
252 {"PH_DEACTIVATE", L1_DEACTIVATE_REQ},
253 {"DL_ESTABLISH", L2_ESTABLISH_REQ},
254 {"DL_RELEASE", L2_RELEASE_REQ},
255 {"UNKNOWN", L3_UNKNOWN_REQ},
256 {"MT_TIMEOUT", L3_TIMEOUT_REQ},
257 {"MT_SETUP", L3_SETUP_REQ},
258 {"MT_SETUP_ACK", L3_SETUP_ACKNOWLEDGE_REQ},
259 {"MT_PROCEEDING", L3_PROCEEDING_REQ},
260 {"MT_ALERTING", L3_ALERTING_REQ},
261 {"MT_CONNECT", L3_CONNECT_REQ},
262 {"MT_CONNECT_ACK", L3_CONNECT_ACKNOWLEDGE_REQ},
263 {"MT_DISCONNECT", L3_DISCONNECT_REQ},
264 {"MT_RELEASE", L3_RELEASE_REQ},
265 {"MT_RELEASE_COMP", L3_RELEASE_COMPLETE_REQ},
266 {"MT_INFORMATION", L3_INFORMATION_REQ},
267 {"MT_PROGRESS", L3_PROGRESS_REQ},
268 {"MT_NOTIFY", L3_NOTIFY_REQ},
269 {"MT_SUSPEND", L3_SUSPEND_REQ},
270 {"MT_SUSPEND_ACK", L3_SUSPEND_ACKNOWLEDGE_REQ},
271 {"MT_SUSPEND_REJ", L3_SUSPEND_REJECT_REQ},
272 {"MT_RESUME", L3_RESUME_REQ},
273 {"MT_RESUME_ACK", L3_RESUME_ACKNOWLEDGE_REQ},
274 {"MT_RESUME_REJ", L3_RESUME_REJECT_REQ},
275 {"MT_HOLD", L3_HOLD_REQ},
276 {"MT_HOLD_ACK", L3_HOLD_ACKNOWLEDGE_REQ},
277 {"MT_HOLD_REJ", L3_HOLD_REJECT_REQ},
278 {"MT_RETRIEVE", L3_RETRIEVE_REQ},
279 {"MT_RETRIEVE_ACK", L3_RETRIEVE_ACKNOWLEDGE_REQ},
280 {"MT_RETRIEVE_REJ", L3_RETRIEVE_REJECT_REQ},
281 {"MT_FACILITY", L3_FACILITY_REQ},
282 {"MT_STATUS", L3_STATUS_REQ},
283 {"MT_RESTART", L3_RESTART_REQ},
284 {"MT_NEW_L3ID", L3_NEW_L3ID_REQ},
285 {"MT_RELEASE_L3ID", L3_RELEASE_L3ID_REQ},
288 static const char *isdn_prim[4] = {
294 void l1l2l3_trace_header(struct mISDNport *mISDNport, class PmISDN *port, unsigned int msg, int direction)
299 SCPY(msgtext, "<<UNKNOWN MESSAGE>>");
300 /* select message and primitive text */
302 while(isdn_message[i].name) {
303 // if (msg == L3_NOTIFY_REQ) printf("val = %x %s\n", isdn_message[i].value, isdn_message[i].name);
304 if (isdn_message[i].value == (msg&0xffffff00)) {
305 SCPY(msgtext, isdn_message[i].name);
310 SCAT(msgtext, isdn_prim[msg&0x00000003]);
313 if (direction && (msg&0xffffff00)!=L3_NEW_L3ID_REQ && (msg&0xffffff00)!=L3_RELEASE_L3ID_REQ) {
315 if (mISDNport->ntmode) {
316 if (direction == DIRECTION_OUT)
317 SCAT(msgtext, " N->U");
319 SCAT(msgtext, " N<-U");
321 if (direction == DIRECTION_OUT)
322 SCAT(msgtext, " U->N");
324 SCAT(msgtext, " U<-N");
329 /* init trace with given values */
330 start_trace(mISDNport?mISDNport->portnum:-1,
331 mISDNport?(mISDNport->ifport?mISDNport->ifport->interface:NULL):NULL,
332 port?numberrize_callerinfo(port->p_callerinfo.id, port->p_callerinfo.ntype, options.national, options.international):NULL,
333 port?port->p_dialinginfo.id:NULL,
336 port?port->p_serial:0,
342 * send control information to the channel (dsp-module)
344 void ph_control(struct mISDNport *mISDNport, class PmISDN *isdnport, int sock, unsigned int c1, unsigned int c2, const char *trace_name, int trace_value)
346 unsigned char buffer[MISDN_HEADER_LEN+sizeof(int)+sizeof(int)];
347 struct mISDNhead *ctrl = (struct mISDNhead *)buffer;
348 unsigned int *d = (unsigned int *)(buffer+MISDN_HEADER_LEN);
355 if (c1 == DTMF_TONE_START && c2 == 0) {
359 ctrl->prim = PH_CONTROL_REQ;
363 ret = sendto(sock, buffer, MISDN_HEADER_LEN+len, 0, NULL, 0);
365 PERROR("Failed to send to socket %d\n", sock);
366 chan_trace_header(mISDNport, isdnport, "BCHANNEL control", DIRECTION_OUT);
367 if (c1 == DSP_CONF_JOIN)
368 add_trace(trace_name, NULL, "0x%08x", trace_value);
370 add_trace(trace_name, NULL, "%d", trace_value);
374 void ph_control_block(struct mISDNport *mISDNport, class PmISDN *isdnport, int sock, unsigned int c1, void *c2, int c2_len, const char *trace_name, int trace_value)
376 unsigned char buffer[MISDN_HEADER_LEN+sizeof(int)+c2_len];
377 struct mISDNhead *ctrl = (struct mISDNhead *)buffer;
378 unsigned int *d = (unsigned int *)(buffer+MISDN_HEADER_LEN);
384 ctrl->prim = PH_CONTROL_REQ;
387 memcpy(d, c2, c2_len);
388 ret = sendto(sock, buffer, MISDN_HEADER_LEN+sizeof(int)+c2_len, 0, NULL, 0);
390 PERROR("Failed to send to socket %d\n", sock);
391 chan_trace_header(mISDNport, isdnport, "BCHANNEL control", DIRECTION_OUT);
392 add_trace(trace_name, NULL, "%d", trace_value);
396 static int b_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i);
399 * subfunction for bchannel_event
402 static int _bchannel_create(struct mISDNport *mISDNport, int i)
405 struct sockaddr_mISDN addr;
407 if (mISDNport->b_sock[i].inuse) {
408 PERROR("Error: Socket already created for index %d\n", i);
413 //#warning testing without DSP
414 // 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);
415 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);
416 if (mISDNport->b_sock[i].fd < 0) {
417 PERROR("Error: Failed to open bchannel-socket for index %d with mISDN-DSP layer. Did you load mISDN_dsp.ko?\n", i);
421 /* register callback for read */
422 register_fd(&mISDNport->b_sock[i], LCR_FD_READ, b_sock_callback, mISDNport, i);
424 /* bind socket to bchannel */
425 addr.family = AF_ISDN;
426 addr.dev = mISDNport->portnum;
427 addr.channel = i+1+(i>=15);
428 ret = bind(mISDNport->b_sock[i].fd, (struct sockaddr *)&addr, sizeof(addr));
430 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);
431 close(mISDNport->b_sock[i].fd);
432 unregister_fd(&mISDNport->b_sock[i]);
436 chan_trace_header(mISDNport, mISDNport->b_port[i], "BCHANNEL create socket", DIRECTION_OUT);
437 add_trace("channel", NULL, "%d", i+1+(i>=15));
438 add_trace("socket", NULL, "%d", mISDNport->b_sock[i].fd);
446 * subfunction for bchannel_event
447 * activate / deactivate request
449 static void _bchannel_activate(struct mISDNport *mISDNport, int i, int activate, int timeout)
451 struct mISDNhead act;
454 if (!mISDNport->b_sock[i].inuse)
456 act.prim = (activate)?PH_ACTIVATE_REQ:PH_DEACTIVATE_REQ;
458 ret = sendto(mISDNport->b_sock[i].fd, &act, MISDN_HEADER_LEN, 0, NULL, 0);
460 PERROR("Failed to send to socket %d\n", mISDNport->b_sock[i].fd);
463 chan_trace_header(mISDNport, mISDNport->b_port[i], activate ? "BCHANNEL activate" : "BCHANNEL deactivate", DIRECTION_OUT);
464 add_trace("channel", NULL, "%d", i+1+(i>=15));
466 add_trace("event", NULL, "timeout recovery");
472 * subfunction for bchannel_event
475 static void _bchannel_configure(struct mISDNport *mISDNport, int i)
480 if (!mISDNport->b_sock[i].inuse)
482 handle = mISDNport->b_sock[i].fd;
483 port = mISDNport->b_port[i];
484 mode = mISDNport->b_mode[i];
486 PERROR("bchannel index i=%d not associated with a port object\n", i);
490 /* set dsp features */
491 if (port->p_m_txdata)
492 ph_control(mISDNport, port, handle, (port->p_m_txdata)?DSP_TXDATA_ON:DSP_TXDATA_OFF, 0, "DSP-TXDATA", port->p_m_txdata);
493 if (port->p_m_delay && mode == B_MODE_TRANSPARENT)
494 ph_control(mISDNport, port, handle, DSP_DELAY, port->p_m_delay, "DSP-DELAY", port->p_m_delay);
495 if (port->p_m_tx_dejitter && mode == B_MODE_TRANSPARENT)
496 ph_control(mISDNport, port, handle, DSP_TX_DEJITTER, port->p_m_tx_dejitter, "DSP-TX_DEJITTER", port->p_m_tx_dejitter);
497 if (port->p_m_tx_gain && mode == B_MODE_TRANSPARENT)
498 ph_control(mISDNport, port, handle, DSP_VOL_CHANGE_TX, port->p_m_tx_gain, "DSP-TX_GAIN", port->p_m_tx_gain);
499 if (port->p_m_rx_gain && mode == B_MODE_TRANSPARENT)
500 ph_control(mISDNport, port, handle, DSP_VOL_CHANGE_RX, port->p_m_rx_gain, "DSP-RX_GAIN", port->p_m_rx_gain);
501 if (port->p_m_pipeline[0] && mode == B_MODE_TRANSPARENT)
502 ph_control_block(mISDNport, port, handle, DSP_PIPELINE_CFG, port->p_m_pipeline, strlen(port->p_m_pipeline)+1, "DSP-PIPELINE", 0);
503 if (port->p_m_conf && !port->p_m_mute)
504 ph_control(mISDNport, port, handle, DSP_CONF_JOIN, port->p_m_conf, "DSP-CONF", port->p_m_conf);
506 ph_control(mISDNport, port, handle, DSP_ECHO_ON, 0, "DSP-ECHO", 1);
507 if (port->p_m_tone && mode == B_MODE_TRANSPARENT)
508 ph_control(mISDNport, port, handle, DSP_TONE_PATT_ON, port->p_m_tone, "DSP-TONE", port->p_m_tone);
510 ph_control(mISDNport, port, handle, DSP_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
511 // if (port->p_m_txmix && mode == B_MODE_TRANSPARENT)
512 // ph_control(mISDNport, port, handle, DSP_MIX_ON, 0, "DSP-MIX", 1);
513 if (port->p_m_dtmf && mode == B_MODE_TRANSPARENT)
514 ph_control(mISDNport, port, handle, DTMF_TONE_START, port->p_m_dtmf_threshold, "DSP-DTMF", 1);
515 if (port->p_m_crypt && mode == B_MODE_TRANSPARENT)
516 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);
520 void PmISDN::set_conf(int oldconf, int newconf)
522 if (oldconf != newconf) {
523 PDEBUG(DEBUG_BCHANNEL, "we change conference from conf=%d to conf=%d.\n", oldconf, newconf);
524 if (p_m_b_index > -1)
525 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
526 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, (newconf)?DSP_CONF_JOIN:DSP_CONF_SPLIT, newconf, "DSP-CONF", newconf);
528 PDEBUG(DEBUG_BCHANNEL, "we already have conf=%d.\n", newconf);
533 * subfunction for bchannel_event
536 static void _bchannel_destroy(struct mISDNport *mISDNport, int i)
538 if (!mISDNport->b_sock[i].inuse)
540 chan_trace_header(mISDNport, mISDNport->b_port[i], "BCHANNEL remove socket", DIRECTION_OUT);
541 add_trace("channel", NULL, "%d", i+1+(i>=15));
542 add_trace("socket", NULL, "%d", mISDNport->b_sock[i].fd);
544 close(mISDNport->b_sock[i].fd);
545 unregister_fd(&mISDNport->b_sock[i]);
553 A bchannel goes through the following states in this order:
556 No one is using the bchannel.
557 It is available and not linked to Port class, nor reserved.
560 The bchannel stack is created and an activation request is sent.
561 It MAY be linked to Port class, but already unlinked due to Port class removal.
564 The bchannel is active and cofigured to the Port class needs.
565 Also it is linked to a Port class, otherwhise it would be deactivated.
567 - B_STATE_DEACTIVATING
568 The bchannel is in deactivating state, due to deactivation request.
569 It may be linked to a Port class, that likes to reactivate it.
573 After deactivating bchannel, and if not used, the bchannel becomes idle again.
575 A bchannel can have the following events:
578 A bchannel is required by a Port class.
581 The bchannel beomes active.
584 The bchannel is not required by Port class anymore
586 - B_EVENT_DEACTIVATED
587 The bchannel becomes inactive.
589 All actions taken on these events depend on the current bchannel's state and if it is linked to a Port class.
594 * process bchannel events
595 * - mISDNport is a pointer to the port's structure
596 * - i is the index of the bchannel
597 * - event is the B_EVENT_* value
598 * - port is the PmISDN class pointer
600 void bchannel_event(struct mISDNport *mISDNport, int i, int event)
602 class PmISDN *b_port = mISDNport->b_port[i];
603 int state = mISDNport->b_state[i];
604 int timer = -1; // no change
608 char *p_m_pipeline = NULL;
609 unsigned char *p_m_crypt_key = NULL;
610 int p_m_crypt_key_len = 0;
611 int p_m_crypt_key_type = 0;
614 p_m_tx_gain = b_port->p_m_tx_gain;
615 p_m_rx_gain = b_port->p_m_rx_gain;
616 p_m_pipeline = b_port->p_m_pipeline;
617 p_m_crypt_key = b_port->p_m_crypt_key;
618 p_m_crypt_key_len = b_port->p_m_crypt_key_len;
619 p_m_crypt_key_type = /*b_port->p_m_crypt_key_type*/1;
625 /* port must be linked in order to allow activation */
627 FATAL("bchannel must be linked to a Port class\n");
630 /* create stack and send activation request */
631 if (_bchannel_create(mISDNport, i)) {
632 _bchannel_activate(mISDNport, i, 1, 0);
633 state = B_STATE_ACTIVATING;
634 timer = B_TIMER_ACTIVATING;
638 case B_STATE_ACTIVATING:
639 /* do nothing, because it is already activating */
643 /* problems that might ocurr:
644 * B_EVENT_USE is received when channel already in use.
646 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
651 case B_EVENT_ACTIVATED:
654 case B_STATE_ACTIVATING:
656 /* bchannel is active and used by Port class, so we configure bchannel */
657 _bchannel_configure(mISDNport, i);
658 state = B_STATE_ACTIVE;
659 b_port->p_m_load = 0;
660 b_port->update_load();
662 /* bchannel is active, but not used anymore (or has wrong stack config), so we deactivate */
663 _bchannel_activate(mISDNport, i, 0, 0);
664 state = B_STATE_DEACTIVATING;
665 timer = B_TIMER_DEACTIVATING;
670 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
676 FATAL("bchannel must be linked to a Port class\n");
679 /* bchannel is idle due to an error, so we do nothing */
682 case B_STATE_ACTIVATING:
683 /* do nothing because we must wait until bchanenl is active before deactivating */
687 /* bchannel is active, so we deactivate */
688 _bchannel_activate(mISDNport, i, 0, 0);
689 state = B_STATE_DEACTIVATING;
690 timer = B_TIMER_DEACTIVATING;
693 case B_STATE_DEACTIVATING:
694 /* we may have taken an already deactivating bchannel, but do not require it anymore, so we do nothing */
698 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
702 case B_EVENT_DEACTIVATED:
706 /* ignore due to deactivation confirm after unloading */
709 case B_STATE_DEACTIVATING:
710 _bchannel_destroy(mISDNport, i);
711 state = B_STATE_IDLE;
713 /* bchannel is now deactivate, but is requied by Port class, so we reactivate */
714 if (_bchannel_create(mISDNport, i)) {
715 _bchannel_activate(mISDNport, i, 1, 0);
716 state = B_STATE_ACTIVATING;
717 timer = B_TIMER_ACTIVATING;
723 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
727 case B_EVENT_TIMEOUT:
731 /* ignore due to deactivation confirm after unloading */
734 case B_STATE_ACTIVATING:
735 _bchannel_activate(mISDNport, i, 1, 1);
736 timer = B_TIMER_ACTIVATING;
739 case B_STATE_DEACTIVATING:
740 _bchannel_activate(mISDNport, i, 0, 1);
741 timer = B_TIMER_DEACTIVATING;
745 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
750 PERROR("Illegal event %d, please correct.\n", event);
753 mISDNport->b_state[i] = state;
755 unsched_timer(&mISDNport->b_timer[i]);
757 schedule_timer(&mISDNport->b_timer[i], timer, 0);
764 * check for available channel and reserve+set it.
765 * give channel number or SEL_CHANNEL_ANY or SEL_CHANNEL_NO
767 * returns -(cause value) or x = channel x or 0 = no channel
768 * NOTE: no activation is done here
770 int PmISDN::seize_bchannel(int channel, int exclusive)
774 /* the channel is what we have */
775 if (p_m_b_channel == channel)
778 /* if channel already in use, release it */
783 if (channel==CHANNEL_NO || channel==0)
786 /* is channel in range ? */
788 || (channel>p_m_mISDNport->b_num && channel<16)
789 || ((channel-1)>p_m_mISDNport->b_num && channel>16)) /* channel-1 because channel 16 is not counted */
790 return(-6); /* channel unacceptable */
792 /* request exclusive channel */
793 if (exclusive && channel>0) {
794 i = channel-1-(channel>16);
795 if (p_m_mISDNport->b_port[i])
796 return(-44); /* requested channel not available */
800 /* ask for channel */
802 i = channel-1-(channel>16);
803 if (p_m_mISDNport->b_port[i] == NULL)
807 /* search for channel */
809 while(i < p_m_mISDNport->b_num) {
810 if (!p_m_mISDNport->b_port[i]) {
811 channel = i+1+(i>=15);
816 return(-34); /* no free channel */
819 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) seizing bchannel %d (index %d)\n", p_name, channel, i);
821 /* link Port, set parameters */
822 p_m_mISDNport->b_port[i] = this;
824 p_m_b_channel = channel;
825 p_m_b_exclusive = exclusive;
826 p_m_mISDNport->b_mode[i] = p_m_b_mode;
828 /* reserve channel */
829 if (!p_m_b_reserve) {
831 p_m_mISDNport->b_reserved++;
838 * drop reserved channel and unset it.
839 * deactivation is also done
841 void PmISDN::drop_bchannel(void)
843 /* unreserve channel */
845 p_m_mISDNport->b_reserved--;
854 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) dropping bchannel\n", p_name);
856 if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_IDLE)
857 bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_DROP);
858 p_m_mISDNport->b_port[p_m_b_index] = NULL;
859 p_m_mISDNport->b_mode[p_m_b_index] = 0;
869 audio transmission procedure:
870 -----------------------------
873 three sources of audio transmission:
874 - crypto-data high priority
875 - tones high priority (also high)
876 - remote-data low priority
879 a variable that temporarily shows the number of samples elapsed since last transmission process.
880 p_m_last_tv_* is used to store that last timestamp. this is used to calculate the time elapsed.
883 a variable that is increased whenever data is transmitted.
884 it is decreased while time elapses. it stores the number of samples that
885 are currently loaded to dsp module.
886 since clock in dsp module is the same clock for user space process, these
890 there are two levels:
891 p_m_preload will give the load that have to be kept in dsp.
892 ISDN_MAXLOAD (2*p_m_preload) will give the maximum load before dropping.
894 * procedure for low priority data
895 see txfromup() for procedure
896 in short: remote data is ignored during high priority tones
898 * procedure for high priority data
899 whenever load is below p_m_preload, load is filled up to p_m_preload
900 if no more data is available, load becomes empty again.
903 0 p_m_preload ISDN_MAXLOAD
904 +--------------------+----------------------+
906 +--------------------+----------------------+
908 on empty load or on load below p_m_preload, the load is inceased to p_m_preload:
909 0 p_m_preload ISDN_MAXLOAD
910 +--------------------+----------------------+
911 |TTTTTTTTTTTTTTTTTTTT| |
912 +--------------------+----------------------+
914 on empty load, remote-audio causes the load with the remote audio to be increased to p_m_preload.
915 0 p_m_preload ISDN_MAXLOAD
916 +--------------------+----------------------+
917 |TTTTTTTTTTTTTTTTTTTTRRRRR |
918 +--------------------+----------------------+
921 void PmISDN::update_load(void)
923 /* don't trigger load event if event already active */
924 if (p_m_loadtimer.active)
927 schedule_timer(&p_m_loadtimer, 0, 0); /* no delay the first time */
930 static int load_timer(struct lcr_timer *timer, void *instance, int index)
932 class PmISDN *isdnport = (class PmISDN *)instance;
939 void PmISDN::load_tx(void)
943 struct timeval current_time;
946 gettimeofday(¤t_time, NULL);
947 if (p_m_last_tv_sec) {
948 elapsed = 8000 * (current_time.tv_sec - p_m_last_tv_sec)
949 + 8 * (current_time.tv_usec/1000 - p_m_last_tv_msec);
951 /* set clock of last process! */
952 p_m_last_tv_sec = current_time.tv_sec;
953 p_m_last_tv_msec = current_time.tv_usec/1000;
955 /* process only if we have samples and we are active */
956 if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_ACTIVE)
961 if (elapsed < p_m_load)
966 /* to send data, tone must be on */
967 if ((p_tone_name[0] || p_dov_tx || p_m_crypt_msg_loops || p_m_inband_send_on) /* what tones? */
968 && (p_m_load < p_m_preload) /* not too much load? */
969 && (p_state==PORT_STATE_CONNECT || p_m_mISDNport->tones || p_m_inband_send_on)) { /* connected or inband-tones? */
970 int tosend = p_m_preload - p_m_load, length;
971 unsigned char buf[MISDN_HEADER_LEN+tosend];
972 struct mISDNhead *frm = (struct mISDNhead *)buf;
973 unsigned char *p = buf+MISDN_HEADER_LEN;
975 /* copy inband signalling (e.g. used by ss5) */
976 if (p_m_inband_send_on && tosend) {
977 tosend -= inband_send(p, tosend);
980 /* copy crypto loops */
981 while (p_m_crypt_msg_loops && tosend) {
982 /* how much do we have to send */
983 length = p_m_crypt_msg_len - p_m_crypt_msg_current;
989 /* copy message (part) to buffer */
990 memcpy(p, p_m_crypt_msg+p_m_crypt_msg_current, length);
993 p_m_crypt_msg_current += length;
994 if (p_m_crypt_msg_current == p_m_crypt_msg_len) {
996 p_m_crypt_msg_current = 0;
997 p_m_crypt_msg_loops--;
998 if (!p_m_crypt_msg_loops)
1000 // puts("eine loop weniger");
1009 tosend -= dov_tx(p, tosend);
1013 if (p_tone_name[0] && tosend) {
1014 tosend -= read_audio(p, tosend);
1018 if (p_m_preload - p_m_load - tosend > 0) {
1019 frm->prim = PH_DATA_REQ;
1021 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);
1023 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);
1024 p_m_load += p_m_preload - p_m_load - tosend;
1029 schedule_timer(&p_m_loadtimer, 0, PORT_TRANSMIT * 125);
1032 /* handle timeouts */
1033 static int mISDN_timeout(struct lcr_timer *timer, void *instance, int i)
1035 class PmISDN *isdnport = (class PmISDN *)instance;
1036 struct lcr_msg *message;
1038 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);
1039 /* send timeout to endpoint */
1040 message = message_create(isdnport->p_serial, ACTIVE_EPOINT(isdnport->p_epointlist), PORT_TO_EPOINT, MESSAGE_TIMEOUT);
1041 message->param.state = isdnport->p_state;
1042 message_put(message);
1049 * whenever we get audio data from bchannel, we process it here
1051 void PmISDN::bchannel_receive(struct mISDNhead *hh, unsigned char *data, int len)
1053 unsigned int cont = *((unsigned int *)data);
1054 struct lcr_msg *message;
1058 if (hh->prim == PH_CONTROL_IND) {
1060 PERROR("SHORT READ OF PH_CONTROL INDICATION\n");
1063 if ((cont&(~DTMF_TONE_MASK)) == DTMF_TONE_VAL) {
1064 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1065 add_trace("DTMF", NULL, "%c", cont & DTMF_TONE_MASK);
1067 add_trace("info", NULL, "DTMF is disabled");
1071 if (p_type == PORT_TYPE_POTS_FXS_IN && p_state == PORT_STATE_IN_OVERLAP) {
1072 class Pfxs *pfxs = (class Pfxs *)this;
1073 if (!pfxs->p_m_fxs_allow_dtmf) {
1074 PDEBUG(DEBUG_PORT, "PmISDN(%s) DTMF for FXS currently disabled\n", p_name);
1077 SCCAT(p_dialinginfo.id, cont & DTMF_TONE_MASK);
1078 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_INFORMATION);
1079 message->param.information.id[0] = cont & DTMF_TONE_MASK;
1080 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION INFORMATION digit '%s'\n", p_name, message->param.information.id);
1081 message_put(message);
1083 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_DTMF);
1084 message->param.dtmf = cont & DTMF_TONE_MASK;
1085 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION DTMF digit '%c'\n", p_name, message->param.dtmf);
1086 message_put(message);
1092 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1093 add_trace("DSP-CRYPT", NULL, "error");
1095 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1096 message->param.crypt.type = CC_ERROR_IND;
1097 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION reject of blowfish.\n", p_name);
1098 message_put(message);
1102 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1103 add_trace("DSP-CRYPT", NULL, "ok");
1105 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1106 message->param.crypt.type = CC_ACTBF_CONF;
1107 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION accept of blowfish.\n", p_name);
1108 message_put(message);
1112 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1113 add_trace("unknown", NULL, "0x%x", cont);
1118 if (hh->prim == PH_CONTROL_IND) {
1121 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1122 add_trace("unknown", NULL, "0x%x", hh->id);
1127 if (hh->prim == PH_DATA_REQ || hh->prim == DL_DATA_REQ) {
1129 /* if tx is off, it may happen that fifos send us pending informations, we just ignore them */
1130 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring tx data, because 'txdata' is turned off\n", p_name);
1133 /* see below (same condition) */
1134 if (p_state!=PORT_STATE_CONNECT
1135 && !p_m_mISDNport->tones)
1137 // printf(".");fflush(stdout);return;
1139 record(data, len, 1); // from up
1141 tap(data, len, 1); // from up
1144 if (hh->prim != PH_DATA_IND && hh->prim != DL_DATA_IND) {
1145 PERROR("Bchannel received unknown primitve: 0x%x\n", hh->prim);
1149 /* dov is processed */
1153 /* inband is processed */
1154 if (p_m_inband_receive_on)
1155 inband_receive(data, len);
1157 /* send to remote, if bridged */
1158 bridge_tx(data, len);
1160 /* calls will not process any audio data unless
1161 * the call is connected OR tones feature is enabled.
1163 #ifndef DEBUG_COREBRIDGE
1164 if (p_state!=PORT_STATE_CONNECT
1165 && !p_m_mISDNport->tones)
1170 /* the bearer capability must be audio in order to send and receive
1171 * audio prior or after connect.
1173 if (!(p_bearerinfo.capability&CLASS_CAPABILITY_AUDIO) && p_state!=PORT_STATE_CONNECT)
1177 /* if rx is off, it may happen that fifos send us pending informations, we just ignore them */
1179 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring data, because rx is turned off\n", p_name);
1185 record(data, len, 0); // from down
1187 tap(data, len, 0); // from down
1189 /* randomize and listen to crypt message if enabled */
1190 if (p_m_crypt_listen) {
1191 /* the noisy randomizer */
1195 mISDN_rand[mISDN_rand_count & 0xff] += *p++;
1197 cryptman_listen_bch(data, len);
1205 void PmISDN::set_echotest(int echo)
1207 if (p_m_echo != echo) {
1209 PDEBUG(DEBUG_ISDN, "we set echo to echo=%d.\n", p_m_echo);
1211 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1212 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);
1219 void PmISDN::set_tone(const char *dir, const char *tone)
1224 /* if no directory is given (by extension), we use interface.conf or options.conf */
1225 if (!dir || !dir[0]) {
1226 if (p_m_mISDNport->ifport->tones_dir[0])
1227 dir = p_m_mISDNport->ifport->tones_dir;
1228 else if (options.tones_dir[0])
1229 dir = options.tones_dir;
1234 PDEBUG(DEBUG_ISDN, "isdn port now plays tone:'%s'.\n", tone);
1240 /* check for dsp tones */
1241 if (!strcmp(dir, "american"))
1243 if (!strcmp(dir, "german"))
1245 if (!strcmp(dir, "oldgerman"))
1246 dsp = DSP_OLDGERMAN;
1248 /* check if we NOT really have to use a dsp-tone */
1249 if (dsp == DSP_NONE) {
1252 if (p_m_b_index > -1)
1253 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) {
1254 PDEBUG(DEBUG_ISDN, "we reset tone from id=%d to OFF.\n", p_m_tone);
1255 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TONE_PATT_OFF, 0, "DSP-TONE", 0);
1258 Port::set_tone(dir, tone);
1262 /* now we USE dsp-tone, convert name */
1263 if (!strcmp(tone, "dialtone")) {
1265 case DSP_AMERICAN: id = TONE_AMERICAN_DIALTONE; break;
1266 case DSP_GERMAN: id = TONE_GERMAN_DIALTONE; break;
1267 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALTONE; break;
1269 } else if (!strcmp(tone, "dialpbx")) {
1271 case DSP_AMERICAN: id = TONE_AMERICAN_DIALPBX; break;
1272 case DSP_GERMAN: id = TONE_GERMAN_DIALPBX; break;
1273 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALPBX; break;
1275 } else if (!strcmp(tone, "ringing")) {
1277 case DSP_AMERICAN: id = TONE_AMERICAN_RINGING; break;
1278 case DSP_GERMAN: id = TONE_GERMAN_RINGING; break;
1279 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGING; break;
1281 } else if (!strcmp(tone, "ringpbx")) {
1283 case DSP_AMERICAN: id = TONE_AMERICAN_RINGPBX; break;
1284 case DSP_GERMAN: id = TONE_GERMAN_RINGPBX; break;
1285 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGPBX; break;
1287 } else if (!strcmp(tone, "busy")) {
1290 case DSP_AMERICAN: id = TONE_AMERICAN_BUSY; break;
1291 case DSP_GERMAN: id = TONE_GERMAN_BUSY; break;
1292 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1294 } else if (!strcmp(tone, "release")) {
1297 case DSP_AMERICAN: id = TONE_AMERICAN_HANGUP; break;
1298 case DSP_GERMAN: id = TONE_GERMAN_HANGUP; break;
1299 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDHANGUP; break;
1301 } else if (!strcmp(tone, "cause_10"))
1303 else if (!strcmp(tone, "cause_11"))
1305 else if (!strcmp(tone, "cause_22")) {
1307 case DSP_AMERICAN: id = TONE_SPECIAL_INFO; break;
1308 case DSP_GERMAN: id = TONE_GERMAN_GASSENBESETZT; break;
1309 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1311 } else if (!strncmp(tone, "cause_", 6))
1312 id = TONE_SPECIAL_INFO;
1316 /* if we have a tone that is not supported by dsp */
1317 if (id==TONE_OFF && tone[0])
1321 if (p_m_tone != id) {
1324 PDEBUG(DEBUG_ISDN, "we set tone to id=%d.\n", p_m_tone);
1325 if (p_m_b_index > -1)
1326 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)
1327 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);
1329 /* turn user-space tones off in cases of no tone OR dsp tone */
1330 Port::set_tone("",NULL);
1334 /* MESSAGE_mISDNSIGNAL */
1335 //extern struct lcr_msg *dddebug;
1336 void PmISDN::message_mISDNsignal(unsigned int epoint_id, int message_id, union parameter *param)
1338 int oldconf, newconf;
1339 switch(param->mISDNsignal.message) {
1340 case mISDNSIGNAL_VOLUME:
1341 if (p_m_tx_gain != param->mISDNsignal.tx_gain) {
1342 p_m_tx_gain = param->mISDNsignal.tx_gain;
1343 PDEBUG(DEBUG_BCHANNEL, "we change tx-volume to shift=%d.\n", p_m_tx_gain);
1344 if (p_m_b_index > -1)
1345 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT)
1346 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_VOL_CHANGE_TX, p_m_tx_gain, "DSP-TX_GAIN", p_m_tx_gain);
1348 PDEBUG(DEBUG_BCHANNEL, "we already have tx-volume shift=%d.\n", p_m_rx_gain);
1349 if (p_m_rx_gain != param->mISDNsignal.rx_gain) {
1350 p_m_rx_gain = param->mISDNsignal.rx_gain;
1351 PDEBUG(DEBUG_BCHANNEL, "we change rx-volume to shift=%d.\n", p_m_rx_gain);
1352 if (p_m_b_index > -1)
1353 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)
1354 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);
1356 PDEBUG(DEBUG_BCHANNEL, "we already have rx-volume shift=%d.\n", p_m_rx_gain);
1359 case mISDNSIGNAL_CONF:
1360 oldconf = p_m_mute?0:p_m_conf;
1361 p_m_conf = param->mISDNsignal.conf;
1362 newconf = p_m_mute?0:p_m_conf;
1363 set_conf(oldconf, newconf);
1366 case mISDNSIGNAL_DELAY:
1367 if (p_m_delay != param->mISDNsignal.delay) {
1368 p_m_delay = param->mISDNsignal.delay;
1369 PDEBUG(DEBUG_BCHANNEL, "we change delay mode to delay=%d.\n", p_m_delay);
1370 if (p_m_b_index > -1)
1371 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)
1372 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);
1374 PDEBUG(DEBUG_BCHANNEL, "we already have delay=%d.\n", p_m_delay);
1378 PERROR("PmISDN(%s) unsupported signal message %d.\n", p_name, param->mISDNsignal.message);
1383 void PmISDN::message_crypt(unsigned int epoint_id, int message_id, union parameter *param)
1385 struct lcr_msg *message;
1387 switch(param->crypt.type) {
1388 case CC_ACTBF_REQ: /* activate blowfish */
1390 p_m_crypt_key_len = param->crypt.len;
1391 if (p_m_crypt_key_len > (int)sizeof(p_m_crypt_key)) {
1392 PERROR("PmISDN(%s) key too long %d > %d\n", p_name, p_m_crypt_key_len, sizeof(p_m_crypt_key));
1393 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1394 message->param.crypt.type = CC_ERROR_IND;
1395 message_put(message);
1398 memcpy(p_m_crypt_key, param->crypt.data, p_m_crypt_key_len);
1400 PDEBUG(DEBUG_BCHANNEL, "we set encryption to crypt=%d. (0 means OFF)\n", p_m_crypt);
1401 if (p_m_b_index > -1)
1402 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)
1403 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);
1406 case CC_DACT_REQ: /* deactivate session encryption */
1411 case CR_LISTEN_REQ: /* start listening to messages */
1412 p_m_crypt_listen = 1;
1414 p_m_crypt_listen_state = 0;
1417 case CR_UNLISTEN_REQ: /* stop listening to messages */
1418 p_m_crypt_listen = 0;
1422 case CR_MESSAGE_REQ: /* send message */
1423 p_m_crypt_msg_len = cryptman_encode_bch(param->crypt.data, param->crypt.len, p_m_crypt_msg, sizeof(p_m_crypt_msg));
1424 if (!p_m_crypt_msg_len) {
1425 PERROR("PmISDN(%s) message too long %d > %d\n", p_name, param->crypt.len-1, sizeof(p_m_crypt_msg));
1428 p_m_crypt_msg_current = 0; /* reset */
1429 p_m_crypt_msg_loops = 6; /* enable */
1432 /* disable txmix, or we get corrupt data due to audio process */
1433 if (p_m_txmix && p_m_b_index>=0 && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT) {
1434 PDEBUG(DEBUG_BCHANNEL, "for sending CR_MESSAGE_REQ, we reset txmix from txmix=%d.\n", p_m_txmix);
1435 ph_control(p_m_mISDNport, this, p_mISDNport->b_sock[p_m_b_index].fd, DSP_MIX_OFF, 0, "DSP-TXMIX", 0);
1441 PERROR("PmISDN(%s) unknown crypt message %d\n", p_name, param->crypt.type);
1447 void PmISDN::message_vootp(unsigned int epoint_id, int message_id, union parameter *param)
1449 struct lcr_msg *message;
1451 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_UPDATEBRIDGE);
1452 message_put(message);
1455 does not make sense, since remote port may dejitter
1456 if (param->vootp.enable) {
1457 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received vootp enable order, so we disable de-jitter.\n", p_name);
1458 p_m_disable_dejitter = 1;
1465 * endpoint sends messages to the port
1467 int PmISDN::message_epoint(unsigned int epoint_id, int message_id, union parameter *param)
1469 /* messages also handled by base class */
1470 switch(message_id) {
1471 case MESSAGE_VOOTP: /* crypt control command */
1472 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received VoOTP encryption\n", p_name);
1473 message_vootp(epoint_id, message_id, param);
1477 if (Port::message_epoint(epoint_id, message_id, param)) {
1478 if (message_id == MESSAGE_BRIDGE)
1483 /* messages not handled by base class */
1484 switch(message_id) {
1485 case MESSAGE_mISDNSIGNAL: /* user command */
1486 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received special ISDN SIGNAL %d.\n", p_name, param->mISDNsignal.message);
1487 message_mISDNsignal(epoint_id, message_id, param);
1490 case MESSAGE_CRYPT: /* crypt control command */
1491 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received encryption command '%d'.\n", p_name, param->crypt.type);
1492 message_crypt(epoint_id, message_id, param);
1495 case MESSAGE_DISABLE_DEJITTER:
1496 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received de-jitter disable order.\n", p_name);
1497 p_m_disable_dejitter = 1;
1498 p_m_preload = param->queue;
1506 void PmISDN::update_rxoff(void)
1508 int tx_dejitter = 0;
1510 /* call bridges in user space OR crypto OR recording */
1511 if (p_bridge || p_m_crypt_msg_loops || p_m_crypt_listen || p_record || p_tap || p_m_inband_receive_on || p_dov_rx) {
1512 /* rx IS required */
1516 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is required, so we turn them on\n", __FUNCTION__);
1517 if (p_m_b_index > -1)
1518 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1519 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_RECEIVE_ON, 0, "DSP-RXOFF", 0);
1522 /* rx NOT required */
1526 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is not required, so we turn them off\n", __FUNCTION__);
1527 if (p_m_b_index > -1)
1528 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1529 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
1532 /* recording / tapping */
1533 if (p_record || p_tap) {
1534 /* txdata IS required */
1538 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is required, so we turn them on\n", __FUNCTION__);
1539 if (p_m_b_index > -1)
1540 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1541 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TXDATA_ON, 0, "DSP-TXDATA", 1);
1544 /* txdata NOT required */
1548 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is not required, so we turn them off\n", __FUNCTION__);
1549 if (p_m_b_index > -1)
1550 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1551 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TXDATA_OFF, 0, "DSP-TXDATA", 0);
1554 /* dejitter on bridge */
1555 if (p_bridge && !p_m_disable_dejitter)
1557 if (p_m_tx_dejitter != tx_dejitter) {
1558 p_m_tx_dejitter = tx_dejitter;
1559 PDEBUG(DEBUG_BCHANNEL, "we change dejitter mode to %s.\n", (p_m_tx_dejitter) ? "on" : "off");
1560 if (p_m_b_index > -1)
1561 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)
1562 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);
1566 static int mISDN_upqueue(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1568 struct mISDNport *mISDNport;
1572 int __attribute__((__unused__)) ret;
1574 /* unset global semaphore */
1576 // with a very small incident, upqueue_avail may be set by mISDN thread and
1577 // another byte may be sent to the pipe, which causes a call to this function
1578 // again with nothing in the upqueue. this is no problem.
1579 ret = read(fd->fd, &byte, 1);
1581 /* process all ports */
1582 mISDNport = mISDNport_first;
1584 /* handle queued up-messages (d-channel) */
1585 while ((mb = mdequeue(&mISDNport->upqueue))) {
1588 case MPH_ACTIVATE_IND:
1589 if (mISDNport->l1link != 1) {
1590 l1l2l3_trace_header(mISDNport, NULL, L1_ACTIVATE_IND, DIRECTION_IN);
1592 mISDNport->l1link = 1;
1596 case MPH_DEACTIVATE_IND:
1597 if (mISDNport->l1link != 0) {
1598 l1l2l3_trace_header(mISDNport, NULL, L1_DEACTIVATE_IND, DIRECTION_IN);
1600 mISDNport->l1link = 0;
1604 case MPH_INFORMATION_IND:
1605 PDEBUG(DEBUG_ISDN, "Received MPH_INFORMATION_IND for port %d (%s).\n", mISDNport->portnum, mISDNport->ifport->interface->name);
1607 case L1_SIGNAL_LOS_ON:
1610 case L1_SIGNAL_LOS_OFF:
1613 case L1_SIGNAL_AIS_ON:
1616 case L1_SIGNAL_AIS_OFF:
1619 case L1_SIGNAL_RDI_ON:
1622 case L1_SIGNAL_RDI_OFF:
1625 case L1_SIGNAL_SLIP_TX:
1626 mISDNport->slip_tx++;
1628 case L1_SIGNAL_SLIP_RX:
1629 mISDNport->slip_rx++;
1634 case MT_L2ESTABLISH:
1635 l1l2l3_trace_header(mISDNport, NULL, L2_ESTABLISH_IND, DIRECTION_IN);
1636 add_trace("tei", NULL, "%d", l3m->pid);
1638 mISDNport->l2link = 1;
1640 mISDNport->l2mask[l3m->pid >> 3] |= (1 << (l3m->pid & 7));
1641 if ((!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127) {
1642 if (mISDNport->l2establish.active) {
1643 unsched_timer(&mISDNport->l2establish);
1644 PDEBUG(DEBUG_ISDN, "the link became active before l2establish timer expiry.\n");
1651 mISDNport->l2mask[l3m->pid >> 3] &= ~(1 << (l3m->pid & 7));
1652 if (!mISDNport->l2establish.active) {
1653 l1l2l3_trace_header(mISDNport, NULL, L2_RELEASE_IND, DIRECTION_IN);
1654 add_trace("tei", NULL, "%d", l3m->pid);
1656 /* down if not nt-ptmp */
1657 if (!mISDNport->ntmode || mISDNport->ptp)
1658 mISDNport->l2link = 0;
1660 if ((!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127) {
1661 if (!mISDNport->l2establish.active && mISDNport->l2hold) {
1662 PDEBUG(DEBUG_ISDN, "set timer and establish.\n");
1663 schedule_timer(&mISDNport->l2establish, 5, 0);
1664 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
1670 /* l3-data is sent to LCR */
1671 stack2manager(mISDNport, l3m->type, l3m->pid, l3m);
1676 mISDNport = mISDNport->next;
1681 /* l2 establish timer fires */
1682 static int l2establish_timeout(struct lcr_timer *timer, void *instance, int i)
1684 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1686 if (mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode)) {
1687 PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link portnum=%d.\n", mISDNport->portnum);
1688 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
1689 schedule_timer(&mISDNport->l2establish, 5, 0); /* 5 seconds */
1695 /* handle frames from bchannel */
1696 static int b_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1698 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1699 unsigned char buffer[2048+MISDN_HEADER_LEN];
1700 struct mISDNhead *hh = (struct mISDNhead *)buffer;
1703 ret = recv(fd->fd, buffer, sizeof(buffer), 0);
1705 PERROR("read error frame, errno %d\n", errno);
1708 if (ret < (int)MISDN_HEADER_LEN) {
1709 PERROR("read short frame, got %d, expected %d\n", ret, (int)MISDN_HEADER_LEN);
1713 /* we don't care about confirms, we use rx data to sync tx */
1717 /* we receive audio data, we respond to it AND we send tones */
1722 case PH_CONTROL_IND:
1723 if (mISDNport->b_port[i])
1724 mISDNport->b_port[i]->bchannel_receive(hh, buffer+MISDN_HEADER_LEN, ret-MISDN_HEADER_LEN);
1726 PDEBUG(DEBUG_BCHANNEL, "b-channel is not associated to an ISDNPort (socket %d), ignoring.\n", fd->fd);
1729 case PH_ACTIVATE_IND:
1730 case DL_ESTABLISH_IND:
1731 case PH_ACTIVATE_CNF:
1732 case DL_ESTABLISH_CNF:
1733 PDEBUG(DEBUG_BCHANNEL, "DL_ESTABLISH confirm: bchannel is now activated (socket %d).\n", fd->fd);
1734 bchannel_event(mISDNport, i, B_EVENT_ACTIVATED);
1737 case PH_DEACTIVATE_IND:
1738 case DL_RELEASE_IND:
1739 case PH_DEACTIVATE_CNF:
1740 case DL_RELEASE_CNF:
1741 PDEBUG(DEBUG_BCHANNEL, "DL_RELEASE confirm: bchannel is now de-activated (socket %d).\n", fd->fd);
1742 bchannel_event(mISDNport, i, B_EVENT_DEACTIVATED);
1746 PERROR("child message not handled: prim(0x%x) socket(%d) msg->len(%d)\n", hh->prim, fd->fd, ret-MISDN_HEADER_LEN);
1752 /* process timer events for bchannel handling */
1753 static int b_timer_timeout(struct lcr_timer *timer, void *instance, int i)
1755 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1757 bchannel_event(mISDNport, i, B_EVENT_TIMEOUT);
1763 int do_layer3(struct mlayer3 *ml3, unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1767 * l3m must be queued, except for MT_ASSIGN
1770 struct mISDNport *mISDNport = (struct mISDNport *)ml3->priv;
1773 #ifdef OLD_MT_ASSIGN
1774 /* special MT_ASSIGN handling:
1776 * if we request a PID from mlayer, we always do it while lcr is locked.
1777 * therefore we must check the MT_ASSIGN reply first before we lock.
1778 * this is because the MT_ASSIGN reply is received with the requesting
1779 * process, not by the mlayer thread!
1780 * this means, that the reply is sent during call of the request.
1781 * we must check if we get a reply and we know that we lcr is currently
1784 if (cmd==MT_ASSIGN && (pid&MISDN_PID_CR_FLAG) && (pid>>16)==MISDN_CES_MASTER) {
1785 /* let's do some checking if someone changes stack behaviour */
1786 if (mt_assign_pid != 0)
1787 FATAL("someone played with the mISDNuser stack. MT_ASSIGN not currently expected.\n");
1788 mt_assign_pid = pid;
1792 /* queue message, create, if required */
1794 l3m = alloc_l3_msg();
1796 FATAL("No memory for layer 3 message\n");
1798 mb = container_of(l3m, struct mbuffer, l3);
1801 mqueue_tail(&mISDNport->upqueue, mb);
1802 if (!upqueue_avail) {
1803 // multiple threads may cause multiple calls of this section, but this
1804 // results only in multiple processing of the upqueue read.
1805 // this is no problem.
1808 int __attribute__((__unused__)) ret;
1809 ret = write(upqueue_pipe[1], &byte, 1);
1814 int mISDN_getportbyname(int sock, int cnt, char *portname)
1816 struct mISDN_devinfo devinfo;
1820 while (port < cnt) {
1822 ret = ioctl(sock, IMGETDEVINFO, &devinfo);
1825 if (!strcasecmp(devinfo.name, portname))
1835 #ifdef ISDN_P_FXS_POTS
1836 /* handle frames from pots */
1837 static int pots_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1839 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1840 unsigned char buffer[2048+MISDN_HEADER_LEN];
1841 struct mISDNhead *hh = (struct mISDNhead *)buffer;
1845 ret = recv(fd->fd, buffer, sizeof(buffer), 0);
1847 PERROR("read error frame, errno %d\n", errno);
1850 if (ret < (int)MISDN_HEADER_LEN) {
1851 PERROR("read short frame, got %d, expected %d\n", ret, (int)MISDN_HEADER_LEN);
1855 case PH_CONTROL_IND:
1856 cont = *((unsigned int *)(buffer + MISDN_HEADER_LEN));
1857 /* l1-control is sent to LCR */
1858 if (mISDNport->ntmode)
1859 stack2manager_fxs(mISDNport, cont);
1861 PERROR("FXO not supported!\n");
1863 case PH_ACTIVATE_REQ:
1867 PERROR("child message not handled: prim(0x%x) socket(%d) msg->len(%d)\n", hh->prim, fd->fd, ret-MISDN_HEADER_LEN);
1875 * global function to add a new card (port)
1877 struct mISDNport *mISDNport_open(struct interface_port *ifport)
1880 struct mISDNport *mISDNport, **mISDNportp;
1881 int port = ifport->portnum;
1882 int ptp = ifport->ptp;
1883 int force_nt = ifport->nt;
1884 int l1hold = ifport->l1hold;
1885 int l2hold = ifport->l2hold;
1886 int ss5 = ifport->ss5;
1890 // struct mlayer3 *ml3;
1891 struct mISDN_devinfo devinfo;
1892 unsigned int protocol, prop;
1894 /* check port counts */
1895 ret = ioctl(mISDNsocket, IMGETCOUNT, &cnt);
1897 fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret);
1902 PERROR_RUNTIME("Found no card. Please be sure to load card drivers.\n");
1906 port = mISDN_getportbyname(mISDNsocket, cnt, ifport->portname);
1908 PERROR_RUNTIME("Port name '%s' not found, use 'misdn_info' tool to list all existing ports.\n", ifport->portname);
1911 // note: 'port' has still the port number
1913 if (port>cnt || port<0) {
1914 PERROR_RUNTIME("Port (%d) given at 'ports' (options.conf) is out of existing port range (%d-%d)\n", port, 0, cnt);
1918 /* get port attributes */
1919 pri = bri = pots = nt = te = 0;
1921 ret = ioctl(mISDNsocket, IMGETDEVINFO, &devinfo);
1923 PERROR_RUNTIME("Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", port, ret);
1926 if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0)) {
1930 if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0)) {
1934 if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1)) {
1938 if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1)) {
1942 #ifdef ISDN_P_FXS_POTS
1943 if (devinfo.Dprotocols & (1 << ISDN_P_FXO_POTS)) {
1947 if (devinfo.Dprotocols & (1 << ISDN_P_FXS_POTS)) {
1952 if (force_nt && !nt) {
1954 PERROR_RUNTIME("Port %d does not support NT-mode\n", port);
1956 PERROR_RUNTIME("Port %d does not support FXS-mode\n", port);
1960 PERROR_RUNTIME("Port %d supports BRI and PRI?? What kind of controller is that?. (Can't use this!)\n", port);
1963 if (!bri && !pri && !pots) {
1964 PERROR_RUNTIME("Port %d does not support BRI nor PRI nor POTS!\n", port);
1968 PERROR_RUNTIME("Port %d does not support NT-mode nor TE-mode!\n", port);
1971 /* set NT by turning off TE */
1974 /* if TE an NT is supported (and not forced to NT), turn off NT */
1978 PERROR_RUNTIME("Port %d uses FXO-mode, but not supported by LCR!\n", port);
1982 /* check for double use of port */
1984 mISDNport = mISDNport_first;
1986 if (mISDNport->portnum == port)
1988 mISDNport = mISDNport->next;
1991 PERROR_RUNTIME("Port %d already in use by LCR. You can't use a NT port multiple times.\n", port);
1996 /* check for continous channelmap with no bchannel on slot 16 */
1997 if (test_channelmap(0, devinfo.channelmap)) {
1998 PERROR_RUNTIME("Port %d provides channel 0, but we cannot access it!\n", port);
2002 while(i < (int)devinfo.nrbchan + 1) {
2004 if (test_channelmap(i, devinfo.channelmap)) {
2005 PERROR("Port %d provides bchannel 16. Pleas upgrade mISDN, if this port is mISDN loopback interface.\n", port);
2009 if (!test_channelmap(i, devinfo.channelmap)) {
2010 PERROR_RUNTIME("Port %d has no channel on slot %d!\n", port, i);
2017 /* add mISDNport structure */
2018 mISDNportp = &mISDNport_first;
2020 mISDNportp = &((*mISDNportp)->next);
2021 mISDNport = (struct mISDNport *)MALLOC(sizeof(struct mISDNport));
2022 add_timer(&mISDNport->l2establish, l2establish_timeout, mISDNport, 0);
2024 /* ss5 link is always active */
2025 mISDNport->l1link = 1;
2026 mISDNport->l2link = 1;
2028 mISDNport->l1link = -1;
2029 mISDNport->l2link = -1;
2032 *mISDNportp = mISDNport;
2034 /* if pri, must set PTP */
2038 /* set ss5 params */
2040 /* try to keep interface enabled */
2060 /* allocate ressources of port */
2063 protocol = (nt)?L3_PROTOCOL_DSS1_NET:L3_PROTOCOL_DSS1_USER;
2064 prop = (1 << MISDN_FLG_L2_CLEAN);
2065 if (ptp) // ptp forced
2066 prop |= (1 << MISDN_FLG_PTP);
2067 if (nt) // supports hold/retrieve on nt-mode
2068 prop |= (1 << MISDN_FLG_NET_HOLD);
2069 if (l1hold) // supports layer 1 hold
2070 prop |= (1 << MISDN_FLG_L1_HOLD);
2071 if (l2hold) // supports layer 2 hold
2072 prop |= (1 << MISDN_FLG_L2_HOLD);
2073 /* open layer 3 and init upqueue */
2074 /* queue must be initializes, because l3-thread may send messages during open_layer3() */
2075 mqueue_init(&mISDNport->upqueue);
2076 mISDNport->ml3 = open_layer3(port, protocol, prop , do_layer3, mISDNport);
2077 if (!mISDNport->ml3) {
2078 mqueue_purge(&mISDNport->upqueue);
2079 PERROR_RUNTIME("open_layer3() failed for port %d\n", port);
2087 "PORT (open failed)");
2089 mISDNport_close(mISDNport);
2093 #ifdef ISDN_P_FXS_POTS
2096 struct sockaddr_mISDN addr;
2097 struct mISDNhead act;
2100 /* queue must be initializes, because even pots interfaces are checked at mISDN_upqueue loop */
2101 mqueue_init(&mISDNport->upqueue);
2102 sock = socket(PF_ISDN, SOCK_DGRAM, (nt) ? ISDN_P_FXS_POTS : ISDN_P_FXO_POTS);
2104 PERROR_RUNTIME("Cannot open mISDN due to '%s'.\n", strerror(errno));
2107 /* bind socket to dchannel */
2108 addr.family = AF_ISDN;
2111 ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
2113 PERROR_RUNTIME("Error: Failed to bind pots control channel\n");
2121 "PORT (open failed)");
2125 act.prim = PH_ACTIVATE_REQ;
2127 ret = sendto(sock, &act, MISDN_HEADER_LEN, 0, NULL, 0);
2129 PERROR("Failed to send to socket %d\n", sock);
2130 mISDNport->pots_sock.fd = sock;
2131 register_fd(&mISDNport->pots_sock, LCR_FD_READ, pots_sock_callback, mISDNport, i);
2135 SCPY(mISDNport->name, devinfo.name);
2136 mISDNport->b_num = devinfo.nrbchan;
2137 mISDNport->portnum = port;
2138 mISDNport->ntmode = nt;
2139 mISDNport->pots = pots;
2140 mISDNport->tespecial = ifport->tespecial;
2141 mISDNport->pri = pri;
2142 mISDNport->ptp = ptp;
2143 mISDNport->l1hold = l1hold;
2144 mISDNport->l2hold = l2hold;
2145 mISDNport->ss5 = ss5;
2146 PDEBUG(DEBUG_ISDN, "Port has %d b-channels.\n", mISDNport->b_num);
2148 while(i < mISDNport->b_num) {
2149 mISDNport->b_state[i] = B_STATE_IDLE;
2150 add_timer(&mISDNport->b_timer[i], b_timer_timeout, mISDNport, i);
2154 /* if ptp, pull up the link */
2155 if (!pots && mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode)) {
2156 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
2157 l1l2l3_trace_header(mISDNport, NULL, L2_ESTABLISH_REQ, DIRECTION_OUT);
2158 add_trace("tei", NULL, "%d", 0);
2160 schedule_timer(&mISDNport->l2establish, 5, 0); /* 5 seconds */
2163 /* for POTS or nt-mode ptmp the link is always up */
2164 if (pots || (mISDNport->ntmode && !mISDNport->ptp))
2165 mISDNport->l2link = 1;
2167 PDEBUG(DEBUG_BCHANNEL, "using 'mISDN_dsp.o' module\n");
2169 start_trace(mISDNport->portnum,
2178 add_trace("mode", NULL, (mISDNport->ntmode)?"network":"terminal");
2180 add_trace("mode", NULL, (mISDNport->ntmode)?"FXS":"FXO");
2181 add_trace("channels", NULL, "%d", mISDNport->b_num);
2183 add_trace("ccitt#5", NULL, "enabled");
2191 * load static port instances, if required by mISDNport
2193 void mISDNport_static(struct mISDNport *mISDNport)
2198 while(i < mISDNport->b_num) {
2201 ss5_create_channel(mISDNport, i);
2209 * function to free ALL cards (ports)
2211 void mISDNport_close_all(void)
2213 /* free all ports */
2214 while(mISDNport_first)
2215 mISDNport_close(mISDNport_first);
2219 * free only one port
2221 void mISDNport_close(struct mISDNport *mISDNport)
2223 struct mISDNport **mISDNportp;
2225 class PmISDN *isdnport;
2228 /* remove all port instance that are linked to this mISDNport */
2232 if ((port->p_type&PORT_CLASS_MASK) == PORT_CLASS_mISDN) {
2233 isdnport = (class PmISDN *)port;
2234 if (isdnport->p_m_mISDNport && isdnport->p_m_mISDNport == mISDNport) {
2235 PDEBUG(DEBUG_ISDN, "port %s uses mISDNport %d, destroying it.\n", isdnport->p_name, mISDNport->portnum);
2243 /* only if we are already part of interface */
2244 if (mISDNport->ifport) {
2245 start_trace(mISDNport->portnum,
2246 mISDNport->ifport->interface,
2256 /* free bchannels */
2258 while(i < mISDNport->b_num) {
2259 if (mISDNport->b_sock[i].inuse) {
2260 _bchannel_destroy(mISDNport, i);
2261 PDEBUG(DEBUG_BCHANNEL, "freeing %s port %d bchannel (index %d).\n", (mISDNport->ntmode)?"NT":"TE", mISDNport->portnum, i);
2263 if (mISDNport->b_timer[i].inuse) {
2264 del_timer(&mISDNport->b_timer[i]);
2268 del_timer(&mISDNport->l2establish);
2270 /* close layer 3, if open */
2271 if (mISDNport->ml3) {
2272 close_layer3(mISDNport->ml3);
2275 /* close layer 1, if open */
2276 if (mISDNport->pots_sock.fd) {
2277 unregister_fd(&mISDNport->pots_sock);
2278 close(mISDNport->pots_sock.fd);
2282 mqueue_purge(&mISDNport->upqueue);
2284 /* remove from list */
2285 mISDNportp = &mISDNport_first;
2286 while(*mISDNportp) {
2287 if (*mISDNportp == mISDNport) {
2288 *mISDNportp = (*mISDNportp)->next;
2292 mISDNportp = &((*mISDNportp)->next);
2296 FATAL("mISDNport not in list\n");
2298 FREE(mISDNport, sizeof(struct mISDNport));
2305 * enque data from remote port
2307 int PmISDN::bridge_rx(unsigned char *data, int length)
2309 unsigned char buf[MISDN_HEADER_LEN+((length>p_m_preload)?length:p_m_preload)];
2310 struct mISDNhead *hh = (struct mISDNhead *)buf;
2313 if ((ret = Port::bridge_rx(data, length)))
2316 if (p_m_b_index < 0)
2318 if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_ACTIVE)
2321 /* check if high priority tones exist
2322 * ignore data in this case
2324 if (p_tone_name[0] || p_dov_tx || p_m_crypt_msg_loops || p_m_inband_send_on)
2327 /* preload procedure
2328 * if transmit buffer in DSP module is empty,
2329 * preload it to DSP_LOAD to prevent jitter gaps.
2331 * if load runs empty, preload again.
2333 if (p_m_disable_dejitter && p_m_load == 0 && p_m_preload > 0) {
2334 //printf("preload=%d\n", p_m_preload);
2335 hh->prim = PH_DATA_REQ;
2337 memset(buf+MISDN_HEADER_LEN, silence, p_m_preload);
2338 ret = sendto(p_m_mISDNport->b_sock[p_m_b_index].fd, buf, MISDN_HEADER_LEN+p_m_preload, 0, NULL, 0);
2340 PERROR("Failed to send to socket %d\n", p_m_mISDNport->b_sock[p_m_b_index].fd);
2341 p_m_load += p_m_preload;
2342 schedule_timer(&p_m_loadtimer, 0, PORT_TRANSMIT * 125);
2345 /* drop if load would exceed ISDN_MAXLOAD
2346 * this keeps the delay not too high
2348 //printf("load=%d len=%d 2*preload=%d\n", p_m_load, length, p_m_preload << 1);
2349 if (p_m_disable_dejitter && p_m_preload > 0 && p_m_load+length > (p_m_preload << 1))
2352 /* make and send frame */
2353 hh->prim = PH_DATA_REQ;
2355 memcpy(buf+MISDN_HEADER_LEN, data, length);
2356 ret = sendto(p_m_mISDNport->b_sock[p_m_b_index].fd, buf, MISDN_HEADER_LEN+length, 0, NULL, 0);
2358 PERROR("Failed to send to socket %d\n", p_m_mISDNport->b_sock[p_m_b_index].fd);
2364 int PmISDN::inband_send(unsigned char *buffer, int len)
2366 PERROR("this function must be derived to function!\n");
2370 void PmISDN::inband_send_on(void)
2372 PDEBUG(DEBUG_PORT, "turning inband signalling send on.\n");
2373 p_m_inband_send_on = 1;
2376 void PmISDN::inband_send_off(void)
2378 PDEBUG(DEBUG_PORT, "turning inband signalling send off.\n");
2379 p_m_inband_send_on = 0;
2382 void PmISDN::inband_receive(unsigned char *buffer, int len)
2385 // if (len >= SS5_DECODER_NPOINTS)
2386 // ss5_decode(buffer, SS5_DECODER_NPOINTS);
2387 PERROR("this function must be derived to function!\n");
2390 void PmISDN::inband_receive_on(void)
2392 /* this must work during constructor, see ss5.cpp */
2393 PDEBUG(DEBUG_PORT, "turning inband signalling receive on.\n");
2394 p_m_inband_receive_on = 1;
2398 void PmISDN::inband_receive_off(void)
2400 PDEBUG(DEBUG_PORT, "turning inband signalling receive off.\n");
2401 p_m_inband_receive_on = 0;
2405 void PmISDN::mute_on(void)
2409 PDEBUG(DEBUG_PORT, "turning mute on.\n");
2411 set_conf(p_m_conf, 0);
2414 void PmISDN::mute_off(void)
2418 PDEBUG(DEBUG_PORT, "turning mute off.\n");
2420 set_conf(0, p_m_conf);