1 /*****************************************************************************\
3 ** Linux Call Router **
5 **---------------------------------------------------------------------------**
6 ** Copyright: Andreas Eversberg **
8 ** mISDN port abstraction for dss1 **
10 \*****************************************************************************/
14 #include <mISDN/q931.h>
17 #ifdef __compiler_offsetof
18 #define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
20 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
24 #define container_of(ptr, type, member) ({ \
25 const typeof( ((type *)0)->member ) *__mptr = (ptr); \
26 (type *)( (char *)__mptr - offsetof(type,member) );})
29 // timeouts if activating/deactivating response from mISDN got lost
30 #define B_TIMER_ACTIVATING 1 // seconds
31 #define B_TIMER_DEACTIVATING 1 // seconds
33 /* list of mISDN ports */
34 struct mISDNport *mISDNport_first;
36 /* noise randomizer */
37 unsigned char mISDN_rand[256];
38 int mISDN_rand_count = 0;
41 unsigned int mt_assign_pid = ~0;
45 static int upqueue_pipe[2];
46 static struct lcr_fd upqueue_fd;
47 int upqueue_avail = 0;
49 static int mISDN_upqueue(struct lcr_fd *fd, unsigned int what, void *instance, int i);
50 static int mISDN_timeout(struct lcr_timer *timer, void *instance, int i);
52 static int my_mISDNlib_debug(const char *file, int line, const char *func, int level, const char *fmt, va_list va)
57 ret = vfprintf(debug_fp, fmt, va);
61 static struct mi_ext_fn_s myfn;
63 int mISDN_initialize(void)
68 /* try to open raw socket to check kernel */
69 mISDNsocket = socket(PF_ISDN, SOCK_RAW, ISDN_P_BASE);
70 if (mISDNsocket < 0) {
71 fprintf(stderr, "Cannot open mISDN due to '%s'. (Does your Kernel support socket based mISDN? Protocol family is %d.)\n", strerror(errno), PF_ISDN);
76 // set debug printout function
77 myfn.prt_debug = my_mISDNlib_debug;
79 ver = init_layer3(4, &myfn); // buffer of 4
81 /* open debug, if enabled and not only stack debugging */
83 SPRINT(filename, "%s/debug.log", LOG_DIR);
84 debug_fp = fopen(filename, "a");
87 if (options.deb & DEBUG_STACK)
88 mISDN_set_debug_level(0xfffffeff);
90 mISDN_set_debug_level(0);
92 if (pipe(upqueue_pipe) < 0)
93 FATAL("Failed to open pipe\n");
94 memset(&upqueue_fd, 0, sizeof(upqueue_fd));
95 upqueue_fd.fd = upqueue_pipe[0];
96 register_fd(&upqueue_fd, LCR_FD_READ, mISDN_upqueue, NULL, 0);
101 void mISDN_deinitialize(void)
109 if (mISDNsocket > -1)
112 if (upqueue_fd.inuse) {
113 unregister_fd(&upqueue_fd);
114 close(upqueue_pipe[0]);
115 close(upqueue_pipe[1]);
120 int load_timer(struct lcr_timer *timer, void *instance, int index);
125 PmISDN::PmISDN(int type, mISDNport *mISDNport, char *portname, struct port_settings *settings, int channel, int exclusive, int mode) : Port(type, portname, settings)
127 p_m_mISDNport = mISDNport;
128 p_m_portnum = mISDNport->portnum;
135 p_m_tx_gain = mISDNport->ifport->interface->tx_gain;
136 p_m_rx_gain = mISDNport->ifport->interface->rx_gain;
145 p_m_inband_send_on = 0;
146 p_m_inband_receive_on = 0;
147 p_m_dtmf = !mISDNport->ifport->nodtmf;
148 memset(&p_m_timeout, 0, sizeof(p_m_timeout));
149 add_timer(&p_m_timeout, mISDN_timeout, this, 0);
150 SCPY(p_m_pipeline, mISDNport->ifport->interface->pipeline);
153 memset(&p_m_loadtimer, 0, sizeof(p_m_loadtimer));
154 add_timer(&p_m_loadtimer, load_timer, this, 0);
160 p_m_crypt_listen = 0;
161 p_m_crypt_msg_loops = 0;
162 p_m_crypt_msg_loops = 0;
163 p_m_crypt_msg_len = 0;
164 p_m_crypt_msg[0] = '\0';
165 p_m_crypt_msg_current = 0;
166 p_m_crypt_key_len = 0;
167 p_m_crypt_listen = 0;
168 p_m_crypt_listen_state = 0;
169 p_m_crypt_listen_len = 0;
170 p_m_crypt_listen_msg[0] = '\0';
171 p_m_crypt_listen_crc = 0;
172 if (mISDNport->ifport->interface->bf_len >= 4 && mISDNport->ifport->interface->bf_len <= 56) {
173 memcpy(p_m_crypt_key, mISDNport->ifport->interface->bf_key, p_m_crypt_key_len);
174 p_m_crypt_key_len = mISDNport->ifport->interface->bf_len;
178 /* if any channel requested by constructor */
179 if (channel == CHANNEL_ANY) {
180 /* reserve channel */
182 mISDNport->b_reserved++;
185 /* reserve channel */
186 if (channel > 0) // only if constructor was called with a channel resevation
187 seize_bchannel(channel, exclusive);
189 /* we increase the number of objects: */
191 PDEBUG(DEBUG_ISDN, "Created new mISDNPort(%s). Currently %d objects use, port #%d\n", portname, mISDNport->use, p_m_portnum);
192 //inband_receive_on();
201 struct lcr_msg *message;
203 del_timer(&p_m_timeout);
204 del_timer(&p_m_loadtimer);
206 /* remove bchannel relation */
210 while (p_epointlist) {
211 PDEBUG(DEBUG_ISDN, "destroy mISDNPort(%s). endpoint still exists, releaseing.\n", p_name);
212 message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
213 message->param.disconnectinfo.cause = 16;
214 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
215 message_put(message);
216 /* remove from list */
217 free_epointlist(p_epointlist);
220 /* we decrease the number of objects: */
221 p_m_mISDNport->use--;
222 PDEBUG(DEBUG_ISDN, "destroyed mISDNPort(%s). Currently %d objects\n", p_name, p_m_mISDNport->use);
229 void chan_trace_header(struct mISDNport *mISDNport, class PmISDN *port, const char *msgtext, int direction)
231 /* init trace with given values */
232 start_trace(mISDNport?mISDNport->portnum:-1,
233 (mISDNport)?((mISDNport->ifport)?mISDNport->ifport->interface:NULL):NULL,
234 port?numberrize_callerinfo(port->p_callerinfo.id, port->p_callerinfo.ntype, options.national, options.international):NULL,
235 port?port->p_dialinginfo.id:NULL,
238 port?port->p_serial:0,
246 static struct isdn_message {
250 {"PH_ACTIVATE", L1_ACTIVATE_REQ},
251 {"PH_DEACTIVATE", L1_DEACTIVATE_REQ},
252 {"DL_ESTABLISH", L2_ESTABLISH_REQ},
253 {"DL_RELEASE", L2_RELEASE_REQ},
254 {"UNKNOWN", L3_UNKNOWN_REQ},
255 {"MT_TIMEOUT", L3_TIMEOUT_REQ},
256 {"MT_SETUP", L3_SETUP_REQ},
257 {"MT_SETUP_ACK", L3_SETUP_ACKNOWLEDGE_REQ},
258 {"MT_PROCEEDING", L3_PROCEEDING_REQ},
259 {"MT_ALERTING", L3_ALERTING_REQ},
260 {"MT_CONNECT", L3_CONNECT_REQ},
261 {"MT_CONNECT_ACK", L3_CONNECT_ACKNOWLEDGE_REQ},
262 {"MT_DISCONNECT", L3_DISCONNECT_REQ},
263 {"MT_RELEASE", L3_RELEASE_REQ},
264 {"MT_RELEASE_COMP", L3_RELEASE_COMPLETE_REQ},
265 {"MT_INFORMATION", L3_INFORMATION_REQ},
266 {"MT_PROGRESS", L3_PROGRESS_REQ},
267 {"MT_NOTIFY", L3_NOTIFY_REQ},
268 {"MT_SUSPEND", L3_SUSPEND_REQ},
269 {"MT_SUSPEND_ACK", L3_SUSPEND_ACKNOWLEDGE_REQ},
270 {"MT_SUSPEND_REJ", L3_SUSPEND_REJECT_REQ},
271 {"MT_RESUME", L3_RESUME_REQ},
272 {"MT_RESUME_ACK", L3_RESUME_ACKNOWLEDGE_REQ},
273 {"MT_RESUME_REJ", L3_RESUME_REJECT_REQ},
274 {"MT_HOLD", L3_HOLD_REQ},
275 {"MT_HOLD_ACK", L3_HOLD_ACKNOWLEDGE_REQ},
276 {"MT_HOLD_REJ", L3_HOLD_REJECT_REQ},
277 {"MT_RETRIEVE", L3_RETRIEVE_REQ},
278 {"MT_RETRIEVE_ACK", L3_RETRIEVE_ACKNOWLEDGE_REQ},
279 {"MT_RETRIEVE_REJ", L3_RETRIEVE_REJECT_REQ},
280 {"MT_FACILITY", L3_FACILITY_REQ},
281 {"MT_STATUS", L3_STATUS_REQ},
282 {"MT_RESTART", L3_RESTART_REQ},
283 {"MT_NEW_L3ID", L3_NEW_L3ID_REQ},
284 {"MT_RELEASE_L3ID", L3_RELEASE_L3ID_REQ},
287 static const char *isdn_prim[4] = {
293 void l1l2l3_trace_header(struct mISDNport *mISDNport, class PmISDN *port, unsigned int msg, int direction)
298 SCPY(msgtext, "<<UNKNOWN MESSAGE>>");
299 /* select message and primitive text */
301 while(isdn_message[i].name) {
302 // if (msg == L3_NOTIFY_REQ) printf("val = %x %s\n", isdn_message[i].value, isdn_message[i].name);
303 if (isdn_message[i].value == (msg&0xffffff00)) {
304 SCPY(msgtext, isdn_message[i].name);
309 SCAT(msgtext, isdn_prim[msg&0x00000003]);
312 if (direction && (msg&0xffffff00)!=L3_NEW_L3ID_REQ && (msg&0xffffff00)!=L3_RELEASE_L3ID_REQ) {
314 if (mISDNport->ntmode) {
315 if (direction == DIRECTION_OUT)
316 SCAT(msgtext, " N->U");
318 SCAT(msgtext, " N<-U");
320 if (direction == DIRECTION_OUT)
321 SCAT(msgtext, " U->N");
323 SCAT(msgtext, " U<-N");
328 /* init trace with given values */
329 start_trace(mISDNport?mISDNport->portnum:-1,
330 mISDNport?(mISDNport->ifport?mISDNport->ifport->interface:NULL):NULL,
331 port?numberrize_callerinfo(port->p_callerinfo.id, port->p_callerinfo.ntype, options.national, options.international):NULL,
332 port?port->p_dialinginfo.id:NULL,
335 port?port->p_serial:0,
341 * send control information to the channel (dsp-module)
343 void ph_control(struct mISDNport *mISDNport, class PmISDN *isdnport, int sock, unsigned int c1, unsigned int c2, const char *trace_name, int trace_value)
345 unsigned char buffer[MISDN_HEADER_LEN+sizeof(int)+sizeof(int)];
346 struct mISDNhead *ctrl = (struct mISDNhead *)buffer;
347 unsigned int *d = (unsigned int *)(buffer+MISDN_HEADER_LEN);
353 ctrl->prim = PH_CONTROL_REQ;
357 ret = sendto(sock, buffer, MISDN_HEADER_LEN+sizeof(int)*2, 0, NULL, 0);
359 PERROR("Failed to send to socket %d\n", sock);
360 chan_trace_header(mISDNport, isdnport, "BCHANNEL control", DIRECTION_OUT);
361 if (c1 == DSP_CONF_JOIN)
362 add_trace(trace_name, NULL, "0x%08x", trace_value);
364 add_trace(trace_name, NULL, "%d", trace_value);
368 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)
370 unsigned char buffer[MISDN_HEADER_LEN+sizeof(int)+c2_len];
371 struct mISDNhead *ctrl = (struct mISDNhead *)buffer;
372 unsigned int *d = (unsigned int *)(buffer+MISDN_HEADER_LEN);
378 ctrl->prim = PH_CONTROL_REQ;
381 memcpy(d, c2, c2_len);
382 ret = sendto(sock, buffer, MISDN_HEADER_LEN+sizeof(int)+c2_len, 0, NULL, 0);
384 PERROR("Failed to send to socket %d\n", sock);
385 chan_trace_header(mISDNport, isdnport, "BCHANNEL control", DIRECTION_OUT);
386 add_trace(trace_name, NULL, "%d", trace_value);
390 static int b_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i);
393 * subfunction for bchannel_event
396 static int _bchannel_create(struct mISDNport *mISDNport, int i)
399 struct sockaddr_mISDN addr;
401 if (mISDNport->b_sock[i].inuse) {
402 PERROR("Error: Socket already created for index %d\n", i);
407 //#warning testing without DSP
408 // 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);
409 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);
410 if (mISDNport->b_sock[i].fd < 0) {
411 PERROR("Error: Failed to open bchannel-socket for index %d with mISDN-DSP layer. Did you load mISDN_dsp.ko?\n", i);
415 /* register callback for read */
416 register_fd(&mISDNport->b_sock[i], LCR_FD_READ, b_sock_callback, mISDNport, i);
418 /* bind socket to bchannel */
419 addr.family = AF_ISDN;
420 addr.dev = mISDNport->portnum;
421 addr.channel = i+1+(i>=15);
422 ret = bind(mISDNport->b_sock[i].fd, (struct sockaddr *)&addr, sizeof(addr));
424 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);
425 close(mISDNport->b_sock[i].fd);
426 unregister_fd(&mISDNport->b_sock[i]);
430 chan_trace_header(mISDNport, mISDNport->b_port[i], "BCHANNEL create socket", DIRECTION_OUT);
431 add_trace("channel", NULL, "%d", i+1+(i>=15));
432 add_trace("socket", NULL, "%d", mISDNport->b_sock[i].fd);
440 * subfunction for bchannel_event
441 * activate / deactivate request
443 static void _bchannel_activate(struct mISDNport *mISDNport, int i, int activate, int timeout)
445 struct mISDNhead act;
448 if (!mISDNport->b_sock[i].inuse)
450 act.prim = (activate)?PH_ACTIVATE_REQ:PH_DEACTIVATE_REQ;
452 ret = sendto(mISDNport->b_sock[i].fd, &act, MISDN_HEADER_LEN, 0, NULL, 0);
454 PERROR("Failed to send to socket %d\n", mISDNport->b_sock[i].fd);
457 chan_trace_header(mISDNport, mISDNport->b_port[i], activate ? "BCHANNEL activate" : "BCHANNEL deactivate", DIRECTION_OUT);
458 add_trace("channel", NULL, "%d", i+1+(i>=15));
460 add_trace("event", NULL, "timeout recovery");
466 * subfunction for bchannel_event
469 static void _bchannel_configure(struct mISDNport *mISDNport, int i)
474 if (!mISDNport->b_sock[i].inuse)
476 handle = mISDNport->b_sock[i].fd;
477 port = mISDNport->b_port[i];
478 mode = mISDNport->b_mode[i];
480 PERROR("bchannel index i=%d not associated with a port object\n", i);
484 /* set dsp features */
485 if (port->p_m_txdata)
486 ph_control(mISDNport, port, handle, (port->p_m_txdata)?DSP_TXDATA_ON:DSP_TXDATA_OFF, 0, "DSP-TXDATA", port->p_m_txdata);
487 if (port->p_m_delay && mode == B_MODE_TRANSPARENT)
488 ph_control(mISDNport, port, handle, DSP_DELAY, port->p_m_delay, "DSP-DELAY", port->p_m_delay);
489 if (port->p_m_tx_dejitter && mode == B_MODE_TRANSPARENT)
490 ph_control(mISDNport, port, handle, DSP_TX_DEJITTER, port->p_m_tx_dejitter, "DSP-TX_DEJITTER", port->p_m_tx_dejitter);
491 if (port->p_m_tx_gain && mode == B_MODE_TRANSPARENT)
492 ph_control(mISDNport, port, handle, DSP_VOL_CHANGE_TX, port->p_m_tx_gain, "DSP-TX_GAIN", port->p_m_tx_gain);
493 if (port->p_m_rx_gain && mode == B_MODE_TRANSPARENT)
494 ph_control(mISDNport, port, handle, DSP_VOL_CHANGE_RX, port->p_m_rx_gain, "DSP-RX_GAIN", port->p_m_rx_gain);
495 if (port->p_m_pipeline[0] && mode == B_MODE_TRANSPARENT)
496 ph_control_block(mISDNport, port, handle, DSP_PIPELINE_CFG, port->p_m_pipeline, strlen(port->p_m_pipeline)+1, "DSP-PIPELINE", 0);
497 if (port->p_m_conf && !port->p_m_mute)
498 ph_control(mISDNport, port, handle, DSP_CONF_JOIN, port->p_m_conf, "DSP-CONF", port->p_m_conf);
500 ph_control(mISDNport, port, handle, DSP_ECHO_ON, 0, "DSP-ECHO", 1);
501 if (port->p_m_tone && mode == B_MODE_TRANSPARENT)
502 ph_control(mISDNport, port, handle, DSP_TONE_PATT_ON, port->p_m_tone, "DSP-TONE", port->p_m_tone);
504 ph_control(mISDNport, port, handle, DSP_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
505 // if (port->p_m_txmix && mode == B_MODE_TRANSPARENT)
506 // ph_control(mISDNport, port, handle, DSP_MIX_ON, 0, "DSP-MIX", 1);
507 if (port->p_m_dtmf && mode == B_MODE_TRANSPARENT)
508 ph_control(mISDNport, port, handle, DTMF_TONE_START, 0, "DSP-DTMF", 1);
509 if (port->p_m_crypt && mode == B_MODE_TRANSPARENT)
510 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);
514 void PmISDN::set_conf(int oldconf, int newconf)
516 if (oldconf != newconf) {
517 PDEBUG(DEBUG_BCHANNEL, "we change conference from conf=%d to conf=%d.\n", oldconf, newconf);
518 if (p_m_b_index > -1)
519 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
520 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);
522 PDEBUG(DEBUG_BCHANNEL, "we already have conf=%d.\n", newconf);
527 * subfunction for bchannel_event
530 static void _bchannel_destroy(struct mISDNport *mISDNport, int i)
532 if (!mISDNport->b_sock[i].inuse)
534 chan_trace_header(mISDNport, mISDNport->b_port[i], "BCHANNEL remove socket", DIRECTION_OUT);
535 add_trace("channel", NULL, "%d", i+1+(i>=15));
536 add_trace("socket", NULL, "%d", mISDNport->b_sock[i].fd);
538 close(mISDNport->b_sock[i].fd);
539 unregister_fd(&mISDNport->b_sock[i]);
547 A bchannel goes through the following states in this order:
550 No one is using the bchannel.
551 It is available and not linked to Port class, nor reserved.
554 The bchannel stack is created and an activation request is sent.
555 It MAY be linked to Port class, but already unlinked due to Port class removal.
558 The bchannel is active and cofigured to the Port class needs.
559 Also it is linked to a Port class, otherwhise it would be deactivated.
561 - B_STATE_DEACTIVATING
562 The bchannel is in deactivating state, due to deactivation request.
563 It may be linked to a Port class, that likes to reactivate it.
567 After deactivating bchannel, and if not used, the bchannel becomes idle again.
569 A bchannel can have the following events:
572 A bchannel is required by a Port class.
575 The bchannel beomes active.
578 The bchannel is not required by Port class anymore
580 - B_EVENT_DEACTIVATED
581 The bchannel becomes inactive.
583 All actions taken on these events depend on the current bchannel's state and if it is linked to a Port class.
588 * process bchannel events
589 * - mISDNport is a pointer to the port's structure
590 * - i is the index of the bchannel
591 * - event is the B_EVENT_* value
592 * - port is the PmISDN class pointer
594 void bchannel_event(struct mISDNport *mISDNport, int i, int event)
596 class PmISDN *b_port = mISDNport->b_port[i];
597 int state = mISDNport->b_state[i];
598 int timer = -1; // no change
601 char *p_m_pipeline = NULL;
602 unsigned char *p_m_crypt_key = NULL;
603 int p_m_crypt_key_len = 0;
604 int p_m_crypt_key_type = 0;
607 p_m_tx_gain = b_port->p_m_tx_gain;
608 p_m_rx_gain = b_port->p_m_rx_gain;
609 p_m_pipeline = b_port->p_m_pipeline;
610 p_m_crypt_key = b_port->p_m_crypt_key;
611 p_m_crypt_key_len = b_port->p_m_crypt_key_len;
612 p_m_crypt_key_type = /*b_port->p_m_crypt_key_type*/1;
617 /* port must be linked in order to allow activation */
619 FATAL("bchannel must be linked to a Port class\n");
622 /* create stack and send activation request */
623 if (_bchannel_create(mISDNport, i)) {
624 _bchannel_activate(mISDNport, i, 1, 0);
625 state = B_STATE_ACTIVATING;
626 timer = B_TIMER_ACTIVATING;
630 case B_STATE_ACTIVATING:
631 /* do nothing, because it is already activating */
635 /* problems that might ocurr:
636 * B_EVENT_USE is received when channel already in use.
638 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
643 case B_EVENT_ACTIVATED:
646 case B_STATE_ACTIVATING:
648 /* bchannel is active and used by Port class, so we configure bchannel */
649 _bchannel_configure(mISDNport, i);
650 state = B_STATE_ACTIVE;
651 b_port->p_m_load = 0;
653 /* bchannel is active, but not used anymore (or has wrong stack config), so we deactivate */
654 _bchannel_activate(mISDNport, i, 0, 0);
655 state = B_STATE_DEACTIVATING;
656 timer = B_TIMER_DEACTIVATING;
661 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
667 FATAL("bchannel must be linked to a Port class\n");
670 /* bchannel is idle due to an error, so we do nothing */
673 case B_STATE_ACTIVATING:
674 /* do nothing because we must wait until bchanenl is active before deactivating */
678 /* bchannel is active, so we deactivate */
679 _bchannel_activate(mISDNport, i, 0, 0);
680 state = B_STATE_DEACTIVATING;
681 timer = B_TIMER_DEACTIVATING;
684 case B_STATE_DEACTIVATING:
685 /* we may have taken an already deactivating bchannel, but do not require it anymore, so we do nothing */
689 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
693 case B_EVENT_DEACTIVATED:
697 /* ignore due to deactivation confirm after unloading */
700 case B_STATE_DEACTIVATING:
701 _bchannel_destroy(mISDNport, i);
702 state = B_STATE_IDLE;
704 /* bchannel is now deactivate, but is requied by Port class, so we reactivate */
705 if (_bchannel_create(mISDNport, i)) {
706 _bchannel_activate(mISDNport, i, 1, 0);
707 state = B_STATE_ACTIVATING;
708 timer = B_TIMER_ACTIVATING;
714 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
718 case B_EVENT_TIMEOUT:
722 /* ignore due to deactivation confirm after unloading */
725 case B_STATE_ACTIVATING:
726 _bchannel_activate(mISDNport, i, 1, 1);
727 timer = B_TIMER_ACTIVATING;
730 case B_STATE_DEACTIVATING:
731 _bchannel_activate(mISDNport, i, 0, 1);
732 timer = B_TIMER_DEACTIVATING;
736 PERROR("Illegal event %d at state %d, please correct.\n", event, state);
741 PERROR("Illegal event %d, please correct.\n", event);
744 mISDNport->b_state[i] = state;
746 unsched_timer(&mISDNport->b_timer[i]);
748 schedule_timer(&mISDNport->b_timer[i], timer, 0);
755 * check for available channel and reserve+set it.
756 * give channel number or SEL_CHANNEL_ANY or SEL_CHANNEL_NO
758 * returns -(cause value) or x = channel x or 0 = no channel
759 * NOTE: no activation is done here
761 int PmISDN::seize_bchannel(int channel, int exclusive)
765 /* the channel is what we have */
766 if (p_m_b_channel == channel)
769 /* if channel already in use, release it */
774 if (channel==CHANNEL_NO || channel==0)
777 /* is channel in range ? */
779 || (channel>p_m_mISDNport->b_num && channel<16)
780 || ((channel-1)>p_m_mISDNport->b_num && channel>16)) /* channel-1 because channel 16 is not counted */
781 return(-6); /* channel unacceptable */
783 /* request exclusive channel */
784 if (exclusive && channel>0) {
785 i = channel-1-(channel>16);
786 if (p_m_mISDNport->b_port[i])
787 return(-44); /* requested channel not available */
791 /* ask for channel */
793 i = channel-1-(channel>16);
794 if (p_m_mISDNport->b_port[i] == NULL)
798 /* search for channel */
800 while(i < p_m_mISDNport->b_num) {
801 if (!p_m_mISDNport->b_port[i]) {
802 channel = i+1+(i>=15);
807 return(-34); /* no free channel */
810 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) seizing bchannel %d (index %d)\n", p_name, channel, i);
812 /* link Port, set parameters */
813 p_m_mISDNport->b_port[i] = this;
815 p_m_b_channel = channel;
816 p_m_b_exclusive = exclusive;
817 p_m_mISDNport->b_mode[i] = p_m_b_mode;
819 /* reserve channel */
820 if (!p_m_b_reserve) {
822 p_m_mISDNport->b_reserved++;
829 * drop reserved channel and unset it.
830 * deactivation is also done
832 void PmISDN::drop_bchannel(void)
834 /* unreserve channel */
836 p_m_mISDNport->b_reserved--;
845 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) dropping bchannel\n", p_name);
847 if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_IDLE)
848 bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_DROP);
849 p_m_mISDNport->b_port[p_m_b_index] = NULL;
850 p_m_mISDNport->b_mode[p_m_b_index] = 0;
860 audio transmission procedure:
861 -----------------------------
864 three sources of audio transmission:
865 - crypto-data high priority
866 - tones high priority (also high)
867 - remote-data low priority
870 a variable that temporarily shows the number of samples elapsed since last transmission process.
871 p_m_last_tv_* is used to store that last timestamp. this is used to calculate the time elapsed.
874 a variable that is increased whenever data is transmitted.
875 it is decreased while time elapses. it stores the number of samples that
876 are currently loaded to dsp module.
877 since clock in dsp module is the same clock for user space process, these
881 there are two levels:
882 ISDN_LOAD will give the load that have to be kept in dsp.
883 ISDN_MAXLOAD will give the maximum load before dropping.
885 * procedure for low priority data
886 see txfromup() for procedure
887 in short: remote data is ignored during high priority tones
889 * procedure for high priority data
890 whenever load is below ISDN_LOAD, load is filled up to ISDN_LOAD
891 if no more data is available, load becomes empty again.
894 0 ISDN_LOAD ISDN_MAXLOAD
895 +--------------------+----------------------+
897 +--------------------+----------------------+
899 on empty load or on load below ISDN_LOAD, the load is inceased to ISDN_LOAD:
900 0 ISDN_LOAD ISDN_MAXLOAD
901 +--------------------+----------------------+
902 |TTTTTTTTTTTTTTTTTTTT| |
903 +--------------------+----------------------+
905 on empty load, remote-audio causes the load with the remote audio to be increased to ISDN_LOAD.
906 0 ISDN_LOAD ISDN_MAXLOAD
907 +--------------------+----------------------+
908 |TTTTTTTTTTTTTTTTTTTTRRRRR |
909 +--------------------+----------------------+
912 void PmISDN::update_load(void)
914 /* don't trigger load event if: */
915 if (!p_tone_name[0] && !p_m_crypt_msg_loops && !p_m_inband_send_on)
918 /* don't trigger load event if event already active */
919 if (p_m_loadtimer.active)
922 schedule_timer(&p_m_loadtimer, 0, 0); /* no delay the first time */
925 int load_timer(struct lcr_timer *timer, void *instance, int index)
927 class PmISDN *isdnport = (class PmISDN *)instance;
934 void PmISDN::load_tx(void)
938 struct timeval current_time;
941 gettimeofday(¤t_time, NULL);
942 if (p_m_last_tv_sec) {
943 elapsed = 8000 * (current_time.tv_sec - p_m_last_tv_sec)
944 + 8 * (current_time.tv_usec/1000 - p_m_last_tv_msec);
946 /* set clock of last process! */
947 p_m_last_tv_sec = current_time.tv_sec;
948 p_m_last_tv_msec = current_time.tv_usec/1000;
950 /* process only if we have samples and we are active */
951 if (elapsed && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE) {
953 if (elapsed < p_m_load)
958 /* to send data, tone must be on */
959 if ((p_tone_name[0] || p_m_crypt_msg_loops || p_m_inband_send_on) /* what tones? */
960 && (p_m_load < ISDN_LOAD) /* not too much load? */
961 && (p_state==PORT_STATE_CONNECT || p_m_mISDNport->tones || p_m_inband_send_on)) { /* connected or inband-tones? */
962 int tosend = ISDN_LOAD - p_m_load, length;
963 unsigned char buf[MISDN_HEADER_LEN+tosend];
964 struct mISDNhead *frm = (struct mISDNhead *)buf;
965 unsigned char *p = buf+MISDN_HEADER_LEN;
967 /* copy inband signalling (e.g. used by ss5) */
968 if (p_m_inband_send_on && tosend) {
969 tosend -= inband_send(p, tosend);
972 /* copy crypto loops */
973 while (p_m_crypt_msg_loops && tosend) {
974 /* how much do we have to send */
975 length = p_m_crypt_msg_len - p_m_crypt_msg_current;
981 /* copy message (part) to buffer */
982 memcpy(p, p_m_crypt_msg+p_m_crypt_msg_current, length);
985 p_m_crypt_msg_current += length;
986 if (p_m_crypt_msg_current == p_m_crypt_msg_len) {
988 p_m_crypt_msg_current = 0;
989 p_m_crypt_msg_loops--;
990 if (!p_m_crypt_msg_loops)
992 // puts("eine loop weniger");
1000 if (p_tone_name[0] && tosend) {
1001 tosend -= read_audio(p, tosend);
1005 if (ISDN_LOAD - p_m_load - tosend > 0) {
1006 frm->prim = PH_DATA_REQ;
1008 ret = sendto(p_m_mISDNport->b_sock[p_m_b_index].fd, buf, MISDN_HEADER_LEN+ISDN_LOAD-p_m_load-tosend, 0, NULL, 0);
1010 PERROR("Failed to send to socket %d (samples = %d)\n", p_m_mISDNport->b_sock[p_m_b_index].fd, ISDN_LOAD-p_m_load-tosend);
1011 p_m_load += ISDN_LOAD - p_m_load - tosend;
1016 if (p_tone_name[0] || p_m_crypt_msg_loops || p_m_inband_send_on || p_m_load) {
1017 schedule_timer(&p_m_loadtimer, 0, PORT_TRANSMIT * 125);
1021 /* handle timeouts */
1022 static int mISDN_timeout(struct lcr_timer *timer, void *instance, int i)
1024 class PmISDN *isdnport = (class PmISDN *)instance;
1025 struct lcr_msg *message;
1027 PDEBUG(DEBUG_ISDN, "(%s) timeout after %d seconds detected (state=%d).\n", isdnport->p_name, isdnport->p_m_timeout.timeout.tv_sec, isdnport->p_state);
1028 /* send timeout to endpoint */
1029 message = message_create(isdnport->p_serial, ACTIVE_EPOINT(isdnport->p_epointlist), PORT_TO_EPOINT, MESSAGE_TIMEOUT);
1030 message->param.state = isdnport->p_state;
1031 message_put(message);
1038 * whenever we get audio data from bchannel, we process it here
1040 void PmISDN::bchannel_receive(struct mISDNhead *hh, unsigned char *data, int len)
1042 unsigned int cont = *((unsigned int *)data);
1043 struct lcr_msg *message;
1047 if (hh->prim == PH_CONTROL_IND) {
1049 PERROR("SHORT READ OF PH_CONTROL INDICATION\n");
1052 if ((cont&(~DTMF_TONE_MASK)) == DTMF_TONE_VAL) {
1053 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1054 add_trace("DTMF", NULL, "%c", cont & DTMF_TONE_MASK);
1056 add_trace("info", NULL, "DTMF is disabled");
1060 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_DTMF);
1061 message->param.dtmf = cont & DTMF_TONE_MASK;
1062 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION DTMF digit '%c'\n", p_name, message->param.dtmf);
1063 message_put(message);
1068 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1069 add_trace("DSP-CRYPT", NULL, "error");
1071 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1072 message->param.crypt.type = CC_ERROR_IND;
1073 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION reject of blowfish.\n", p_name);
1074 message_put(message);
1078 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1079 add_trace("DSP-CRYPT", NULL, "ok");
1081 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1082 message->param.crypt.type = CC_ACTBF_CONF;
1083 PDEBUG(DEBUG_PORT, "PmISDN(%s) PH_CONTROL INDICATION accept of blowfish.\n", p_name);
1084 message_put(message);
1088 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1089 add_trace("unknown", NULL, "0x%x", cont);
1094 if (hh->prim == PH_CONTROL_IND) {
1097 chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
1098 add_trace("unknown", NULL, "0x%x", hh->id);
1103 if (hh->prim == PH_DATA_REQ || hh->prim == DL_DATA_REQ) {
1105 /* if tx is off, it may happen that fifos send us pending informations, we just ignore them */
1106 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring tx data, because 'txdata' is turned off\n", p_name);
1109 /* see below (same condition) */
1110 if (p_state!=PORT_STATE_CONNECT
1111 && !p_m_mISDNport->tones)
1113 // printf(".");fflush(stdout);return;
1115 record(data, len, 1); // from up
1118 if (hh->prim != PH_DATA_IND && hh->prim != DL_DATA_IND) {
1119 PERROR("Bchannel received unknown primitve: 0x%x\n", hh->prim);
1123 /* inband is processed */
1124 if (p_m_inband_receive_on)
1125 inband_receive(data, len);
1127 /* send to remote, if bridged */
1128 bridge_tx(data, len);
1130 /* calls will not process any audio data unless
1131 * the call is connected OR tones feature is enabled.
1133 #ifndef DEBUG_COREBRIDGE
1134 if (p_state!=PORT_STATE_CONNECT
1135 && !p_m_mISDNport->tones)
1140 /* the bearer capability must be audio in order to send and receive
1141 * audio prior or after connect.
1143 if (!(p_bearerinfo.capability&CLASS_CAPABILITY_AUDIO) && p_state!=PORT_STATE_CONNECT)
1147 /* if rx is off, it may happen that fifos send us pending informations, we just ignore them */
1149 PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring data, because rx is turned off\n", p_name);
1155 record(data, len, 0); // from down
1157 /* randomize and listen to crypt message if enabled */
1158 if (p_m_crypt_listen) {
1159 /* the noisy randomizer */
1163 mISDN_rand[mISDN_rand_count & 0xff] += *p++;
1165 cryptman_listen_bch(data, len);
1173 void PmISDN::set_echotest(int echo)
1175 if (p_m_echo != echo) {
1177 PDEBUG(DEBUG_ISDN, "we set echo to echo=%d.\n", p_m_echo);
1179 if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1180 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);
1187 void PmISDN::set_tone(const char *dir, const char *tone)
1192 /* if no directory is given (by extension), we use interface.conf or options.conf */
1193 if (!dir || !dir[0]) {
1194 if (p_m_mISDNport->ifport->tones_dir[0])
1195 dir = p_m_mISDNport->ifport->tones_dir;
1196 else if (options.tones_dir[0])
1197 dir = options.tones_dir;
1202 PDEBUG(DEBUG_ISDN, "isdn port now plays tone:'%s'.\n", tone);
1208 /* check for dsp tones */
1209 if (!strcmp(dir, "american"))
1211 if (!strcmp(dir, "german"))
1213 if (!strcmp(dir, "oldgerman"))
1214 dsp = DSP_OLDGERMAN;
1216 /* check if we NOT really have to use a dsp-tone */
1217 if (dsp == DSP_NONE) {
1220 if (p_m_b_index > -1)
1221 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) {
1222 PDEBUG(DEBUG_ISDN, "we reset tone from id=%d to OFF.\n", p_m_tone);
1223 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TONE_PATT_OFF, 0, "DSP-TONE", 0);
1226 Port::set_tone(dir, tone);
1230 /* now we USE dsp-tone, convert name */
1231 if (!strcmp(tone, "dialtone")) {
1233 case DSP_AMERICAN: id = TONE_AMERICAN_DIALTONE; break;
1234 case DSP_GERMAN: id = TONE_GERMAN_DIALTONE; break;
1235 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALTONE; break;
1237 } else if (!strcmp(tone, "dialpbx")) {
1239 case DSP_AMERICAN: id = TONE_AMERICAN_DIALPBX; break;
1240 case DSP_GERMAN: id = TONE_GERMAN_DIALPBX; break;
1241 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALPBX; break;
1243 } else if (!strcmp(tone, "ringing")) {
1245 case DSP_AMERICAN: id = TONE_AMERICAN_RINGING; break;
1246 case DSP_GERMAN: id = TONE_GERMAN_RINGING; break;
1247 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGING; break;
1249 } else if (!strcmp(tone, "ringpbx")) {
1251 case DSP_AMERICAN: id = TONE_AMERICAN_RINGPBX; break;
1252 case DSP_GERMAN: id = TONE_GERMAN_RINGPBX; break;
1253 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGPBX; break;
1255 } else if (!strcmp(tone, "busy")) {
1258 case DSP_AMERICAN: id = TONE_AMERICAN_BUSY; break;
1259 case DSP_GERMAN: id = TONE_GERMAN_BUSY; break;
1260 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1262 } else if (!strcmp(tone, "release")) {
1265 case DSP_AMERICAN: id = TONE_AMERICAN_HANGUP; break;
1266 case DSP_GERMAN: id = TONE_GERMAN_HANGUP; break;
1267 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDHANGUP; break;
1269 } else if (!strcmp(tone, "cause_10"))
1271 else if (!strcmp(tone, "cause_11"))
1273 else if (!strcmp(tone, "cause_22")) {
1275 case DSP_AMERICAN: id = TONE_SPECIAL_INFO; break;
1276 case DSP_GERMAN: id = TONE_GERMAN_GASSENBESETZT; break;
1277 case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
1279 } else if (!strncmp(tone, "cause_", 6))
1280 id = TONE_SPECIAL_INFO;
1284 /* if we have a tone that is not supported by dsp */
1285 if (id==TONE_OFF && tone[0])
1289 if (p_m_tone != id) {
1292 PDEBUG(DEBUG_ISDN, "we set tone to id=%d.\n", p_m_tone);
1293 if (p_m_b_index > -1)
1294 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)
1295 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);
1297 /* turn user-space tones off in cases of no tone OR dsp tone */
1298 Port::set_tone("",NULL);
1302 /* MESSAGE_mISDNSIGNAL */
1303 //extern struct lcr_msg *dddebug;
1304 void PmISDN::message_mISDNsignal(unsigned int epoint_id, int message_id, union parameter *param)
1306 int oldconf, newconf;
1307 switch(param->mISDNsignal.message) {
1308 case mISDNSIGNAL_VOLUME:
1309 if (p_m_tx_gain != param->mISDNsignal.tx_gain) {
1310 p_m_tx_gain = param->mISDNsignal.tx_gain;
1311 PDEBUG(DEBUG_BCHANNEL, "we change tx-volume to shift=%d.\n", p_m_tx_gain);
1312 if (p_m_b_index > -1)
1313 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)
1314 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);
1316 PDEBUG(DEBUG_BCHANNEL, "we already have tx-volume shift=%d.\n", p_m_rx_gain);
1317 if (p_m_rx_gain != param->mISDNsignal.rx_gain) {
1318 p_m_rx_gain = param->mISDNsignal.rx_gain;
1319 PDEBUG(DEBUG_BCHANNEL, "we change rx-volume to shift=%d.\n", p_m_rx_gain);
1320 if (p_m_b_index > -1)
1321 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)
1322 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);
1324 PDEBUG(DEBUG_BCHANNEL, "we already have rx-volume shift=%d.\n", p_m_rx_gain);
1327 case mISDNSIGNAL_CONF:
1328 oldconf = p_m_mute?0:p_m_conf;
1329 p_m_conf = param->mISDNsignal.conf;
1330 newconf = p_m_mute?0:p_m_conf;
1331 set_conf(oldconf, newconf);
1334 case mISDNSIGNAL_DELAY:
1335 if (p_m_delay != param->mISDNsignal.delay) {
1336 p_m_delay = param->mISDNsignal.delay;
1337 PDEBUG(DEBUG_BCHANNEL, "we change delay mode to delay=%d.\n", p_m_delay);
1338 if (p_m_b_index > -1)
1339 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)
1340 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);
1342 PDEBUG(DEBUG_BCHANNEL, "we already have delay=%d.\n", p_m_delay);
1346 PERROR("PmISDN(%s) unsupported signal message %d.\n", p_name, param->mISDNsignal.message);
1351 void PmISDN::message_crypt(unsigned int epoint_id, int message_id, union parameter *param)
1353 struct lcr_msg *message;
1355 switch(param->crypt.type) {
1356 case CC_ACTBF_REQ: /* activate blowfish */
1358 p_m_crypt_key_len = param->crypt.len;
1359 if (p_m_crypt_key_len > (int)sizeof(p_m_crypt_key)) {
1360 PERROR("PmISDN(%s) key too long %d > %d\n", p_name, p_m_crypt_key_len, sizeof(p_m_crypt_key));
1361 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
1362 message->param.crypt.type = CC_ERROR_IND;
1363 message_put(message);
1366 memcpy(p_m_crypt_key, param->crypt.data, p_m_crypt_key_len);
1368 PDEBUG(DEBUG_BCHANNEL, "we set encryption to crypt=%d. (0 means OFF)\n", p_m_crypt);
1369 if (p_m_b_index > -1)
1370 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)
1371 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);
1374 case CC_DACT_REQ: /* deactivate session encryption */
1379 case CR_LISTEN_REQ: /* start listening to messages */
1380 p_m_crypt_listen = 1;
1382 p_m_crypt_listen_state = 0;
1385 case CR_UNLISTEN_REQ: /* stop listening to messages */
1386 p_m_crypt_listen = 0;
1390 case CR_MESSAGE_REQ: /* send message */
1391 p_m_crypt_msg_len = cryptman_encode_bch(param->crypt.data, param->crypt.len, p_m_crypt_msg, sizeof(p_m_crypt_msg));
1392 if (!p_m_crypt_msg_len) {
1393 PERROR("PmISDN(%s) message too long %d > %d\n", p_name, param->crypt.len-1, sizeof(p_m_crypt_msg));
1396 p_m_crypt_msg_current = 0; /* reset */
1397 p_m_crypt_msg_loops = 6; /* enable */
1401 /* disable txmix, or we get corrupt data due to audio process */
1402 if (p_m_txmix && p_m_b_index>=0 && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT) {
1403 PDEBUG(DEBUG_BCHANNEL, "for sending CR_MESSAGE_REQ, we reset txmix from txmix=%d.\n", p_m_txmix);
1404 ph_control(p_m_mISDNport, this, p_mISDNport->b_sock[p_m_b_index].fd, DSP_MIX_OFF, 0, "DSP-TXMIX", 0);
1410 PERROR("PmISDN(%s) unknown crypt message %d\n", p_name, param->crypt.type);
1416 * endpoint sends messages to the port
1418 int PmISDN::message_epoint(unsigned int epoint_id, int message_id, union parameter *param)
1420 if (Port::message_epoint(epoint_id, message_id, param)) {
1421 if (message_id == MESSAGE_BRIDGE)
1426 switch(message_id) {
1427 case MESSAGE_mISDNSIGNAL: /* user command */
1428 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received special ISDN SIGNAL %d.\n", p_name, param->mISDNsignal.message);
1429 message_mISDNsignal(epoint_id, message_id, param);
1432 case MESSAGE_CRYPT: /* crypt control command */
1433 PDEBUG(DEBUG_ISDN, "PmISDN(%s) received encryption command '%d'.\n", p_name, param->crypt.type);
1434 message_crypt(epoint_id, message_id, param);
1441 void PmISDN::update_rxoff(void)
1443 int tx_dejitter = 0;
1445 /* call bridges in user space OR crypto OR recording */
1446 if (p_bridge || p_m_crypt_msg_loops || p_m_crypt_listen || p_record || p_m_inband_receive_on) {
1447 /* rx IS required */
1451 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is required, so we turn them on\n", __FUNCTION__);
1452 if (p_m_b_index > -1)
1453 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1454 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_RECEIVE_ON, 0, "DSP-RXOFF", 0);
1457 /* rx NOT required */
1461 PDEBUG(DEBUG_BCHANNEL, "%s: receive data is not required, so we turn them off\n", __FUNCTION__);
1462 if (p_m_b_index > -1)
1463 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1464 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_RECEIVE_OFF, 0, "DSP-RXOFF", 1);
1469 /* txdata IS required */
1473 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is required, so we turn them on\n", __FUNCTION__);
1474 if (p_m_b_index > -1)
1475 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1476 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TXDATA_ON, 0, "DSP-TXDATA", 1);
1479 /* txdata NOT required */
1483 PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is not required, so we turn them off\n", __FUNCTION__);
1484 if (p_m_b_index > -1)
1485 if (p_m_mISDNport->b_port[p_m_b_index] && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
1486 ph_control(p_m_mISDNport, this, p_m_mISDNport->b_sock[p_m_b_index].fd, DSP_TXDATA_OFF, 0, "DSP-TXDATA", 0);
1489 /* dejitter on bridge */
1492 if (p_m_tx_dejitter != tx_dejitter) {
1493 p_m_tx_dejitter = tx_dejitter;
1494 PDEBUG(DEBUG_BCHANNEL, "we change dejitter mode to delay=%d.\n", p_m_tx_dejitter);
1495 if (p_m_b_index > -1)
1496 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)
1497 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);
1501 static int mISDN_upqueue(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1503 struct mISDNport *mISDNport;
1509 /* unset global semaphore */
1511 // with a very small incident, upqueue_avail may be set by mISDN thread and
1512 // another byte may be sent to the pipe, which causes a call to this function
1513 // again with nothing in the upqueue. this is no problem.
1514 ret = read(fd->fd, &byte, 1);
1516 /* process all ports */
1517 mISDNport = mISDNport_first;
1519 /* handle queued up-messages (d-channel) */
1520 while ((mb = mdequeue(&mISDNport->upqueue))) {
1523 case MPH_ACTIVATE_IND:
1524 if (mISDNport->l1link != 1) {
1525 l1l2l3_trace_header(mISDNport, NULL, L1_ACTIVATE_IND, DIRECTION_IN);
1527 mISDNport->l1link = 1;
1531 case MPH_DEACTIVATE_IND:
1532 if (mISDNport->l1link != 0) {
1533 l1l2l3_trace_header(mISDNport, NULL, L1_DEACTIVATE_IND, DIRECTION_IN);
1535 mISDNport->l1link = 0;
1539 case MPH_INFORMATION_IND:
1540 PDEBUG(DEBUG_ISDN, "Received MPH_INFORMATION_IND for port %d (%s).\n", mISDNport->portnum, mISDNport->ifport->interface->name);
1542 case L1_SIGNAL_LOS_ON:
1545 case L1_SIGNAL_LOS_OFF:
1548 case L1_SIGNAL_AIS_ON:
1551 case L1_SIGNAL_AIS_OFF:
1554 case L1_SIGNAL_RDI_ON:
1557 case L1_SIGNAL_RDI_OFF:
1560 case L1_SIGNAL_SLIP_TX:
1561 mISDNport->slip_tx++;
1563 case L1_SIGNAL_SLIP_RX:
1564 mISDNport->slip_rx++;
1569 case MT_L2ESTABLISH:
1570 l1l2l3_trace_header(mISDNport, NULL, L2_ESTABLISH_IND, DIRECTION_IN);
1571 add_trace("tei", NULL, "%d", l3m->pid);
1573 mISDNport->l2link = 1;
1575 mISDNport->l2mask[l3m->pid >> 3] |= (1 << (l3m->pid & 7));
1576 if ((!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127) {
1577 if (mISDNport->l2establish.active) {
1578 unsched_timer(&mISDNport->l2establish);
1579 PDEBUG(DEBUG_ISDN, "the link became active before l2establish timer expiry.\n");
1586 mISDNport->l2mask[l3m->pid >> 3] &= ~(1 << (l3m->pid & 7));
1587 if (!mISDNport->l2establish.active) {
1588 l1l2l3_trace_header(mISDNport, NULL, L2_RELEASE_IND, DIRECTION_IN);
1589 add_trace("tei", NULL, "%d", l3m->pid);
1591 /* down if not nt-ptmp */
1592 if (!mISDNport->ntmode || mISDNport->ptp)
1593 mISDNport->l2link = 0;
1595 if ((!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127) {
1596 if (!mISDNport->l2establish.active && mISDNport->l2hold) {
1597 PDEBUG(DEBUG_ISDN, "set timer and establish.\n");
1598 schedule_timer(&mISDNport->l2establish, 5, 0);
1599 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
1605 /* l3-data is sent to LCR */
1606 stack2manager(mISDNport, l3m->type, l3m->pid, l3m);
1611 mISDNport = mISDNport->next;
1616 /* l2 establish timer fires */
1617 static int l2establish_timeout(struct lcr_timer *timer, void *instance, int i)
1619 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1621 if (mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode)) {
1622 PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link portnum=%d.\n", mISDNport->portnum);
1623 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
1624 schedule_timer(&mISDNport->l2establish, 5, 0); /* 5 seconds */
1630 /* handle frames from bchannel */
1631 static int b_sock_callback(struct lcr_fd *fd, unsigned int what, void *instance, int i)
1633 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1634 unsigned char buffer[2048+MISDN_HEADER_LEN];
1635 struct mISDNhead *hh = (struct mISDNhead *)buffer;
1638 ret = recv(fd->fd, buffer, sizeof(buffer), 0);
1640 PERROR("read error frame, errno %d\n", errno);
1643 if (ret < (int)MISDN_HEADER_LEN) {
1644 PERROR("read short frame, got %d, expected %d\n", ret, (int)MISDN_HEADER_LEN);
1648 /* we don't care about confirms, we use rx data to sync tx */
1652 /* we receive audio data, we respond to it AND we send tones */
1657 case PH_CONTROL_IND:
1658 if (mISDNport->b_port[i])
1659 mISDNport->b_port[i]->bchannel_receive(hh, buffer+MISDN_HEADER_LEN, ret-MISDN_HEADER_LEN);
1661 PDEBUG(DEBUG_BCHANNEL, "b-channel is not associated to an ISDNPort (socket %d), ignoring.\n", fd->fd);
1664 case PH_ACTIVATE_IND:
1665 case DL_ESTABLISH_IND:
1666 case PH_ACTIVATE_CNF:
1667 case DL_ESTABLISH_CNF:
1668 PDEBUG(DEBUG_BCHANNEL, "DL_ESTABLISH confirm: bchannel is now activated (socket %d).\n", fd->fd);
1669 bchannel_event(mISDNport, i, B_EVENT_ACTIVATED);
1672 case PH_DEACTIVATE_IND:
1673 case DL_RELEASE_IND:
1674 case PH_DEACTIVATE_CNF:
1675 case DL_RELEASE_CNF:
1676 PDEBUG(DEBUG_BCHANNEL, "DL_RELEASE confirm: bchannel is now de-activated (socket %d).\n", fd->fd);
1677 bchannel_event(mISDNport, i, B_EVENT_DEACTIVATED);
1681 PERROR("child message not handled: prim(0x%x) socket(%d) msg->len(%d)\n", hh->prim, fd->fd, ret-MISDN_HEADER_LEN);
1687 /* process timer events for bchannel handling */
1688 static int b_timer_timeout(struct lcr_timer *timer, void *instance, int i)
1690 struct mISDNport *mISDNport = (struct mISDNport *)instance;
1692 bchannel_event(mISDNport, i, B_EVENT_TIMEOUT);
1698 int do_layer3(struct mlayer3 *ml3, unsigned int cmd, unsigned int pid, struct l3_msg *l3m)
1702 * l3m must be queued, except for MT_ASSIGN
1705 struct mISDNport *mISDNport = (struct mISDNport *)ml3->priv;
1708 #ifdef OLD_MT_ASSIGN
1709 /* special MT_ASSIGN handling:
1711 * if we request a PID from mlayer, we always do it while lcr is locked.
1712 * therefore we must check the MT_ASSIGN reply first before we lock.
1713 * this is because the MT_ASSIGN reply is received with the requesting
1714 * process, not by the mlayer thread!
1715 * this means, that the reply is sent during call of the request.
1716 * we must check if we get a reply and we know that we lcr is currently
1719 if (cmd==MT_ASSIGN && (pid&MISDN_PID_CR_FLAG) && (pid>>16)==MISDN_CES_MASTER) {
1720 /* let's do some checking if someone changes stack behaviour */
1721 if (mt_assign_pid != 0)
1722 FATAL("someone played with the mISDNuser stack. MT_ASSIGN not currently expected.\n");
1723 mt_assign_pid = pid;
1727 /* queue message, create, if required */
1729 l3m = alloc_l3_msg();
1731 FATAL("No memory for layer 3 message\n");
1733 mb = container_of(l3m, struct mbuffer, l3);
1736 mqueue_tail(&mISDNport->upqueue, mb);
1737 if (!upqueue_avail) {
1738 // multiple threads may cause multiple calls of this section, but this
1739 // results only in multiple processing of the upqueue read.
1740 // this is no problem.
1744 ret = write(upqueue_pipe[1], &byte, 1);
1749 int mISDN_getportbyname(int sock, int cnt, char *portname)
1751 struct mISDN_devinfo devinfo;
1755 while (port < cnt) {
1757 ret = ioctl(sock, IMGETDEVINFO, &devinfo);
1760 if (!strcasecmp(devinfo.name, portname))
1771 * global function to add a new card (port)
1773 struct mISDNport *mISDNport_open(struct interface_port *ifport)
1776 struct mISDNport *mISDNport, **mISDNportp;
1777 int port = ifport->portnum;
1778 int ptp = ifport->ptp;
1779 int force_nt = ifport->nt;
1780 int l1hold = ifport->l1hold;
1781 int l2hold = ifport->l2hold;
1782 int ss5 = ifport->ss5;
1786 // struct mlayer3 *ml3;
1787 struct mISDN_devinfo devinfo;
1788 unsigned int protocol, prop;
1790 /* check port counts */
1791 ret = ioctl(mISDNsocket, IMGETCOUNT, &cnt);
1793 fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret);
1798 PERROR_RUNTIME("Found no card. Please be sure to load card drivers.\n");
1802 port = mISDN_getportbyname(mISDNsocket, cnt, ifport->portname);
1804 PERROR_RUNTIME("Port name '%s' not found, use 'misdn_info' tool to list all existing ports.\n", ifport->portname);
1807 // note: 'port' has still the port number
1809 if (port>cnt || port<0) {
1810 PERROR_RUNTIME("Port (%d) given at 'ports' (options.conf) is out of existing port range (%d-%d)\n", port, 0, cnt);
1814 /* get port attributes */
1815 pri = bri = pots = nt = te = 0;
1817 ret = ioctl(mISDNsocket, IMGETDEVINFO, &devinfo);
1819 PERROR_RUNTIME("Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", port, ret);
1822 if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0)) {
1826 if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0)) {
1830 if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1)) {
1834 if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1)) {
1839 if (devinfo.Dprotocols & (1 << ISDN_P_FXS)) {
1845 if (devinfo.Dprotocols & (1 << ISDN_P_FXO)) {
1850 if (force_nt && !nt) {
1851 PERROR_RUNTIME("Port %d does not support NT-mode\n", port);
1855 PERROR_RUNTIME("Port %d supports BRI and PRI?? What kind of controller is that?. (Can't use this!)\n", port);
1858 if (pots && !bri && !pri) {
1859 PERROR_RUNTIME("Port %d supports POTS, LCR does not!\n", port);
1863 PERROR_RUNTIME("Port %d does not support BRI nor PRI!\n", port);
1867 PERROR_RUNTIME("Port %d does not support NT-mode nor TE-mode!\n", port);
1870 /* set NT by turning off TE */
1873 /* if TE an NT is supported (and not forced to NT), turn off NT */
1877 /* check for double use of port */
1879 mISDNport = mISDNport_first;
1881 if (mISDNport->portnum == port)
1883 mISDNport = mISDNport->next;
1886 PERROR_RUNTIME("Port %d already in use by LCR. You can't use a NT port multiple times.\n", port);
1891 /* check for continous channelmap with no bchannel on slot 16 */
1892 if (test_channelmap(0, devinfo.channelmap)) {
1893 PERROR_RUNTIME("Port %d provides channel 0, but we cannot access it!\n", port);
1897 while(i < (int)devinfo.nrbchan + 1) {
1899 if (test_channelmap(i, devinfo.channelmap)) {
1900 PERROR("Port %d provides bchannel 16. Pleas upgrade mISDN, if this port is mISDN loopback interface.\n", port);
1904 if (!test_channelmap(i, devinfo.channelmap)) {
1905 PERROR_RUNTIME("Port %d has no channel on slot %d!\n", port, i);
1912 /* add mISDNport structure */
1913 mISDNportp = &mISDNport_first;
1915 mISDNportp = &((*mISDNportp)->next);
1916 mISDNport = (struct mISDNport *)MALLOC(sizeof(struct mISDNport));
1917 add_timer(&mISDNport->l2establish, l2establish_timeout, mISDNport, 0);
1919 /* ss5 link is always active */
1920 mISDNport->l1link = 1;
1921 mISDNport->l2link = 1;
1923 mISDNport->l1link = -1;
1924 mISDNport->l2link = -1;
1927 *mISDNportp = mISDNport;
1929 /* if pri, must set PTP */
1933 /* set ss5 params */
1935 /* try to keep interface enabled */
1955 /* allocate ressources of port */
1956 protocol = (nt)?L3_PROTOCOL_DSS1_NET:L3_PROTOCOL_DSS1_USER;
1957 prop = (1 << MISDN_FLG_L2_CLEAN);
1958 if (ptp) // ptp forced
1959 prop |= (1 << MISDN_FLG_PTP);
1960 if (nt) // supports hold/retrieve on nt-mode
1961 prop |= (1 << MISDN_FLG_NET_HOLD);
1962 if (l1hold) // supports layer 1 hold
1963 prop |= (1 << MISDN_FLG_L1_HOLD);
1964 if (l2hold) // supports layer 2 hold
1965 prop |= (1 << MISDN_FLG_L2_HOLD);
1966 /* open layer 3 and init upqueue */
1967 /* queue must be initializes, because l3-thread may send messages during open_layer3() */
1968 mqueue_init(&mISDNport->upqueue);
1969 mISDNport->ml3 = open_layer3(port, protocol, prop , do_layer3, mISDNport);
1970 if (!mISDNport->ml3) {
1971 mqueue_purge(&mISDNport->upqueue);
1972 PERROR_RUNTIME("open_layer3() failed for port %d\n", port);
1980 "PORT (open failed)");
1982 mISDNport_close(mISDNport);
1986 SCPY(mISDNport->name, devinfo.name);
1987 mISDNport->b_num = devinfo.nrbchan;
1988 mISDNport->portnum = port;
1989 mISDNport->ntmode = nt;
1990 mISDNport->tespecial = ifport->tespecial;
1991 mISDNport->pri = pri;
1992 mISDNport->ptp = ptp;
1993 mISDNport->l1hold = l1hold;
1994 mISDNport->l2hold = l2hold;
1995 mISDNport->ss5 = ss5;
1996 PDEBUG(DEBUG_ISDN, "Port has %d b-channels.\n", mISDNport->b_num);
1998 while(i < mISDNport->b_num) {
1999 mISDNport->b_state[i] = B_STATE_IDLE;
2000 add_timer(&mISDNport->b_timer[i], b_timer_timeout, mISDNport, i);
2004 /* if ptp, pull up the link */
2005 if (mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode)) {
2006 mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
2007 l1l2l3_trace_header(mISDNport, NULL, L2_ESTABLISH_REQ, DIRECTION_OUT);
2008 add_trace("tei", NULL, "%d", 0);
2010 schedule_timer(&mISDNport->l2establish, 5, 0); /* 5 seconds */
2013 /* for nt-mode ptmp the link is always up */
2014 if (mISDNport->ntmode && !mISDNport->ptp)
2015 mISDNport->l2link = 1;
2017 PDEBUG(DEBUG_BCHANNEL, "using 'mISDN_dsp.o' module\n");
2019 start_trace(mISDNport->portnum,
2027 add_trace("mode", NULL, (mISDNport->ntmode)?"network":"terminal");
2028 add_trace("channels", NULL, "%d", mISDNport->b_num);
2030 add_trace("ccitt#5", NULL, "enabled");
2038 * load static port instances, if required by mISDNport
2040 void mISDNport_static(struct mISDNport *mISDNport)
2045 while(i < mISDNport->b_num) {
2048 ss5_create_channel(mISDNport, i);
2056 * function to free ALL cards (ports)
2058 void mISDNport_close_all(void)
2060 /* free all ports */
2061 while(mISDNport_first)
2062 mISDNport_close(mISDNport_first);
2066 * free only one port
2068 void mISDNport_close(struct mISDNport *mISDNport)
2070 struct mISDNport **mISDNportp;
2072 class PmISDN *isdnport;
2075 /* remove all port instance that are linked to this mISDNport */
2079 if ((port->p_type&PORT_CLASS_MASK) == PORT_CLASS_mISDN) {
2080 isdnport = (class PmISDN *)port;
2081 if (isdnport->p_m_mISDNport && isdnport->p_m_mISDNport == mISDNport) {
2082 PDEBUG(DEBUG_ISDN, "port %s uses mISDNport %d, destroying it.\n", isdnport->p_name, mISDNport->portnum);
2090 /* only if we are already part of interface */
2091 if (mISDNport->ifport) {
2092 start_trace(mISDNport->portnum,
2093 mISDNport->ifport->interface,
2103 /* free bchannels */
2105 while(i < mISDNport->b_num) {
2106 if (mISDNport->b_sock[i].inuse) {
2107 _bchannel_destroy(mISDNport, i);
2108 PDEBUG(DEBUG_BCHANNEL, "freeing %s port %d bchannel (index %d).\n", (mISDNport->ntmode)?"NT":"TE", mISDNport->portnum, i);
2110 if (mISDNport->b_timer[i].inuse) {
2111 del_timer(&mISDNport->b_timer[i]);
2115 del_timer(&mISDNport->l2establish);
2117 /* close layer 3, if open */
2118 if (mISDNport->ml3) {
2119 close_layer3(mISDNport->ml3);
2123 mqueue_purge(&mISDNport->upqueue);
2125 /* remove from list */
2126 mISDNportp = &mISDNport_first;
2127 while(*mISDNportp) {
2128 if (*mISDNportp == mISDNport) {
2129 *mISDNportp = (*mISDNportp)->next;
2133 mISDNportp = &((*mISDNportp)->next);
2137 FATAL("mISDNport not in list\n");
2139 FREE(mISDNport, sizeof(struct mISDNport));
2146 * enque data from upper buffer
2148 int PmISDN::bridge_rx(unsigned char *data, int length)
2150 unsigned char buf[MISDN_HEADER_LEN+((length>ISDN_LOAD)?length:ISDN_LOAD)];
2151 struct mISDNhead *hh = (struct mISDNhead *)buf;
2154 if (p_m_b_index < 0)
2156 if (p_m_mISDNport->b_state[p_m_b_index] != B_STATE_ACTIVE)
2159 /* check if high priority tones exist
2160 * ignore data in this case
2162 if (p_tone_name[0] || p_m_crypt_msg_loops || p_m_inband_send_on)
2165 /* preload procedure
2166 * if transmit buffer in DSP module is empty,
2167 * preload it to DSP_LOAD to prevent jitter gaps.
2169 if (p_m_load == 0 && ISDN_LOAD > 0) {
2170 hh->prim = PH_DATA_REQ;
2172 memset(buf+MISDN_HEADER_LEN, (options.law=='a')?0x2a:0xff, ISDN_LOAD);
2173 ret = sendto(p_m_mISDNport->b_sock[p_m_b_index].fd, buf, MISDN_HEADER_LEN+ISDN_LOAD, 0, NULL, 0);
2175 PERROR("Failed to send to socket %d\n", p_m_mISDNport->b_sock[p_m_b_index].fd);
2176 p_m_load += ISDN_LOAD;
2177 schedule_timer(&p_m_loadtimer, 0, PORT_TRANSMIT * 125);
2180 /* drop if load would exceed ISDN_MAXLOAD
2181 * this keeps the delay not too high
2183 if (p_m_load+length > ISDN_MAXLOAD)
2186 /* make and send frame */
2187 hh->prim = PH_DATA_REQ;
2189 memcpy(buf+MISDN_HEADER_LEN, data, length);
2190 ret = sendto(p_m_mISDNport->b_sock[p_m_b_index].fd, buf, MISDN_HEADER_LEN+length, 0, NULL, 0);
2192 PERROR("Failed to send to socket %d\n", p_m_mISDNport->b_sock[p_m_b_index].fd);
2198 int PmISDN::inband_send(unsigned char *buffer, int len)
2200 PERROR("this function must be derived to function!\n");
2204 void PmISDN::inband_send_on(void)
2206 PDEBUG(DEBUG_PORT, "turning inband signalling send on.\n");
2207 p_m_inband_send_on = 1;
2208 /* trigger inband transmit */
2212 void PmISDN::inband_send_off(void)
2214 PDEBUG(DEBUG_PORT, "turning inband signalling send off.\n");
2215 p_m_inband_send_on = 0;
2218 void PmISDN::inband_receive(unsigned char *buffer, int len)
2221 // if (len >= SS5_DECODER_NPOINTS)
2222 // ss5_decode(buffer, SS5_DECODER_NPOINTS);
2223 PERROR("this function must be derived to function!\n");
2226 void PmISDN::inband_receive_on(void)
2228 /* this must work during constructor, see ss5.cpp */
2229 PDEBUG(DEBUG_PORT, "turning inband signalling receive on.\n");
2230 p_m_inband_receive_on = 1;
2234 void PmISDN::inband_receive_off(void)
2236 PDEBUG(DEBUG_PORT, "turning inband signalling receive off.\n");
2237 p_m_inband_receive_on = 0;
2241 void PmISDN::mute_on(void)
2245 PDEBUG(DEBUG_PORT, "turning mute on.\n");
2247 set_conf(p_m_conf, 0);
2250 void PmISDN::mute_off(void)
2254 PDEBUG(DEBUG_PORT, "turning mute off.\n");
2256 set_conf(0, p_m_conf);