Wed Aug 18 22:34:25 2010

Asterisk developer's documentation


isdn_lib.c File Reference

Interface to mISDN. More...

#include <syslog.h>
#include <sys/time.h>
#include <mISDNuser/isdn_debug.h>
#include "isdn_lib_intern.h"
#include "isdn_lib.h"
#include "asterisk/causes.h"
#include <mISDNuser/net_l2.h>
#include <mISDNuser/tone.h>
#include <unistd.h>
#include <semaphore.h>
#include <pthread.h>
#include <signal.h>

Go to the source code of this file.

Data Structures

struct  misdn_lib

Defines

#define ARRAY_LEN(a)   (sizeof(a) / sizeof(a[0]))
#define ECHOCAN_OFF   124
#define ECHOCAN_ON   123
#define ISDN_PID_L3_B_USER   0x430000ff
#define ISDN_PID_L4_B_USER   0x440000ff
#define MAXPROCS   0x100
#define MISDN_DEBUG   0
#define MISDN_DSP
#define MISDN_GEN_SILENCE
#define MISDN_IBUF_SIZE   512
#define RETURN(a, b)   {retval=a; goto b;}
#define TONE_ALERT_CNT   41
#define TONE_ALERT_SILENCE_CNT   200
#define TONE_BUSY_CNT   20
#define TONE_BUSY_SILENCE_CNT   48

Enumerations

enum  global_states { MISDN_INITIALIZING, MISDN_INITIALIZED }

Functions

static void bc_next_state_change (struct misdn_bchannel *bc, enum bchannel_state state)
char * bc_state2str (enum bchannel_state state)
void bc_state_change (struct misdn_bchannel *bc, enum bchannel_state state)
int bchdev_echocancel_activate (struct misdn_bchannel *dev)
void bchdev_echocancel_deactivate (struct misdn_bchannel *dev)
static char * bearer2str (int cap)
static int clean_up_bc (struct misdn_bchannel *bc)
static void clear_l3 (struct misdn_stack *stack)
static msg_t * create_l2msg (int prim, int dinfo, int size)
msg_t * create_l3msg (int prim, int mt, int dinfo, int size, int ntmode)
static int create_process (int midev, struct misdn_bchannel *bc)
static int do_tone (struct misdn_bchannel *bc, int len)
static void dump_chan_list (struct misdn_stack *stack)
void ec_chunk (struct misdn_bchannel *bc, unsigned char *rxchunk, unsigned char *txchunk, int chunk_size)
static void empty_bc (struct misdn_bchannel *bc)
static int empty_chan_in_stack (struct misdn_stack *stack, int channel)
static const char * fac2str (enum FacFunction facility)
static msg_t * fetch_msg (int midev)
static struct misdn_bchannelfind_bc_by_addr (unsigned long addr)
static struct misdn_bchannelfind_bc_by_channel (int port, int channel)
static struct misdn_bchannelfind_bc_by_confid (unsigned long confid)
misdn_bchannelfind_bc_by_l3id (struct misdn_stack *stack, unsigned long l3id)
static struct misdn_bchannelfind_bc_by_masked_l3id (struct misdn_stack *stack, unsigned long l3id, unsigned long mask)
static int find_free_chan_in_stack (struct misdn_stack *stack, struct misdn_bchannel *bc, int channel, int dec)
static struct misdn_stackfind_stack_by_addr (int addr)
static struct misdn_stackfind_stack_by_mgr (manager_t *mgr_nt)
static struct misdn_stackfind_stack_by_port (int port)
static char * flip_buf_bits (char *buf, int len)
misdn_stackget_misdn_stack (void)
void get_show_stack_details (int port, char *buf)
misdn_stackget_stack_by_bc (struct misdn_bchannel *bc)
static int handle_bchan (msg_t *msg)
static int handle_cr (struct misdn_stack *stack, iframe_t *frm)
static int handle_err (msg_t *msg)
static int handle_event (struct misdn_bchannel *bc, enum event_e event, iframe_t *frm)
static int handle_event_nt (void *dat, void *arg)
static int handle_frm (msg_t *msg)
static int handle_frm_nt (msg_t *msg)
static int handle_l1 (msg_t *msg)
static int handle_l2 (msg_t *msg)
static int handle_mgmt (msg_t *msg)
static int handle_timers (msg_t *msg)
static int init_bc (struct misdn_stack *stack, struct misdn_bchannel *bc, int midev, int port, int bidx, char *msn, int firsttime)
static void init_flip_bits (void)
void isdn_lib_stop_dtmf (struct misdn_bchannel *bc)
void isdn_lib_update_ec (struct misdn_bchannel *bc)
void isdn_lib_update_rxgain (struct misdn_bchannel *bc)
void isdn_lib_update_txgain (struct misdn_bchannel *bc)
void manager_bchannel_activate (struct misdn_bchannel *bc)
void manager_bchannel_cleanup (struct misdn_bchannel *bc)
void manager_bchannel_deactivate (struct misdn_bchannel *bc)
void manager_bchannel_setup (struct misdn_bchannel *bc)
void manager_clean_bc (struct misdn_bchannel *bc)
void manager_ec_disable (struct misdn_bchannel *bc)
void manager_ec_enable (struct misdn_bchannel *bc)
static void manager_event_handler (void *arg)
misdn_bchannelmanager_find_bc_by_pid (int pid)
char * manager_isdn_get_info (enum event_e event)
int manager_isdn_handler (iframe_t *frm, msg_t *msg)
void manager_ph_control (struct misdn_bchannel *bc, int c1, int c2)
void manager_ph_control_block (struct misdn_bchannel *bc, int c1, void *c2, int c2_len)
int misdn_cap_is_speech (int cap)
void misdn_dump_chanlist ()
int misdn_inband_avail (struct misdn_bchannel *bc)
void misdn_join_conf (struct misdn_bchannel *bc, int conf_id)
void misdn_lib_bridge (struct misdn_bchannel *bc1, struct misdn_bchannel *bc2)
void misdn_lib_destroy (void)
void misdn_lib_echo (struct misdn_bchannel *bc, int onoff)
misdn_bchannelmisdn_lib_find_held_bc (int port, int l3_id)
 Find a held call's B channel record.
misdn_bchannelmisdn_lib_get_free_bc (int port, int channel, int inout, int dec)
static int misdn_lib_get_l1_down (struct misdn_stack *stack)
static int misdn_lib_get_l1_up (struct misdn_stack *stack)
static int misdn_lib_get_l2_down (struct misdn_stack *stack)
int misdn_lib_get_l2_up (struct misdn_stack *stack)
int misdn_lib_get_maxchans (int port)
int misdn_lib_get_port_down (int port)
int misdn_lib_get_port_info (int port)
int misdn_lib_get_port_up (int port)
static int misdn_lib_get_short_status (struct misdn_stack *stack)
int misdn_lib_init (char *portlist, struct misdn_lib_iface *iface, void *user_data)
int misdn_lib_is_port_blocked (int port)
int misdn_lib_is_ptp (int port)
static void misdn_lib_isdn_event_catcher (void *arg)
void misdn_lib_isdn_l1watcher (int port)
void misdn_lib_log_ies (struct misdn_bchannel *bc)
int misdn_lib_maxports_get (void)
void misdn_lib_nt_debug_init (int flags, char *file)
void misdn_lib_nt_keepcalls (int kc)
int misdn_lib_pid_restart (int pid)
int misdn_lib_port_block (int port)
int misdn_lib_port_is_nt (int port)
int misdn_lib_port_is_pri (int port)
int misdn_lib_port_restart (int port)
int misdn_lib_port_unblock (int port)
int misdn_lib_port_up (int port, int check)
void misdn_lib_reinit_nt_stack (int port)
void misdn_lib_release (struct misdn_bchannel *bc)
int misdn_lib_send_event (struct misdn_bchannel *bc, enum event_e event)
int misdn_lib_send_restart (int port, int channel)
void misdn_lib_send_tone (struct misdn_bchannel *bc, enum tone_e tone)
void misdn_lib_setup_bc (struct misdn_bchannel *bc)
void misdn_lib_split_bridge (struct misdn_bchannel *bc1, struct misdn_bchannel *bc2)
void misdn_lib_tone_generator_start (struct misdn_bchannel *bc)
void misdn_lib_tone_generator_stop (struct misdn_bchannel *bc)
int misdn_lib_tx2misdn_frm (struct misdn_bchannel *bc, void *data, int len)
void misdn_make_dummy (struct misdn_bchannel *dummybc, int port, int l3id, int nt, int channel)
static void misdn_send_lock (struct misdn_bchannel *bc)
static void misdn_send_unlock (struct misdn_bchannel *bc)
void misdn_split_conf (struct misdn_bchannel *bc, int conf_id)
void misdn_tx_jitter (struct misdn_bchannel *bc, int len)
static void prepare_bc (struct misdn_bchannel *bc, int channel)
int queue_cleanup_bc (struct misdn_bchannel *bc)
int release_cr (struct misdn_stack *stack, mISDNuser_head_t *hh)
static int send_msg (int midev, struct misdn_bchannel *bc, msg_t *dmsg)
static int set_chan_in_stack (struct misdn_stack *stack, int channel)
int setup_bc (struct misdn_bchannel *bc)
static void stack_destroy (struct misdn_stack *stack)
void stack_holder_add (struct misdn_stack *stack, struct misdn_bchannel *holder)
misdn_bchannelstack_holder_find (struct misdn_stack *stack, unsigned long l3id)
void stack_holder_remove (struct misdn_stack *stack, struct misdn_bchannel *holder)
static struct misdn_stackstack_init (int midev, int port, int ptp)
void te_lib_destroy (int midev)
int te_lib_init (void)
static int test_inuse (struct misdn_bchannel *bc)

Variables

static int entity
static char flip_table [256]
static struct misdn_libglob_mgr
static enum global_states global_state = MISDN_INITIALIZING
sem_t handler_started
isdn_msg msgs_g []
static int mypid = 1
static int new_te_id = 0
static int nt_err_cnt = 0
char tone_425_flip [TONE_425_SIZE]
char tone_silence_flip [TONE_SILENCE_SIZE]


Detailed Description

Interface to mISDN.

Author:
Christian Richter <crich@beronet.com>

Definition in file isdn_lib.c.


Define Documentation

#define ARRAY_LEN (  )     (sizeof(a) / sizeof(a[0]))

Definition at line 32 of file isdn_lib.c.

#define ECHOCAN_OFF   124

Definition at line 221 of file isdn_lib.c.

Referenced by manager_ec_disable().

#define ECHOCAN_ON   123

Definition at line 220 of file isdn_lib.c.

Referenced by manager_ec_enable().

#define ISDN_PID_L3_B_USER   0x430000ff

Definition at line 239 of file isdn_lib.c.

#define ISDN_PID_L4_B_USER   0x440000ff

Definition at line 240 of file isdn_lib.c.

#define MAXPROCS   0x100

Definition at line 813 of file isdn_lib.c.

Referenced by create_process().

#define MISDN_DEBUG   0

Definition at line 224 of file isdn_lib.c.

#define MISDN_DSP

#define MISDN_GEN_SILENCE

#define MISDN_IBUF_SIZE   512

Definition at line 243 of file isdn_lib.c.

Referenced by init_bc().

#define RETURN ( a,
 )     {retval=a; goto b;}

Definition at line 3398 of file isdn_lib.c.

Referenced by misdn_lib_send_event().

#define TONE_ALERT_CNT   41

Definition at line 246 of file isdn_lib.c.

#define TONE_ALERT_SILENCE_CNT   200

Definition at line 247 of file isdn_lib.c.

#define TONE_BUSY_CNT   20

Definition at line 249 of file isdn_lib.c.

#define TONE_BUSY_SILENCE_CNT   48

Definition at line 250 of file isdn_lib.c.


Enumeration Type Documentation

enum global_states

Enumerator:
MISDN_INITIALIZING 
MISDN_INITIALIZED 

Definition at line 183 of file isdn_lib.c.

00183                    {
00184    MISDN_INITIALIZING,
00185    MISDN_INITIALIZED
00186 } ;


Function Documentation

static void bc_next_state_change ( struct misdn_bchannel bc,
enum bchannel_state  state 
) [static]

Definition at line 638 of file isdn_lib.c.

References bc_state2str(), cb_log, misdn_bchannel::next_bc_state, and misdn_bchannel::port.

Referenced by misdn_lib_bridge().

00639 {
00640    cb_log(5,bc->port,"BC_NEXT_STATE_CHANGE: from:%s to:%s\n",
00641           bc_state2str(bc->next_bc_state),
00642           bc_state2str(state) );
00643 
00644    bc->next_bc_state=state;
00645 }

char* bc_state2str ( enum bchannel_state  state  ) 

Definition at line 589 of file isdn_lib.c.

References BCHAN_ACTIVATED, BCHAN_ACTIVE, BCHAN_BRIDGE, BCHAN_BRIDGED, BCHAN_CLEAN, BCHAN_CLEAN_REQUEST, BCHAN_CLEANED, BCHAN_EMPTY, BCHAN_ERROR, BCHAN_RELEASE, BCHAN_RELEASED, BCHAN_SETUP, BCHAN_SETUPED, and s.

Referenced by bc_next_state_change(), bc_state_change(), cb_events(), handle_bchan(), handle_err(), misdn_lib_send_event(), misdn_lib_split_bridge(), misdn_lib_tx2misdn_frm(), print_bc_info(), and setup_bc().

00589                                               {
00590    int i;
00591    
00592    struct bchan_state_s {
00593       char *n;
00594       enum bchannel_state s;
00595    } states[] = {
00596       {"BCHAN_CLEANED", BCHAN_CLEANED },
00597       {"BCHAN_EMPTY", BCHAN_EMPTY},
00598       {"BCHAN_SETUP", BCHAN_SETUP},
00599       {"BCHAN_SETUPED", BCHAN_SETUPED},
00600       {"BCHAN_ACTIVE", BCHAN_ACTIVE},
00601       {"BCHAN_ACTIVATED", BCHAN_ACTIVATED},
00602       {"BCHAN_BRIDGE",  BCHAN_BRIDGE},
00603       {"BCHAN_BRIDGED", BCHAN_BRIDGED},
00604       {"BCHAN_RELEASE", BCHAN_RELEASE},
00605       {"BCHAN_RELEASED", BCHAN_RELEASED},
00606       {"BCHAN_CLEAN", BCHAN_CLEAN},
00607       {"BCHAN_CLEAN_REQUEST", BCHAN_CLEAN_REQUEST},
00608       {"BCHAN_ERROR", BCHAN_ERROR}
00609    };
00610    
00611    for (i=0; i< sizeof(states)/sizeof(struct bchan_state_s); i++)
00612       if ( states[i].s == state)
00613          return states[i].n;
00614 
00615    return "UNKNOWN";
00616 }

void bc_state_change ( struct misdn_bchannel bc,
enum bchannel_state  state 
)

Definition at line 618 of file isdn_lib.c.

References misdn_bchannel::bc_state, bc_state2str(), BCHAN_ACTIVATED, BCHAN_BRIDGED, BCHAN_EMPTY, cb_log, misdn_bchannel::conf_id, misdn_bchannel::l3_id, misdn_join_conf(), misdn_bchannel::next_bc_state, and misdn_bchannel::port.

Referenced by clean_up_bc(), handle_bchan(), handle_frm(), init_bc(), manager_bchannel_deactivate(), misdn_join_conf(), misdn_lib_send_event(), and misdn_split_conf().

00619 {
00620    cb_log(5,bc->port,"BC_STATE_CHANGE: l3id:%x from:%s to:%s\n",
00621       bc->l3_id,
00622           bc_state2str(bc->bc_state),
00623           bc_state2str(state) );
00624    
00625    switch (state) {
00626       case BCHAN_ACTIVATED:
00627          if (bc->next_bc_state ==  BCHAN_BRIDGED) {
00628             misdn_join_conf(bc, bc->conf_id);
00629             bc->next_bc_state = BCHAN_EMPTY;
00630             return;
00631          }
00632       default:
00633          bc->bc_state=state;
00634          break;
00635    }
00636 }

int bchdev_echocancel_activate ( struct misdn_bchannel dev  ) 

void bchdev_echocancel_deactivate ( struct misdn_bchannel dev  ) 

static char* bearer2str ( int  cap  )  [static]

Definition at line 284 of file isdn_lib.c.

References INFO_CAPABILITY_AUDIO_3_1K, INFO_CAPABILITY_DIGITAL_RESTRICTED, INFO_CAPABILITY_DIGITAL_UNRESTRICTED, and INFO_CAPABILITY_SPEECH.

00284                                  {
00285    static char *bearers[]={
00286       "Speech",
00287       "Audio 3.1k",
00288       "Unres Digital",
00289       "Res Digital",
00290       "Unknown Bearer"
00291    };
00292    
00293    switch (cap) {
00294    case INFO_CAPABILITY_SPEECH:
00295       return bearers[0];
00296       break;
00297    case INFO_CAPABILITY_AUDIO_3_1K:
00298       return bearers[1];
00299       break;
00300    case INFO_CAPABILITY_DIGITAL_UNRESTRICTED:
00301       return bearers[2];
00302       break;
00303    case INFO_CAPABILITY_DIGITAL_RESTRICTED:
00304       return bearers[3];
00305       break;
00306    default:
00307       return bearers[4];
00308       break;
00309    }
00310 }

static int clean_up_bc ( struct misdn_bchannel bc  )  [static]

Definition at line 757 of file isdn_lib.c.

References misdn_bchannel::b_stid, misdn_stack::bc, misdn_bchannel::bc_state, bc_state_change(), BCHAN_CLEANED, buff, cb_log, get_stack_by_bc(), misdn_bchannel::layer_id, manager_bchannel_deactivate(), manager_ec_disable(), misdn_stack::midev, misdn_bchannel::pid, misdn_stack::port, and misdn_bchannel::port.

Referenced by clear_l3(), handle_bchan(), handle_cr(), handle_event_nt(), handle_frm(), manager_event_handler(), misdn_lib_release(), misdn_lib_send_event(), misdn_lib_send_restart(), and misdn_lib_setup_bc().

00758 {
00759    int ret=0;
00760    unsigned char buff[32];
00761    struct misdn_stack * stack;
00762 
00763    cb_log(3, bc?bc->port:0, "$$$ CLEANUP CALLED pid:%d\n", bc?bc->pid:-1);
00764    
00765    if (!bc  ) return -1;
00766    stack=get_stack_by_bc(bc);
00767    
00768    if (!stack) return -1;
00769    
00770    switch (bc->bc_state ) {
00771    case BCHAN_CLEANED:
00772       cb_log(5, stack->port, "$$$ Already cleaned up bc with stid :%x\n", bc->b_stid);
00773       return -1;
00774       
00775    default:
00776       break;
00777    }
00778    
00779    cb_log(2, stack->port, "$$$ Cleaning up bc with stid :%x pid:%d\n", bc->b_stid, bc->pid);
00780    
00781    manager_ec_disable(bc);
00782 
00783    manager_bchannel_deactivate(bc);
00784 
00785    mISDN_write_frame(stack->midev, buff, bc->layer_id|FLG_MSG_TARGET|FLG_MSG_DOWN, MGR_DELLAYER | REQUEST, 0, 0, NULL, TIMEOUT_1SEC);
00786    
00787    bc->b_stid = 0;
00788    bc_state_change(bc, BCHAN_CLEANED);
00789    
00790    return ret;
00791 }

static void clear_l3 ( struct misdn_stack stack  )  [static]

Definition at line 795 of file isdn_lib.c.

References misdn_stack::b_num, misdn_stack::bc, cb_event, clean_up_bc(), empty_bc(), empty_chan_in_stack(), EVENT_CLEANUP, global_state, and MISDN_INITIALIZED.

Referenced by handle_mgmt(), and misdn_lib_port_restart().

00796 {
00797    int i;
00798 
00799    for (i=0; i<=stack->b_num; i++) {
00800       if (global_state == MISDN_INITIALIZED)  {
00801          cb_event(EVENT_CLEANUP, &stack->bc[i], NULL); 
00802          empty_bc(&stack->bc[i]);
00803          clean_up_bc(&stack->bc[i]);
00804          empty_chan_in_stack(stack, i + 1);
00805          stack->bc[i].in_use = 0;
00806       }
00807       
00808    } 
00809 }

static msg_t* create_l2msg ( int  prim,
int  dinfo,
int  size 
) [static]

Definition at line 343 of file isdn_lib.c.

Referenced by misdn_lib_get_l2_down(), and misdn_lib_get_l2_up().

00344 {
00345    int i = 0;
00346    msg_t *dmsg;
00347   
00348    while(i < 10)
00349    {
00350       dmsg = prep_l3data_msg(prim, dinfo, size, 256, NULL);
00351       if (dmsg)
00352          return(dmsg);
00353       
00354       if (!i)
00355          printf("cannot allocate memory, trying again...\n");
00356       i++;
00357       usleep(300000);
00358    }
00359    printf("cannot allocate memory, system overloaded.\n");
00360    exit(-1);
00361 }

msg_t* create_l3msg ( int  prim,
int  mt,
int  dinfo,
int  size,
int  ntmode 
)

Definition at line 365 of file isdn_lib.c.

Referenced by build_alerting(), build_connect(), build_connect_acknowledge(), build_disconnect(), build_facility(), build_hold(), build_hold_acknowledge(), build_hold_reject(), build_information(), build_notify(), build_proceeding(), build_progress(), build_release(), build_release_complete(), build_restart(), build_resume(), build_resume_acknowledge(), build_resume_reject(), build_retrieve(), build_retrieve_acknowledge(), build_retrieve_reject(), build_setup(), build_setup_acknowledge(), build_status(), build_status_enquiry(), build_suspend(), build_suspend_acknowledge(), build_suspend_reject(), build_timeout(), build_user_information(), and handle_event_nt().

00366 {
00367    int i = 0;
00368    msg_t *dmsg;
00369    Q931_info_t *qi;
00370    iframe_t *frm;
00371   
00372    if (!ntmode)
00373       size = sizeof(Q931_info_t)+2;
00374   
00375    while(i < 10) {
00376       if (ntmode) {
00377          dmsg = prep_l3data_msg(prim, dinfo, size, 256, NULL);
00378          if (dmsg) {
00379             return(dmsg);
00380          }
00381       } else {
00382          dmsg = alloc_msg(size+256+mISDN_HEADER_LEN+DEFAULT_HEADROOM);
00383          if (dmsg)
00384          {
00385             memset(msg_put(dmsg,size+mISDN_HEADER_LEN), 0, size+mISDN_HEADER_LEN);
00386             frm = (iframe_t *)dmsg->data;
00387             frm->prim = prim;
00388             frm->dinfo = dinfo;
00389             qi = (Q931_info_t *)(dmsg->data + mISDN_HEADER_LEN);
00390             qi->type = mt;
00391             return(dmsg);
00392          }
00393       }
00394     
00395       if (!i) printf("cannot allocate memory, trying again...\n");
00396       i++;
00397       usleep(300000);
00398    }
00399    printf("cannot allocate memory, system overloaded.\n");
00400    exit(-1);
00401 }

static int create_process ( int  midev,
struct misdn_bchannel bc 
) [static]

Definition at line 929 of file isdn_lib.c.

References misdn_stack::bc, cb_log, misdn_bchannel::channel, misdn_bchannel::channel_preselected, find_free_chan_in_stack(), get_stack_by_bc(), misdn_bchannel::l3_id, MAXPROCS, misdn_stack::nt, misdn_stack::port, and misdn_stack::procids.

Referenced by misdn_lib_send_event().

00930 {
00931    iframe_t ncr;
00932    int l3_id;
00933    int proc_id;
00934    struct misdn_stack *stack;
00935 
00936    stack = get_stack_by_bc(bc);
00937    if (stack->nt) {
00938       if (find_free_chan_in_stack(stack, bc, bc->channel_preselected ? bc->channel : 0, 0) < 0) {
00939          return -1;
00940       }
00941       cb_log(4, stack->port, " -->  found channel: %d\n", bc->channel);
00942 
00943       for (proc_id = 0; proc_id < MAXPROCS; ++proc_id) {
00944          if (stack->procids[proc_id] == 0) {
00945             break;
00946          }
00947       }  /* end for */
00948       if (proc_id == MAXPROCS) {
00949          cb_log(0, stack->port, "Couldn't Create New ProcId.\n");
00950          return -1;
00951       }
00952 
00953       stack->procids[proc_id] = 1;
00954 
00955       l3_id = 0xff00 | proc_id;
00956       bc->l3_id = l3_id;
00957       cb_log(3, stack->port, " --> new_l3id %x\n", l3_id);
00958    } else {
00959       if ((stack->pri && stack->ptp) || bc->te_choose_channel) {
00960          /* we know exactly which channels are in use */
00961          if (find_free_chan_in_stack(stack, bc, bc->channel_preselected ? bc->channel : 0, bc->dec) < 0) {
00962             return -1;
00963          }
00964          cb_log(2, stack->port, " -->  found channel: %d\n", bc->channel);
00965       } else {
00966          /* other phones could have made a call also on this port (ptmp) */
00967          bc->channel = 0xff;
00968       }
00969 
00970       /* if we are in te-mode, we need to create a process first */
00971       if (++new_te_id > 0xffff) {
00972          new_te_id = 0x0001;
00973       }
00974 
00975       l3_id = (entity << 16) | new_te_id;
00976       bc->l3_id = l3_id;
00977       cb_log(3, stack->port, "--> new_l3id %x\n", l3_id);
00978 
00979       /* send message */
00980       ncr.prim = CC_NEW_CR | REQUEST;
00981       ncr.addr = (stack->upper_id | FLG_MSG_DOWN);
00982       ncr.dinfo = l3_id;
00983       ncr.len = 0;
00984       mISDN_write(midev, &ncr, mISDN_HEADER_LEN + ncr.len, TIMEOUT_1SEC);
00985    }
00986 
00987    return l3_id;
00988 }

static int do_tone ( struct misdn_bchannel bc,
int  len 
) [static]

Definition at line 2275 of file isdn_lib.c.

References cb_event, EVENT_TONE_GENERATE, misdn_bchannel::generate_tone, glob_mgr, misdn_tx_jitter(), misdn_bchannel::nojitter, misdn_bchannel::tone_cnt, and misdn_lib::user_data.

Referenced by handle_bchan().

02276 {
02277    bc->tone_cnt=len;
02278    
02279    if (bc->generate_tone) {
02280       cb_event(EVENT_TONE_GENERATE, bc, glob_mgr->user_data);
02281       
02282       if ( !bc->nojitter ) {
02283          misdn_tx_jitter(bc,len);
02284       }
02285       
02286       return 1;
02287    }
02288    
02289    return 0;
02290 }

static void dump_chan_list ( struct misdn_stack stack  )  [static]

Definition at line 458 of file isdn_lib.c.

References misdn_stack::b_num, misdn_stack::bc, cb_log, misdn_stack::channels, misdn_bchannel::in_use, and misdn_stack::port.

Referenced by empty_chan_in_stack(), handle_cr(), misdn_dump_chanlist(), and set_chan_in_stack().

00459 {
00460    int i;
00461 
00462    for (i=0; i <= stack->b_num; i++) {
00463       cb_log(6, stack->port, "Idx:%d stack->cchan:%d in_use:%d Chan:%d\n",i,stack->channels[i], stack->bc[i].in_use, i+1);
00464    }
00465 }

void ec_chunk ( struct misdn_bchannel bc,
unsigned char *  rxchunk,
unsigned char *  txchunk,
int  chunk_size 
)

static void empty_bc ( struct misdn_bchannel bc  )  [static]

Definition at line 658 of file isdn_lib.c.

References misdn_bchannel::active, misdn_bchannel::AOCD_need_export, AST_CAUSE_NORMAL_CLEARING, misdn_bchannel::bframe_len, misdn_bchannel::cad, misdn_bchannel::capability, misdn_bchannel::cause, misdn_bchannel::channel, misdn_bchannel::channel_found, misdn_bchannel::conf_id, misdn_bchannel::cpnnumplan, misdn_bchannel::crypt, misdn_bchannel::crypt_key, misdn_bchannel::curprx, misdn_bchannel::curptx, misdn_bchannel::cw, misdn_bchannel::dad, misdn_bchannel::dec, misdn_bchannel::display, misdn_bchannel::dnumplan, misdn_bchannel::dummy, misdn_bchannel::early_bconnect, misdn_bchannel::ec_deftaps, misdn_bchannel::ec_enable, EVENT_NOTHING, misdn_bchannel::evq, misdn_bchannel::fac_in, misdn_bchannel::fac_out, misdn_bchannel::generate_tone, misdn_bchannel::hdlc, INFO_CAPABILITY_SPEECH, INFO_CODEC_ALAW, misdn_bchannel::info_dad, misdn_bchannel::infos_pending, misdn_bchannel::last_used, misdn_bchannel::law, misdn_bchannel::mode, misdn_bchannel::need_more_infos, misdn_bchannel::nodsp, misdn_bchannel::nojitter, NUMPLAN_UNKNOWN, misdn_bchannel::oad, misdn_bchannel::onumplan, misdn_bchannel::orig, misdn_bchannel::orig_dad, misdn_bchannel::out_cause, misdn_bchannel::pres, misdn_bchannel::progress_coding, misdn_bchannel::progress_indicator, misdn_bchannel::progress_location, misdn_bchannel::rad, misdn_bchannel::rate, misdn_bchannel::restart_channel, misdn_bchannel::rnumplan, misdn_bchannel::rxgain, misdn_bchannel::send_dtmf, misdn_bchannel::sending_complete, misdn_bchannel::te_choose_channel, misdn_bchannel::time_usec, misdn_bchannel::tone_cnt, misdn_bchannel::txgain, misdn_bchannel::urate, misdn_bchannel::user1, misdn_bchannel::uu, and misdn_bchannel::uulen.

Referenced by clear_l3(), handle_cr(), handle_event_nt(), handle_frm(), init_bc(), manager_clean_bc(), misdn_lib_release(), misdn_lib_send_event(), and misdn_lib_send_restart().

00659 {
00660    bc->dummy=0;
00661 
00662    bc->bframe_len=0;
00663 
00664    bc->cw= 0;
00665 
00666    bc->dec=0;
00667    bc->channel = 0;
00668 
00669    bc->sending_complete = 0;
00670 
00671    bc->restart_channel=0;
00672    
00673    bc->conf_id = 0;
00674 
00675    bc->need_more_infos = 0;
00676    
00677    bc->send_dtmf=0;
00678    bc->nodsp=0;
00679    bc->nojitter=0;
00680 
00681    bc->time_usec=0;
00682    
00683    bc->rxgain=0;
00684    bc->txgain=0;
00685 
00686    bc->crypt=0;
00687    bc->curptx=0; bc->curprx=0;
00688    
00689    bc->crypt_key[0] = 0;
00690    
00691    bc->generate_tone=0;
00692    bc->tone_cnt=0;
00693   
00694    bc->dnumplan=NUMPLAN_UNKNOWN;
00695    bc->onumplan=NUMPLAN_UNKNOWN;
00696    bc->rnumplan=NUMPLAN_UNKNOWN;
00697    bc->cpnnumplan=NUMPLAN_UNKNOWN;
00698    
00699 
00700    bc->active = 0;
00701 
00702    bc->early_bconnect = 1;
00703    
00704 #ifdef MISDN_1_2
00705    *bc->pipeline = 0;
00706 #else
00707    bc->ec_enable = 0;
00708    bc->ec_deftaps = 128;
00709 #endif
00710 
00711    bc->AOCD_need_export = 0;
00712 
00713    bc->orig=0;
00714   
00715    bc->cause = AST_CAUSE_NORMAL_CLEARING;
00716    bc->out_cause = AST_CAUSE_NORMAL_CLEARING;
00717    bc->pres = 0;  /* allowed */
00718    
00719    bc->evq=EVENT_NOTHING;
00720 
00721    bc->progress_coding=0;
00722    bc->progress_location=0;
00723    bc->progress_indicator=0;
00724    
00725 /** Set Default Bearer Caps **/
00726    bc->capability=INFO_CAPABILITY_SPEECH;
00727    bc->law=INFO_CODEC_ALAW;
00728    bc->mode=0;
00729    bc->rate=0x10;
00730    bc->user1=0;
00731    bc->urate=0;
00732    
00733    bc->hdlc=0;
00734    
00735    
00736    bc->info_dad[0] = 0;
00737    bc->display[0] = 0;
00738    bc->infos_pending[0] = 0;
00739    bc->cad[0] = 0;
00740    bc->oad[0] = 0;
00741    bc->dad[0] = 0;
00742    bc->rad[0] = 0;
00743    bc->orig_dad[0] = 0;
00744    bc->uu[0]=0;
00745    bc->uulen=0;
00746    
00747    bc->fac_in.Function = Fac_None;
00748    bc->fac_out.Function = Fac_None;
00749    
00750    bc->te_choose_channel = 0;
00751    bc->channel_found= 0;
00752 
00753    gettimeofday(&bc->last_used, NULL);
00754 }

static int empty_chan_in_stack ( struct misdn_stack stack,
int  channel 
) [static]

Definition at line 576 of file isdn_lib.c.

References cb_log, misdn_stack::channels, dump_chan_list(), MAX_BCHANS, and misdn_stack::port.

Referenced by clear_l3(), handle_cr(), handle_event_nt(), handle_frm(), manager_clean_bc(), misdn_lib_release(), and misdn_lib_send_event().

00577 {
00578    if (channel<=0 || channel>MAX_BCHANS) {
00579       cb_log(0,stack?stack->port:0, "empty_chan_in_stack: cannot empty channel %d\n",channel);
00580       return -1;
00581    }
00582    
00583    cb_log (4, stack?stack->port:0, "empty_chan_in_stack: %d\n",channel); 
00584    stack->channels[channel-1] = 0;
00585    dump_chan_list(stack);
00586    return 0;
00587 }

static const char* fac2str ( enum FacFunction  facility  )  [static]

Definition at line 3330 of file isdn_lib.c.

References ARRAY_LEN, and name.

Referenced by misdn_lib_log_ies().

03331 {
03332    static const struct { 
03333       enum FacFunction facility; 
03334       char *name;
03335    } arr[] = {
03336 /* *INDENT-OFF* */
03337       { Fac_None, "Fac_None" },
03338       { Fac_GetSupportedServices, "Fac_GetSupportedServices" },
03339       { Fac_Listen, "Fac_Listen" },
03340       { Fac_Suspend, "Fac_Suspend" },
03341       { Fac_Resume, "Fac_Resume" },
03342       { Fac_CFActivate, "Fac_CFActivate" },
03343       { Fac_CFDeactivate, "Fac_CFDeactivate" },
03344       { Fac_CFInterrogateParameters, "Fac_CFInterrogateParameters" },
03345       { Fac_CFInterrogateNumbers, "Fac_CFInterrogateNumbers" },
03346       { Fac_CD, "Fac_CD" },
03347       { Fac_AOCDCurrency, "Fac_AOCDCurrency" },
03348       { Fac_AOCDChargingUnit, "Fac_AOCDChargingUnit" },
03349 /* *INDENT-ON* */
03350    };
03351    
03352    unsigned index;
03353    
03354    for (index = 0; index < ARRAY_LEN(arr); ++index) {
03355       if (arr[index].facility == facility) {
03356          return arr[index].name;
03357       }
03358    }
03359 
03360    return "unknown";
03361 }

static msg_t* fetch_msg ( int  midev  )  [static]

Definition at line 3042 of file isdn_lib.c.

References cb_log, errno, and msg.

Referenced by misdn_lib_isdn_event_catcher().

03043 {
03044    msg_t *msg=alloc_msg(MAX_MSG_SIZE);
03045    int r;
03046 
03047    if (!msg) {
03048       cb_log(0, 0, "fetch_msg: alloc msg failed !!");
03049       return NULL;
03050    }
03051 
03052    AGAIN:
03053       r=mISDN_read(midev,msg->data,MAX_MSG_SIZE, TIMEOUT_10SEC);
03054       msg->len=r;
03055     
03056       if (r==0) {
03057          free_msg(msg); /* danger, cause usually freeing in main_loop */
03058          cb_log(6,0,"Got empty Msg..\n");
03059          return NULL;
03060       }
03061 
03062       if (r<0) {
03063          if (errno == EAGAIN) {
03064             /*we wait for mISDN here*/
03065             cb_log(4,0,"mISDN_read wants us to wait\n");
03066             usleep(5000);
03067             goto AGAIN;
03068          }
03069          
03070          cb_log(0,0,"mISDN_read returned :%d error:%s (%d)\n",r,strerror(errno),errno); 
03071       }
03072 
03073 #if 0
03074                if  (!(frm->prim == (DL_DATA|INDICATION) )|| (frm->prim == (PH_DATA|INDICATION)))
03075                        cb_log(0,0,"prim: %x dinfo:%x addr:%x msglen:%d frm->len:%d\n",frm->prim, frm->dinfo, frm->addr, msg->len,frm->len );
03076 #endif
03077       return msg;
03078 }

static struct misdn_bchannel* find_bc_by_addr ( unsigned long  addr  )  [static]

Definition at line 1512 of file isdn_lib.c.

References misdn_bchannel::addr, misdn_stack::b_num, misdn_stack::bc, glob_mgr, misdn_bchannel::in_use, misdn_bchannel::layer_id, misdn_stack::next, and misdn_lib::stack_list.

Referenced by handle_bchan().

01513 {
01514    struct misdn_stack *stack;
01515    int i;
01516 
01517    for (stack = glob_mgr->stack_list; stack; stack = stack->next) {
01518       for (i = 0; i <= stack->b_num; i++) {
01519          if (stack->bc[i].in_use
01520             && ((stack->bc[i].addr & STACK_ID_MASK) == (addr & STACK_ID_MASK)
01521                || stack->bc[i].layer_id == addr)) {
01522             return &stack->bc[i];
01523          }
01524       }
01525    }
01526    
01527    return NULL;
01528 }

static struct misdn_bchannel* find_bc_by_channel ( int  port,
int  channel 
) [static]

Definition at line 1546 of file isdn_lib.c.

References misdn_stack::b_num, misdn_stack::bc, misdn_bchannel::channel, find_stack_by_port(), and misdn_bchannel::in_use.

Referenced by handle_err().

01547 {
01548    struct misdn_stack *stack = find_stack_by_port(port);
01549    int i;
01550 
01551    if (!stack) {
01552       return NULL;
01553    }
01554    
01555    for (i = 0; i <= stack->b_num; i++) {
01556       if (stack->bc[i].in_use && stack->bc[i].channel == channel) {
01557          return &stack->bc[i];
01558       }
01559    }
01560       
01561    return NULL;
01562 }

static struct misdn_bchannel* find_bc_by_confid ( unsigned long  confid  )  [static]

Definition at line 1530 of file isdn_lib.c.

References misdn_stack::b_num, misdn_stack::bc, misdn_bchannel::conf_id, glob_mgr, misdn_bchannel::in_use, misdn_stack::next, and misdn_lib::stack_list.

Referenced by misdn_lib_send_event().

01531 {
01532    struct misdn_stack *stack;
01533    int i;
01534    
01535    for (stack = glob_mgr->stack_list; stack; stack = stack->next) {
01536       for (i = 0; i <= stack->b_num; i++) {
01537          if (stack->bc[i].in_use && stack->bc[i].conf_id == confid) {
01538             return &stack->bc[i];
01539          }
01540       }
01541    }
01542    return NULL;
01543 }

struct misdn_bchannel * find_bc_by_l3id ( struct misdn_stack stack,
unsigned long  l3id 
)

Definition at line 1500 of file isdn_lib.c.

References misdn_stack::b_num, misdn_stack::bc, misdn_bchannel::in_use, and misdn_bchannel::l3_id.

Referenced by handle_cr(), handle_event_nt(), handle_frm(), manager_event_handler(), and release_cr().

01501 {
01502    int i;
01503 
01504    for (i = 0; i <= stack->b_num; i++) {
01505       if (stack->bc[i].in_use && stack->bc[i].l3_id == l3id) {
01506          return &stack->bc[i];
01507       }
01508    }
01509    return stack_holder_find(stack,l3id);
01510 }

static struct misdn_bchannel* find_bc_by_masked_l3id ( struct misdn_stack stack,
unsigned long  l3id,
unsigned long  mask 
) [static]

Definition at line 1487 of file isdn_lib.c.

References misdn_stack::b_num, misdn_stack::bc, misdn_bchannel::in_use, and misdn_bchannel::l3_id.

Referenced by handle_event_nt().

01488 {
01489    int i;
01490 
01491    for (i = 0; i <= stack->b_num; i++) {
01492       if (stack->bc[i].in_use && (stack->bc[i].l3_id & mask) == (l3id & mask)) {
01493          return &stack->bc[i];
01494       }
01495    }
01496    return stack_holder_find(stack,l3id);
01497 }

static int find_free_chan_in_stack ( struct misdn_stack stack,
struct misdn_bchannel bc,
int  channel,
int  dec 
) [static]

Definition at line 499 of file isdn_lib.c.

References misdn_stack::b_num, misdn_stack::bc, cb_log, chan, misdn_bchannel::channel_found, misdn_stack::channels, MAX_BCHANS, misdn_stack::port, misdn_stack::pri, pthread_mutex_lock, and misdn_stack::st_lock.

Referenced by create_process(), handle_event(), handle_event_nt(), and misdn_lib_send_event().

00500 {
00501    int i;
00502    int chan=0;
00503    int bnums = stack->pri ? stack->b_num : stack->b_num - 1;
00504 
00505    if (bc->channel_found)  
00506       return 0;
00507    
00508    bc->channel_found=1;
00509 
00510    cb_log(5,stack->port,"find_free_chan: req_chan:%d\n",channel);
00511 
00512    if (channel < 0 || channel > MAX_BCHANS) {
00513       cb_log(0, stack->port, " !! out of bound call to find_free_chan_in_stack! (ch:%d)\n", channel);
00514       return 0;
00515    }
00516    
00517    channel--;
00518 
00519    pthread_mutex_lock(&stack->st_lock);
00520    if (dec) {
00521       for (i = bnums; i >=0; i--) {
00522          if (i != 15 && (channel < 0 || i == channel)) { /* skip E1 D channel ;) and work with chan preselection */
00523             if (!stack->channels[i]) {
00524                cb_log (3, stack->port, " --> found chan%s: %d\n", channel>=0?" (preselected)":"", i+1);
00525                chan=i+1;
00526                break;
00527             }
00528          }
00529       }
00530    } else {
00531       for (i = 0; i <= bnums; i++) {
00532          if (i != 15 && (channel < 0 || i == channel)) { /* skip E1 D channel ;) and work with chan preselection */
00533             if (!stack->channels[i]) {
00534                cb_log (3, stack->port, " --> found chan%s: %d\n", channel>=0?" (preselected)":"", i+1);
00535                chan=i+1;
00536                break;
00537             }
00538          }
00539       }
00540    }
00541 
00542    if (!chan) {
00543       pthread_mutex_unlock(&stack->st_lock);
00544       cb_log (1, stack->port, " !! NO FREE CHAN IN STACK\n");
00545       dump_chan_list(stack);
00546       bc->out_cause = AST_CAUSE_NORMAL_CIRCUIT_CONGESTION;
00547       return -1;
00548    }  
00549 
00550    if (set_chan_in_stack(stack, chan)<0) {
00551       pthread_mutex_unlock(&stack->st_lock);
00552       cb_log (0, stack->port, "Channel Already in use:%d\n", chan);
00553       bc->out_cause = AST_CAUSE_REQUESTED_CHAN_UNAVAIL;
00554       return -1;
00555    }
00556    pthread_mutex_unlock(&stack->st_lock);
00557 
00558    bc->channel=chan;
00559    return 0;
00560 }

static struct misdn_stack* find_stack_by_addr ( int  addr  )  [static]

Definition at line 1448 of file isdn_lib.c.

References glob_mgr, misdn_stack::next, misdn_lib::stack_list, and misdn_stack::upper_id.

Referenced by handle_frm(), handle_frm_nt(), handle_l1(), handle_l2(), and handle_mgmt().

01449 {
01450    struct misdn_stack *stack;
01451    
01452    for (stack=glob_mgr->stack_list;
01453         stack;
01454         stack=stack->next) {
01455       if ( (stack->upper_id&STACK_ID_MASK) == (addr&STACK_ID_MASK)) return stack;
01456 
01457    }
01458   
01459    return NULL;
01460 }

static struct misdn_stack* find_stack_by_mgr ( manager_t *  mgr_nt  )  [static]

Definition at line 1475 of file isdn_lib.c.

References glob_mgr, misdn_stack::mgr, misdn_stack::next, and misdn_lib::stack_list.

Referenced by handle_event_nt().

01476 {
01477    struct misdn_stack *stack;
01478   
01479    for (stack=glob_mgr->stack_list;
01480         stack;
01481         stack=stack->next) 
01482       if ( &stack->mgr == mgr_nt) return stack;
01483   
01484    return NULL;
01485 }

static struct misdn_stack* find_stack_by_port ( int  port  )  [static]

Definition at line 1463 of file isdn_lib.c.

References glob_mgr, misdn_stack::next, misdn_stack::port, and misdn_lib::stack_list.

Referenced by find_bc_by_channel(), handle_err(), manager_event_handler(), misdn_lib_get_port_info(), misdn_lib_port_restart(), misdn_lib_reinit_nt_stack(), and misdn_lib_send_restart().

01464 {
01465    struct misdn_stack *stack;
01466   
01467    for (stack=glob_mgr->stack_list;
01468         stack;
01469         stack=stack->next) 
01470       if (stack->port == port) return stack;
01471   
01472    return NULL;
01473 }

static char* flip_buf_bits ( char *  buf,
int  len 
) [static]

Definition at line 328 of file isdn_lib.c.

References flip_table.

Referenced by handle_bchan(), misdn_lib_init(), misdn_lib_tx2misdn_frm(), and misdn_tx_jitter().

00329 {
00330    int i;
00331    char * start = buf;
00332    
00333    for (i = 0 ; i < len; i++) {
00334       buf[i] = flip_table[(unsigned char)buf[i]];
00335    }
00336    
00337    return start;
00338 }

struct misdn_stack * get_misdn_stack ( void   ) 

Definition at line 4617 of file isdn_lib.c.

References glob_mgr, and misdn_lib::stack_list.

Referenced by get_show_stack_details(), get_stack_by_bc(), misdn_dump_chanlist(), misdn_lib_find_held_bc(), misdn_lib_get_maxchans(), misdn_lib_is_port_blocked(), misdn_lib_is_ptp(), misdn_lib_nt_keepcalls(), misdn_lib_port_block(), misdn_lib_port_is_nt(), misdn_lib_port_is_pri(), and misdn_lib_port_unblock().

04617                                       {
04618    return glob_mgr->stack_list;
04619 }

void get_show_stack_details ( int  port,
char *  buf 
)

Definition at line 162 of file isdn_lib.c.

References get_misdn_stack(), misdn_stack::next, and misdn_stack::port.

Referenced by handle_cli_misdn_show_port(), and handle_cli_misdn_show_stacks().

00163 {
00164    struct misdn_stack *stack=get_misdn_stack();
00165    
00166    for ( ; stack; stack=stack->next) {
00167       if (stack->port == port) break;
00168    }
00169    
00170    if (stack) {
00171       sprintf(buf, "* Port %d Type %s Prot. %s L2Link %s L1Link:%s Blocked:%d",
00172          stack->port, stack->nt ? "NT" : "TE", stack->ptp ? "PTP" : "PMP",
00173          stack->l2link ? "UP" : "DOWN", stack->l1link ? "UP" : "DOWN",
00174          stack->blocked);
00175    } else {
00176       buf[0]=0;
00177    }
00178 }

struct misdn_stack* get_stack_by_bc ( struct misdn_bchannel bc  ) 

Definition at line 146 of file isdn_lib.c.

References misdn_stack::bc, get_misdn_stack(), misdn_stack::next, misdn_bchannel::port, and misdn_stack::port.

Referenced by clean_up_bc(), create_process(), dec_ie_channel_id(), enc_ie_channel_id(), handle_bchan(), handle_event(), manager_bchannel_activate(), manager_bchannel_deactivate(), manager_clean_bc(), manager_ec_disable(), manager_ec_enable(), misdn_lib_log_ies(), misdn_lib_release(), misdn_lib_send_event(), misdn_lib_tx2misdn_frm(), parse_release_complete(), parse_restart(), send_msg(), and setup_bc().

00147 {
00148    struct misdn_stack *stack = get_misdn_stack();
00149 
00150    if (!bc)
00151       return NULL;
00152    
00153    for ( ; stack; stack = stack->next) {
00154       if (bc->port == stack->port)
00155          return stack;
00156    }
00157 
00158    return NULL;
00159 }

static int handle_bchan ( msg_t *  msg  )  [static]

Definition at line 2388 of file isdn_lib.c.

References misdn_bchannel::addr, misdn_bchannel::b_stid, misdn_stack::bc, misdn_bchannel::bc_state, bc_state2str(), bc_state_change(), BCHAN_ACTIVATED, BCHAN_CLEAN_REQUEST, BCHAN_SETUP, BCHAN_SETUPED, misdn_bchannel::bframe, misdn_bchannel::bframe_len, buf, misdn_bchannel::capability, cb_event, cb_log, misdn_bchannel::channel, clean_up_bc(), misdn_bchannel::dad, misdn_bchannel::dnumplan, do_tone(), misdn_bchannel::dtmf, errno, EVENT_BCHAN_DATA, EVENT_DTMF_TONE, find_bc_by_addr(), flip_buf_bits(), get_stack_by_bc(), glob_mgr, misdn_bchannel::layer, misdn_stack::midev, misdn_cap_is_speech(), misdn_tx_jitter(), misdn_bchannel::nojitter, misdn_bchannel::oad, misdn_bchannel::onumplan, misdn_bchannel::pid, misdn_stack::port, misdn_bchannel::port, and misdn_lib::user_data.

Referenced by handle_err(), and manager_isdn_handler().

02389 {
02390    iframe_t *frm= (iframe_t*)msg->data;
02391    struct misdn_bchannel *bc=find_bc_by_addr(frm->addr);
02392    struct misdn_stack *stack;
02393    
02394    if (!bc) {
02395       cb_log(1,0,"handle_bchan: BC not found for prim:%x with addr:%x dinfo:%x\n", frm->prim, frm->addr, frm->dinfo);
02396       return 0 ;
02397    }
02398    
02399    stack = get_stack_by_bc(bc);
02400    
02401    if (!stack) {
02402       cb_log(0, bc->port,"handle_bchan: STACK not found for prim:%x with addr:%x dinfo:%x\n", frm->prim, frm->addr, frm->dinfo);
02403       return 0;
02404    }
02405    
02406    switch (frm->prim) {
02407 
02408    case MGR_SETSTACK| CONFIRM:
02409       cb_log(3, stack->port, "BCHAN: MGR_SETSTACK|CONFIRM pid:%d\n",bc->pid);
02410       break;
02411       
02412    case MGR_SETSTACK| INDICATION:
02413       cb_log(3, stack->port, "BCHAN: MGR_SETSTACK|IND pid:%d\n",bc->pid);
02414    break;
02415 #if 0
02416    AGAIN:
02417       bc->addr = mISDN_get_layerid(stack->midev, bc->b_stid, bc->layer);
02418       if (!bc->addr) {
02419 
02420          if (errno == EAGAIN) {
02421             usleep(1000);
02422             goto AGAIN;
02423          }
02424          
02425          cb_log(0,stack->port,"$$$ Get Layer (%d) Id Error: %s\n",bc->layer,strerror(errno));
02426          
02427          /* we kill the channel later, when we received some
02428             data. */
02429          bc->addr= frm->addr;
02430       } else if ( bc->addr < 0) {
02431          cb_log(0, stack->port,"$$$ bc->addr <0 Error:%s\n",strerror(errno));
02432          bc->addr=0;
02433       }
02434       
02435       cb_log(4, stack->port," --> Got Adr %x\n", bc->addr);
02436 
02437       free_msg(msg);
02438    
02439       
02440       switch(bc->bc_state) {
02441       case BCHAN_SETUP:
02442          bc_state_change(bc,BCHAN_SETUPED);
02443       break;
02444 
02445       case BCHAN_CLEAN_REQUEST:
02446       default:
02447          cb_log(0, stack->port," --> STATE WASN'T SETUP (but %s) in SETSTACK|IND pid:%d\n",bc_state2str(bc->bc_state), bc->pid);
02448          clean_up_bc(bc);
02449       }
02450       return 1;
02451 #endif
02452 
02453    case MGR_DELLAYER| INDICATION:
02454       cb_log(3, stack->port, "BCHAN: MGR_DELLAYER|IND pid:%d\n",bc->pid);
02455       break;
02456       
02457    case MGR_DELLAYER| CONFIRM:
02458       cb_log(3, stack->port, "BCHAN: MGR_DELLAYER|CNF pid:%d\n",bc->pid);
02459       
02460       bc->pid=0;
02461       bc->addr=0;
02462       
02463       free_msg(msg);
02464       return 1;
02465       
02466    case PH_ACTIVATE | INDICATION:
02467    case DL_ESTABLISH | INDICATION:
02468       cb_log(3, stack->port, "BCHAN: ACT Ind pid:%d\n", bc->pid);
02469 
02470       free_msg(msg);
02471       return 1;    
02472 
02473    case PH_ACTIVATE | CONFIRM:
02474    case DL_ESTABLISH | CONFIRM:
02475       
02476       cb_log(3, stack->port, "BCHAN: bchan ACT Confirm pid:%d\n",bc->pid);
02477       free_msg(msg);
02478       
02479       return 1;    
02480 
02481    case DL_ESTABLISH | REQUEST:
02482       {
02483          char buf[128];
02484          mISDN_write_frame(stack->midev, buf, bc->addr | FLG_MSG_TARGET | FLG_MSG_DOWN,  DL_ESTABLISH | CONFIRM, 0,0, NULL, TIMEOUT_1SEC);
02485       }
02486       free_msg(msg);
02487       return 1;
02488 
02489    case DL_RELEASE|REQUEST:
02490       {
02491          char buf[128];
02492          mISDN_write_frame(stack->midev, buf, bc->addr | FLG_MSG_TARGET | FLG_MSG_DOWN,  DL_RELEASE| CONFIRM, 0,0, NULL, TIMEOUT_1SEC);
02493       }
02494       free_msg(msg);
02495       return 1;
02496       
02497    case PH_DEACTIVATE | INDICATION:
02498    case DL_RELEASE | INDICATION:
02499       cb_log (3, stack->port, "BCHAN: DeACT Ind pid:%d\n",bc->pid);
02500       
02501       free_msg(msg);
02502       return 1;
02503     
02504    case PH_DEACTIVATE | CONFIRM:
02505    case DL_RELEASE | CONFIRM:
02506       cb_log(3, stack->port, "BCHAN: DeACT Conf pid:%d\n",bc->pid);
02507       
02508       free_msg(msg);
02509       return 1;
02510     
02511    case PH_CONTROL|INDICATION:
02512    {
02513       unsigned int *cont = (unsigned int *) &frm->data.p;
02514       
02515       cb_log(4, stack->port, "PH_CONTROL: channel:%d oad%d:%s dad%d:%s \n", bc->channel, bc->onumplan,bc->oad, bc->dnumplan,bc->dad);
02516 
02517       if ((*cont & ~DTMF_TONE_MASK) == DTMF_TONE_VAL) {
02518          int dtmf = *cont & DTMF_TONE_MASK;
02519          cb_log(4, stack->port, " --> DTMF TONE: %c\n",dtmf);
02520          bc->dtmf=dtmf;
02521          cb_event(EVENT_DTMF_TONE, bc, glob_mgr->user_data);
02522    
02523          free_msg(msg);
02524          return 1;
02525       }
02526       if (*cont == BF_REJECT) {
02527          cb_log(4, stack->port, " --> BF REJECT\n");
02528          free_msg(msg);
02529          return 1;
02530       }
02531       if (*cont == BF_ACCEPT) {
02532          cb_log(4, stack->port, " --> BF ACCEPT\n");
02533          free_msg(msg);
02534          return 1;
02535       }
02536    }
02537    break;
02538 
02539    case PH_DATA|REQUEST:
02540    case DL_DATA|REQUEST:
02541       cb_log(0, stack->port, "DL_DATA REQUEST \n");
02542       do_tone(bc, 64);
02543       
02544       free_msg(msg);
02545       return 1;
02546    
02547    
02548    case PH_DATA|INDICATION:
02549    case DL_DATA|INDICATION:
02550    {
02551       bc->bframe = (void*)&frm->data.i;
02552       bc->bframe_len = frm->len;
02553 
02554       /** Anyway flip the bufbits **/
02555       if ( misdn_cap_is_speech(bc->capability) ) 
02556          flip_buf_bits(bc->bframe, bc->bframe_len);
02557    
02558 
02559       if (!bc->bframe_len) {
02560          cb_log(2, stack->port, "DL_DATA INDICATION bc->addr:%x frm->addr:%x\n", bc->addr, frm->addr);
02561          free_msg(msg);
02562          return 1;
02563       }
02564 
02565       if ( (bc->addr&STACK_ID_MASK) != (frm->addr&STACK_ID_MASK) ) {
02566          cb_log(2, stack->port, "DL_DATA INDICATION bc->addr:%x frm->addr:%x\n", bc->addr, frm->addr);
02567          free_msg(msg);
02568          return 1;
02569       }
02570       
02571 #if MISDN_DEBUG
02572       cb_log(0, stack->port, "DL_DATA INDICATION Len %d\n", frm->len);
02573 
02574 #endif
02575       
02576       if ( (bc->bc_state == BCHAN_ACTIVATED) && frm->len > 0) {
02577          int t;
02578 
02579 #ifdef MISDN_B_DEBUG
02580          cb_log(0,bc->port,"do_tone START\n");
02581 #endif
02582          t=do_tone(bc,frm->len);
02583 
02584 #ifdef MISDN_B_DEBUG
02585          cb_log(0,bc->port,"do_tone STOP (%d)\n",t);
02586 #endif
02587          if (  !t ) {
02588             int i;
02589             
02590             if ( misdn_cap_is_speech(bc->capability)) {
02591                if ( !bc->nojitter ) {
02592 #ifdef MISDN_B_DEBUG
02593                   cb_log(0,bc->port,"tx_jitter START\n");
02594 #endif
02595                   misdn_tx_jitter(bc,frm->len);
02596 #ifdef MISDN_B_DEBUG
02597                   cb_log(0,bc->port,"tx_jitter STOP\n");
02598 #endif
02599                }
02600             }
02601 
02602 #ifdef MISDN_B_DEBUG 
02603             cb_log(0,bc->port,"EVENT_B_DATA START\n");
02604 #endif
02605             
02606             i = cb_event(EVENT_BCHAN_DATA, bc, glob_mgr->user_data);
02607 #ifdef MISDN_B_DEBUG 
02608             cb_log(0,bc->port,"EVENT_B_DATA STOP\n");
02609 #endif
02610             
02611             if (i<0) {
02612                cb_log(10,stack->port,"cb_event returned <0\n");
02613                /*clean_up_bc(bc);*/
02614             }
02615          }
02616       }
02617       free_msg(msg);
02618       return 1;
02619    }
02620 
02621 
02622    case PH_CONTROL | CONFIRM:
02623       cb_log(4, stack->port, "PH_CONTROL|CNF bc->addr:%x\n", frm->addr);
02624       free_msg(msg);
02625       return 1;
02626 
02627    case PH_DATA | CONFIRM:
02628    case DL_DATA|CONFIRM:
02629 #if MISDN_DEBUG
02630 
02631       cb_log(0, stack->port, "Data confirmed\n");
02632 
02633 #endif
02634       free_msg(msg);
02635       return 1;
02636    case DL_DATA|RESPONSE:
02637 #if MISDN_DEBUG
02638       cb_log(0, stack->port, "Data response\n");
02639 
02640 #endif
02641       break;
02642    }
02643   
02644    return 0;
02645 }

static int handle_cr ( struct misdn_stack stack,
iframe_t *  frm 
) [static]

Definition at line 1653 of file isdn_lib.c.

References cb_event, cb_log, misdn_bchannel::channel, clean_up_bc(), dump_chan_list(), empty_bc(), empty_chan_in_stack(), EVENT_CLEANUP, find_bc_by_l3id(), free, glob_mgr, misdn_bchannel::in_use, misdn_bchannel::l3_id, misdn_lib_get_free_bc(), misdn_make_dummy(), misdn_bchannel::need_disconnect, misdn_bchannel::need_release, misdn_bchannel::need_release_complete, misdn_stack::nt, misdn_stack::port, misdn_bchannel::stack_holder, stack_holder_remove(), and misdn_lib::user_data.

Referenced by handle_event_nt(), handle_frm(), and release_cr().

01654 {
01655    struct misdn_bchannel *bc;
01656 
01657    if (!stack) return -1;
01658   
01659    switch (frm->prim) {
01660    case CC_NEW_CR|INDICATION:
01661       cb_log(7, stack->port, " --> lib: NEW_CR Ind with l3id:%x on this port.\n",frm->dinfo);
01662 
01663       bc = misdn_lib_get_free_bc(stack->port, 0, 1, 0);
01664       if (!bc) {
01665          cb_log(0, stack->port, " --> !! lib: No free channel!\n");
01666          return -1;
01667       }
01668   
01669       cb_log(7, stack->port, " --> new_process: New L3Id: %x\n",frm->dinfo);
01670       bc->l3_id=frm->dinfo;
01671       return 1;
01672    case CC_NEW_CR|CONFIRM:
01673       return 1;
01674    case CC_NEW_CR|REQUEST:
01675       return 1;
01676    case CC_RELEASE_CR|REQUEST:
01677       return 1;
01678    case CC_RELEASE_CR|CONFIRM:
01679       break;
01680    case CC_RELEASE_CR|INDICATION:
01681       cb_log(4, stack->port, " --> lib: RELEASE_CR Ind with l3id:%x\n",frm->dinfo);
01682       {
01683          struct misdn_bchannel *bc=find_bc_by_l3id(stack, frm->dinfo);
01684          struct misdn_bchannel dummybc;
01685       
01686          if (!bc) {
01687             cb_log(4, stack->port, " --> Didn't find BC so temporarily creating dummy BC (l3id:%x) on this port.\n", frm->dinfo);
01688             misdn_make_dummy(&dummybc, stack->port, frm->dinfo, stack->nt, 0);
01689             
01690             bc=&dummybc; 
01691          }
01692       
01693          if (bc) {
01694             int channel = bc->channel;
01695             cb_log(4, stack->port, " --> lib: CLEANING UP l3id: %x\n",frm->dinfo);
01696 
01697             /*bc->pid = 0;*/
01698             bc->need_disconnect=0;
01699             bc->need_release=0;
01700             bc->need_release_complete=0;
01701 
01702             cb_event(EVENT_CLEANUP, bc, glob_mgr->user_data);
01703 
01704             empty_bc(bc);
01705             clean_up_bc(bc);
01706 
01707             if (channel>0)
01708                empty_chan_in_stack(stack,channel);
01709             bc->in_use=0;
01710 
01711             dump_chan_list(stack);
01712 
01713             if (bc->stack_holder) {
01714                cb_log(4,stack->port, "REMOVING Holder\n");
01715                stack_holder_remove( stack, bc);
01716                free(bc);
01717             }
01718          }
01719          else {
01720             if (stack->nt) 
01721                cb_log(4, stack->port, "BC with dinfo: %x  not found.. (prim was %x and addr %x)\n",frm->dinfo, frm->prim, frm->addr);
01722          }
01723       
01724          return 1;
01725       }
01726       break;
01727    }
01728   
01729    return 0;
01730 }

static int handle_err ( msg_t *  msg  )  [static]

Definition at line 3634 of file isdn_lib.c.

References misdn_stack::bc, misdn_bchannel::bc_state, bc_state2str(), cb_log, misdn_bchannel::channel, find_bc_by_channel(), find_stack_by_port(), handle_bchan(), misdn_stack::l1link, misdn_stack::l2link, misdn_lib_get_l1_down(), misdn_lib_get_l2_down(), and misdn_bchannel::port.

Referenced by manager_isdn_handler().

03635 {
03636    iframe_t *frm = (iframe_t*) msg->data;
03637 
03638 
03639    if (!frm->addr) {
03640       static int cnt=0;
03641       if (!cnt)
03642          cb_log(0,0,"mISDN Msg without Address pr:%x dinfo:%x\n",frm->prim,frm->dinfo);
03643       cnt++;
03644       if (cnt>100) {
03645          cb_log(0,0,"mISDN Msg without Address pr:%x dinfo:%x (already more than 100 of them)\n",frm->prim,frm->dinfo);
03646          cnt=0;
03647       }
03648       
03649       free_msg(msg);
03650       return 1;
03651       
03652    }
03653    
03654    switch (frm->prim) {
03655       case MGR_SETSTACK|INDICATION:
03656          return handle_bchan(msg);
03657       break;
03658 
03659       case MGR_SETSTACK|CONFIRM:
03660       case MGR_CLEARSTACK|CONFIRM:
03661          free_msg(msg) ; 
03662          return 1;
03663       break;
03664 
03665       case DL_DATA|CONFIRM:
03666          cb_log(4,0,"DL_DATA|CONFIRM\n");
03667          free_msg(msg);
03668          return 1;
03669 
03670       case PH_CONTROL|CONFIRM:
03671          cb_log(4,0,"PH_CONTROL|CONFIRM\n");
03672          free_msg(msg);
03673          return 1;
03674 
03675       case DL_DATA|INDICATION:
03676       {
03677          int port=(frm->addr&MASTER_ID_MASK) >> 8;
03678          int channel=(frm->addr&CHILD_ID_MASK) >> 16;
03679          struct misdn_bchannel *bc;
03680 
03681          /*we flush the read buffer here*/
03682          
03683          cb_log(9,0,"BCHAN DATA without BC: addr:%x port:%d channel:%d\n",frm->addr, port,channel);
03684          
03685          free_msg(msg); 
03686          return 1;
03687          
03688          
03689          bc = find_bc_by_channel(port, channel);
03690 
03691          if (!bc) {
03692             struct misdn_stack *stack = find_stack_by_port(port);
03693 
03694             if (!stack) {
03695                cb_log(0,0," --> stack not found\n");
03696                free_msg(msg);
03697                return 1;
03698             }
03699             
03700             cb_log(0,0," --> bc not found by channel\n");
03701             if (stack->l2link)
03702                misdn_lib_get_l2_down(stack);
03703 
03704             if (stack->l1link)
03705                misdn_lib_get_l1_down(stack);
03706 
03707             free_msg(msg);
03708             return 1;
03709          }
03710          
03711          cb_log(3,port," --> BC in state:%s\n", bc_state2str(bc->bc_state));
03712       }
03713    }
03714 
03715    return 0;
03716 }

static int handle_event ( struct misdn_bchannel bc,
enum event_e  event,
iframe_t *  frm 
) [static]

Definition at line 1568 of file isdn_lib.c.

References misdn_stack::bc, cb_log, EVENT_ALERTING, EVENT_CONNECT, EVENT_CONNECT_ACKNOWLEDGE, EVENT_PROCEEDING, EVENT_PROGRESS, EVENT_RELEASE, EVENT_RELEASE_COMPLETE, EVENT_SETUP, EVENT_SETUP_ACKNOWLEDGE, find_free_chan_in_stack(), get_stack_by_bc(), manager_ec_enable(), manager_ph_control(), manager_ph_control_block(), misdn_cap_is_speech(), misdn_lib_send_event(), misdn_stack::nt, misdn_stack::port, misdn_stack::pri, misdn_stack::ptp, and setup_bc().

01569 {
01570    struct misdn_stack *stack=get_stack_by_bc(bc);
01571    
01572    if (!stack->nt) {
01573       
01574       switch (event) {
01575 
01576       case EVENT_CONNECT_ACKNOWLEDGE:
01577          setup_bc(bc);
01578 
01579          if ( *bc->crypt_key ) {
01580             cb_log(4, stack->port, "ENABLING BLOWFISH channel:%d oad%d:%s dad%d:%s\n", bc->channel, bc->onumplan,bc->oad, bc->dnumplan,bc->dad);
01581             manager_ph_control_block(bc,  BF_ENABLE_KEY, bc->crypt_key, strlen(bc->crypt_key) );
01582          }
01583 
01584          if (misdn_cap_is_speech(bc->capability)) {
01585             if (  !bc->nodsp) manager_ph_control(bc,  DTMF_TONE_START, 0);
01586             manager_ec_enable(bc);
01587 
01588             if ( bc->txgain != 0 ) {
01589                cb_log(4, stack->port, "--> Changing txgain to %d\n", bc->txgain);
01590                manager_ph_control(bc, VOL_CHANGE_TX, bc->txgain);
01591             }
01592             if ( bc->rxgain != 0 ) {
01593                cb_log(4, stack->port, "--> Changing rxgain to %d\n", bc->rxgain);
01594                manager_ph_control(bc, VOL_CHANGE_RX, bc->rxgain);
01595             }
01596          }
01597 
01598          break;
01599       case EVENT_CONNECT:
01600 
01601          if ( *bc->crypt_key ) {
01602             cb_log(4, stack->port, "ENABLING BLOWFISH channel:%d oad%d:%s dad%d:%s\n", bc->channel, bc->onumplan,bc->oad, bc->dnumplan,bc->dad);
01603             manager_ph_control_block(bc,  BF_ENABLE_KEY, bc->crypt_key, strlen(bc->crypt_key) );
01604          }
01605       case EVENT_ALERTING:
01606       case EVENT_PROGRESS:
01607       case EVENT_PROCEEDING:
01608       case EVENT_SETUP_ACKNOWLEDGE:
01609       case EVENT_SETUP:
01610       {
01611          if (bc->channel == 0xff || bc->channel<=0)
01612             bc->channel=0;
01613 
01614          if (find_free_chan_in_stack(stack, bc, bc->channel, 0)<0){
01615             if (!stack->pri && !stack->ptp)  {
01616                bc->cw=1;
01617                break;
01618             }
01619 
01620             if (!bc->channel)
01621                cb_log(0, stack->port, "Any Channel Requested, but we have no more!!\n");
01622             else 
01623                cb_log(0, stack->port,
01624                   "Requested Channel Already in Use releasing this call with cause %d!!!!\n",
01625                   bc->out_cause);
01626 
01627             /* when the channel is already in use, we can't
01628              * simply clear it, we need to make sure that 
01629              * it will still be marked as in_use in the 
01630              * available channels list.*/
01631             bc->channel=0;
01632 
01633             misdn_lib_send_event(bc,EVENT_RELEASE_COMPLETE);
01634             return -1;
01635          }
01636       }
01637 
01638       setup_bc(bc);
01639       break;
01640 
01641       case EVENT_RELEASE_COMPLETE:
01642       case EVENT_RELEASE:
01643          break;
01644       default:
01645          break;
01646       }
01647    } else {    /** NT MODE **/
01648       
01649    }
01650    return 0;
01651 }

int handle_event_nt ( void *  dat,
void *  arg 
) [static]

Definition at line 1867 of file isdn_lib.c.

References AST_CAUSE_USER_BUSY, misdn_stack::bc, misdn_bchannel::cause, cb_event, cb_log, misdn_bchannel::channel, clean_up_bc(), create_l3msg(), empty_bc(), empty_chan_in_stack(), EVENT_NEW_L3ID, EVENT_PORT_ALARM, EVENT_RELEASE, EVENT_RELEASE_COMPLETE, EVENT_SETUP, find_bc_by_l3id(), find_bc_by_masked_l3id(), find_free_chan_in_stack(), find_stack_by_mgr(), free, glob_mgr, handle_cr(), misdn_bchannel::in_use, isdn_get_info(), isdn_msg_get_event(), isdn_msg_parse_event(), misdn_stack::l1link, misdn_stack::l2link, misdn_stack::l2upcnt, misdn_bchannel::l3_id, misdn_lib_get_free_bc(), misdn_lib_get_l2_up(), misdn_lib_reinit_nt_stack(), misdn_lib_send_event(), misdn_lib_send_restart(), misdn_make_dummy(), mISDNUSER_HEAD_SIZE, msg, msgs_g, misdn_stack::nst, misdn_stack::nstlock, misdn_stack::nt, misdn_bchannel::port, misdn_stack::port, misdn_stack::procids, pthread_mutex_lock, pthread_mutex_unlock, misdn_stack::ptp, release_cr(), misdn_stack::restart_sent, stack_holder_find(), stack_holder_remove(), misdn_stack::upper_id, and misdn_lib::user_data.

Referenced by misdn_lib_reinit_nt_stack().

01868 {
01869    manager_t *mgr = (manager_t *)dat;
01870    msg_t *msg = (msg_t *)arg;
01871    mISDNuser_head_t *hh;
01872    struct misdn_stack *stack;
01873    int reject=0;
01874 
01875    if (!msg || !mgr)
01876       return(-EINVAL);
01877 
01878    stack = find_stack_by_mgr(mgr);
01879    hh=(mISDNuser_head_t*)msg->data;
01880 
01881    /*
01882     * When we are called from the mISDNuser lib, the nstlock is held and it
01883     * must be held when we return.  We unlock here because the lib may be
01884     * entered again recursively.
01885     */
01886    pthread_mutex_unlock(&stack->nstlock);
01887 
01888    cb_log(5, stack->port, " --> lib: prim %x dinfo %x\n",hh->prim, hh->dinfo);
01889    {
01890       switch(hh->prim){
01891       case CC_RETRIEVE|INDICATION:
01892       {
01893          struct misdn_bchannel *bc;
01894          struct misdn_bchannel *hold_bc;
01895 
01896          iframe_t frm; /* fake te frm to add callref to global callreflist */
01897          frm.dinfo = hh->dinfo;
01898 
01899          frm.addr=stack->upper_id | FLG_MSG_DOWN;
01900 
01901          frm.prim = CC_NEW_CR|INDICATION;
01902          
01903          if (handle_cr( stack, &frm)< 0) {
01904             msg_t *dmsg;
01905             cb_log(4, stack->port, "Patch from MEIDANIS:Sending RELEASE_COMPLETE %x (No free Chan for you..)\n", hh->dinfo);
01906             dmsg = create_l3msg(CC_RELEASE_COMPLETE | REQUEST,MT_RELEASE_COMPLETE, hh->dinfo,sizeof(RELEASE_COMPLETE_t), 1);
01907             pthread_mutex_lock(&stack->nstlock);
01908             stack->nst.manager_l3(&stack->nst, dmsg);
01909             free_msg(msg);
01910             return 0;
01911          }
01912          
01913          bc = find_bc_by_l3id(stack, hh->dinfo);
01914          hold_bc = stack_holder_find(stack, bc->l3_id);
01915          cb_log(4, stack->port, "bc_l3id:%x holded_bc_l3id:%x\n",bc->l3_id, hold_bc->l3_id);
01916 
01917          if (hold_bc) {
01918             cb_log(4, stack->port, "REMOVING Holder\n");
01919 
01920             /*swap the backup to our new channel back*/
01921             stack_holder_remove(stack, hold_bc);
01922             memcpy(bc, hold_bc, sizeof(*bc));
01923             free(hold_bc);
01924 
01925             bc->holded=0;
01926             bc->b_stid=0;
01927          }
01928          
01929       }
01930          
01931          break;
01932          
01933       case CC_SETUP|CONFIRM:
01934       {
01935          struct misdn_bchannel *bc=find_bc_by_l3id(stack, hh->dinfo);
01936          int l3id = *((int *)(((u_char *)msg->data)+ mISDNUSER_HEAD_SIZE));
01937          cb_log(4, stack->port, " --> lib: Event_ind:SETUP CONFIRM [NT] : new L3ID  is %x\n",l3id );
01938    
01939          if (bc) {
01940             cb_log (2, bc->port, "I IND :CC_SETUP|CONFIRM: old l3id:%x new l3id:%x\n", bc->l3_id, l3id);
01941             bc->l3_id = l3id;
01942             cb_event(EVENT_NEW_L3ID, bc, glob_mgr->user_data);
01943          } else {
01944             cb_log(4, stack->port, "Bc Not found (after SETUP CONFIRM)\n");
01945          }
01946       }
01947       free_msg(msg);
01948       pthread_mutex_lock(&stack->nstlock);
01949       return 0;
01950       
01951       case CC_SETUP|INDICATION:
01952       {
01953          struct misdn_bchannel* bc=misdn_lib_get_free_bc(stack->port, 0, 1, 0);
01954          if (!bc) {
01955             msg_t *dmsg;
01956             cb_log(4, stack->port, "Patch from MEIDANIS:Sending RELEASE_COMPLETE %x (No free Chan for you..)\n", hh->dinfo);
01957             dmsg = create_l3msg(CC_RELEASE_COMPLETE | REQUEST,MT_RELEASE_COMPLETE, hh->dinfo,sizeof(RELEASE_COMPLETE_t), 1);
01958             pthread_mutex_lock(&stack->nstlock);
01959             stack->nst.manager_l3(&stack->nst, dmsg);
01960             free_msg(msg);
01961             return 0;
01962          }
01963   
01964          cb_log(4, stack->port, " --> new_process: New L3Id: %x\n",hh->dinfo);
01965          bc->l3_id=hh->dinfo;
01966       }
01967       break;
01968 
01969       case CC_CONNECT_ACKNOWLEDGE|INDICATION:
01970       break;
01971       
01972       case CC_ALERTING|INDICATION:
01973       case CC_PROCEEDING|INDICATION:
01974       case CC_SETUP_ACKNOWLEDGE|INDICATION:
01975          if(!stack->ptp) break;  
01976       case CC_CONNECT|INDICATION:
01977       break;
01978       case CC_DISCONNECT|INDICATION:
01979       {
01980          struct misdn_bchannel *bc=find_bc_by_l3id(stack, hh->dinfo);
01981          if (!bc) {
01982             bc=find_bc_by_masked_l3id(stack, hh->dinfo, 0xffff0000);
01983             if (bc) { 
01984                int myprocid=bc->l3_id&0x0000ffff;
01985                hh->dinfo=(hh->dinfo&0xffff0000)|myprocid;
01986                cb_log(3,stack->port,"Reject dinfo: %x cause:%d\n",hh->dinfo,bc->cause);
01987                reject=1;      
01988             }
01989          }
01990       }
01991       break;
01992       
01993       case CC_FACILITY|INDICATION:
01994       {
01995          struct misdn_bchannel *bc=find_bc_by_l3id(stack, hh->dinfo);
01996          if (!bc) {
01997             bc=find_bc_by_masked_l3id(stack, hh->dinfo, 0xffff0000);
01998             if (bc) { 
01999                int myprocid=bc->l3_id&0x0000ffff;
02000                hh->dinfo=(hh->dinfo&0xffff0000)|myprocid;
02001                cb_log(4,bc->port,"Repaired reject Bug, new dinfo: %x\n",hh->dinfo);
02002             }
02003          }
02004       }
02005       break;
02006       
02007       case CC_RELEASE_COMPLETE|INDICATION:
02008          break;
02009 
02010       case CC_SUSPEND|INDICATION:
02011       {
02012          msg_t *dmsg;
02013          cb_log(4, stack->port, " --> Got Suspend, sending Reject for now\n");
02014          dmsg = create_l3msg(CC_SUSPEND_REJECT | REQUEST,MT_SUSPEND_REJECT, hh->dinfo,sizeof(RELEASE_COMPLETE_t), 1);
02015          pthread_mutex_lock(&stack->nstlock);
02016          stack->nst.manager_l3(&stack->nst, dmsg);
02017          free_msg(msg);
02018          return 0;
02019       }
02020       break;
02021       case CC_RESUME|INDICATION:
02022          break;
02023 
02024       case CC_RELEASE|CONFIRM:
02025          {
02026             struct misdn_bchannel *bc=find_bc_by_l3id(stack, hh->dinfo);
02027 
02028             if (bc) { 
02029                cb_log(1, stack->port, "CC_RELEASE|CONFIRM (l3id:%x), sending RELEASE_COMPLETE\n", hh->dinfo);
02030                misdn_lib_send_event(bc, EVENT_RELEASE_COMPLETE);
02031             }
02032          }
02033          break;
02034          
02035       case CC_RELEASE|INDICATION:
02036          break;
02037 
02038       case CC_RELEASE_CR|INDICATION:
02039          release_cr(stack, hh);
02040          free_msg(msg);
02041          pthread_mutex_lock(&stack->nstlock);
02042          return 0 ;
02043       break;
02044       
02045       case CC_NEW_CR|INDICATION:
02046          /*  Got New CR for bchan, for now I handle this one in */
02047          /*  connect_ack, Need to be changed */
02048       {
02049          struct misdn_bchannel *bc=find_bc_by_l3id(stack, hh->dinfo);
02050          int l3id = *((int *)(((u_char *)msg->data)+ mISDNUSER_HEAD_SIZE));
02051          if (!bc) {
02052             cb_log(0, stack->port, " --> In NEW_CR: didn't found bc ??\n");
02053             pthread_mutex_lock(&stack->nstlock);
02054             return -1;
02055          }
02056          if (((l3id&0xff00)!=0xff00) && ((bc->l3_id&0xff00)==0xff00)) {
02057             cb_log(4, stack->port, " --> Removing Process Id:%x on this port.\n", 0xff&bc->l3_id);
02058             stack->procids[bc->l3_id&0xff] = 0 ;
02059          }
02060          cb_log(4, stack->port, "lib: Event_ind:CC_NEW_CR : very new L3ID  is %x\n",l3id );
02061    
02062          bc->l3_id =l3id;
02063          cb_event(EVENT_NEW_L3ID, bc, glob_mgr->user_data);
02064    
02065          free_msg(msg);
02066          pthread_mutex_lock(&stack->nstlock);
02067          return 0;
02068       }
02069       
02070       case DL_ESTABLISH | INDICATION:
02071       case DL_ESTABLISH | CONFIRM:
02072       {
02073          cb_log(3, stack->port, "%% GOT L2 Activate Info.\n");
02074          
02075          if (stack->ptp && stack->l2link) {
02076             cb_log(0, stack->port, "%% GOT L2 Activate Info. but we're activated already.. this l2 is faulty, blocking port\n");
02077             cb_event(EVENT_PORT_ALARM, &stack->bc[0], glob_mgr->user_data);
02078          }
02079 
02080          if (stack->ptp && !stack->restart_sent) {
02081             /* make sure we restart the interface of the 
02082              * other side */
02083             stack->restart_sent=1;
02084             misdn_lib_send_restart(stack->port, -1);
02085 
02086          }
02087       
02088          /* when we get the L2 UP, the L1 is UP definitely too*/
02089          stack->l2link = 1;
02090          stack->l2upcnt=0;
02091          
02092          free_msg(msg);
02093          pthread_mutex_lock(&stack->nstlock);
02094          return 0;
02095       }
02096       break;
02097 
02098 
02099       case DL_RELEASE | INDICATION:
02100       case DL_RELEASE | CONFIRM:
02101       {
02102          if (stack->ptp) {
02103             cb_log(3 , stack->port, "%% GOT L2 DeActivate Info.\n");
02104 
02105             if (stack->l2upcnt>3) {
02106                cb_log(0 , stack->port, "!!! Could not Get the L2 up after 3 Attempts!!!\n");
02107             }  else {
02108 #if 0
02109                if (stack->nt) misdn_lib_reinit_nt_stack(stack->port);
02110 #endif
02111                if (stack->l1link) {
02112                   misdn_lib_get_l2_up(stack);
02113                   stack->l2upcnt++;
02114                }
02115             }
02116             
02117          } else 
02118             cb_log(3, stack->port, "%% GOT L2 DeActivate Info.\n");
02119          
02120          stack->l2link = 0;
02121          free_msg(msg);
02122          pthread_mutex_lock(&stack->nstlock);
02123          return 0;
02124       }
02125       break;
02126       }
02127    }
02128    
02129    {
02130       /*  Parse Events and fire_up to App. */
02131       struct misdn_bchannel *bc;
02132       struct misdn_bchannel dummybc;
02133       
02134       enum event_e event = isdn_msg_get_event(msgs_g, msg, 1);
02135     
02136       bc=find_bc_by_l3id(stack, hh->dinfo);
02137     
02138       if (!bc) {
02139          cb_log(4, stack->port, " --> Didn't find BC so temporarily creating dummy BC (l3id:%x).\n", hh->dinfo);
02140          misdn_make_dummy(&dummybc, stack->port,  hh->dinfo, stack->nt, 0);
02141          bc=&dummybc; 
02142       }
02143       if (bc ) {
02144          isdn_msg_parse_event(msgs_g,msg,bc, 1);
02145 
02146          switch (event) {
02147             case EVENT_SETUP:
02148                if (bc->channel<=0 || bc->channel==0xff) 
02149                   bc->channel=0;
02150             
02151                if (find_free_chan_in_stack(stack,bc, bc->channel,0)<0) {
02152                   msg_t *dmsg;
02153                   cb_log(4, stack->port, "Patch from MEIDANIS:Sending RELEASE_COMPLETE %x (No free Chan for you..)\n", hh->dinfo);
02154                   dmsg = create_l3msg(CC_RELEASE_COMPLETE | REQUEST,MT_RELEASE_COMPLETE, hh->dinfo,sizeof(RELEASE_COMPLETE_t), 1);
02155                   pthread_mutex_lock(&stack->nstlock);
02156                   stack->nst.manager_l3(&stack->nst, dmsg);
02157                   free_msg(msg);
02158                   return 0;
02159                }
02160                break;
02161             case EVENT_RELEASE:
02162             case EVENT_RELEASE_COMPLETE:
02163                {
02164                int channel=bc->channel;
02165                int tmpcause=bc->cause; 
02166                          empty_bc(bc);
02167                bc->cause=tmpcause;
02168                clean_up_bc(bc);
02169 
02170                if (channel>0)
02171                                  empty_chan_in_stack(stack,channel);
02172                bc->in_use=0;
02173                }
02174                break;
02175 
02176             default:
02177             break;
02178          }
02179          
02180          if(!isdn_get_info(msgs_g,event,1)) {
02181             cb_log(4, stack->port, "Unknown Event Ind: prim %x dinfo %x\n",hh->prim, hh->dinfo);
02182          } else {
02183             if (reject) {
02184                switch(bc->cause){
02185                   case AST_CAUSE_USER_BUSY:
02186                      cb_log(1, stack->port, "Siemens Busy reject..\n");
02187 
02188                      break;
02189                   default:
02190                      break;
02191                }
02192             }
02193             cb_event(event, bc, glob_mgr->user_data);
02194          }
02195       } else {
02196          cb_log(4, stack->port, "No BC found with l3id: prim %x dinfo %x\n",hh->prim, hh->dinfo);
02197       }
02198 
02199       free_msg(msg);
02200    }
02201 
02202 
02203    pthread_mutex_lock(&stack->nstlock);
02204    return 0;
02205 }

static int handle_frm ( msg_t *  msg  )  [static]

Definition at line 2684 of file isdn_lib.c.

References AST_CAUSE_NORMAL_CLEARING, AST_CAUSE_REQUESTED_CHAN_UNAVAIL, bc_state_change(), BCHAN_CLEANED, misdn_bchannel::cause, cb_event, cb_log, misdn_bchannel::channel, clean_up_bc(), empty_bc(), empty_chan_in_stack(), EVENT_RELEASE_COMPLETE, EVENT_RESTART, EVENT_SETUP, find_bc_by_l3id(), find_stack_by_addr(), glob_mgr, handle_cr(), handle_event(), misdn_bchannel::in_use, isdn_get_info(), isdn_msg_get_event(), isdn_msg_parse_event(), misdn_lib_send_event(), misdn_lib_send_restart(), misdn_make_dummy(), msgs_g, misdn_bchannel::out_cause, misdn_bchannel::port, RESPONSE_IGNORE_SETUP, RESPONSE_IGNORE_SETUP_WITHOUT_CLOSE, RESPONSE_OK, RESPONSE_RELEASE_SETUP, misdn_bchannel::restart_channel, and misdn_lib::user_data.

Referenced by manager_event_handler(), and manager_isdn_handler().

02685 {
02686    iframe_t *frm = (iframe_t*) msg->data;
02687    
02688    struct misdn_stack *stack=find_stack_by_addr(frm->addr);
02689 
02690    if (!stack || stack->nt) {
02691       return 0;
02692    }
02693    
02694    cb_log(4,stack?stack->port:0,"handle_frm: frm->addr:%x frm->prim:%x\n",frm->addr,frm->prim);
02695 
02696    {
02697       struct misdn_bchannel dummybc;
02698       struct misdn_bchannel *bc;
02699       int ret=handle_cr(stack, frm);
02700 
02701       if (ret<0) {
02702          cb_log(3,stack?stack->port:0,"handle_frm: handle_cr <0 prim:%x addr:%x\n", frm->prim, frm->addr);
02703 
02704 
02705       }
02706 
02707       if(ret) {
02708          free_msg(msg);
02709          return 1;
02710       }
02711     
02712       bc=find_bc_by_l3id(stack, frm->dinfo);
02713 
02714       if (!bc && (frm->prim==(CC_RESTART|CONFIRM)) ) {
02715          misdn_make_dummy(&dummybc, stack->port, MISDN_ID_GLOBAL, stack->nt, 0);
02716          bc=&dummybc;
02717       }
02718 
02719       if (!bc && (frm->prim==(CC_SETUP|INDICATION)) ) {
02720          misdn_make_dummy(&dummybc, stack->port, MISDN_ID_GLOBAL, stack->nt, 0);
02721          dummybc.port=stack->port;
02722          dummybc.l3_id=frm->dinfo;
02723          bc=&dummybc;
02724 
02725          misdn_lib_send_event(bc,EVENT_RELEASE_COMPLETE);
02726 
02727          free_msg(msg);
02728          return 1;
02729       }
02730 
02731     
02732 handle_frm_bc:
02733       if (bc ) {
02734          enum event_e event = isdn_msg_get_event(msgs_g, msg, 0);
02735          enum event_response_e response=RESPONSE_OK;
02736          int ret;
02737       
02738          isdn_msg_parse_event(msgs_g,msg,bc, 0);
02739          
02740          /** Preprocess some Events **/
02741          ret = handle_event(bc, event, frm);
02742          if (ret<0) {
02743             cb_log(0,stack->port,"couldn't handle event\n");
02744             free_msg(msg);
02745             return 1;
02746          }
02747          /*  shoot up event to App: */
02748          cb_log(5, stack->port, "lib Got Prim: Addr %x prim %x dinfo %x\n",frm->addr, frm->prim, frm->dinfo);
02749       
02750          if(!isdn_get_info(msgs_g,event,0)) 
02751             cb_log(0, stack->port, "Unknown Event Ind: Addr:%x prim %x dinfo %x\n",frm->addr, frm->prim, frm->dinfo);
02752          else
02753             response=cb_event(event, bc, glob_mgr->user_data);
02754 #if 1
02755          if (event == EVENT_SETUP) {
02756             switch (response) {
02757             case RESPONSE_IGNORE_SETUP_WITHOUT_CLOSE:
02758 
02759                cb_log(0, stack->port, "TOTALLY IGNORING SETUP\n");               
02760                
02761                break;
02762             case RESPONSE_IGNORE_SETUP:
02763                /* I think we should send CC_RELEASE_CR, but am not sure*/
02764                bc->out_cause = AST_CAUSE_NORMAL_CLEARING;
02765             
02766             case RESPONSE_RELEASE_SETUP:
02767                misdn_lib_send_event(bc,EVENT_RELEASE_COMPLETE);
02768                if (bc->channel>0)
02769                   empty_chan_in_stack(stack, bc->channel);
02770                empty_bc(bc);
02771                bc_state_change(bc,BCHAN_CLEANED);
02772                bc->in_use=0;
02773 
02774                cb_log(0, stack->port, "GOT IGNORE SETUP\n");
02775                break;
02776             case RESPONSE_OK:
02777                cb_log(4, stack->port, "GOT SETUP OK\n");
02778 
02779                
02780                break;
02781             default:
02782                break;
02783             }
02784          }
02785 
02786          if (event == EVENT_RELEASE_COMPLETE) {
02787             /* release bchannel only after we've announced the RELEASE_COMPLETE */
02788             int channel=bc->channel;
02789             int tmpcause=bc->cause; 
02790             int tmp_out_cause=bc->out_cause; 
02791             empty_bc(bc);
02792             bc->cause=tmpcause;
02793             bc->out_cause=tmp_out_cause;
02794             clean_up_bc(bc);
02795             bc->in_use = 0;
02796             
02797             if (tmpcause == AST_CAUSE_REQUESTED_CHAN_UNAVAIL) {
02798                cb_log(0, stack->port, "**** Received CAUSE:%d, restarting channel %d\n", AST_CAUSE_REQUESTED_CHAN_UNAVAIL, channel);
02799                misdn_lib_send_restart(stack->port, channel);
02800             }
02801             if (channel > 0) {
02802                empty_chan_in_stack(stack, channel);
02803             }
02804          }
02805 
02806          if (event == EVENT_RESTART) {
02807             cb_log(0, stack->port, "**** Received RESTART channel:%d\n", bc->restart_channel);
02808             empty_chan_in_stack(stack, bc->restart_channel);
02809          }
02810 
02811          cb_log(5, stack->port, "Freeing Msg on prim:%x \n",frm->prim);
02812 
02813          
02814          free_msg(msg);
02815          return 1;
02816 #endif
02817       
02818       } else {
02819          struct misdn_bchannel dummybc;
02820          if (frm->prim!=(CC_FACILITY|INDICATION))
02821             cb_log(0, stack->port, " --> Didn't find BC so temporarily creating dummy BC (l3id:%x) on this port.\n", frm->dinfo);
02822          else
02823             cb_log(5, stack->port, " --> Using Dummy BC for FACILITy\n");
02824 
02825          memset (&dummybc,0,sizeof(dummybc));
02826          dummybc.port=stack->port;
02827          dummybc.l3_id=frm->dinfo;
02828          bc=&dummybc; 
02829          goto handle_frm_bc;
02830       }
02831    }
02832 
02833    cb_log(4, stack->port, "TE_FRM_HANDLER: Returning 0 on prim:%x \n",frm->prim);
02834    return 0;
02835 }

static int handle_frm_nt ( msg_t *  msg  )  [static]

Definition at line 2649 of file isdn_lib.c.

References cb_log, find_stack_by_addr(), nt_err_cnt, pthread_mutex_lock, and pthread_mutex_unlock.

Referenced by manager_event_handler(), and manager_isdn_handler().

02650 {
02651    iframe_t *frm= (iframe_t*)msg->data;
02652    struct misdn_stack *stack;
02653    int err=0;
02654 
02655    stack=find_stack_by_addr( frm->addr );
02656 
02657    
02658   
02659    if (!stack || !stack->nt) {
02660       return 0;
02661    }
02662 
02663    
02664    pthread_mutex_lock(&stack->nstlock);
02665    if ((err=stack->nst.l1_l2(&stack->nst,msg))) {
02666       pthread_mutex_unlock(&stack->nstlock);
02667       if (nt_err_cnt > 0 ) {
02668          if (nt_err_cnt < 100) {
02669             nt_err_cnt++; 
02670             cb_log(0, stack->port, "NT Stack sends us error: %d \n", err);
02671          } else if (nt_err_cnt < 105){
02672             cb_log(0, stack->port, "NT Stack sends us error: %d over 100 times, so I'll stop this message\n", err);
02673             nt_err_cnt = - 1; 
02674          }
02675       }
02676       free_msg(msg);
02677       return 1;
02678    }
02679    pthread_mutex_unlock(&stack->nstlock);
02680    return 1;
02681 }

static int handle_l1 ( msg_t *  msg  )  [static]

Definition at line 2838 of file isdn_lib.c.

References cb_event, cb_log, EVENT_CLEANUP, EVENT_NOTHING, find_stack_by_addr(), glob_mgr, global_state, isdn_get_info(), MISDN_INITIALIZED, misdn_lib_get_l2_up(), misdn_lib_send_event(), msgs_g, pthread_mutex_lock, pthread_mutex_unlock, and misdn_lib::user_data.

Referenced by manager_isdn_handler().

02839 {
02840    iframe_t *frm = (iframe_t*) msg->data;
02841    struct misdn_stack *stack = find_stack_by_addr(frm->addr);
02842    int i ;
02843    
02844    if (!stack) return 0 ;
02845 
02846    switch (frm->prim) {
02847    case PH_ACTIVATE | CONFIRM:
02848    case PH_ACTIVATE | INDICATION:
02849       cb_log (3, stack->port, "L1: PH L1Link Up!\n");
02850       stack->l1link=1;
02851       
02852       if (stack->nt) {
02853          
02854          pthread_mutex_lock(&stack->nstlock);
02855          if (stack->nst.l1_l2(&stack->nst, msg))
02856             free_msg(msg);
02857          pthread_mutex_unlock(&stack->nstlock);
02858 
02859          if (stack->ptp)
02860             misdn_lib_get_l2_up(stack);
02861       } else {
02862          free_msg(msg);
02863       }
02864       
02865       for (i=0;i<=stack->b_num; i++) {
02866          if (stack->bc[i].evq != EVENT_NOTHING) {
02867             cb_log(4, stack->port, "Firing Queued Event %s because L1 got up\n", isdn_get_info(msgs_g, stack->bc[i].evq, 0));
02868             misdn_lib_send_event(&stack->bc[i],stack->bc[i].evq);
02869             stack->bc[i].evq=EVENT_NOTHING;
02870          }
02871          
02872       }
02873       return 1;
02874 
02875    case PH_ACTIVATE | REQUEST:
02876       free_msg(msg);
02877       cb_log(3,stack->port,"L1: PH_ACTIVATE|REQUEST \n");
02878       return 1;
02879       
02880    case PH_DEACTIVATE | REQUEST:
02881       free_msg(msg);
02882       cb_log(3,stack->port,"L1: PH_DEACTIVATE|REQUEST \n");
02883       return 1;
02884       
02885    case PH_DEACTIVATE | CONFIRM:
02886    case PH_DEACTIVATE | INDICATION:
02887       cb_log (3, stack->port, "L1: PH L1Link Down! \n");
02888    
02889 #if 0
02890       for (i=0; i<=stack->b_num; i++) {
02891          if (global_state == MISDN_INITIALIZED)  {
02892             cb_event(EVENT_CLEANUP, &stack->bc[i], glob_mgr->user_data);
02893          }
02894       }
02895 #endif
02896       
02897       if (stack->nt) {
02898          pthread_mutex_lock(&stack->nstlock);
02899          if (stack->nst.l1_l2(&stack->nst, msg))
02900             free_msg(msg);
02901          pthread_mutex_unlock(&stack->nstlock);
02902       } else {
02903          free_msg(msg);
02904       }
02905       
02906       stack->l1link=0;
02907       stack->l2link=0;
02908       return 1;
02909    }
02910   
02911    return 0;
02912 }

static int handle_l2 ( msg_t *  msg  )  [static]

Definition at line 2914 of file isdn_lib.c.

References cb_event, cb_log, EVENT_PORT_ALARM, find_stack_by_addr(), glob_mgr, and misdn_lib::user_data.

Referenced by manager_isdn_handler().

02915 {
02916    iframe_t *frm = (iframe_t*) msg->data;
02917 
02918    struct misdn_stack *stack = find_stack_by_addr(frm->addr);
02919    
02920    if (!stack) {
02921       return 0 ;
02922    }
02923    
02924    switch(frm->prim) {
02925 
02926    case DL_ESTABLISH | REQUEST:
02927       cb_log(1,stack->port,"DL_ESTABLISH|REQUEST \n");
02928       free_msg(msg);
02929       return 1;
02930    case DL_RELEASE | REQUEST:
02931       cb_log(1,stack->port,"DL_RELEASE|REQUEST \n");
02932       free_msg(msg);
02933       return 1;
02934       
02935    case DL_ESTABLISH | INDICATION:
02936    case DL_ESTABLISH | CONFIRM:
02937    {
02938       cb_log (3, stack->port, "L2: L2Link Up! \n");
02939       if (stack->ptp && stack->l2link) {
02940          cb_log (-1, stack->port, "L2: L2Link Up! but it's already UP.. must be faulty, blocking port\n"); 
02941          cb_event(EVENT_PORT_ALARM, &stack->bc[0], glob_mgr->user_data);
02942       }
02943       stack->l2link=1;
02944       free_msg(msg);
02945       return 1;
02946    }
02947    break;
02948     
02949    case DL_RELEASE | INDICATION:
02950    case DL_RELEASE | CONFIRM:
02951    {
02952       cb_log (3, stack->port, "L2: L2Link Down! \n");
02953       stack->l2link=0;
02954       
02955       free_msg(msg);
02956       return 1;
02957    }
02958    break;
02959    }
02960    return 0;
02961 }

static int handle_mgmt ( msg_t *  msg  )  [static]

Definition at line 2963 of file isdn_lib.c.

References cb_log, clear_l3(), and find_stack_by_addr().

Referenced by manager_isdn_handler().

02964 {
02965    iframe_t *frm = (iframe_t*) msg->data;
02966    struct misdn_stack *stack;
02967 
02968    if ( (frm->addr == 0) && (frm->prim == (MGR_DELLAYER|CONFIRM)) ) {
02969       cb_log(2, 0, "MGMT: DELLAYER|CONFIRM Addr: 0 !\n") ;
02970       free_msg(msg);
02971       return 1;
02972    }
02973    
02974    stack = find_stack_by_addr(frm->addr);
02975    
02976    if (!stack) {
02977       if (frm->prim == (MGR_DELLAYER|CONFIRM)) {
02978          cb_log(2, 0, "MGMT: DELLAYER|CONFIRM Addr: %x !\n",
02979                frm->addr) ;
02980          free_msg(msg);
02981          return 1;
02982       }
02983       
02984       return 0;
02985    }
02986    
02987    switch(frm->prim) {
02988    case MGR_SHORTSTATUS | INDICATION:
02989    case MGR_SHORTSTATUS | CONFIRM:
02990       cb_log(5, stack->port, "MGMT: Short status dinfo %x\n",frm->dinfo);
02991       
02992       switch (frm->dinfo) {
02993       case SSTATUS_L1_ACTIVATED:
02994          cb_log(3, stack->port, "MGMT: SSTATUS: L1_ACTIVATED \n");
02995          stack->l1link=1;
02996       
02997          break;
02998       case SSTATUS_L1_DEACTIVATED:
02999          cb_log(3, stack->port, "MGMT: SSTATUS: L1_DEACTIVATED \n");
03000          stack->l1link=0;
03001 #if 0
03002          clear_l3(stack);
03003 #endif
03004          break;
03005 
03006       case SSTATUS_L2_ESTABLISHED:
03007          cb_log(3, stack->port, "MGMT: SSTATUS: L2_ESTABLISH \n");
03008          stack->l2link=1;
03009          break;
03010          
03011       case SSTATUS_L2_RELEASED:
03012          cb_log(3, stack->port, "MGMT: SSTATUS: L2_RELEASED \n");
03013          stack->l2link=0;
03014          break;
03015       }
03016       
03017       free_msg(msg);
03018       return 1;
03019       
03020    case MGR_SETSTACK | INDICATION:
03021       cb_log(4, stack->port, "MGMT: SETSTACK|IND dinfo %x\n",frm->dinfo);
03022       free_msg(msg);
03023       return 1;
03024    case MGR_DELLAYER | CONFIRM:
03025       cb_log(4, stack->port, "MGMT: DELLAYER|CNF dinfo %x\n",frm->dinfo) ;
03026       free_msg(msg);
03027       return 1;
03028       
03029    }
03030    
03031    /*
03032    if ( (frm->prim & 0x0f0000) ==  0x0f0000) {
03033    cb_log(5, 0, "$$$ MGMT FRAME: prim %x addr %x dinfo %x\n",frm->prim, frm->addr, frm->dinfo) ;
03034    free_msg(msg);
03035    return 1;
03036    } */
03037     
03038    return 0;
03039 }

static int handle_timers ( msg_t *  msg  )  [static]

Definition at line 2208 of file isdn_lib.c.

References cb_log, glob_mgr, misdn_stack::midev, misdn_stack::next, misdn_stack::nst, misdn_stack::nstlock, misdn_stack::nt, pthread_mutex_lock, pthread_mutex_unlock, and misdn_lib::stack_list.

Referenced by manager_isdn_handler().

02209 {
02210    iframe_t *frm= (iframe_t*)msg->data;
02211    struct misdn_stack *stack; 
02212   
02213    /* Timer Stuff */
02214    switch (frm->prim) {
02215    case MGR_INITTIMER | CONFIRM:
02216    case MGR_ADDTIMER | CONFIRM:
02217    case MGR_DELTIMER | CONFIRM:
02218    case MGR_REMOVETIMER | CONFIRM:
02219       free_msg(msg);
02220       return(1);
02221    }
02222   
02223   
02224   
02225    if (frm->prim==(MGR_TIMER | INDICATION) ) {
02226       for (stack = glob_mgr->stack_list;
02227            stack;
02228            stack = stack->next) {
02229          itimer_t *it;
02230       
02231          if (!stack->nt) continue;
02232       
02233          it = stack->nst.tlist;
02234          /* find timer */
02235          for(it=stack->nst.tlist;
02236              it;
02237              it=it->next) {
02238             if (it->id == (int)frm->addr)
02239                break;
02240          }
02241          if (it) {
02242             int ret;
02243             ret = mISDN_write_frame(stack->midev, msg->data, frm->addr,
02244                      MGR_TIMER | RESPONSE, 0, 0, NULL, TIMEOUT_1SEC);
02245             test_and_clear_bit(FLG_TIMER_RUNING, (long unsigned int *)&it->Flags);
02246             pthread_mutex_lock(&stack->nstlock);
02247             ret = it->function(it->data);
02248             pthread_mutex_unlock(&stack->nstlock);
02249             free_msg(msg);
02250             return 1;
02251          }
02252       }
02253     
02254       cb_log(0, 0, "Timer Msg without Timer ??\n");
02255       free_msg(msg);
02256       return 1;
02257    }
02258   
02259    return 0;
02260 }

static int init_bc ( struct misdn_stack stack,
struct misdn_bchannel bc,
int  midev,
int  port,
int  bidx,
char *  msn,
int  firsttime 
) [static]

IFACE

Definition at line 1170 of file isdn_lib.c.

References misdn_bchannel::astbuf, misdn_stack::bc, bc_state_change(), BCHAN_CLEANED, buff, cb_log, empty_bc(), send_lock::lock, malloc, MISDN_IBUF_SIZE, misdn_bchannel::msn, misdn_stack::nt, misdn_bchannel::nt, misdn_stack::port, misdn_bchannel::port, misdn_stack::pri, misdn_bchannel::pri, pthread_mutex_init, and misdn_bchannel::send_lock.

Referenced by misdn_lib_init().

01171 {
01172    unsigned char buff[1025] = "";
01173    iframe_t *frm = (iframe_t *)buff;
01174    int ret;
01175   
01176    if (!bc) return -1;
01177   
01178    cb_log(8, port, "Init.BC %d.\n",bidx);
01179    
01180    memset(bc, 0,sizeof(struct misdn_bchannel));
01181 
01182    bc->send_lock=malloc(sizeof(struct send_lock));
01183    if (!bc->send_lock) {
01184       return -1;
01185    }
01186    pthread_mutex_init(&bc->send_lock->lock, NULL);
01187    
01188    if (msn) {
01189       int l = sizeof(bc->msn);
01190       strncpy(bc->msn,msn, l);
01191       bc->msn[l-1] = 0;
01192    }
01193    
01194    
01195    empty_bc(bc);
01196    bc_state_change(bc, BCHAN_CLEANED);
01197    
01198    bc->port=stack->port;
01199    bc->nt=stack->nt?1:0;
01200    bc->pri=stack->pri;
01201    
01202    {
01203       ibuffer_t* ibuf= init_ibuffer(MISDN_IBUF_SIZE);
01204 
01205       if (!ibuf) return -1;
01206       
01207       clear_ibuffer( ibuf);
01208       
01209       ibuf->rsem=malloc(sizeof(sem_t));
01210       if (!ibuf->rsem) {
01211          return -1;
01212       }
01213       
01214       bc->astbuf=ibuf;
01215 
01216       if (sem_init(ibuf->rsem,1,0)<0)
01217          sem_init(ibuf->rsem,0,0);
01218       
01219    }
01220    
01221    {
01222       stack_info_t *stinf;
01223       ret = mISDN_get_stack_info(midev, stack->port, buff, sizeof(buff));
01224       if (ret < 0) {
01225          cb_log(0, port, "%s: Cannot get stack info for this port. (ret=%d)\n", __FUNCTION__, ret);
01226          return -1;
01227       }
01228     
01229       stinf = (stack_info_t *)&frm->data.p;
01230     
01231       cb_log(8, port, " --> Child %x\n",stinf->child[bidx]);
01232    }
01233   
01234    return 0;
01235 }

static void init_flip_bits ( void   )  [static]

Definition at line 315 of file isdn_lib.c.

References flip_table.

Referenced by misdn_lib_init().

00316 {
00317    int i,k;
00318    
00319    for (i = 0 ; i < 256 ; i++) {
00320       unsigned char sample = 0 ;
00321       for (k = 0; k<8; k++) {
00322          if ( i & 1 << k ) sample |= 0x80 >>  k;
00323       }
00324       flip_table[i] = sample;
00325    }
00326 }

void isdn_lib_stop_dtmf ( struct misdn_bchannel bc  ) 

Definition at line 4380 of file isdn_lib.c.

References misdn_stack::bc, and manager_ph_control().

Referenced by process_ast_dsp().

04381 {
04382    manager_ph_control(bc, DTMF_TONE_STOP, 0);
04383 }

void isdn_lib_update_ec ( struct misdn_bchannel bc  ) 

Definition at line 4368 of file isdn_lib.c.

References misdn_stack::bc, misdn_bchannel::ec_enable, manager_ec_disable(), and manager_ec_enable().

Referenced by process_ast_dsp().

04369 {
04370 #ifdef MISDN_1_2
04371    if (*bc->pipeline)
04372 #else
04373    if (bc->ec_enable)
04374 #endif
04375       manager_ec_enable(bc);
04376    else
04377       manager_ec_disable(bc);
04378 }

void isdn_lib_update_rxgain ( struct misdn_bchannel bc  ) 

Definition at line 4358 of file isdn_lib.c.

References misdn_stack::bc, manager_ph_control(), and misdn_bchannel::rxgain.

Referenced by process_ast_dsp().

04359 {
04360    manager_ph_control(bc, VOL_CHANGE_RX, bc->rxgain);
04361 }

void isdn_lib_update_txgain ( struct misdn_bchannel bc  ) 

Definition at line 4363 of file isdn_lib.c.

References misdn_stack::bc, manager_ph_control(), and misdn_bchannel::txgain.

Referenced by process_ast_dsp().

04364 {
04365    manager_ph_control(bc, VOL_CHANGE_TX, bc->txgain);
04366 }

void manager_bchannel_activate ( struct misdn_bchannel bc  ) 

Definition at line 4241 of file isdn_lib.c.

References misdn_bchannel::addr, misdn_bchannel::astbuf, misdn_stack::bc, buf, cb_log, get_stack_by_bc(), misdn_stack::midev, misdn_bchannel::port, and misdn_stack::port.

04242 {
04243    char buf[128];
04244 
04245    struct misdn_stack *stack=get_stack_by_bc(bc);
04246 
04247    if (!stack) {
04248       cb_log(0, bc->port, "bchannel_activate: Stack not found !");
04249       return ;
04250    }
04251    
04252    /* we must activate if we are deactivated */
04253    clear_ibuffer(bc->astbuf);
04254    
04255    cb_log(5, stack->port, "$$$ Bchan Activated addr %x\n", bc->addr);
04256    
04257    mISDN_write_frame(stack->midev, buf, bc->addr | FLG_MSG_DOWN,  DL_ESTABLISH | REQUEST, 0,0, NULL, TIMEOUT_1SEC);
04258 
04259    return ;
04260 }

void manager_bchannel_cleanup ( struct misdn_bchannel bc  ) 

void manager_bchannel_deactivate ( struct misdn_bchannel bc  ) 

Definition at line 4263 of file isdn_lib.c.

References misdn_bchannel::addr, misdn_bchannel::astbuf, misdn_stack::bc, misdn_bchannel::bc_state, bc_state_change(), BCHAN_ACTIVATED, BCHAN_BRIDGED, BCHAN_RELEASE, buf, cb_log, misdn_bchannel::conf_id, misdn_bchannel::generate_tone, get_stack_by_bc(), misdn_stack::midev, misdn_split_conf(), misdn_bchannel::port, and misdn_stack::port.

Referenced by clean_up_bc().

04264 {
04265    struct misdn_stack *stack=get_stack_by_bc(bc);
04266    iframe_t dact;
04267    char buf[128]; 
04268 
04269    switch (bc->bc_state) {
04270       case BCHAN_ACTIVATED:
04271          break;
04272       case BCHAN_BRIDGED:
04273          misdn_split_conf(bc,bc->conf_id);
04274          break;
04275       default:
04276          cb_log( 4, bc->port,"bchan_deactivate: called but not activated\n");
04277          return ;
04278 
04279    }
04280    
04281    cb_log(5, stack->port, "$$$ Bchan deActivated addr %x\n", bc->addr);
04282    
04283    bc->generate_tone=0;
04284    
04285    dact.prim = DL_RELEASE | REQUEST;
04286    dact.addr = bc->addr | FLG_MSG_DOWN;
04287    dact.dinfo = 0;
04288    dact.len = 0;
04289    mISDN_write_frame(stack->midev, buf, bc->addr | FLG_MSG_DOWN, DL_RELEASE|REQUEST,0,0,NULL, TIMEOUT_1SEC);
04290 
04291    clear_ibuffer(bc->astbuf);
04292    
04293    bc_state_change(bc,BCHAN_RELEASE);
04294   
04295    return;
04296 }

void manager_bchannel_setup ( struct misdn_bchannel bc  ) 

void manager_clean_bc ( struct misdn_bchannel bc  ) 

Definition at line 4407 of file isdn_lib.c.

References misdn_stack::bc, cb_event, misdn_bchannel::channel, empty_bc(), empty_chan_in_stack(), EVENT_CLEANUP, get_stack_by_bc(), and misdn_bchannel::in_use.

Referenced by misdn_lib_pid_restart().

04408 {
04409    struct misdn_stack *stack=get_stack_by_bc(bc);
04410    
04411    if (bc->channel>0)
04412       empty_chan_in_stack(stack, bc->channel);
04413    empty_bc(bc);
04414    bc->in_use=0;
04415 
04416    cb_event(EVENT_CLEANUP, bc, NULL); 
04417 }

void manager_ec_disable ( struct misdn_bchannel bc  ) 

Definition at line 4596 of file isdn_lib.c.

References misdn_stack::bc, misdn_bchannel::capability, cb_log, misdn_bchannel::ec_enable, ECHOCAN_OFF, get_stack_by_bc(), manager_ph_control(), manager_ph_control_block(), misdn_cap_is_speech(), and misdn_stack::port.

Referenced by clean_up_bc(), handle_cli_misdn_toggle_echocancel(), and isdn_lib_update_ec().

04597 {
04598    struct misdn_stack *stack=get_stack_by_bc(bc);
04599    
04600    cb_log(4, stack?stack->port:0," --> ec_disable\n");
04601 
04602    if (!misdn_cap_is_speech(bc->capability)) {
04603       cb_log(1, stack?stack->port:0, " --> no speech? cannot disable EC\n");
04604       return;
04605    }
04606 
04607 #ifdef MISDN_1_2
04608    manager_ph_control_block(bc, PIPELINE_CFG, "", 0);
04609 #else
04610    if ( ! bc->ec_enable) {
04611       cb_log(3, stack?stack->port:0, "Sending Control ECHOCAN_OFF\n");
04612       manager_ph_control(bc,  ECHOCAN_OFF, 0);
04613    }
04614 #endif
04615 }

void manager_ec_enable ( struct misdn_bchannel bc  ) 

Definition at line 4547 of file isdn_lib.c.

References misdn_stack::bc, misdn_bchannel::capability, cb_log, misdn_bchannel::ec_deftaps, misdn_bchannel::ec_enable, ECHOCAN_ON, get_stack_by_bc(), manager_ph_control_block(), misdn_cap_is_speech(), and misdn_stack::port.

Referenced by handle_cli_misdn_toggle_echocancel(), handle_event(), isdn_lib_update_ec(), and misdn_lib_send_event().

04548 {
04549    struct misdn_stack *stack=get_stack_by_bc(bc);
04550    
04551    cb_log(4, stack?stack->port:0,"ec_enable\n");
04552 
04553    if (!misdn_cap_is_speech(bc->capability)) {
04554       cb_log(1, stack?stack->port:0, " --> no speech? cannot enable EC\n");
04555    } else {
04556 
04557 #ifdef MISDN_1_2
04558    if (*bc->pipeline) {
04559       cb_log(3, stack?stack->port:0,"Sending Control PIPELINE_CFG %s\n",bc->pipeline);
04560       manager_ph_control_block(bc, PIPELINE_CFG, bc->pipeline, strlen(bc->pipeline) + 1);
04561    }
04562 #else
04563    int ec_arr[2];
04564 
04565    if (bc->ec_enable) {
04566       cb_log(3, stack?stack->port:0,"Sending Control ECHOCAN_ON taps:%d\n",bc->ec_deftaps);
04567    
04568       switch (bc->ec_deftaps) {
04569       case 4:
04570       case 8:
04571       case 16:
04572       case 32:
04573       case 64:
04574       case 128:
04575       case 256:
04576       case 512:
04577       case 1024:
04578          cb_log(4, stack->port, "Taps is %d\n",bc->ec_deftaps);
04579          break;
04580       default:
04581          cb_log(0, stack->port, "Taps should be power of 2\n");
04582          bc->ec_deftaps=128;
04583       }
04584    
04585       ec_arr[0]=bc->ec_deftaps;
04586       ec_arr[1]=0;
04587       
04588       manager_ph_control_block(bc,  ECHOCAN_ON,  ec_arr, sizeof(ec_arr));
04589    }
04590 #endif
04591    }
04592 }

static void manager_event_handler ( void *  arg  )  [static]

Definition at line 3947 of file isdn_lib.c.

References misdn_lib::activatequeue, cb_log, clean_up_bc(), misdn_stack::downqueue, find_bc_by_l3id(), find_stack_by_port(), glob_mgr, handle_frm(), handle_frm_nt(), misdn_lib::midev, misdn_make_dummy(), misdn_lib::new_msg, misdn_stack::next, misdn_stack::nst, misdn_stack::nstlock, misdn_stack::nt, misdn_stack::port, misdn_bchannel::port, pthread_mutex_lock, pthread_mutex_unlock, send_msg(), misdn_lib::stack_list, and misdn_stack::upqueue.

03948 {
03949    sem_post(&handler_started); 
03950    while (1) {
03951       struct misdn_stack *stack;
03952       msg_t *msg;
03953     
03954       /** wait for events **/
03955       sem_wait(&glob_mgr->new_msg);
03956     
03957       for (msg=msg_dequeue(&glob_mgr->activatequeue);
03958            msg;
03959            msg=msg_dequeue(&glob_mgr->activatequeue)
03960          )
03961       {
03962    
03963          iframe_t *frm =  (iframe_t*) msg->data ;
03964 
03965          switch ( frm->prim) {
03966 
03967          case MGR_CLEARSTACK | REQUEST:
03968             /*a queued bchannel cleanup*/
03969             {
03970                struct misdn_stack *stack=find_stack_by_port(frm->dinfo);
03971                struct misdn_bchannel *bc;
03972                if (!stack) {
03973                   cb_log(0,0,"no stack found with port [%d]!! so we cannot cleanup the bc\n",frm->dinfo);
03974                   free_msg(msg);
03975                   break;
03976                }
03977                
03978                bc = find_bc_by_l3id(stack, frm->addr);
03979                if (bc) {
03980                   cb_log(1,bc->port,"CLEARSTACK queued, cleaning up\n");
03981                   clean_up_bc(bc);
03982                } else {
03983                   cb_log(0,stack->port,"bc could not be cleaned correctly !! addr [%x]\n",frm->addr);
03984                }
03985             }
03986             free_msg(msg); 
03987             break;
03988          case MGR_SETSTACK | REQUEST :
03989             free_msg(msg);
03990             break;
03991          default:
03992             mISDN_write(glob_mgr->midev, frm, mISDN_HEADER_LEN+frm->len, TIMEOUT_1SEC);
03993             free_msg(msg);
03994          }
03995       }
03996 
03997       for (stack=glob_mgr->stack_list;
03998            stack;
03999            stack=stack->next ) { 
04000 
04001          while ( (msg=msg_dequeue(&stack->upqueue)) ) {
04002             /** Handle L2/3 Signalling after bchans **/ 
04003             if (!handle_frm_nt(msg)) {
04004                /* Maybe it's TE */
04005                if (!handle_frm(msg)) {
04006                   /* wow none! */
04007                   cb_log(0,stack->port,"Wow we've got a strange issue while dequeueing a Frame\n");
04008                }
04009             }
04010          }
04011 
04012          /* Here we should check if we really want to 
04013             send all the messages we've queued, lets 
04014             assume we've queued a Disconnect, but 
04015             received it already from the other side!*/
04016            
04017          while ( (msg=msg_dequeue(&stack->downqueue)) ) {
04018             if (stack->nt ) {
04019                pthread_mutex_lock(&stack->nstlock);
04020                if (stack->nst.manager_l3(&stack->nst, msg))
04021                   cb_log(0, stack->port, "Error@ Sending Message in NT-Stack.\n");
04022                pthread_mutex_unlock(&stack->nstlock);
04023             } else {
04024                iframe_t *frm = (iframe_t *)msg->data;
04025                struct misdn_bchannel *bc = find_bc_by_l3id(stack, frm->dinfo);
04026                if (bc)
04027                   send_msg(glob_mgr->midev, bc, msg);
04028                else  {
04029                   if (frm->dinfo == MISDN_ID_GLOBAL || frm->dinfo == MISDN_ID_DUMMY ) {
04030                      struct misdn_bchannel dummybc;
04031                      cb_log(5,0," --> GLOBAL/DUMMY\n");
04032                      misdn_make_dummy(&dummybc, stack->port, frm->dinfo, stack->nt, 0);
04033                      send_msg(glob_mgr->midev, &dummybc, msg);
04034                   } else {
04035                      cb_log(0,0,"No bc for Message\n");
04036                   }
04037                }
04038             }
04039          }
04040       }
04041    }
04042 }

struct misdn_bchannel * manager_find_bc_by_pid ( int  pid  ) 

Definition at line 3184 of file isdn_lib.c.

References misdn_stack::b_num, misdn_stack::bc, glob_mgr, misdn_bchannel::in_use, misdn_stack::next, misdn_bchannel::pid, and misdn_lib::stack_list.

Referenced by misdn_lib_pid_restart().

03185 {
03186    struct misdn_stack *stack;
03187    int i;
03188   
03189    for (stack = glob_mgr->stack_list; stack; stack = stack->next) {
03190       for (i = 0; i <= stack->b_num; i++) {
03191          if (stack->bc[i].in_use && stack->bc[i].pid == pid) {
03192             return &stack->bc[i];
03193          }
03194       }
03195    }
03196   
03197    return NULL;
03198 }

char* manager_isdn_get_info ( enum event_e  event  ) 

Definition at line 4236 of file isdn_lib.c.

References isdn_get_info(), and msgs_g.

Referenced by cb_events().

04237 {
04238    return isdn_get_info(msgs_g , event, 0);
04239 }

int manager_isdn_handler ( iframe_t *  frm,
msg_t *  msg 
)

Definition at line 3736 of file isdn_lib.c.

References cb_log, handle_bchan(), handle_err(), handle_frm(), handle_frm_nt(), handle_l1(), handle_l2(), handle_mgmt(), handle_timers(), and LOG_NOTICE.

Referenced by misdn_lib_isdn_event_catcher().

03737 {  
03738 
03739    if (frm->dinfo==0xffffffff && frm->prim==(PH_DATA|CONFIRM)) {
03740       cb_log(0,0,"SERIOUS BUG, dinfo == 0xffffffff, prim == PH_DATA | CONFIRM !!!!\n");
03741    }
03742 
03743    if ( ((frm->addr | ISDN_PID_BCHANNEL_BIT )>> 28 ) == 0x5) {
03744       static int unhandled_bmsg_count=1000;
03745       if (handle_bchan(msg)) {
03746          return 0 ;
03747       }
03748          
03749       if (unhandled_bmsg_count==1000) {
03750          cb_log(0, 0, "received 1k Unhandled Bchannel Messages: prim %x len %d from addr %x, dinfo %x on this port.\n",frm->prim, frm->len, frm->addr, frm->dinfo);     
03751          unhandled_bmsg_count=0;
03752       }
03753 
03754       unhandled_bmsg_count++;
03755       free_msg(msg);
03756       return 0;
03757    }  
03758 
03759 #ifdef RECV_FRM_SYSLOG_DEBUG
03760    syslog(LOG_NOTICE,"mISDN recv: P(%02d): ADDR:%x PRIM:%x DINFO:%x\n",stack->port, frm->addr, frm->prim, frm->dinfo);
03761 #endif
03762 
03763    if (handle_timers(msg)) 
03764       return 0 ;
03765 
03766    
03767    if (handle_mgmt(msg)) 
03768       return 0 ; 
03769    
03770    if (handle_l2(msg)) 
03771       return 0 ;
03772 
03773    /* Its important to handle l1 AFTER l2  */
03774    if (handle_l1(msg)) 
03775       return 0 ;
03776    
03777    if (handle_frm_nt(msg)) {
03778       return 0;
03779    }
03780 
03781    if (handle_frm(msg)) {
03782       return 0;
03783    }
03784 
03785    if (handle_err(msg)) {
03786       return 0 ;
03787    }
03788 
03789    cb_log(0, 0, "Unhandled Message: prim %x len %d from addr %x, dinfo %x on this port.\n",frm->prim, frm->len, frm->addr, frm->dinfo);      
03790    free_msg(msg);
03791    
03792 
03793    return 0;
03794 }

void manager_ph_control ( struct misdn_bchannel bc,
int  c1,
int  c2 
)

Definition at line 4337 of file isdn_lib.c.

References misdn_bchannel::addr, misdn_stack::bc, cb_log, glob_mgr, misdn_lib::midev, and misdn_bchannel::port.

Referenced by handle_event(), isdn_lib_stop_dtmf(), isdn_lib_update_rxgain(), isdn_lib_update_txgain(), manager_ec_disable(), misdn_join_conf(), misdn_lib_echo(), misdn_lib_send_event(), misdn_lib_send_tone(), and misdn_split_conf().

04338 {
04339    unsigned char buffer[mISDN_HEADER_LEN+2*sizeof(int)];
04340    iframe_t *ctrl = (iframe_t *)buffer; /* preload data */
04341    unsigned int *d = (unsigned int*)&ctrl->data.p;
04342    /*struct misdn_stack *stack=get_stack_by_bc(bc);*/
04343    
04344    cb_log(4,bc->port,"ph_control: c1:%x c2:%x\n",c1,c2);
04345    
04346    ctrl->prim = PH_CONTROL | REQUEST;
04347    ctrl->addr = bc->addr | FLG_MSG_DOWN;
04348    ctrl->dinfo = 0;
04349    ctrl->len = sizeof(unsigned int)*2;
04350    *d++ = c1;
04351    *d++ = c2;
04352    mISDN_write(glob_mgr->midev, ctrl, mISDN_HEADER_LEN+ctrl->len, TIMEOUT_1SEC);
04353 }

void manager_ph_control_block ( struct misdn_bchannel bc,
int  c1,
void *  c2,
int  c2_len 
)

Definition at line 4388 of file isdn_lib.c.

References misdn_bchannel::addr, misdn_stack::bc, glob_mgr, and misdn_lib::midev.

Referenced by handle_event(), manager_ec_disable(), manager_ec_enable(), and misdn_lib_send_event().

04389 {
04390    unsigned char buffer[mISDN_HEADER_LEN+sizeof(int)+c2_len];
04391    iframe_t *ctrl = (iframe_t *)buffer;
04392    unsigned int *d = (unsigned int *)&ctrl->data.p;
04393    /*struct misdn_stack *stack=get_stack_by_bc(bc);*/
04394    
04395    ctrl->prim = PH_CONTROL | REQUEST;
04396    ctrl->addr = bc->addr | FLG_MSG_DOWN;
04397    ctrl->dinfo = 0;
04398    ctrl->len = sizeof(unsigned int) + c2_len;
04399    *d++ = c1;
04400    memcpy(d, c2, c2_len);
04401    mISDN_write(glob_mgr->midev, ctrl, mISDN_HEADER_LEN+ctrl->len, TIMEOUT_1SEC);
04402 }

int misdn_cap_is_speech ( int  cap  ) 

Poor mans version

Definition at line 430 of file isdn_lib.c.

References INFO_CAPABILITY_DIGITAL_RESTRICTED, and INFO_CAPABILITY_DIGITAL_UNRESTRICTED.

Referenced by cb_events(), handle_bchan(), handle_event(), manager_ec_disable(), manager_ec_enable(), misdn_lib_send_event(), and misdn_lib_tx2misdn_frm().

00432 {
00433    if ( (cap != INFO_CAPABILITY_DIGITAL_UNRESTRICTED) &&
00434         (cap != INFO_CAPABILITY_DIGITAL_RESTRICTED) ) return 1;
00435    return 0;
00436 }

void misdn_dump_chanlist ( void   ) 

Definition at line 468 of file isdn_lib.c.

References dump_chan_list(), get_misdn_stack(), and misdn_stack::next.

Referenced by handle_cli_misdn_show_channels().

00469 {
00470    struct misdn_stack *stack=get_misdn_stack();
00471    for ( ; stack; stack=stack->next) {
00472       dump_chan_list(stack);
00473    }
00474 
00475 }

int misdn_inband_avail ( struct misdn_bchannel bc  ) 

Definition at line 438 of file isdn_lib.c.

References misdn_bchannel::early_bconnect, INFO_PI_CALL_NOT_E2E_ISDN, INFO_PI_CALLED_NOT_ISDN, INFO_PI_INBAND_AVAILABLE, and misdn_bchannel::progress_indicator.

Referenced by cb_events(), and misdn_indication().

00439 {
00440 
00441    if (!bc->early_bconnect) {
00442       /* We have opted to never receive any available inband recorded messages */
00443       return 0;
00444    }
00445    
00446    switch (bc->progress_indicator) {
00447    case INFO_PI_INBAND_AVAILABLE:
00448    case INFO_PI_CALL_NOT_E2E_ISDN:
00449    case INFO_PI_CALLED_NOT_ISDN:
00450       return 1;
00451    default:
00452       return 0;
00453    }
00454    return 0;
00455 }

void misdn_join_conf ( struct misdn_bchannel bc,
int  conf_id 
)

Definition at line 4623 of file isdn_lib.c.

References misdn_bchannel::addr, misdn_stack::bc, bc_state_change(), BCHAN_BRIDGED, cb_log, manager_ph_control(), misdn_lib_tx2misdn_frm(), and misdn_bchannel::port.

Referenced by bc_state_change(), and misdn_lib_bridge().

04624 {
04625    char data[16] = "";
04626 
04627    bc_state_change(bc,BCHAN_BRIDGED);
04628    manager_ph_control(bc, CMX_RECEIVE_OFF, 0);
04629    manager_ph_control(bc, CMX_CONF_JOIN, conf_id);
04630 
04631    cb_log(3,bc->port, "Joining bc:%x in conf:%d\n",bc->addr,conf_id);
04632 
04633    misdn_lib_tx2misdn_frm(bc, data, sizeof(data) - 1);
04634 }

void misdn_lib_bridge ( struct misdn_bchannel bc1,
struct misdn_bchannel bc2 
)

Definition at line 4646 of file isdn_lib.c.

References bc_next_state_change(), BCHAN_ACTIVATED, BCHAN_BRIDGED, cb_log, misdn_join_conf(), misdn_bchannel::pid, and misdn_bchannel::port.

Referenced by misdn_bridge().

04647 {
04648    int conf_id = bc1->pid + 1;
04649    struct misdn_bchannel *bc_list[] = { bc1, bc2, NULL };
04650    struct misdn_bchannel **bc;
04651 
04652    cb_log(4, bc1->port, "I Send: BRIDGE from:%d to:%d\n",bc1->port,bc2->port);
04653 
04654    for (bc=bc_list; *bc;  bc++) { 
04655       (*bc)->conf_id=conf_id;
04656       cb_log(4, (*bc)->port, " --> bc_addr:%x\n",(*bc)->addr);
04657    
04658       switch((*bc)->bc_state) {
04659          case BCHAN_ACTIVATED:
04660             misdn_join_conf(*bc,conf_id);
04661             break;
04662          default:
04663             bc_next_state_change(*bc,BCHAN_BRIDGED);
04664             break;
04665       }
04666    }
04667 }

void misdn_lib_destroy ( void   ) 

Definition at line 4203 of file isdn_lib.c.

References misdn_bchannel::addr, misdn_stack::b_num, misdn_stack::bc, buf, cb_log, misdn_lib::event_handler_thread, misdn_lib::event_thread, glob_mgr, global_state, misdn_stack::midev, misdn_lib::midev, MISDN_INITIALIZED, misdn_stack::next, misdn_stack::port, stack_destroy(), misdn_lib::stack_list, and te_lib_destroy().

Referenced by unload_module().

04204 {
04205    struct misdn_stack *help;
04206    int i;
04207   
04208    for ( help=glob_mgr->stack_list; help; help=help->next ) {
04209       for(i=0;i<=help->b_num; i++) {
04210          char buf[1024];
04211          mISDN_write_frame(help->midev, buf, help->bc[i].addr, MGR_DELLAYER | REQUEST, 0, 0, NULL, TIMEOUT_1SEC);
04212          help->bc[i].addr = 0;
04213       }
04214       cb_log (1, help->port, "Destroying this port.\n");
04215       stack_destroy(help);
04216    }
04217    
04218    if (global_state == MISDN_INITIALIZED) {
04219       cb_log(4, 0, "Killing Handler Thread\n");
04220       if ( pthread_cancel(glob_mgr->event_handler_thread) == 0 ) {
04221          cb_log(4, 0, "Joining Handler Thread\n");
04222          pthread_join(glob_mgr->event_handler_thread, NULL);
04223       }
04224      
04225       cb_log(4, 0, "Killing Main Thread\n");
04226       if ( pthread_cancel(glob_mgr->event_thread) == 0 ) {
04227          cb_log(4, 0, "Joining Main Thread\n");
04228          pthread_join(glob_mgr->event_thread, NULL);
04229       }
04230    }
04231   
04232    cb_log(1, 0, "Closing mISDN device\n");
04233    te_lib_destroy(glob_mgr->midev);
04234 }

void misdn_lib_echo ( struct misdn_bchannel bc,
int  onoff 
)

Definition at line 4689 of file isdn_lib.c.

References cb_log, manager_ph_control(), and misdn_bchannel::port.

04690 {
04691    cb_log(3,bc->port, " --> ECHO %s\n", onoff?"ON":"OFF");
04692    manager_ph_control(bc, onoff?CMX_ECHO_ON:CMX_ECHO_OFF, 0);
04693 }

struct misdn_bchannel* misdn_lib_find_held_bc ( int  port,
int  l3_id 
)

Find a held call's B channel record.

Parameters:
port Port the call is on.
l3_id mISDN Layer 3 ID of held call.
Returns:
Found bc-record or NULL.

Definition at line 4499 of file isdn_lib.c.

References misdn_stack::bc, get_misdn_stack(), misdn_stack::next, misdn_stack::port, and stack_holder_find().

Referenced by misdn_hangup().

04500 {
04501    struct misdn_bchannel *bc;
04502    struct misdn_stack *stack;
04503 
04504    bc = NULL;
04505    for (stack = get_misdn_stack(); stack; stack = stack->next) {
04506       if (stack->port == port) {
04507          bc = stack_holder_find(stack, l3_id);
04508          break;
04509       }
04510    }
04511 
04512    return bc;
04513 }

struct misdn_bchannel* misdn_lib_get_free_bc ( int  port,
int  channel,
int  inout,
int  dec 
)

Definition at line 3241 of file isdn_lib.c.

References misdn_stack::b_num, misdn_stack::bc, misdn_stack::blocked, cb_log, misdn_bchannel::channel, misdn_bchannel::cw, misdn_bchannel::dec, glob_mgr, MAX_BCHANS, misdn_stack::next, misdn_stack::port, prepare_bc(), misdn_stack::pri, pthread_mutex_lock, pthread_mutex_unlock, misdn_stack::ptp, misdn_stack::st_lock, misdn_lib::stack_list, and test_inuse().

Referenced by handle_cr(), handle_event_nt(), and misdn_request().

03242 {
03243    struct misdn_stack *stack;
03244    int i;
03245    
03246    if (channel < 0 || channel > MAX_BCHANS) {
03247       cb_log(0,port,"Requested channel out of bounds (%d)\n",channel);
03248       return NULL;
03249    }
03250 
03251    for (stack=glob_mgr->stack_list; stack; stack=stack->next) {
03252     
03253       if (stack->port == port) {
03254          int maxnum;
03255 
03256          if (stack->blocked) {
03257             cb_log(0,port,"Port is blocked\n");
03258             return NULL;
03259          }
03260       
03261          pthread_mutex_lock(&stack->st_lock);
03262          if (channel > 0) {
03263             if (channel <= stack->b_num) {
03264                for (i = 0; i < stack->b_num; i++) {
03265                   if ( stack->bc[i].channel == channel) {
03266                      if (test_inuse(&stack->bc[i])) { 
03267                         pthread_mutex_unlock(&stack->st_lock);
03268                         cb_log(0,port,"Requested channel:%d on port:%d is already in use\n",channel, port);
03269                         return NULL;
03270 
03271                      } else {
03272                         prepare_bc(&stack->bc[i], channel);
03273                         pthread_mutex_unlock(&stack->st_lock);
03274                         return &stack->bc[i];
03275                      }
03276                   }
03277                }
03278             } else {
03279                pthread_mutex_unlock(&stack->st_lock);
03280                cb_log(0,port,"Requested channel:%d is out of bounds on port:%d\n",channel, port);
03281                return NULL;
03282             }
03283          }
03284 
03285          maxnum = inout && !stack->pri && !stack->ptp ? stack->b_num + 1 : stack->b_num;
03286 
03287          if (dec) {
03288             for (i = maxnum-1; i>=0; i--) {
03289                if (!test_inuse(&stack->bc[i])) {
03290                   /* 3. channel on bri means CW*/
03291                   if (!stack->pri && i==stack->b_num)
03292                      stack->bc[i].cw=1;
03293                      
03294                   prepare_bc(&stack->bc[i], channel);
03295                   stack->bc[i].dec=1;
03296                   pthread_mutex_unlock(&stack->st_lock);
03297                   return &stack->bc[i];
03298                }
03299             }
03300          } else {
03301             for (i = 0; i <maxnum; i++) {
03302                if (!test_inuse(&stack->bc[i])) {
03303                   /* 3. channel on bri means CW*/
03304                   if (!stack->pri && i==stack->b_num)
03305                      stack->bc[i].cw=1;
03306 
03307                   prepare_bc(&stack->bc[i], channel);
03308                   pthread_mutex_unlock(&stack->st_lock);
03309                   return &stack->bc[i];
03310                }
03311             }
03312          }
03313          pthread_mutex_unlock(&stack->st_lock);
03314 
03315          cb_log(1,port,"There is no free channel on port (%d)\n",port);
03316          return NULL;
03317       }
03318    }
03319 
03320    cb_log(0,port,"Port is not configured (%d)\n",port);
03321    return NULL;
03322 }

static int misdn_lib_get_l1_down ( struct misdn_stack stack  )  [static]

Definition at line 815 of file isdn_lib.c.

References cb_log, misdn_stack::lower_id, misdn_stack::midev, and misdn_stack::port.

Referenced by handle_err(), and misdn_lib_get_port_down().

00816 {
00817    /* Pull Up L1 */ 
00818    iframe_t act;
00819    act.prim = PH_DEACTIVATE | REQUEST; 
00820    act.addr = stack->lower_id|FLG_MSG_DOWN;
00821    act.dinfo = 0;
00822    act.len = 0;
00823 
00824    cb_log(1, stack->port, "SENDING PH_DEACTIVATE | REQ\n");
00825    return mISDN_write(stack->midev, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
00826 }

static int misdn_lib_get_l1_up ( struct misdn_stack stack  )  [static]

Definition at line 856 of file isdn_lib.c.

References misdn_stack::midev, and misdn_stack::upper_id.

Referenced by misdn_lib_get_port_up(), misdn_lib_isdn_l1watcher(), misdn_lib_reinit_nt_stack(), and misdn_lib_send_event().

00857 {
00858    /* Pull Up L1 */ 
00859    iframe_t act;
00860    act.prim = PH_ACTIVATE | REQUEST; 
00861    act.addr = (stack->upper_id | FLG_MSG_DOWN)  ;
00862 
00863    
00864    act.dinfo = 0;
00865    act.len = 0;
00866 
00867    return mISDN_write(stack->midev, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
00868 
00869 }

static int misdn_lib_get_l2_down ( struct misdn_stack stack  )  [static]

Definition at line 829 of file isdn_lib.c.

References create_l2msg(), misdn_stack::midev, misdn_stack::nst, misdn_stack::nstlock, misdn_stack::nt, pthread_mutex_lock, pthread_mutex_unlock, misdn_stack::ptp, and misdn_stack::upper_id.

Referenced by handle_err(), and misdn_lib_get_port_down().

00830 {
00831    
00832    if (stack->ptp && (stack->nt) ) {
00833       msg_t *dmsg;
00834       /* L2 */
00835       dmsg = create_l2msg(DL_RELEASE| REQUEST, 0, 0);
00836       
00837       pthread_mutex_lock(&stack->nstlock);
00838       if (stack->nst.manager_l3(&stack->nst, dmsg))
00839          free_msg(dmsg);
00840       pthread_mutex_unlock(&stack->nstlock);
00841    } else {
00842       iframe_t act;
00843       
00844       act.prim = DL_RELEASE| REQUEST;
00845       act.addr = (stack->upper_id |FLG_MSG_DOWN)  ;
00846       
00847       act.dinfo = 0;
00848       act.len = 0;
00849       return mISDN_write(stack->midev, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
00850    }
00851    
00852    return 0;
00853 }

int misdn_lib_get_l2_up ( struct misdn_stack stack  ) 

Definition at line 871 of file isdn_lib.c.

References create_l2msg(), misdn_stack::midev, misdn_stack::nst, misdn_stack::nstlock, misdn_stack::nt, pthread_mutex_lock, pthread_mutex_unlock, misdn_stack::ptp, and misdn_stack::upper_id.

Referenced by handle_event_nt(), handle_l1(), misdn_lib_get_port_up(), misdn_lib_isdn_l1watcher(), and misdn_lib_reinit_nt_stack().

00872 {
00873    
00874    if (stack->ptp && (stack->nt) ) {
00875       msg_t *dmsg;
00876       /* L2 */
00877       dmsg = create_l2msg(DL_ESTABLISH | REQUEST, 0, 0);
00878       
00879       pthread_mutex_lock(&stack->nstlock);
00880       if (stack->nst.manager_l3(&stack->nst, dmsg))
00881          free_msg(dmsg);
00882       pthread_mutex_unlock(&stack->nstlock);
00883    } else {
00884       iframe_t act;
00885       
00886       act.prim = DL_ESTABLISH | REQUEST;
00887       act.addr = (stack->upper_id |FLG_MSG_DOWN)  ;
00888       
00889       act.dinfo = 0;
00890       act.len = 0;
00891       return mISDN_write(stack->midev, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
00892    }
00893    
00894    return 0;
00895 }

int misdn_lib_get_maxchans ( int  port  ) 

Definition at line 131 of file isdn_lib.c.

References get_misdn_stack(), misdn_stack::next, misdn_stack::port, and misdn_stack::pri.

Referenced by misdn_request().

00132 {
00133    struct misdn_stack *stack=get_misdn_stack();
00134    for ( ; stack; stack=stack->next) {
00135       if (stack->port == port) {
00136          if (stack->pri) 
00137             return 30;
00138          else
00139             return 2;
00140       }
00141    }
00142    return -1;
00143 }

int misdn_lib_get_port_down ( int  port  ) 

Definition at line 1778 of file isdn_lib.c.

References glob_mgr, misdn_stack::l2link, misdn_lib_get_l1_down(), misdn_lib_get_l2_down(), misdn_stack::next, misdn_stack::port, and misdn_lib::stack_list.

Referenced by handle_cli_misdn_port_down().

01779 { /* Pull Down L1 */ 
01780    struct misdn_stack *stack;
01781    for (stack=glob_mgr->stack_list;
01782         stack;
01783         stack=stack->next) {
01784       if (stack->port == port) {
01785             if (stack->l2link)
01786                misdn_lib_get_l2_down(stack);
01787             misdn_lib_get_l1_down(stack);
01788          return 0;
01789       }
01790    }
01791    return 0;
01792 }

int misdn_lib_get_port_info ( int  port  ) 

Definition at line 3799 of file isdn_lib.c.

References misdn_lib::activatequeue, cb_log, find_stack_by_port(), glob_mgr, misdn_lib::new_msg, and misdn_stack::upper_id.

03800 {
03801    msg_t *msg=alloc_msg(MAX_MSG_SIZE);
03802    iframe_t *frm;
03803    struct misdn_stack *stack=find_stack_by_port(port);
03804    if (!msg) {
03805       cb_log(0, port, "misdn_lib_get_port_info: alloc_msg failed!\n");
03806       return -1;
03807    }
03808    frm=(iframe_t*)msg->data;
03809    if (!stack ) {
03810       cb_log(0, port, "There is no Stack for this port.\n");
03811       return -1;
03812    }
03813    /* activate bchannel */
03814    frm->prim = CC_STATUS_ENQUIRY | REQUEST;
03815 
03816    frm->addr = stack->upper_id| FLG_MSG_DOWN;
03817 
03818    frm->dinfo = 0;
03819    frm->len = 0;
03820   
03821    msg_queue_tail(&glob_mgr->activatequeue, msg);
03822    sem_post(&glob_mgr->new_msg);
03823 
03824   
03825    return 0; 
03826 }

int misdn_lib_get_port_up ( int  port  ) 

Definition at line 1756 of file isdn_lib.c.

References glob_mgr, misdn_stack::l1link, misdn_stack::l2link, misdn_lib_get_l1_up(), misdn_lib_get_l2_up(), misdn_stack::next, misdn_stack::port, and misdn_lib::stack_list.

Referenced by handle_cli_misdn_port_up(), and misdn_check_l2l1().

01757 { /* Pull Up L1 */ 
01758    struct misdn_stack *stack;
01759    
01760    for (stack=glob_mgr->stack_list;
01761         stack;
01762         stack=stack->next) {
01763       
01764       if (stack->port == port) {
01765 
01766          if (!stack->l1link)
01767             misdn_lib_get_l1_up(stack);
01768          if (!stack->l2link)
01769             misdn_lib_get_l2_up(stack);
01770          
01771          return 0;
01772       }
01773    }
01774    return 0;
01775 }

static int misdn_lib_get_short_status ( struct misdn_stack stack  )  [static]

Definition at line 912 of file isdn_lib.c.

References misdn_stack::midev, and misdn_stack::upper_id.

Referenced by misdn_lib_isdn_l1watcher().

00913 {
00914    iframe_t act;
00915    
00916    
00917    act.prim = MGR_SHORTSTATUS | REQUEST; 
00918    
00919    act.addr = (stack->upper_id | MSG_BROADCAST)  ;
00920 
00921    act.dinfo = SSTATUS_BROADCAST_BIT | SSTATUS_ALL;
00922    
00923    act.len = 0;
00924    return mISDN_write(stack->midev, &act, mISDN_HEADER_LEN+act.len, TIMEOUT_1SEC);
00925 }

int misdn_lib_init ( char *  portlist,
struct misdn_lib_iface iface,
void *  user_data 
)

Definition at line 4095 of file isdn_lib.c.

References misdn_lib::activatequeue, misdn_stack::b_num, misdn_stack::bc, calloc, cb_event, misdn_lib_iface::cb_event, cb_jb_empty, misdn_lib_iface::cb_jb_empty, cb_log, misdn_lib_iface::cb_log, first, flip_buf_bits(), glob_mgr, init_bc(), init_flip_bits(), misdn_stack::mgr, misdn_lib::midev, misdn_stack::midev, misdn_lib_nt_debug_init(), misdn_lib::new_msg, misdn_stack::next, misdn_stack::port, ptp, stack_init(), te_lib_init(), tone_425_flip, and tone_silence_flip.

Referenced by load_module().

04096 {
04097    struct misdn_lib *mgr=calloc(1, sizeof(struct misdn_lib));
04098    char *tok, *tokb;
04099    char plist[1024];
04100    int midev;
04101    int port_count=0;
04102  
04103    cb_log = iface->cb_log;
04104    cb_event = iface->cb_event;
04105    cb_jb_empty = iface->cb_jb_empty;
04106    
04107    glob_mgr = mgr;
04108   
04109    msg_init();
04110 
04111    misdn_lib_nt_debug_init(0,NULL);
04112    
04113    if (!portlist || (*portlist == 0) ) return 1;
04114    
04115    init_flip_bits();
04116    
04117    {
04118       strncpy(plist,portlist, 1024);
04119       plist[1023] = 0;
04120    }
04121   
04122    memcpy(tone_425_flip,tone_425,TONE_425_SIZE);
04123    flip_buf_bits(tone_425_flip,TONE_425_SIZE);
04124 
04125    memcpy(tone_silence_flip,tone_SILENCE,TONE_SILENCE_SIZE);
04126    flip_buf_bits(tone_silence_flip,TONE_SILENCE_SIZE);
04127   
04128    midev=te_lib_init();
04129    mgr->midev=midev;
04130 
04131    port_count=mISDN_get_stack_count(midev);
04132   
04133    msg_queue_init(&mgr->activatequeue);
04134   
04135    if (sem_init(&mgr->new_msg, 1, 0)<0)
04136       sem_init(&mgr->new_msg, 0, 0);
04137  
04138    for (tok=strtok_r(plist," ,",&tokb );
04139         tok; 
04140         tok=strtok_r(NULL," ,",&tokb)) {
04141       int port = atoi(tok);
04142       struct misdn_stack *stack;
04143       static int first=1;
04144       int ptp=0;
04145     
04146       if (strstr(tok, "ptp"))
04147          ptp=1;
04148 
04149       if (port > port_count) {
04150          cb_log(0, port, "Couldn't Initialize this port since we have only %d ports\n", port_count);
04151          exit(1);
04152       }
04153       stack=stack_init(midev, port, ptp);
04154     
04155       if (!stack) {
04156          perror("stack_init");
04157          exit(1);
04158       }
04159     
04160       {
04161          int i;
04162          for(i=0;i<=stack->b_num; i++) {
04163             int r;
04164             if ((r=init_bc(stack, &stack->bc[i], stack->midev,port,i, "", 1))<0) {
04165                cb_log(0, port, "Got Err @ init_bc :%d\n",r);
04166                exit(1);
04167             }
04168          }
04169       }
04170 
04171       if (stack && first) {
04172          mgr->stack_list=stack;
04173          first=0;
04174          continue;
04175       }
04176     
04177       if (stack) {
04178          struct misdn_stack * help;
04179          for ( help=mgr->stack_list; help; help=help->next ) 
04180             if (help->next == NULL) break;
04181          help->next=stack;
04182       }
04183     
04184    }
04185   
04186    if (sem_init(&handler_started, 1, 0)<0)
04187       sem_init(&handler_started, 0, 0);
04188   
04189    cb_log(8, 0, "Starting Event Handler\n");
04190    pthread_create( &mgr->event_handler_thread, NULL,(void*)manager_event_handler, mgr);
04191   
04192    sem_wait(&handler_started) ;
04193    cb_log(8, 0, "Starting Event Catcher\n");
04194    pthread_create( &mgr->event_thread, NULL, (void*)misdn_lib_isdn_event_catcher, mgr);
04195   
04196    cb_log(8, 0, "Event Catcher started\n");
04197 
04198    global_state= MISDN_INITIALIZED; 
04199   
04200    return (mgr == NULL);
04201 }

int misdn_lib_is_port_blocked ( int  port  ) 

Definition at line 111 of file isdn_lib.c.

References misdn_stack::blocked, get_misdn_stack(), misdn_stack::next, and misdn_stack::port.

00112 {  
00113    struct misdn_stack *stack=get_misdn_stack();
00114    for ( ; stack; stack=stack->next) {
00115       if (stack->port == port) {
00116          return stack->blocked;
00117       }
00118    }
00119    return -1;
00120 }

int misdn_lib_is_ptp ( int  port  ) 

Definition at line 122 of file isdn_lib.c.

References get_misdn_stack(), misdn_stack::next, misdn_stack::port, and misdn_stack::ptp.

Referenced by cb_events(), and do_immediate_setup().

00123 {
00124    struct misdn_stack *stack=get_misdn_stack();
00125    for ( ; stack; stack=stack->next) {
00126       if (stack->port == port) return stack->ptp;
00127    }
00128    return -1;
00129 }

static void misdn_lib_isdn_event_catcher ( void *  arg  )  [static]

Definition at line 3099 of file isdn_lib.c.

References cb_log, fetch_msg(), manager_isdn_handler(), misdn_lib::midev, and msg.

03100 {
03101    struct misdn_lib *mgr = arg;
03102    int zero_frm=0 , fff_frm=0 ;
03103    int midev= mgr->midev;
03104    int port=0;
03105    
03106    while (1) {
03107       msg_t *msg = fetch_msg(midev); 
03108       iframe_t *frm;
03109       
03110       
03111       if (!msg) continue;
03112       
03113       frm = (iframe_t*) msg->data;
03114       
03115       /** When we make a call from NT2Ast we get these frames **/
03116       if (frm->len == 0 && frm->addr == 0 && frm->dinfo == 0 && frm->prim == 0 ) {
03117          zero_frm++; 
03118          free_msg(msg);
03119          continue;
03120       } else {
03121          if (zero_frm) {
03122             cb_log(0, port, "*** Alert: %d zero_frms caught\n", zero_frm);
03123             zero_frm = 0 ;
03124          }
03125       }
03126       
03127       /** I get this sometimes after setup_bc **/
03128       if (frm->len == 0 &&  frm->dinfo == 0 && frm->prim == 0xffffffff ) {
03129          fff_frm++; 
03130          free_msg(msg);
03131          continue;
03132       } else {
03133          if (fff_frm) {
03134             cb_log(0, port, "*** Alert: %d fff_frms caught\n", fff_frm);
03135             fff_frm = 0 ;
03136          }
03137       }
03138       
03139       manager_isdn_handler(frm, msg);
03140    }
03141 
03142 }

void misdn_lib_isdn_l1watcher ( int  port  ) 

Definition at line 3080 of file isdn_lib.c.

References cb_log, glob_mgr, misdn_stack::l1link, misdn_lib_get_l1_up(), misdn_lib_get_l2_up(), misdn_lib_get_short_status(), misdn_stack::next, misdn_stack::port, and misdn_lib::stack_list.

Referenced by misdn_l1_task().

03081 {
03082    struct misdn_stack *stack;
03083 
03084    for (stack = glob_mgr->stack_list; stack && (stack->port != port); stack = stack->next)
03085       ;
03086 
03087    if (stack) {
03088       cb_log(4, port, "Checking L1 State\n");   
03089       if (!stack->l1link) {
03090          cb_log(4, port, "L1 State Down, trying to get it up again\n"); 
03091          misdn_lib_get_short_status(stack);
03092          misdn_lib_get_l1_up(stack); 
03093          misdn_lib_get_l2_up(stack); 
03094       }
03095    }
03096 }

void misdn_lib_log_ies ( struct misdn_bchannel bc  ) 

Definition at line 3363 of file isdn_lib.c.

References misdn_bchannel::addr, misdn_bchannel::b_stid, misdn_stack::bc, bearer2str(), misdn_bchannel::cad, misdn_bchannel::capability, misdn_bchannel::cause, cb_log, misdn_bchannel::channel, misdn_bchannel::cpnnumplan, misdn_bchannel::dnumplan, fac2str(), misdn_bchannel::fac_in, misdn_bchannel::fac_out, get_stack_by_bc(), misdn_bchannel::holded, misdn_bchannel::info_dad, misdn_bchannel::keypad, misdn_bchannel::l3_id, misdn_bchannel::layer_id, misdn_bchannel::mode, misdn_stack::nt, misdn_bchannel::onumplan, misdn_bchannel::out_cause, misdn_stack::port, misdn_bchannel::pres, misdn_bchannel::progress_indicator, misdn_bchannel::rad, misdn_bchannel::rate, misdn_bchannel::rnumplan, misdn_bchannel::screen, misdn_bchannel::sending_complete, misdn_bchannel::stack_holder, misdn_bchannel::urate, and misdn_bchannel::user1.

Referenced by cb_events(), and misdn_lib_send_event().

03364 {
03365    struct misdn_stack *stack;
03366 
03367    if (!bc) return;
03368 
03369    stack = get_stack_by_bc(bc);
03370 
03371    if (!stack) return;
03372 
03373    cb_log(2, stack->port, " --> channel:%d mode:%s cause:%d ocause:%d rad:%s cad:%s\n", bc->channel, stack->nt?"NT":"TE", bc->cause, bc->out_cause, bc->rad, bc->cad);
03374    
03375    cb_log(2, stack->port,
03376           " --> info_dad:%s onumplan:%c dnumplan:%c rnumplan:%c cpnnumplan:%c\n",
03377           bc->info_dad,
03378           bc->onumplan>=0?'0'+bc->onumplan:' ',
03379           bc->dnumplan>=0?'0'+bc->dnumplan:' ',
03380           bc->rnumplan>=0?'0'+bc->rnumplan:' ',
03381           bc->cpnnumplan>=0?'0'+bc->cpnnumplan:' '
03382       );
03383    
03384    cb_log(3, stack->port, " --> caps:%s pi:%x keypad:%s sending_complete:%d\n", bearer2str(bc->capability),bc->progress_indicator, bc->keypad, bc->sending_complete);
03385    cb_log(4, stack->port, " --> screen:%d --> pres:%d\n",
03386          bc->screen, bc->pres);
03387    
03388    cb_log(4, stack->port, " --> addr:%x l3id:%x b_stid:%x layer_id:%x\n", bc->addr, bc->l3_id, bc->b_stid, bc->layer_id);
03389    
03390    cb_log(4, stack->port, " --> facility:%s out_facility:%s\n",fac2str(bc->fac_in.Function),fac2str(bc->fac_out.Function));
03391 
03392    cb_log(5, stack->port, " --> urate:%d rate:%d mode:%d user1:%d\n", bc->urate, bc->rate, bc->mode,bc->user1);
03393    
03394    cb_log(5, stack->port, " --> bc:%p h:%d sh:%d\n", bc, bc->holded, bc->stack_holder);
03395 }

int misdn_lib_maxports_get ( void   ) 

Definition at line 4045 of file isdn_lib.c.

Referenced by load_module().

04046 {
04047    /* BE AWARE WE HAVE NO cb_log() HERE! */
04048 
04049    int i = mISDN_open();
04050    int max=0;
04051    
04052    if (i<0)
04053       return -1;
04054 
04055    max = mISDN_get_stack_count(i);
04056    
04057    mISDN_close(i);
04058    
04059    return max;
04060 }

void misdn_lib_nt_debug_init ( int  flags,
char *  file 
)

Definition at line 4075 of file isdn_lib.c.

References f.

Referenced by load_module(), and misdn_lib_init().

04076 {
04077    static int init=0;
04078    char *f;
04079    
04080    if (!flags) 
04081       f=NULL;
04082    else
04083       f=file;
04084 
04085    if (!init) {
04086       debug_init( flags , f, f, f);
04087       init=1;
04088    } else {
04089       debug_close();
04090       debug_init( flags , f, f, f);
04091    }
04092 }

void misdn_lib_nt_keepcalls ( int  kc  ) 

Definition at line 4063 of file isdn_lib.c.

References get_misdn_stack(), misdn_stack::next, and misdn_stack::nst.

Referenced by load_module().

04064 {
04065 #ifdef FEATURE_NET_KEEPCALLS
04066    if (kc) {
04067       struct misdn_stack *stack=get_misdn_stack();
04068       for ( ; stack; stack=stack->next) {
04069          stack->nst.feature |= FEATURE_NET_KEEPCALLS;
04070       }
04071    }
04072 #endif
04073 }

int misdn_lib_pid_restart ( int  pid  ) 

Definition at line 3854 of file isdn_lib.c.

References manager_clean_bc(), and manager_find_bc_by_pid().

Referenced by handle_cli_misdn_restart_pid().

03855 {
03856    struct misdn_bchannel *bc=manager_find_bc_by_pid(pid);
03857 
03858    if (bc) {
03859       manager_clean_bc(bc);
03860    }
03861    return 0;
03862 }

int misdn_lib_port_block ( int  port  ) 

Definition at line 85 of file isdn_lib.c.

References misdn_stack::blocked, get_misdn_stack(), misdn_stack::next, and misdn_stack::port.

Referenced by cb_events(), and handle_cli_misdn_port_block().

00086 {
00087    struct misdn_stack *stack=get_misdn_stack();
00088    for ( ; stack; stack=stack->next) {
00089       if (stack->port == port) {
00090          stack->blocked=1;
00091          return 0;
00092       }
00093    }
00094    return -1;
00095 
00096 }

int misdn_lib_port_is_nt ( int  port  ) 

Definition at line 59 of file isdn_lib.c.

References get_misdn_stack(), misdn_stack::next, misdn_stack::nt, and misdn_stack::port.

Referenced by handle_cli_misdn_send_facility().

00060 {
00061    struct misdn_stack *stack=get_misdn_stack();
00062    for ( ; stack; stack=stack->next) {
00063       if (stack->port == port) {
00064          return stack->nt;
00065       }
00066    }
00067    
00068    return -1;
00069 }

int misdn_lib_port_is_pri ( int  port  ) 

Definition at line 47 of file isdn_lib.c.

References get_misdn_stack(), misdn_stack::next, misdn_stack::port, and misdn_stack::pri.

Referenced by misdn_new(), test_inuse(), and update_name().

00048 {
00049    struct misdn_stack *stack=get_misdn_stack();
00050    for ( ; stack; stack=stack->next) {
00051       if (stack->port == port) {
00052          return stack->pri;
00053       }
00054    }
00055    
00056    return -1;
00057 }

int misdn_lib_port_restart ( int  port  ) 

Definition at line 3904 of file isdn_lib.c.

References misdn_lib::activatequeue, cb_log, clear_l3(), find_stack_by_port(), glob_mgr, misdn_lib_reinit_nt_stack(), misdn_lib::new_msg, misdn_stack::nt, misdn_stack::port, and misdn_stack::upper_id.

Referenced by handle_cli_misdn_restart_port().

03905 {
03906    struct misdn_stack *stack=find_stack_by_port(port);
03907  
03908    cb_log(0, port, "Restarting this port.\n");
03909    if (stack) {
03910       cb_log(0, port, "Stack:%p\n",stack);
03911          
03912       clear_l3(stack);
03913       {
03914          msg_t *msg=alloc_msg(MAX_MSG_SIZE);
03915          iframe_t *frm;
03916 
03917          if (!msg) {
03918             cb_log(0, port, "port_restart: alloc_msg failed\n");
03919             return -1;
03920          }
03921          
03922          frm=(iframe_t*)msg->data;
03923          /* we must activate if we are deactivated */
03924          /* activate bchannel */
03925          frm->prim = DL_RELEASE | REQUEST;
03926          frm->addr = stack->upper_id | FLG_MSG_DOWN;
03927 
03928          frm->dinfo = 0;
03929          frm->len = 0;
03930          msg_queue_tail(&glob_mgr->activatequeue, msg);
03931          sem_post(&glob_mgr->new_msg);
03932       }
03933 
03934       if (stack->nt)
03935          misdn_lib_reinit_nt_stack(stack->port);
03936     
03937    }
03938 
03939    return 0;
03940 }

int misdn_lib_port_unblock ( int  port  ) 

Definition at line 98 of file isdn_lib.c.

References misdn_stack::blocked, get_misdn_stack(), misdn_stack::next, and misdn_stack::port.

Referenced by handle_cli_misdn_port_unblock().

00099 {
00100    struct misdn_stack *stack=get_misdn_stack();
00101    for ( ; stack; stack=stack->next) {
00102       if (stack->port == port) {
00103          stack->blocked=0;
00104          return 0;
00105       }
00106    }
00107    return -1;
00108 
00109 }

int misdn_lib_port_up ( int  port,
int  check 
)

Definition at line 1794 of file isdn_lib.c.

References misdn_stack::blocked, cb_log, glob_mgr, misdn_stack::l1link, misdn_stack::l2link, misdn_stack::next, misdn_stack::port, misdn_stack::ptp, and misdn_lib::stack_list.

Referenced by misdn_check_l2l1(), and misdn_request().

01795 {
01796    struct misdn_stack *stack;
01797 
01798 
01799    for (stack=glob_mgr->stack_list;
01800         stack;
01801         stack=stack->next) {
01802       
01803       if (stack->port == port) {
01804 
01805          if (stack->blocked) {
01806             cb_log(0,port, "Port Blocked:%d L2:%d L1:%d\n", stack->blocked, stack->l2link, stack->l1link);
01807             return -1;
01808          }
01809 
01810          if (stack->ptp ) {
01811 
01812             if (stack->l1link && stack->l2link) {
01813                return 1;
01814             } else {
01815                cb_log(1,port, "Port Down L2:%d L1:%d\n",
01816                   stack->l2link, stack->l1link);
01817                return 0;
01818             }
01819          } else {
01820             if ( !check || stack->l1link )
01821                return 1;
01822             else {
01823                cb_log(1,port, "Port down PMP\n");
01824                return 0;
01825             }
01826          }
01827       }
01828    }
01829   
01830    return -1;
01831 }

void misdn_lib_reinit_nt_stack ( int  port  ) 

Definition at line 4697 of file isdn_lib.c.

References misdn_stack::blocked, misdn_stack::d_stid, find_stack_by_port(), glob_mgr, handle_event_nt(), misdn_stack::l2link, misdn_stack::lower_id, misdn_stack::mgr, misdn_lib::midev, misdn_lib_get_l1_up(), misdn_lib_get_l2_up(), misdn_stack::nst, misdn_stack::pri, misdn_stack::ptp, and misdn_stack::upper_id.

Referenced by handle_event_nt(), and misdn_lib_port_restart().

04698 {
04699    struct misdn_stack *stack=find_stack_by_port(port);
04700    
04701    if (stack) {
04702       stack->l2link=0;
04703       stack->blocked=0;
04704    
04705       cleanup_Isdnl3(&stack->nst);
04706       cleanup_Isdnl2(&stack->nst);
04707 
04708 
04709       memset(&stack->nst, 0, sizeof(net_stack_t));
04710       memset(&stack->mgr, 0, sizeof(manager_t));
04711    
04712       stack->mgr.nst = &stack->nst;
04713       stack->nst.manager = &stack->mgr;
04714     
04715       stack->nst.l3_manager = handle_event_nt;
04716       stack->nst.device = glob_mgr->midev;
04717       stack->nst.cardnr = port;
04718       stack->nst.d_stid = stack->d_stid;
04719    
04720       stack->nst.feature = FEATURE_NET_HOLD;
04721       if (stack->ptp)
04722          stack->nst.feature |= FEATURE_NET_PTP;
04723       if (stack->pri)
04724          stack->nst.feature |= FEATURE_NET_CRLEN2 | FEATURE_NET_EXTCID;
04725       
04726       stack->nst.l1_id = stack->lower_id;
04727       stack->nst.l2_id = stack->upper_id;
04728       
04729       msg_queue_init(&stack->nst.down_queue);
04730    
04731       Isdnl2Init(&stack->nst);
04732       Isdnl3Init(&stack->nst);
04733 
04734       if (!stack->ptp)
04735          misdn_lib_get_l1_up(stack);
04736       misdn_lib_get_l2_up(stack);
04737    }
04738 }

void misdn_lib_release ( struct misdn_bchannel bc  ) 

Definition at line 1734 of file isdn_lib.c.

References misdn_stack::bc, cb_log, misdn_bchannel::channel, clean_up_bc(), empty_bc(), empty_chan_in_stack(), get_stack_by_bc(), and misdn_bchannel::in_use.

Referenced by misdn_hangup().

01735 {
01736    int channel;
01737    struct misdn_stack *stack=get_stack_by_bc(bc);
01738 
01739    if (!stack) {
01740       cb_log(1,0,"misdn_release: No Stack found\n");
01741       return;
01742    }
01743    
01744    channel = bc->channel;
01745    empty_bc(bc);
01746    clean_up_bc(bc);
01747    if (channel > 0) {
01748       empty_chan_in_stack(stack, channel);
01749    }
01750    bc->in_use=0;
01751 }

int misdn_lib_send_event ( struct misdn_bchannel bc,
enum event_e  event 
)

Definition at line 3414 of file isdn_lib.c.

References misdn_bchannel::bc_state, bc_state2str(), bc_state_change(), BCHAN_BRIDGED, BCHAN_CLEANED, misdn_bchannel::capability, misdn_bchannel::cause, cb_log, misdn_bchannel::channel, misdn_bchannel::channel_found, misdn_bchannel::channel_preselected, clean_up_bc(), misdn_bchannel::conf_id, create_process(), misdn_bchannel::crypt_key, misdn_bchannel::dad, misdn_bchannel::dnumplan, misdn_stack::downqueue, empty_bc(), empty_chan_in_stack(), ENOCHAN, EVENT_ALERTING, EVENT_CONNECT, EVENT_CONNECT_ACKNOWLEDGE, EVENT_DISCONNECT, EVENT_HOLD_ACKNOWLEDGE, EVENT_PROCEEDING, EVENT_PROGRESS, EVENT_RELEASE, EVENT_RELEASE_COMPLETE, EVENT_RETRIEVE_ACKNOWLEDGE, EVENT_SETUP, EVENT_SETUP_ACKNOWLEDGE, misdn_bchannel::evq, find_bc_by_confid(), find_free_chan_in_stack(), get_stack_by_bc(), glob_mgr, misdn_bchannel::holded, misdn_bchannel::in_use, isdn_get_info(), isdn_msg_build_event(), misdn_stack::l1link, malloc, manager_ec_enable(), manager_ph_control(), manager_ph_control_block(), misdn_lib::midev, misdn_cap_is_speech(), misdn_lib_get_l1_up(), misdn_lib_log_ies(), misdn_send_lock(), misdn_send_unlock(), misdn_split_conf(), msg, msgs_g, misdn_bchannel::need_disconnect, misdn_bchannel::need_release, misdn_bchannel::need_release_complete, misdn_lib::new_msg, misdn_bchannel::nodsp, misdn_stack::nt, misdn_bchannel::nt, misdn_bchannel::oad, misdn_bchannel::onumplan, misdn_bchannel::out_cause, misdn_bchannel::pid, misdn_bchannel::port, misdn_stack::port, RETURN, misdn_bchannel::rxgain, setup_bc(), stack_holder_add(), misdn_bchannel::txgain, and misdn_stack::upper_id.

Referenced by cb_events(), do_immediate_setup(), handle_cli_misdn_send_display(), handle_cli_misdn_send_facility(), handle_event(), handle_event_nt(), handle_frm(), handle_l1(), misdn_answer(), misdn_call(), misdn_digit_end(), misdn_facility_exec(), misdn_hangup(), misdn_indication(), misdn_lib_send_restart(), misdn_overlap_dial_task(), misdn_send_text(), start_pbx(), and wait_for_digits().

03415 {
03416    msg_t *msg; 
03417    int retval=0;
03418    struct misdn_stack *stack;
03419    struct misdn_bchannel *held_bc;
03420   
03421    if (!bc) RETURN(-1,OUT_POST_UNLOCK);
03422    
03423    stack = get_stack_by_bc(bc);
03424    
03425    if (!stack) {
03426       cb_log(0,bc->port,"SENDEVENT: no Stack for event:%s oad:%s dad:%s \n", isdn_get_info(msgs_g, event, 0), bc->oad, bc->dad);
03427       RETURN(-1,OUT);
03428    }
03429    
03430    misdn_send_lock(bc);
03431 
03432 
03433    cb_log(6,stack->port,"SENDEVENT: stack->nt:%d stack->upperid:%x\n",stack->nt, stack->upper_id);
03434 
03435    if ( stack->nt && !stack->l1link) {
03436       /** Queue Event **/
03437       bc->evq=event;
03438       cb_log(1, stack->port, "Queueing Event %s because L1 is down (btw. Activating L1)\n", isdn_get_info(msgs_g, event, 0));
03439       misdn_lib_get_l1_up(stack);
03440       RETURN(0,OUT);
03441    }
03442    
03443    cb_log(1, stack->port, "I SEND:%s oad:%s dad:%s pid:%d\n", isdn_get_info(msgs_g, event, 0), bc->oad, bc->dad, bc->pid);
03444    cb_log(4, stack->port, " --> bc_state:%s\n",bc_state2str(bc->bc_state));
03445    misdn_lib_log_ies(bc);
03446    
03447    switch (event) {
03448    case EVENT_SETUP:
03449       if (create_process(glob_mgr->midev, bc)<0) {
03450          cb_log(0,  stack->port, " No free channel at the moment @ send_event\n");
03451 
03452          RETURN(-ENOCHAN,OUT);
03453       }
03454       break;
03455 
03456    case EVENT_PROGRESS:
03457    case EVENT_ALERTING:
03458    case EVENT_PROCEEDING:
03459    case EVENT_SETUP_ACKNOWLEDGE:
03460    case EVENT_CONNECT:
03461       if (!stack->nt) break;
03462 
03463    case EVENT_RETRIEVE_ACKNOWLEDGE:
03464 
03465       if (stack->nt) {
03466          if (bc->channel <=0 ) { /*  else we have the channel already */
03467             if (find_free_chan_in_stack(stack, bc, 0, 0)<0) {
03468                cb_log(0, stack->port, " No free channel at the moment\n");
03469                /*FIXME: add disconnect*/
03470                RETURN(-ENOCHAN,OUT);
03471             }
03472          }
03473          /* Its that i generate channels */
03474       }
03475 
03476       retval=setup_bc(bc);
03477       if (retval == -EINVAL) {
03478          cb_log(0,bc->port,"send_event: setup_bc failed\n");
03479       }
03480 
03481       if (misdn_cap_is_speech(bc->capability)) {
03482          if ((event==EVENT_CONNECT)||(event==EVENT_RETRIEVE_ACKNOWLEDGE)) {
03483             if ( *bc->crypt_key ) {
03484                cb_log(4, stack->port,  " --> ENABLING BLOWFISH channel:%d oad%d:%s dad%d:%s \n", bc->channel, bc->onumplan,bc->oad, bc->dnumplan,bc->dad);
03485                
03486                manager_ph_control_block(bc,  BF_ENABLE_KEY, bc->crypt_key, strlen(bc->crypt_key) );
03487             }
03488             
03489             if (!bc->nodsp) manager_ph_control(bc,  DTMF_TONE_START, 0);
03490             manager_ec_enable(bc);
03491             
03492             if (bc->txgain != 0) {
03493                cb_log(4, stack->port,  "--> Changing txgain to %d\n", bc->txgain);
03494                manager_ph_control(bc, VOL_CHANGE_TX, bc->txgain);
03495             }
03496             
03497             if ( bc->rxgain != 0 ) {
03498                cb_log(4, stack->port,  "--> Changing rxgain to %d\n", bc->rxgain);
03499                manager_ph_control(bc, VOL_CHANGE_RX, bc->rxgain);
03500             }
03501          }
03502       }
03503       break;
03504 
03505    case EVENT_HOLD_ACKNOWLEDGE:
03506       held_bc = malloc(sizeof(struct misdn_bchannel));
03507       if (!held_bc) {
03508          cb_log(0, bc->port, "Could not allocate held_bc!!!\n");
03509          RETURN(-1,OUT);
03510       }
03511 
03512       /* backup the bc and put it in storage */
03513       *held_bc = *bc;
03514       held_bc->holded = 1;
03515       held_bc->channel = 0;/* A held call does not have a channel anymore. */
03516       held_bc->channel_preselected = 0;
03517       held_bc->channel_found = 0;
03518       bc_state_change(held_bc, BCHAN_CLEANED);
03519       stack_holder_add(stack, held_bc);
03520    
03521       /* kill the bridge and clean the real b-channel record */
03522       if (stack->nt) {
03523          int channel;
03524          if (bc->bc_state == BCHAN_BRIDGED) {
03525             struct misdn_bchannel *bc2;
03526 
03527             misdn_split_conf(bc,bc->conf_id);
03528             bc2 = find_bc_by_confid(bc->conf_id);
03529             if (!bc2) {
03530                cb_log(0,bc->port,"We have no second bc in bridge???\n");
03531             } else {
03532                misdn_split_conf(bc2,bc->conf_id);
03533             }
03534          }
03535          
03536          channel = bc->channel;
03537 
03538          empty_bc(bc);
03539          clean_up_bc(bc);
03540 
03541          if (channel>0)
03542             empty_chan_in_stack(stack,channel);
03543 
03544          bc->in_use=0;  
03545       }
03546       break;
03547 
03548    /* finishing the channel eh ? */
03549    case EVENT_DISCONNECT:
03550       if (!bc->need_disconnect) {
03551          cb_log(0,bc->port," --> we have already send Disconnect\n");
03552          RETURN(-1,OUT);
03553       }
03554       
03555       bc->need_disconnect=0;
03556       break;
03557    case EVENT_RELEASE:
03558       if (!bc->need_release) {
03559          cb_log(0,bc->port," --> we have already send Release\n");
03560          RETURN(-1,OUT);
03561       }
03562       bc->need_disconnect=0;
03563       bc->need_release=0;
03564       break;
03565    case EVENT_RELEASE_COMPLETE:
03566       if (!bc->need_release_complete) {
03567          cb_log(0,bc->port," --> we have already send Release_complete\n");
03568          RETURN(-1,OUT);
03569       }
03570       bc->need_disconnect=0;
03571       bc->need_release=0;
03572       bc->need_release_complete=0;
03573 
03574       if (!stack->nt) {
03575          /*create cleanup in TE*/
03576          int channel=bc->channel;
03577 
03578          int tmpcause=bc->cause; 
03579          int tmp_out_cause=bc->out_cause; 
03580          empty_bc(bc);
03581          bc->cause=tmpcause;
03582          bc->out_cause=tmp_out_cause;
03583          clean_up_bc(bc);
03584          
03585          if (channel>0)
03586             empty_chan_in_stack(stack,channel);
03587          
03588          bc->in_use=0;
03589       }
03590       break;
03591     
03592    case EVENT_CONNECT_ACKNOWLEDGE:
03593 
03594       if ( bc->nt || misdn_cap_is_speech(bc->capability)) {
03595          int retval=setup_bc(bc);
03596          if (retval == -EINVAL){
03597             cb_log(0,bc->port,"send_event: setup_bc failed\n");
03598             
03599          }
03600       }
03601       
03602       if (misdn_cap_is_speech(bc->capability)) {
03603          if (  !bc->nodsp) manager_ph_control(bc,  DTMF_TONE_START, 0);
03604          manager_ec_enable(bc);
03605 
03606          if ( bc->txgain != 0 ) {
03607             cb_log(4, stack->port, "--> Changing txgain to %d\n", bc->txgain);
03608             manager_ph_control(bc, VOL_CHANGE_TX, bc->txgain);
03609          }
03610          if ( bc->rxgain != 0 ) {
03611             cb_log(4, stack->port, "--> Changing rxgain to %d\n", bc->rxgain);
03612             manager_ph_control(bc, VOL_CHANGE_RX, bc->rxgain);
03613          }
03614       }
03615       break;
03616     
03617    default:
03618       break;
03619    }
03620   
03621    /* Later we should think about sending bchannel data directly to misdn. */
03622    msg = isdn_msg_build_event(msgs_g, bc, event, stack->nt);
03623    msg_queue_tail(&stack->downqueue, msg);
03624    sem_post(&glob_mgr->new_msg);
03625   
03626 OUT:
03627    misdn_send_unlock(bc);
03628 
03629 OUT_POST_UNLOCK:
03630    return retval; 
03631 }

int misdn_lib_send_restart ( int  port,
int  channel 
)

Definition at line 3865 of file isdn_lib.c.

References misdn_stack::b_num, misdn_stack::bc, cb_log, misdn_bchannel::channel, clean_up_bc(), empty_bc(), EVENT_RESTART, find_stack_by_port(), misdn_bchannel::in_use, misdn_lib_send_event(), misdn_make_dummy(), misdn_stack::nt, and misdn_stack::port.

Referenced by handle_cli_misdn_send_restart(), handle_event_nt(), and handle_frm().

03866 {
03867    struct misdn_stack *stack=find_stack_by_port(port);
03868    struct misdn_bchannel dummybc;
03869    /*default is all channels*/
03870    cb_log(0, port, "Sending Restarts on this port.\n");
03871    
03872    misdn_make_dummy(&dummybc, stack->port, MISDN_ID_GLOBAL, stack->nt, 0);
03873 
03874    /*default is all channels*/
03875    if (channel <0) {
03876       dummybc.channel=-1;
03877       cb_log(0, port, "Restarting and all Interfaces\n");
03878       misdn_lib_send_event(&dummybc, EVENT_RESTART);
03879 
03880       return 0;
03881    }
03882 
03883    /*if a channel is specified we restart only this one*/
03884    if (channel >0) {
03885       int cnt;
03886       dummybc.channel=channel;
03887       cb_log(0, port, "Restarting and cleaning channel %d\n",channel);
03888       misdn_lib_send_event(&dummybc, EVENT_RESTART);
03889       /* clean up chan in stack, to be sure we don't think it's
03890        * in use anymore */
03891       for (cnt=0; cnt<=stack->b_num; cnt++) {
03892          if (stack->bc[cnt].in_use && stack->bc[cnt].channel == channel) {
03893             empty_bc(&stack->bc[cnt]);
03894             clean_up_bc(&stack->bc[cnt]);
03895             stack->bc[cnt].in_use=0;
03896          }
03897       }
03898    }
03899 
03900    return 0;
03901 }

void misdn_lib_send_tone ( struct misdn_bchannel bc,
enum tone_e  tone 
)

Definition at line 4515 of file isdn_lib.c.

References misdn_bchannel::addr, misdn_stack::bc, buf, glob_mgr, manager_ph_control(), misdn_lib::midev, TONE_ALERTING, TONE_DIAL, TONE_HANGUP, and TONE_NONE.

Referenced by hanguptone_indicate().

04516 {
04517    char buf[mISDN_HEADER_LEN + 128] = "";
04518    iframe_t *frm = (iframe_t*)buf;
04519 
04520    switch(tone) {
04521    case TONE_DIAL:
04522       manager_ph_control(bc, TONE_PATT_ON, TONE_GERMAN_DIALTONE); 
04523    break;
04524    
04525    case TONE_ALERTING:
04526       manager_ph_control(bc, TONE_PATT_ON, TONE_GERMAN_RINGING);  
04527    break;
04528    
04529    case TONE_HANGUP:
04530       manager_ph_control(bc, TONE_PATT_ON, TONE_GERMAN_HANGUP);   
04531    break;
04532 
04533    case TONE_NONE:
04534    default:
04535       manager_ph_control(bc, TONE_PATT_OFF, TONE_GERMAN_HANGUP);  
04536    }
04537 
04538    frm->prim=DL_DATA|REQUEST;
04539    frm->addr=bc->addr|FLG_MSG_DOWN;
04540    frm->dinfo=0;
04541    frm->len=128;
04542    
04543    mISDN_write(glob_mgr->midev, frm, mISDN_HEADER_LEN+frm->len, TIMEOUT_1SEC);
04544 }

void misdn_lib_setup_bc ( struct misdn_bchannel bc  ) 

Definition at line 991 of file isdn_lib.c.

References misdn_stack::bc, clean_up_bc(), and setup_bc().

00992 {
00993    clean_up_bc(bc);
00994    setup_bc(bc);
00995 }

void misdn_lib_split_bridge ( struct misdn_bchannel bc1,
struct misdn_bchannel bc2 
)

Definition at line 4669 of file isdn_lib.c.

References bc_state2str(), BCHAN_BRIDGED, cb_log, misdn_bchannel::conf_id, and misdn_split_conf().

Referenced by misdn_bridge().

04670 {
04671 
04672    struct misdn_bchannel *bc_list[]={
04673       bc1,bc2,NULL
04674    };
04675    struct misdn_bchannel **bc;
04676       
04677    for (bc=bc_list; *bc;  bc++) { 
04678       if ( (*bc)->bc_state == BCHAN_BRIDGED){
04679          misdn_split_conf( *bc, (*bc)->conf_id);
04680       } else {
04681          cb_log( 2, (*bc)->port, "BC not bridged (state:%s) so not splitting it\n",bc_state2str((*bc)->bc_state));
04682       }
04683    }
04684    
04685 }

void misdn_lib_tone_generator_start ( struct misdn_bchannel bc  ) 

Definition at line 2264 of file isdn_lib.c.

References misdn_bchannel::generate_tone.

Referenced by misdn_write().

02265 {
02266    bc->generate_tone=1;
02267 }

void misdn_lib_tone_generator_stop ( struct misdn_bchannel bc  ) 

Definition at line 2269 of file isdn_lib.c.

References misdn_bchannel::generate_tone.

Referenced by start_bc_tones(), and stop_indicate().

02270 {
02271    bc->generate_tone=0;
02272 }

int misdn_lib_tx2misdn_frm ( struct misdn_bchannel bc,
void *  data,
int  len 
)

Definition at line 4299 of file isdn_lib.c.

References misdn_bchannel::addr, misdn_stack::bc, misdn_bchannel::bc_state, bc_state2str(), BCHAN_ACTIVATED, BCHAN_BRIDGED, buf, misdn_bchannel::capability, cb_log, flip_buf_bits(), get_stack_by_bc(), misdn_stack::midev, misdn_cap_is_speech(), misdn_bchannel::port, and misdn_stack::port.

Referenced by misdn_join_conf().

04300 {
04301    struct misdn_stack *stack=get_stack_by_bc(bc);
04302    char buf[4096 + mISDN_HEADER_LEN];
04303    iframe_t *frm = (iframe_t*)buf;
04304    int r;
04305 
04306    switch (bc->bc_state) {
04307       case BCHAN_ACTIVATED:
04308       case BCHAN_BRIDGED:
04309          break;
04310       default:
04311          cb_log(3, bc->port, "BC not yet activated (state:%s)\n",bc_state2str(bc->bc_state));
04312          return -1;
04313    }
04314    
04315    frm->prim = DL_DATA|REQUEST;
04316    frm->dinfo = 0;
04317    frm->addr = bc->addr | FLG_MSG_DOWN ;
04318    
04319    frm->len = len;
04320    memcpy(&buf[mISDN_HEADER_LEN], data,len);
04321       
04322    if ( misdn_cap_is_speech(bc->capability) ) 
04323       flip_buf_bits( &buf[mISDN_HEADER_LEN], len);
04324    else
04325       cb_log(6, stack->port, "Writing %d data bytes\n",len);
04326    
04327    cb_log(9, stack->port, "Writing %d bytes 2 mISDN\n",len);
04328    r=mISDN_write(stack->midev, buf, frm->len + mISDN_HEADER_LEN, TIMEOUT_INFINIT);
04329    return 0;
04330 }

void misdn_make_dummy ( struct misdn_bchannel dummybc,
int  port,
int  l3id,
int  nt,
int  channel 
)

Definition at line 71 of file isdn_lib.c.

References misdn_bchannel::channel, misdn_bchannel::dummy, misdn_bchannel::l3_id, misdn_bchannel::nt, and misdn_bchannel::port.

Referenced by handle_cli_misdn_send_facility(), handle_cr(), handle_event_nt(), handle_frm(), manager_event_handler(), misdn_lib_send_restart(), and release_cr().

00072 {
00073    memset (dummybc,0,sizeof(struct misdn_bchannel));
00074    dummybc->port=port;
00075    if (l3id==0) 
00076       dummybc->l3_id = MISDN_ID_DUMMY;
00077    else
00078       dummybc->l3_id=l3id;
00079 
00080    dummybc->nt=nt;
00081    dummybc->dummy=1;
00082    dummybc->channel=channel;
00083 }

static void misdn_send_lock ( struct misdn_bchannel bc  )  [static]

Definition at line 3400 of file isdn_lib.c.

References misdn_stack::bc, send_lock::lock, pthread_mutex_lock, and misdn_bchannel::send_lock.

Referenced by misdn_lib_send_event().

03401 {
03402    //cb_log(0,bc->port,"Locking bc->pid:%d\n", bc->pid);
03403    if (bc->send_lock)
03404       pthread_mutex_lock(&bc->send_lock->lock);
03405 }

static void misdn_send_unlock ( struct misdn_bchannel bc  )  [static]

Definition at line 3407 of file isdn_lib.c.

References misdn_stack::bc, send_lock::lock, pthread_mutex_unlock, and misdn_bchannel::send_lock.

Referenced by misdn_lib_send_event().

03408 {
03409    //cb_log(0,bc->port,"UnLocking bc->pid:%d\n", bc->pid);
03410    if (bc->send_lock)
03411       pthread_mutex_unlock(&bc->send_lock->lock);
03412 }

void misdn_split_conf ( struct misdn_bchannel bc,
int  conf_id 
)

Definition at line 4637 of file isdn_lib.c.

References misdn_bchannel::addr, misdn_stack::bc, bc_state_change(), BCHAN_ACTIVATED, cb_log, manager_ph_control(), and misdn_bchannel::port.

Referenced by manager_bchannel_deactivate(), misdn_lib_send_event(), and misdn_lib_split_bridge().

04638 {
04639    bc_state_change(bc,BCHAN_ACTIVATED);
04640    manager_ph_control(bc, CMX_RECEIVE_ON, 0);
04641    manager_ph_control(bc, CMX_CONF_SPLIT, conf_id);
04642 
04643    cb_log(4,bc->port, "Splitting bc:%x in conf:%d\n",bc->addr,conf_id);
04644 }

void misdn_tx_jitter ( struct misdn_bchannel bc,
int  len 
)

Definition at line 2323 of file isdn_lib.c.

References misdn_bchannel::addr, misdn_bchannel::bframe, misdn_bchannel::bframe_len, buf, cb_jb_empty, cb_log, misdn_bchannel::channel, errno, flip_buf_bits(), glob_mgr, misdn_lib::midev, misdn_bchannel::port, and tone_silence_flip.

Referenced by do_tone(), and handle_bchan().

02324 {
02325    char buf[4096 + mISDN_HEADER_LEN];
02326    char *data=&buf[mISDN_HEADER_LEN];
02327    iframe_t *txfrm= (iframe_t*)buf;
02328    int jlen, r;
02329    
02330    jlen=cb_jb_empty(bc,data,len);
02331    
02332    if (jlen) {
02333 #ifdef MISDN_SAVE_DATA
02334       misdn_save_data((bc->port*100+bc->channel), data, jlen, bc->bframe, bc->bframe_len);
02335 #endif
02336       flip_buf_bits( data, jlen);
02337       
02338       if (jlen < len) {
02339          cb_log(1, bc->port, "Jitterbuffer Underrun. Got %d of expected %d\n", jlen, len);
02340       }
02341       
02342       txfrm->prim = DL_DATA|REQUEST;
02343       
02344       txfrm->dinfo = 0;
02345       
02346       txfrm->addr = bc->addr|FLG_MSG_DOWN; /*  | IF_DOWN; */
02347       
02348       txfrm->len =jlen;
02349       cb_log(9, bc->port, "Transmitting %d samples 2 misdn\n", txfrm->len);
02350 
02351       r=mISDN_write( glob_mgr->midev, buf, txfrm->len + mISDN_HEADER_LEN, 8000 );
02352    } else {
02353 #define MISDN_GEN_SILENCE
02354 #ifdef MISDN_GEN_SILENCE
02355       int cnt=len/TONE_SILENCE_SIZE;
02356       int rest=len%TONE_SILENCE_SIZE;
02357       int i;
02358 
02359       for (i=0; i<cnt; i++) {
02360          memcpy(data, tone_silence_flip, TONE_SILENCE_SIZE );
02361          data +=TONE_SILENCE_SIZE;
02362       }
02363 
02364       if (rest) {
02365          memcpy(data, tone_silence_flip, rest);
02366       }
02367 
02368       txfrm->prim = DL_DATA|REQUEST;
02369 
02370       txfrm->dinfo = 0;
02371 
02372       txfrm->addr = bc->addr|FLG_MSG_DOWN; /*  | IF_DOWN; */
02373 
02374       txfrm->len =len;
02375       cb_log(5, bc->port, "Transmitting %d samples of silence to misdn\n", len);
02376 
02377       r=mISDN_write( glob_mgr->midev, buf, txfrm->len + mISDN_HEADER_LEN, 8000 );
02378 #else
02379       r = 0;
02380 #endif
02381    }
02382 
02383    if (r < 0) {
02384       cb_log(1, bc->port, "Error in mISDN_write (%s)\n", strerror(errno));
02385    }
02386 }

static void prepare_bc ( struct misdn_bchannel bc,
int  channel 
) [static]

Definition at line 3220 of file isdn_lib.c.

References misdn_bchannel::addr, AST_CAUSE_NORMAL_CLEARING, misdn_bchannel::b_stid, misdn_bchannel::cause, misdn_bchannel::channel, misdn_bchannel::channel_preselected, misdn_bchannel::in_use, misdn_bchannel::layer_id, mypid, misdn_bchannel::need_disconnect, misdn_bchannel::need_release, misdn_bchannel::need_release_complete, and misdn_bchannel::pid.

Referenced by misdn_lib_get_free_bc().

03221 {
03222    bc->channel = channel;
03223    bc->channel_preselected = channel?1:0;
03224    bc->need_disconnect=1;
03225    bc->need_release=1;
03226    bc->need_release_complete=1;
03227    bc->cause = AST_CAUSE_NORMAL_CLEARING;
03228 
03229    if (++mypid>5000) mypid=1;
03230    bc->pid=mypid;
03231 
03232 #if 0
03233    bc->addr=0;
03234    bc->b_stid=0;
03235    bc->layer_id=0;
03236 #endif
03237 
03238    bc->in_use = 1;
03239 }

int queue_cleanup_bc ( struct misdn_bchannel bc  ) 

Definition at line 3829 of file isdn_lib.c.

References misdn_lib::activatequeue, misdn_stack::bc, cb_log, glob_mgr, misdn_bchannel::l3_id, misdn_lib::new_msg, and misdn_bchannel::port.

03830 {
03831    msg_t *msg=alloc_msg(MAX_MSG_SIZE);
03832    iframe_t *frm;
03833    if (!msg) {
03834       cb_log(0, bc->port, "queue_cleanup_bc: alloc_msg failed!\n");
03835       return -1;
03836    }
03837    frm=(iframe_t*)msg->data;
03838 
03839    /* activate bchannel */
03840    frm->prim = MGR_CLEARSTACK| REQUEST;
03841 
03842    frm->addr = bc->l3_id;
03843 
03844    frm->dinfo = bc->port;
03845    frm->len = 0;
03846   
03847    msg_queue_tail(&glob_mgr->activatequeue, msg);
03848    sem_post(&glob_mgr->new_msg);
03849 
03850    return 0; 
03851 
03852 }

int release_cr ( struct misdn_stack stack,
mISDNuser_head_t *  hh 
)

Definition at line 1834 of file isdn_lib.c.

References misdn_bchannel::addr, cb_log, find_bc_by_l3id(), handle_cr(), misdn_bchannel::l3_id, misdn_make_dummy(), misdn_stack::nt, misdn_stack::port, misdn_stack::procids, and misdn_stack::upper_id.

Referenced by handle_event_nt().

01835 {
01836    struct misdn_bchannel *bc=find_bc_by_l3id(stack, hh->dinfo);
01837    struct misdn_bchannel dummybc;
01838    iframe_t frm; /* fake te frm to remove callref from global callreflist */
01839    frm.dinfo = hh->dinfo;
01840 
01841    frm.addr=stack->upper_id | FLG_MSG_DOWN;
01842 
01843    frm.prim = CC_RELEASE_CR|INDICATION;
01844    cb_log(4, stack->port, " --> CC_RELEASE_CR: Faking Release_cr for %x l3id:%x\n",frm.addr, frm.dinfo);
01845    /** removing procid **/
01846    if (!bc) {
01847       cb_log(4, stack->port, " --> Didn't find BC so temporarily creating dummy BC (l3id:%x) on this port.\n", hh->dinfo);
01848       misdn_make_dummy(&dummybc, stack->port, hh->dinfo, stack->nt, 0);
01849       bc=&dummybc; 
01850    }
01851 
01852    if (bc) {
01853       if ( (bc->l3_id & 0xff00) == 0xff00) {
01854          cb_log(4, stack->port, " --> Removing Process Id:%x on this port.\n", bc->l3_id&0xff);
01855          stack->procids[bc->l3_id&0xff] = 0 ;
01856       }
01857    }
01858    else cb_log(0, stack->port, "Couldn't find BC so I couldn't remove the Process!!!! this is a bad port.\n");
01859 
01860    if (handle_cr(stack, &frm)<0) {
01861    }
01862 
01863    return 0 ;
01864 }

static int send_msg ( int  midev,
struct misdn_bchannel bc,
msg_t *  dmsg 
) [static]

Definition at line 404 of file isdn_lib.c.

References cb_log, get_stack_by_bc(), misdn_bchannel::l3_id, and misdn_bchannel::port.

Referenced by manager_event_handler().

00405 {
00406    iframe_t *frm = (iframe_t *)dmsg->data;
00407    struct misdn_stack *stack=get_stack_by_bc(bc);
00408 
00409    if (!stack) {
00410       cb_log(0,bc->port,"send_msg: IEK!! no stack\n ");
00411       return -1;
00412    }
00413    
00414    frm->addr = (stack->upper_id | FLG_MSG_DOWN);
00415    frm->dinfo = bc->l3_id;
00416    frm->len = (dmsg->len) - mISDN_HEADER_LEN;
00417             
00418    cb_log(4,stack->port,"Sending msg, prim:%x addr:%x dinfo:%x\n",frm->prim,frm->addr,frm->dinfo);
00419 
00420    mISDN_write(midev, dmsg->data, dmsg->len, TIMEOUT_1SEC);
00421    free_msg(dmsg);
00422 
00423    return 0;
00424 }

static int set_chan_in_stack ( struct misdn_stack stack,
int  channel 
) [static]

Definition at line 477 of file isdn_lib.c.

References cb_log, misdn_stack::channels, dump_chan_list(), MAX_BCHANS, and misdn_stack::port.

00478 {
00479 
00480    cb_log(4,stack->port,"set_chan_in_stack: %d\n",channel);
00481    dump_chan_list(stack);
00482    if (channel >=1 && channel <= MAX_BCHANS) {
00483       if (!stack->channels[channel-1])
00484          stack->channels[channel-1] = 1;
00485       else {
00486          cb_log(4,stack->port,"channel already in use:%d\n", channel );
00487          return -1;
00488       }
00489    } else {
00490       cb_log(0,stack->port,"couldn't set channel %d in\n", channel );
00491       return -1;
00492    }
00493   
00494    return 0;
00495 }

int setup_bc ( struct misdn_bchannel bc  ) 

Definition at line 998 of file isdn_lib.c.

References misdn_stack::b_num, misdn_bchannel::b_stid, misdn_stack::b_stids, misdn_stack::bc, misdn_bchannel::bc_state, bc_state2str(), BCHAN_CLEANED, buff, cb_log, misdn_bchannel::channel, get_stack_by_bc(), misdn_stack::midev, misdn_stack::port, and misdn_bchannel::port.

Referenced by handle_event(), misdn_lib_send_event(), and misdn_lib_setup_bc().

00999 {
01000    unsigned char buff[1025];
01001    int midev;
01002    int channel;
01003    int b_stid;
01004    int i;
01005    mISDN_pid_t pid;
01006    int ret;
01007 
01008    struct misdn_stack *stack=get_stack_by_bc(bc);
01009 
01010    if (!stack) {
01011       cb_log(0, bc->port, "setup_bc: NO STACK FOUND!!\n");
01012       return -1;
01013    }
01014    
01015    midev = stack->midev;
01016    channel = bc->channel - 1 - (bc->channel > 16);
01017    b_stid = stack->b_stids[channel >= 0 ? channel : 0];
01018 
01019    switch (bc->bc_state) {
01020       case BCHAN_CLEANED:
01021          break;
01022       default:
01023          cb_log(4, stack->port, "$$$ bc already setup stid :%x (state:%s)\n", b_stid, bc_state2str(bc->bc_state) );
01024          return -1;
01025    }
01026    
01027    cb_log(5, stack->port, "$$$ Setting up bc with stid :%x\n", b_stid);
01028    
01029    /*check if the b_stid is already initialized*/
01030    for (i=0; i <= stack->b_num; i++) {
01031       if (stack->bc[i].b_stid == b_stid) {
01032          cb_log(0, bc->port, "setup_bc: b_stid:%x already in use !!!\n", b_stid);
01033          return -1;
01034       }
01035    }
01036    
01037    if (b_stid <= 0) {
01038       cb_log(0, stack->port," -- Stid <=0 at the moment in channel:%d\n",channel);
01039       
01040       bc_state_change(bc,BCHAN_ERROR);
01041       return 1;
01042    }
01043 
01044    bc->b_stid = b_stid;
01045 
01046    {
01047       layer_info_t li;
01048       memset(&li, 0, sizeof(li));
01049     
01050       li.object_id = -1;
01051       li.extentions = 0;
01052       
01053       li.st = bc->b_stid; /*  given idx */
01054 
01055 
01056 #define MISDN_DSP
01057 #ifndef MISDN_DSP
01058       bc->nodsp=1;
01059 #endif
01060       if ( bc->hdlc || bc->nodsp) {
01061          cb_log(4, stack->port,"setup_bc: without dsp\n");
01062          { 
01063             int l = sizeof(li.name);
01064             strncpy(li.name, "B L3", l);
01065             li.name[l-1] = 0;
01066          }
01067          li.pid.layermask = ISDN_LAYER((3));
01068          li.pid.protocol[3] = ISDN_PID_L3_B_USER;
01069          
01070          bc->layer=3;
01071       } else {
01072          cb_log(4, stack->port,"setup_bc: with dsp\n");
01073          { 
01074             int l = sizeof(li.name);
01075             strncpy(li.name, "B L4", l);
01076             li.name[l-1] = 0;
01077          }
01078          li.pid.layermask = ISDN_LAYER((4));
01079          li.pid.protocol[4] = ISDN_PID_L4_B_USER;
01080 
01081          bc->layer=4;
01082       }  
01083       
01084       ret = mISDN_new_layer(midev, &li);
01085       if (ret ) {
01086          cb_log(0, stack->port,"New Layer Err: %d %s\n",ret,strerror(errno));
01087 
01088          bc_state_change(bc,BCHAN_ERROR);
01089          return(-EINVAL);
01090       }
01091       
01092       bc->layer_id = li.id;
01093    }
01094    
01095    memset(&pid, 0, sizeof(pid));
01096    
01097    
01098    
01099    cb_log(4, stack->port," --> Channel is %d\n", bc->channel);
01100    
01101    if (bc->nodsp) {
01102       cb_log(2, stack->port," --> TRANSPARENT Mode (no DSP, no HDLC)\n");
01103       pid.protocol[1] = ISDN_PID_L1_B_64TRANS;
01104       pid.protocol[2] = ISDN_PID_L2_B_TRANS;
01105       pid.protocol[3] = ISDN_PID_L3_B_USER;
01106       pid.layermask = ISDN_LAYER((1)) | ISDN_LAYER((2)) | ISDN_LAYER((3));
01107       
01108    } else if ( bc->hdlc ) {
01109       cb_log(2, stack->port," --> HDLC Mode\n");
01110       pid.protocol[1] = ISDN_PID_L1_B_64HDLC ;
01111       pid.protocol[2] = ISDN_PID_L2_B_TRANS  ;
01112       pid.protocol[3] = ISDN_PID_L3_B_USER;
01113       pid.layermask = ISDN_LAYER((1)) | ISDN_LAYER((2)) | ISDN_LAYER((3)) ;
01114    } else {
01115       cb_log(2, stack->port," --> TRANSPARENT Mode\n");
01116       pid.protocol[1] = ISDN_PID_L1_B_64TRANS;
01117       pid.protocol[2] = ISDN_PID_L2_B_TRANS;
01118       pid.protocol[3] = ISDN_PID_L3_B_DSP;
01119       pid.protocol[4] = ISDN_PID_L4_B_USER;
01120       pid.layermask = ISDN_LAYER((1)) | ISDN_LAYER((2)) | ISDN_LAYER((3)) | ISDN_LAYER((4));
01121       
01122    } 
01123 
01124    ret = mISDN_set_stack(midev, bc->b_stid, &pid);
01125 
01126    if (ret){
01127       cb_log(0, stack->port,"$$$ Set Stack Err: %d %s\n",ret,strerror(errno));
01128       
01129       mISDN_write_frame(midev, buff, bc->layer_id, MGR_DELLAYER | REQUEST, 0, 0, NULL, TIMEOUT_1SEC);
01130       
01131       bc_state_change(bc,BCHAN_ERROR);
01132       cb_event(EVENT_BCHAN_ERROR, bc, glob_mgr->user_data);
01133       return(-EINVAL);
01134    }
01135 
01136    ret = mISDN_get_setstack_ind(midev, bc->layer_id);
01137 
01138    if (ret) {
01139       cb_log(0, stack->port,"$$$ Set StackIND Err: %d %s\n",ret,strerror(errno));
01140       mISDN_write_frame(midev, buff, bc->layer_id, MGR_DELLAYER | REQUEST, 0, 0, NULL, TIMEOUT_1SEC);
01141       
01142       bc_state_change(bc,BCHAN_ERROR);
01143       cb_event(EVENT_BCHAN_ERROR, bc, glob_mgr->user_data);
01144       return(-EINVAL);
01145    }
01146 
01147    ret = mISDN_get_layerid(midev, bc->b_stid, bc->layer) ;
01148 
01149    bc->addr = ret>0? ret : 0;
01150 
01151    if (!bc->addr) {
01152       cb_log(0, stack->port,"$$$ Get Layerid Err: %d %s\n",ret,strerror(errno));
01153       mISDN_write_frame(midev, buff, bc->layer_id, MGR_DELLAYER | REQUEST, 0, 0, NULL, TIMEOUT_1SEC);
01154       
01155       bc_state_change(bc,BCHAN_ERROR);
01156       cb_event(EVENT_BCHAN_ERROR, bc, glob_mgr->user_data);
01157       return (-EINVAL);
01158    }
01159 
01160    manager_bchannel_activate(bc);
01161    
01162    bc_state_change(bc,BCHAN_ACTIVATED);
01163 
01164    return 0;
01165 }

static void stack_destroy ( struct misdn_stack stack  )  [static]

Definition at line 1427 of file isdn_lib.c.

References buf, misdn_stack::lower_id, misdn_stack::midev, misdn_stack::nst, misdn_stack::nstlock, misdn_stack::nt, pthread_mutex_destroy, misdn_stack::st_lock, and misdn_stack::upper_id.

Referenced by misdn_lib_destroy().

01428 {
01429    char buf[1024];
01430    if (!stack) return;
01431 
01432    if (stack->nt) {
01433       pthread_mutex_destroy(&stack->nstlock);
01434       cleanup_Isdnl2(&stack->nst);
01435       cleanup_Isdnl3(&stack->nst);
01436    }
01437   
01438    if (stack->lower_id) 
01439       mISDN_write_frame(stack->midev, buf, stack->lower_id, MGR_DELLAYER | REQUEST, 0, 0, NULL, TIMEOUT_1SEC);
01440 
01441    if (stack->upper_id) 
01442       mISDN_write_frame(stack->midev, buf, stack->upper_id, MGR_DELLAYER | REQUEST, 0, 0, NULL, TIMEOUT_1SEC);
01443 
01444    pthread_mutex_destroy(&stack->st_lock);
01445 }

void stack_holder_add ( struct misdn_stack stack,
struct misdn_bchannel holder 
)

Definition at line 4420 of file isdn_lib.c.

References cb_log, misdn_stack::holding, misdn_bchannel::l3_id, misdn_bchannel::next, misdn_stack::port, and misdn_bchannel::stack_holder.

Referenced by misdn_lib_send_event().

04421 {
04422    struct misdn_bchannel *help;
04423    cb_log(4,stack->port, "*HOLDER: add %x\n",holder->l3_id);
04424    
04425    holder->stack_holder=1;
04426    holder->next=NULL;
04427    
04428    if (!stack->holding) {
04429       stack->holding = holder;
04430       return;
04431    }
04432   
04433    for (help=stack->holding;
04434         help;
04435         help=help->next) {
04436       if (!help->next) {
04437          help->next=holder;
04438          break;
04439       }
04440    }
04441   
04442 }

struct misdn_bchannel * stack_holder_find ( struct misdn_stack stack,
unsigned long  l3id 
)

Definition at line 4470 of file isdn_lib.c.

References cb_log, misdn_stack::holding, misdn_bchannel::l3_id, misdn_bchannel::next, and misdn_stack::port.

Referenced by handle_event_nt(), and misdn_lib_find_held_bc().

04471 {
04472    struct misdn_bchannel *help;
04473 
04474    cb_log(4,stack?stack->port:0, "*HOLDER: find %lx\n",l3id);
04475    
04476    if (!stack) return NULL;
04477    
04478    for (help=stack->holding;
04479         help;
04480         help=help->next) {
04481       if (help->l3_id == l3id) {
04482          cb_log(4,stack->port, "*HOLDER: found bc\n");
04483          return help;
04484       }
04485    }
04486 
04487    cb_log(4,stack->port, "*HOLDER: find nothing\n");
04488    return NULL;
04489 }

void stack_holder_remove ( struct misdn_stack stack,
struct misdn_bchannel holder 
)

Definition at line 4444 of file isdn_lib.c.

References cb_log, misdn_stack::holding, misdn_bchannel::l3_id, misdn_bchannel::next, misdn_stack::port, and misdn_bchannel::stack_holder.

Referenced by handle_cr(), and handle_event_nt().

04445 {
04446    struct misdn_bchannel *h1;
04447 
04448    if (!holder->stack_holder) return;
04449    
04450    holder->stack_holder=0;
04451    
04452    cb_log(4,stack->port, "*HOLDER: remove %x\n",holder->l3_id);
04453    if (!stack || ! stack->holding) return;
04454   
04455    if (holder == stack->holding) {
04456       stack->holding = stack->holding->next;
04457       return;
04458    }
04459    
04460    for (h1=stack->holding;
04461         h1;
04462         h1=h1->next) {
04463       if (h1->next == holder) {
04464          h1->next=h1->next->next;
04465          return ;
04466       }
04467    }
04468 }

static struct misdn_stack* stack_init ( int  midev,
int  port,
int  ptp 
) [static]

Definition at line 1239 of file isdn_lib.c.

References misdn_stack::b_num, misdn_stack::b_stids, buff, cb_log, misdn_stack::channels, misdn_stack::d_stid, misdn_stack::downqueue, misdn_stack::holding, malloc, MAX_BCHANS, misdn_stack::midev, misdn_stack::nt, misdn_stack::port, misdn_stack::pri, pthread_mutex_init, misdn_stack::ptp, misdn_stack::st_lock, and misdn_stack::upqueue.

Referenced by misdn_lib_init().

01240 {
01241    int ret;
01242    unsigned char buff[1025];
01243    iframe_t *frm = (iframe_t *)buff;
01244    stack_info_t *stinf;
01245    int i; 
01246    layer_info_t li;
01247 
01248    struct misdn_stack *stack = malloc(sizeof(struct misdn_stack));
01249    if (!stack ) return NULL;
01250 
01251 
01252    cb_log(8, port, "Init. Stack.\n");
01253   
01254    memset(stack,0,sizeof(struct misdn_stack));
01255   
01256    for (i=0; i<MAX_BCHANS + 1; i++ ) stack->channels[i]=0;
01257    
01258    stack->port=port;
01259    stack->midev=midev;
01260    stack->ptp=ptp;
01261   
01262    stack->holding=NULL;
01263    stack->pri=0;
01264   
01265    msg_queue_init(&stack->downqueue);
01266    msg_queue_init(&stack->upqueue);
01267 
01268    pthread_mutex_init(&stack->st_lock, NULL);
01269   
01270    /* query port's requirements */
01271    ret = mISDN_get_stack_info(midev, port, buff, sizeof(buff));
01272    if (ret < 0) {
01273       cb_log(0, port, "%s: Cannot get stack info for this port. (ret=%d)\n", __FUNCTION__, ret);
01274       return(NULL);
01275    }
01276   
01277    stinf = (stack_info_t *)&frm->data.p;
01278 
01279    stack->d_stid = stinf->id;
01280    stack->b_num = stinf->childcnt;
01281 
01282    for (i=0; i<=stinf->childcnt; i++)
01283       stack->b_stids[i] = stinf->child[i];
01284   
01285    switch(stinf->pid.protocol[0] & ~ISDN_PID_FEATURE_MASK) {
01286    case ISDN_PID_L0_TE_S0:
01287       stack->nt=0;
01288       break;
01289    case ISDN_PID_L0_NT_S0:
01290       cb_log(8, port, "NT Stack\n");
01291 
01292       stack->nt=1;
01293       break;
01294    case ISDN_PID_L0_TE_E1:
01295       cb_log(8, port, "TE S2M Stack\n");
01296       stack->nt=0;
01297       stack->pri=1;
01298       break;
01299    case ISDN_PID_L0_NT_E1:
01300       cb_log(8, port, "TE S2M Stack\n");
01301       stack->nt=1;
01302       stack->pri=1;
01303       
01304       break;
01305    default:
01306       cb_log(0, port, "this is a unknown port type 0x%08x\n", stinf->pid.protocol[0]);
01307 
01308    }
01309 
01310    if (!stack->nt) {
01311       if (stinf->pid.protocol[2] & ISDN_PID_L2_DF_PTP ) { 
01312          stack->ptp = 1;
01313       } else {
01314          stack->ptp = 0;
01315       }
01316    }
01317    
01318    {
01319       int ret;
01320       int nt=stack->nt;
01321 
01322       cb_log(8, port, "Init. Stack.\n");
01323       
01324       memset(&li, 0, sizeof(li));
01325       {
01326          int l = sizeof(li.name);
01327          strncpy(li.name,nt?"net l2":"user l4", l);
01328          li.name[l-1] = 0;
01329       }
01330       li.object_id = -1;
01331       li.extentions = 0;
01332       li.pid.protocol[nt?2:4] = nt?ISDN_PID_L2_LAPD_NET:ISDN_PID_L4_CAPI20;
01333       li.pid.layermask = ISDN_LAYER((nt?2:4));
01334       li.st = stack->d_stid;
01335       
01336       
01337       ret = mISDN_new_layer(midev, &li);
01338       if (ret) {
01339          cb_log(0, port, "%s: Cannot add layer %d to this port.\n", __FUNCTION__, nt?2:4);
01340          return(NULL);
01341       }
01342       
01343       
01344       stack->upper_id = li.id;
01345       ret = mISDN_register_layer(midev, stack->d_stid, stack->upper_id);
01346       if (ret)
01347       {
01348          cb_log(0,port,"Cannot register layer %d of this port.\n", nt?2:4);
01349          return(NULL);
01350       }
01351       
01352       stack->lower_id = mISDN_get_layerid(midev, stack->d_stid, nt?1:3); 
01353       if (stack->lower_id < 0) {
01354          cb_log(0, port, "%s: Cannot get layer(%d) id of this port.\n", __FUNCTION__, nt?1:3);
01355          return(NULL);
01356       }
01357       
01358       stack->upper_id = mISDN_get_layerid(midev, stack->d_stid, nt?2:4);
01359       if (stack->upper_id < 0) {
01360          cb_log(0, port, "%s: Cannot get layer(%d) id of this port.\n", __FUNCTION__, 2);
01361          return(NULL);
01362       }
01363       
01364       cb_log(8, port, "NT Stacks upper_id %x\n",stack->upper_id);
01365       
01366       
01367       /* create nst (nt-mode only) */
01368       if (nt) {
01369          
01370          memset(&stack->nst, 0, sizeof(net_stack_t));
01371          memset(&stack->mgr, 0, sizeof(manager_t));
01372     
01373          stack->mgr.nst = &stack->nst;
01374          stack->nst.manager = &stack->mgr;
01375     
01376          stack->nst.l3_manager = handle_event_nt;
01377          stack->nst.device = midev;
01378          stack->nst.cardnr = port;
01379          stack->nst.d_stid = stack->d_stid;
01380     
01381          stack->nst.feature = FEATURE_NET_HOLD;
01382          if (stack->ptp)
01383             stack->nst.feature |= FEATURE_NET_PTP;
01384          if (stack->pri)
01385             stack->nst.feature |= FEATURE_NET_CRLEN2 | FEATURE_NET_EXTCID;
01386          
01387          stack->nst.l1_id = stack->lower_id;
01388          stack->nst.l2_id = stack->upper_id;
01389          
01390          msg_queue_init(&stack->nst.down_queue);
01391          pthread_mutex_init(&stack->nstlock, NULL);
01392          
01393          Isdnl2Init(&stack->nst);
01394          Isdnl3Init(&stack->nst);
01395          
01396       } 
01397       
01398       if (!stack->nt) {
01399          /*assume L1 is up, we'll get DEACTIVATES soon, for non
01400           * up L1s*/
01401          stack->l1link=0;
01402       }
01403       stack->l1link=0;
01404       stack->l2link=0;
01405 #if 0 
01406       if (!stack->nt) {
01407          misdn_lib_get_short_status(stack);
01408       } else {
01409          misdn_lib_get_l1_up(stack);
01410          if (!stack->ptp) misdn_lib_get_l1_up(stack);
01411          misdn_lib_get_l2_up(stack);
01412       }
01413 #endif
01414 
01415       misdn_lib_get_short_status(stack);
01416       misdn_lib_get_l1_up(stack);
01417       misdn_lib_get_l2_up(stack); 
01418       
01419    }
01420 
01421    cb_log(8,0,"stack_init: port:%d lowerId:%x  upperId:%x\n",stack->port,stack->lower_id, stack->upper_id);
01422    
01423    return stack;
01424 }

void te_lib_destroy ( int  midev  ) 

Definition at line 3174 of file isdn_lib.c.

References buf, cb_log, and entity.

Referenced by misdn_lib_destroy().

03175 {
03176    char buf[1024];
03177    mISDN_write_frame(midev, buf, 0, MGR_DELENTITY | REQUEST, entity, 0, NULL, TIMEOUT_1SEC);
03178 
03179    cb_log(4, 0, "Entity deleted\n");
03180    mISDN_close(midev);
03181    cb_log(4, 0, "midev closed\n");
03182 }

int te_lib_init ( void   ) 

App Interface

Definition at line 3147 of file isdn_lib.c.

References buff, entity, errno, and misdn_lib::midev.

Referenced by misdn_lib_init().

03147                   {
03148    char buff[1025] = "";
03149    iframe_t *frm=(iframe_t*)buff;
03150    int midev=mISDN_open();
03151    int ret;
03152 
03153    if  (midev<=0) return midev;
03154   
03155 /* create entity for layer 3 TE-mode */
03156    mISDN_write_frame(midev, buff, 0, MGR_NEWENTITY | REQUEST, 0, 0, NULL, TIMEOUT_1SEC);
03157    ret = mISDN_read_frame(midev, frm, sizeof(iframe_t), 0, MGR_NEWENTITY | CONFIRM, TIMEOUT_1SEC);
03158   
03159    if (ret < mISDN_HEADER_LEN) {
03160    noentity:
03161       fprintf(stderr, "cannot request MGR_NEWENTITY from mISDN: %s\n",strerror(errno));
03162       exit(-1);
03163    }
03164   
03165    entity = frm->dinfo & 0xffff ;
03166   
03167    if (!entity)
03168       goto noentity;
03169 
03170    return midev;
03171   
03172 }

static int test_inuse ( struct misdn_bchannel bc  )  [static]

Definition at line 3200 of file isdn_lib.c.

References misdn_bchannel::b_stid, cb_log, misdn_bchannel::in_use, misdn_bchannel::last_used, misdn_lib_port_is_pri(), and misdn_bchannel::port.

Referenced by misdn_lib_get_free_bc().

03201 {
03202    struct timeval now;
03203    gettimeofday(&now, NULL);
03204    if (!bc->in_use) {
03205       if (misdn_lib_port_is_pri(bc->port) && bc->last_used.tv_sec == now.tv_sec ) {
03206          cb_log(2,bc->port, "channel with stid:%x for one second still in use! (n:%d lu:%d)\n", bc->b_stid, (int) now.tv_sec, (int) bc->last_used.tv_sec);
03207          return 1;
03208       }
03209       
03210 
03211       cb_log(3,bc->port, "channel with stid:%x not in use!\n", bc->b_stid);
03212       return 0;
03213    }
03214    
03215    cb_log(2,bc->port, "channel with stid:%x in use!\n", bc->b_stid);
03216    return 1;
03217 }


Variable Documentation

int entity [static]

Definition at line 252 of file isdn_lib.c.

Referenced by te_lib_destroy(), and te_lib_init().

char flip_table[256] [static]

Definition at line 313 of file isdn_lib.c.

Referenced by flip_buf_bits(), and init_flip_bits().

struct misdn_lib* glob_mgr [static]

Definition at line 254 of file isdn_lib.c.

Referenced by do_tone(), find_bc_by_addr(), find_bc_by_confid(), find_stack_by_addr(), find_stack_by_mgr(), find_stack_by_port(), get_misdn_stack(), handle_bchan(), handle_cr(), handle_event_nt(), handle_frm(), handle_l1(), handle_l2(), handle_timers(), manager_event_handler(), manager_find_bc_by_pid(), manager_ph_control(), manager_ph_control_block(), misdn_lib_destroy(), misdn_lib_get_free_bc(), misdn_lib_get_port_down(), misdn_lib_get_port_info(), misdn_lib_get_port_up(), misdn_lib_init(), misdn_lib_isdn_l1watcher(), misdn_lib_port_restart(), misdn_lib_port_up(), misdn_lib_reinit_nt_stack(), misdn_lib_send_event(), misdn_lib_send_tone(), misdn_tx_jitter(), and queue_cleanup_bc().

enum global_states global_state = MISDN_INITIALIZING [static]

Definition at line 188 of file isdn_lib.c.

Referenced by clear_l3(), handle_l1(), and misdn_lib_destroy().

sem_t handler_started

Definition at line 3944 of file isdn_lib.c.

struct isdn_msg msgs_g[]

Msg Array

Definition at line 1163 of file isdn_msg_parser.c.

Referenced by handle_event_nt(), handle_frm(), handle_l1(), manager_isdn_get_info(), and misdn_lib_send_event().

int mypid = 1 [static]

Definition at line 427 of file isdn_lib.c.

Referenced by prepare_bc().

int new_te_id = 0 [static]

Definition at line 811 of file isdn_lib.c.

int nt_err_cnt = 0 [static]

Definition at line 181 of file isdn_lib.c.

Referenced by handle_frm_nt().

char tone_425_flip[TONE_425_SIZE]

Definition at line 256 of file isdn_lib.c.

Referenced by misdn_lib_init().

char tone_silence_flip[TONE_SILENCE_SIZE]

Definition at line 257 of file isdn_lib.c.

Referenced by misdn_lib_init(), and misdn_tx_jitter().


Generated on Wed Aug 18 22:34:25 2010 for Asterisk - the Open Source PBX by  doxygen 1.4.7