diff options
Diffstat (limited to 'drivers/isdn/hardware/eicon/message.c')
| -rw-r--r-- | drivers/isdn/hardware/eicon/message.c | 15051 |
1 files changed, 15051 insertions, 0 deletions
diff --git a/drivers/isdn/hardware/eicon/message.c b/drivers/isdn/hardware/eicon/message.c new file mode 100644 index 000000000..d7c286656 --- /dev/null +++ b/drivers/isdn/hardware/eicon/message.c @@ -0,0 +1,15051 @@ +/* + * + Copyright (c) Eicon Networks, 2002. + * + This source file is supplied for the use with + Eicon Networks range of DIVA Server Adapters. + * + Eicon File Revision : 2.1 + * + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + * + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY OF ANY KIND WHATSOEVER INCLUDING ANY + implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the GNU General Public License for more details. + * + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + + + + + +#include "platform.h" +#include "di_defs.h" +#include "pc.h" +#include "capi20.h" +#include "divacapi.h" +#include "mdm_msg.h" +#include "divasync.h" + + + +#define FILE_ "MESSAGE.C" +#define dprintf + + + + + + + + + +/*------------------------------------------------------------------*/ +/* This is options supported for all adapters that are server by */ +/* XDI driver. Allo it is not necessary to ask it from every adapter*/ +/* and it is not necessary to save it separate for every adapter */ +/* Macrose defined here have only local meaning */ +/*------------------------------------------------------------------*/ +static dword diva_xdi_extended_features = 0; + +#define DIVA_CAPI_USE_CMA 0x00000001 +#define DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR 0x00000002 +#define DIVA_CAPI_XDI_PROVIDES_NO_CANCEL 0x00000004 +#define DIVA_CAPI_XDI_PROVIDES_RX_DMA 0x00000008 + +/* + CAPI can request to process all return codes self only if: + protocol code supports this && xdi supports this +*/ +#define DIVA_CAPI_SUPPORTS_NO_CANCEL(__a__) (((__a__)->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL) && ((__a__)->manufacturer_features & MANUFACTURER_FEATURE_OK_FC_LABEL) && (diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_NO_CANCEL)) + +/*------------------------------------------------------------------*/ +/* local function prototypes */ +/*------------------------------------------------------------------*/ + +static void group_optimization(DIVA_CAPI_ADAPTER *a, PLCI *plci); +static void set_group_ind_mask(PLCI *plci); +static void clear_group_ind_mask_bit(PLCI *plci, word b); +static byte test_group_ind_mask_bit(PLCI *plci, word b); +void AutomaticLaw(DIVA_CAPI_ADAPTER *); +word CapiRelease(word); +word CapiRegister(word); +word api_put(APPL *, CAPI_MSG *); +static word api_parse(byte *, word, byte *, API_PARSE *); +static void api_save_msg(API_PARSE *in, byte *format, API_SAVE *out); +static void api_load_msg(API_SAVE *in, API_PARSE *out); + +word api_remove_start(void); +void api_remove_complete(void); + +static void plci_remove(PLCI *); +static void diva_get_extended_adapter_features(DIVA_CAPI_ADAPTER *a); +static void diva_ask_for_xdi_sdram_bar(DIVA_CAPI_ADAPTER *, IDI_SYNC_REQ *); + +void callback(ENTITY *); + +static void control_rc(PLCI *, byte, byte, byte, byte, byte); +static void data_rc(PLCI *, byte); +static void data_ack(PLCI *, byte); +static void sig_ind(PLCI *); +static void SendInfo(PLCI *, dword, byte **, byte); +static void SendSetupInfo(APPL *, PLCI *, dword, byte **, byte); +static void SendSSExtInd(APPL *, PLCI *plci, dword Id, byte **parms); + +static void VSwitchReqInd(PLCI *plci, dword Id, byte **parms); + +static void nl_ind(PLCI *); + +static byte connect_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte connect_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte connect_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte disconnect_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte disconnect_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte listen_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte info_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte info_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte alert_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte facility_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte facility_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte connect_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte connect_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte connect_b3_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte disconnect_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte disconnect_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte data_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte data_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte reset_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte reset_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte connect_b3_t90_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte select_b_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte manufacturer_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +static byte manufacturer_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); + +static word get_plci(DIVA_CAPI_ADAPTER *); +static void add_p(PLCI *, byte, byte *); +static void add_s(PLCI *plci, byte code, API_PARSE *p); +static void add_ss(PLCI *plci, byte code, API_PARSE *p); +static void add_ie(PLCI *plci, byte code, byte *p, word p_length); +static void add_d(PLCI *, word, byte *); +static void add_ai(PLCI *, API_PARSE *); +static word add_b1(PLCI *, API_PARSE *, word, word); +static word add_b23(PLCI *, API_PARSE *); +static word add_modem_b23(PLCI *plci, API_PARSE *bp_parms); +static void sig_req(PLCI *, byte, byte); +static void nl_req_ncci(PLCI *, byte, byte); +static void send_req(PLCI *); +static void send_data(PLCI *); +static word plci_remove_check(PLCI *); +static void listen_check(DIVA_CAPI_ADAPTER *); +static byte AddInfo(byte **, byte **, byte *, byte *); +static byte getChannel(API_PARSE *); +static void IndParse(PLCI *, word *, byte **, byte); +static byte ie_compare(byte *, byte *); +static word find_cip(DIVA_CAPI_ADAPTER *, byte *, byte *); +static word CPN_filter_ok(byte *cpn, DIVA_CAPI_ADAPTER *, word); + +/* + XON protocol helpers +*/ +static void channel_flow_control_remove(PLCI *plci); +static void channel_x_off(PLCI *plci, byte ch, byte flag); +static void channel_x_on(PLCI *plci, byte ch); +static void channel_request_xon(PLCI *plci, byte ch); +static void channel_xmit_xon(PLCI *plci); +static int channel_can_xon(PLCI *plci, byte ch); +static void channel_xmit_extended_xon(PLCI *plci); + +static byte SendMultiIE(PLCI *plci, dword Id, byte **parms, byte ie_type, dword info_mask, byte setupParse); +static word AdvCodecSupport(DIVA_CAPI_ADAPTER *, PLCI *, APPL *, byte); +static void CodecIdCheck(DIVA_CAPI_ADAPTER *, PLCI *); +static void SetVoiceChannel(PLCI *, byte *, DIVA_CAPI_ADAPTER *); +static void VoiceChannelOff(PLCI *plci); +static void adv_voice_write_coefs(PLCI *plci, word write_command); +static void adv_voice_clear_config(PLCI *plci); + +static word get_b1_facilities(PLCI *plci, byte b1_resource); +static byte add_b1_facilities(PLCI *plci, byte b1_resource, word b1_facilities); +static void adjust_b1_facilities(PLCI *plci, byte new_b1_resource, word new_b1_facilities); +static word adjust_b_process(dword Id, PLCI *plci, byte Rc); +static void adjust_b1_resource(dword Id, PLCI *plci, API_SAVE *bp_msg, word b1_facilities, word internal_command); +static void adjust_b_restore(dword Id, PLCI *plci, byte Rc); +static void reset_b3_command(dword Id, PLCI *plci, byte Rc); +static void select_b_command(dword Id, PLCI *plci, byte Rc); +static void fax_connect_ack_command(dword Id, PLCI *plci, byte Rc); +static void fax_edata_ack_command(dword Id, PLCI *plci, byte Rc); +static void fax_connect_info_command(dword Id, PLCI *plci, byte Rc); +static void fax_adjust_b23_command(dword Id, PLCI *plci, byte Rc); +static void fax_disconnect_command(dword Id, PLCI *plci, byte Rc); +static void hold_save_command(dword Id, PLCI *plci, byte Rc); +static void retrieve_restore_command(dword Id, PLCI *plci, byte Rc); +static void init_b1_config(PLCI *plci); +static void clear_b1_config(PLCI *plci); + +static void dtmf_command(dword Id, PLCI *plci, byte Rc); +static byte dtmf_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg); +static void dtmf_confirmation(dword Id, PLCI *plci); +static void dtmf_indication(dword Id, PLCI *plci, byte *msg, word length); +static void dtmf_parameter_write(PLCI *plci); + + +static void mixer_set_bchannel_id_esc(PLCI *plci, byte bchannel_id); +static void mixer_set_bchannel_id(PLCI *plci, byte *chi); +static void mixer_clear_config(PLCI *plci); +static void mixer_notify_update(PLCI *plci, byte others); +static void mixer_command(dword Id, PLCI *plci, byte Rc); +static byte mixer_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg); +static void mixer_indication_coefs_set(dword Id, PLCI *plci); +static void mixer_indication_xconnect_from(dword Id, PLCI *plci, byte *msg, word length); +static void mixer_indication_xconnect_to(dword Id, PLCI *plci, byte *msg, word length); +static void mixer_remove(PLCI *plci); + + +static void ec_command(dword Id, PLCI *plci, byte Rc); +static byte ec_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg); +static void ec_indication(dword Id, PLCI *plci, byte *msg, word length); + + +static void rtp_connect_b3_req_command(dword Id, PLCI *plci, byte Rc); +static void rtp_connect_b3_res_command(dword Id, PLCI *plci, byte Rc); + + +static int diva_get_dma_descriptor(PLCI *plci, dword *dma_magic); +static void diva_free_dma_descriptor(PLCI *plci, int nr); + +/*------------------------------------------------------------------*/ +/* external function prototypes */ +/*------------------------------------------------------------------*/ + +extern byte MapController(byte); +extern byte UnMapController(byte); +#define MapId(Id)(((Id) & 0xffffff00L) | MapController((byte)(Id))) +#define UnMapId(Id)(((Id) & 0xffffff00L) | UnMapController((byte)(Id))) + +void sendf(APPL *, word, dword, word, byte *, ...); +void *TransmitBufferSet(APPL *appl, dword ref); +void *TransmitBufferGet(APPL *appl, void *p); +void TransmitBufferFree(APPL *appl, void *p); +void *ReceiveBufferGet(APPL *appl, int Num); + +int fax_head_line_time(char *buffer); + + +/*------------------------------------------------------------------*/ +/* Global data definitions */ +/*------------------------------------------------------------------*/ +extern byte max_adapter; +extern byte max_appl; +extern DIVA_CAPI_ADAPTER *adapter; +extern APPL *application; + + + + + + + +static byte remove_started = false; +static PLCI dummy_plci; + + +static struct _ftable { + word command; + byte *format; + byte (*function)(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *); +} ftable[] = { + {_DATA_B3_R, "dwww", data_b3_req}, + {_DATA_B3_I | RESPONSE, "w", data_b3_res}, + {_INFO_R, "ss", info_req}, + {_INFO_I | RESPONSE, "", info_res}, + {_CONNECT_R, "wsssssssss", connect_req}, + {_CONNECT_I | RESPONSE, "wsssss", connect_res}, + {_CONNECT_ACTIVE_I | RESPONSE, "", connect_a_res}, + {_DISCONNECT_R, "s", disconnect_req}, + {_DISCONNECT_I | RESPONSE, "", disconnect_res}, + {_LISTEN_R, "dddss", listen_req}, + {_ALERT_R, "s", alert_req}, + {_FACILITY_R, "ws", facility_req}, + {_FACILITY_I | RESPONSE, "ws", facility_res}, + {_CONNECT_B3_R, "s", connect_b3_req}, + {_CONNECT_B3_I | RESPONSE, "ws", connect_b3_res}, + {_CONNECT_B3_ACTIVE_I | RESPONSE, "", connect_b3_a_res}, + {_DISCONNECT_B3_R, "s", disconnect_b3_req}, + {_DISCONNECT_B3_I | RESPONSE, "", disconnect_b3_res}, + {_RESET_B3_R, "s", reset_b3_req}, + {_RESET_B3_I | RESPONSE, "", reset_b3_res}, + {_CONNECT_B3_T90_ACTIVE_I | RESPONSE, "ws", connect_b3_t90_a_res}, + {_CONNECT_B3_T90_ACTIVE_I | RESPONSE, "", connect_b3_t90_a_res}, + {_SELECT_B_REQ, "s", select_b_req}, + {_MANUFACTURER_R, "dws", manufacturer_req}, + {_MANUFACTURER_I | RESPONSE, "dws", manufacturer_res}, + {_MANUFACTURER_I | RESPONSE, "", manufacturer_res} +}; + +static byte *cip_bc[29][2] = { + { "", "" }, /* 0 */ + { "\x03\x80\x90\xa3", "\x03\x80\x90\xa2" }, /* 1 */ + { "\x02\x88\x90", "\x02\x88\x90" }, /* 2 */ + { "\x02\x89\x90", "\x02\x89\x90" }, /* 3 */ + { "\x03\x90\x90\xa3", "\x03\x90\x90\xa2" }, /* 4 */ + { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 5 */ + { "\x02\x98\x90", "\x02\x98\x90" }, /* 6 */ + { "\x04\x88\xc0\xc6\xe6", "\x04\x88\xc0\xc6\xe6" }, /* 7 */ + { "\x04\x88\x90\x21\x8f", "\x04\x88\x90\x21\x8f" }, /* 8 */ + { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 9 */ + { "", "" }, /* 10 */ + { "", "" }, /* 11 */ + { "", "" }, /* 12 */ + { "", "" }, /* 13 */ + { "", "" }, /* 14 */ + { "", "" }, /* 15 */ + + { "\x03\x80\x90\xa3", "\x03\x80\x90\xa2" }, /* 16 */ + { "\x03\x90\x90\xa3", "\x03\x90\x90\xa2" }, /* 17 */ + { "\x02\x88\x90", "\x02\x88\x90" }, /* 18 */ + { "\x02\x88\x90", "\x02\x88\x90" }, /* 19 */ + { "\x02\x88\x90", "\x02\x88\x90" }, /* 20 */ + { "\x02\x88\x90", "\x02\x88\x90" }, /* 21 */ + { "\x02\x88\x90", "\x02\x88\x90" }, /* 22 */ + { "\x02\x88\x90", "\x02\x88\x90" }, /* 23 */ + { "\x02\x88\x90", "\x02\x88\x90" }, /* 24 */ + { "\x02\x88\x90", "\x02\x88\x90" }, /* 25 */ + { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 26 */ + { "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 27 */ + { "\x02\x88\x90", "\x02\x88\x90" } /* 28 */ +}; + +static byte *cip_hlc[29] = { + "", /* 0 */ + "", /* 1 */ + "", /* 2 */ + "", /* 3 */ + "", /* 4 */ + "", /* 5 */ + "", /* 6 */ + "", /* 7 */ + "", /* 8 */ + "", /* 9 */ + "", /* 10 */ + "", /* 11 */ + "", /* 12 */ + "", /* 13 */ + "", /* 14 */ + "", /* 15 */ + + "\x02\x91\x81", /* 16 */ + "\x02\x91\x84", /* 17 */ + "\x02\x91\xa1", /* 18 */ + "\x02\x91\xa4", /* 19 */ + "\x02\x91\xa8", /* 20 */ + "\x02\x91\xb1", /* 21 */ + "\x02\x91\xb2", /* 22 */ + "\x02\x91\xb5", /* 23 */ + "\x02\x91\xb8", /* 24 */ + "\x02\x91\xc1", /* 25 */ + "\x02\x91\x81", /* 26 */ + "\x03\x91\xe0\x01", /* 27 */ + "\x03\x91\xe0\x02" /* 28 */ +}; + +/*------------------------------------------------------------------*/ + +#define V120_HEADER_LENGTH 1 +#define V120_HEADER_EXTEND_BIT 0x80 +#define V120_HEADER_BREAK_BIT 0x40 +#define V120_HEADER_C1_BIT 0x04 +#define V120_HEADER_C2_BIT 0x08 +#define V120_HEADER_FLUSH_COND (V120_HEADER_BREAK_BIT | V120_HEADER_C1_BIT | V120_HEADER_C2_BIT) + +static byte v120_default_header[] = +{ + + 0x83 /* Ext, BR , res, res, C2 , C1 , B , F */ + +}; + +static byte v120_break_header[] = +{ + + 0xc3 | V120_HEADER_BREAK_BIT /* Ext, BR , res, res, C2 , C1 , B , F */ + +}; + + +/*------------------------------------------------------------------*/ +/* API_PUT function */ +/*------------------------------------------------------------------*/ + +word api_put(APPL *appl, CAPI_MSG *msg) +{ + word i, j, k, l, n; + word ret; + byte c; + byte controller; + DIVA_CAPI_ADAPTER *a; + PLCI *plci; + NCCI *ncci_ptr; + word ncci; + CAPI_MSG *m; + API_PARSE msg_parms[MAX_MSG_PARMS + 1]; + + if (msg->header.length < sizeof(msg->header) || + msg->header.length > MAX_MSG_SIZE) { + dbug(1, dprintf("bad len")); + return _BAD_MSG; + } + + controller = (byte)((msg->header.controller & 0x7f) - 1); + + /* controller starts with 0 up to (max_adapter - 1) */ + if (controller >= max_adapter) + { + dbug(1, dprintf("invalid ctrl")); + return _BAD_MSG; + } + + a = &adapter[controller]; + plci = NULL; + if ((msg->header.plci != 0) && (msg->header.plci <= a->max_plci) && !a->adapter_disabled) + { + dbug(1, dprintf("plci=%x", msg->header.plci)); + plci = &a->plci[msg->header.plci - 1]; + ncci = GET_WORD(&msg->header.ncci); + if (plci->Id + && (plci->appl + || (plci->State == INC_CON_PENDING) + || (plci->State == INC_CON_ALERT) + || (msg->header.command == (_DISCONNECT_I | RESPONSE))) + && ((ncci == 0) + || (msg->header.command == (_DISCONNECT_B3_I | RESPONSE)) + || ((ncci < MAX_NCCI + 1) && (a->ncci_plci[ncci] == plci->Id)))) + { + i = plci->msg_in_read_pos; + j = plci->msg_in_write_pos; + if (j >= i) + { + if (j + msg->header.length + MSG_IN_OVERHEAD <= MSG_IN_QUEUE_SIZE) + i += MSG_IN_QUEUE_SIZE - j; + else + j = 0; + } + else + { + + n = (((CAPI_MSG *)(plci->msg_in_queue))->header.length + MSG_IN_OVERHEAD + 3) & 0xfffc; + + if (i > MSG_IN_QUEUE_SIZE - n) + i = MSG_IN_QUEUE_SIZE - n + 1; + i -= j; + } + + if (i <= ((msg->header.length + MSG_IN_OVERHEAD + 3) & 0xfffc)) + + { + dbug(0, dprintf("Q-FULL1(msg) - len=%d write=%d read=%d wrap=%d free=%d", + msg->header.length, plci->msg_in_write_pos, + plci->msg_in_read_pos, plci->msg_in_wrap_pos, i)); + + return _QUEUE_FULL; + } + c = false; + if ((((byte *) msg) < ((byte *)(plci->msg_in_queue))) + || (((byte *) msg) >= ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue))) + { + if (plci->msg_in_write_pos != plci->msg_in_read_pos) + c = true; + } + if (msg->header.command == _DATA_B3_R) + { + if (msg->header.length < 20) + { + dbug(1, dprintf("DATA_B3 REQ wrong length %d", msg->header.length)); + return _BAD_MSG; + } + ncci_ptr = &(a->ncci[ncci]); + n = ncci_ptr->data_pending; + l = ncci_ptr->data_ack_pending; + k = plci->msg_in_read_pos; + while (k != plci->msg_in_write_pos) + { + if (k == plci->msg_in_wrap_pos) + k = 0; + if ((((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.command == _DATA_B3_R) + && (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.ncci == ncci)) + { + n++; + if (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->info.data_b3_req.Flags & 0x0004) + l++; + } + + k += (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.length + + MSG_IN_OVERHEAD + 3) & 0xfffc; + + } + if ((n >= MAX_DATA_B3) || (l >= MAX_DATA_ACK)) + { + dbug(0, dprintf("Q-FULL2(data) - pending=%d/%d ack_pending=%d/%d", + ncci_ptr->data_pending, n, ncci_ptr->data_ack_pending, l)); + + return _QUEUE_FULL; + } + if (plci->req_in || plci->internal_command) + { + if ((((byte *) msg) >= ((byte *)(plci->msg_in_queue))) + && (((byte *) msg) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue))) + { + dbug(0, dprintf("Q-FULL3(requeue)")); + + return _QUEUE_FULL; + } + c = true; + } + } + else + { + if (plci->req_in || plci->internal_command) + c = true; + else + { + plci->command = msg->header.command; + plci->number = msg->header.number; + } + } + if (c) + { + dbug(1, dprintf("enqueue msg(0x%04x,0x%x,0x%x) - len=%d write=%d read=%d wrap=%d free=%d", + msg->header.command, plci->req_in, plci->internal_command, + msg->header.length, plci->msg_in_write_pos, + plci->msg_in_read_pos, plci->msg_in_wrap_pos, i)); + if (j == 0) + plci->msg_in_wrap_pos = plci->msg_in_write_pos; + m = (CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]); + for (i = 0; i < msg->header.length; i++) + ((byte *)(plci->msg_in_queue))[j++] = ((byte *) msg)[i]; + if (m->header.command == _DATA_B3_R) + { + + m->info.data_b3_req.Data = (dword)(long)(TransmitBufferSet(appl, m->info.data_b3_req.Data)); + + } + + j = (j + 3) & 0xfffc; + + *((APPL **)(&((byte *)(plci->msg_in_queue))[j])) = appl; + plci->msg_in_write_pos = j + MSG_IN_OVERHEAD; + return 0; + } + } + else + { + plci = NULL; + } + } + dbug(1, dprintf("com=%x", msg->header.command)); + + for (j = 0; j < MAX_MSG_PARMS + 1; j++) msg_parms[j].length = 0; + for (i = 0, ret = _BAD_MSG; i < ARRAY_SIZE(ftable); i++) { + + if (ftable[i].command == msg->header.command) { + /* break loop if the message is correct, otherwise continue scan */ + /* (for example: CONNECT_B3_T90_ACT_RES has two specifications) */ + if (!api_parse(msg->info.b, (word)(msg->header.length - 12), ftable[i].format, msg_parms)) { + ret = 0; + break; + } + for (j = 0; j < MAX_MSG_PARMS + 1; j++) msg_parms[j].length = 0; + } + } + if (ret) { + dbug(1, dprintf("BAD_MSG")); + if (plci) plci->command = 0; + return ret; + } + + + c = ftable[i].function(GET_DWORD(&msg->header.controller), + msg->header.number, + a, + plci, + appl, + msg_parms); + + channel_xmit_extended_xon(plci); + + if (c == 1) send_req(plci); + if (c == 2 && plci) plci->req_in = plci->req_in_start = plci->req_out = 0; + if (plci && !plci->req_in) plci->command = 0; + return 0; +} + + +/*------------------------------------------------------------------*/ +/* api_parse function, check the format of api messages */ +/*------------------------------------------------------------------*/ + +static word api_parse(byte *msg, word length, byte *format, API_PARSE *parms) +{ + word i; + word p; + + for (i = 0, p = 0; format[i]; i++) { + if (parms) + { + parms[i].info = &msg[p]; + } + switch (format[i]) { + case 'b': + p += 1; + break; + case 'w': + p += 2; + break; + case 'd': + p += 4; + break; + case 's': + if (msg[p] == 0xff) { + parms[i].info += 2; + parms[i].length = msg[p + 1] + (msg[p + 2] << 8); + p += (parms[i].length + 3); + } + else { + parms[i].length = msg[p]; + p += (parms[i].length + 1); + } + break; + } + + if (p > length) return true; + } + if (parms) parms[i].info = NULL; + return false; +} + +static void api_save_msg(API_PARSE *in, byte *format, API_SAVE *out) +{ + word i, j, n = 0; + byte *p; + + p = out->info; + for (i = 0; format[i] != '\0'; i++) + { + out->parms[i].info = p; + out->parms[i].length = in[i].length; + switch (format[i]) + { + case 'b': + n = 1; + break; + case 'w': + n = 2; + break; + case 'd': + n = 4; + break; + case 's': + n = in[i].length + 1; + break; + } + for (j = 0; j < n; j++) + *(p++) = in[i].info[j]; + } + out->parms[i].info = NULL; + out->parms[i].length = 0; +} + +static void api_load_msg(API_SAVE *in, API_PARSE *out) +{ + word i; + + i = 0; + do + { + out[i].info = in->parms[i].info; + out[i].length = in->parms[i].length; + } while (in->parms[i++].info); +} + + +/*------------------------------------------------------------------*/ +/* CAPI remove function */ +/*------------------------------------------------------------------*/ + +word api_remove_start(void) +{ + word i; + word j; + + if (!remove_started) { + remove_started = true; + for (i = 0; i < max_adapter; i++) { + if (adapter[i].request) { + for (j = 0; j < adapter[i].max_plci; j++) { + if (adapter[i].plci[j].Sig.Id) plci_remove(&adapter[i].plci[j]); + } + } + } + return 1; + } + else { + for (i = 0; i < max_adapter; i++) { + if (adapter[i].request) { + for (j = 0; j < adapter[i].max_plci; j++) { + if (adapter[i].plci[j].Sig.Id) return 1; + } + } + } + } + api_remove_complete(); + return 0; +} + + +/*------------------------------------------------------------------*/ +/* internal command queue */ +/*------------------------------------------------------------------*/ + +static void init_internal_command_queue(PLCI *plci) +{ + word i; + + dbug(1, dprintf("%s,%d: init_internal_command_queue", + (char *)(FILE_), __LINE__)); + + plci->internal_command = 0; + for (i = 0; i < MAX_INTERNAL_COMMAND_LEVELS; i++) + plci->internal_command_queue[i] = NULL; +} + + +static void start_internal_command(dword Id, PLCI *plci, t_std_internal_command command_function) +{ + word i; + + dbug(1, dprintf("[%06lx] %s,%d: start_internal_command", + UnMapId(Id), (char *)(FILE_), __LINE__)); + + if (plci->internal_command == 0) + { + plci->internal_command_queue[0] = command_function; + (*command_function)(Id, plci, OK); + } + else + { + i = 1; + while (plci->internal_command_queue[i] != NULL) + i++; + plci->internal_command_queue[i] = command_function; + } +} + + +static void next_internal_command(dword Id, PLCI *plci) +{ + word i; + + dbug(1, dprintf("[%06lx] %s,%d: next_internal_command", + UnMapId(Id), (char *)(FILE_), __LINE__)); + + plci->internal_command = 0; + plci->internal_command_queue[0] = NULL; + while (plci->internal_command_queue[1] != NULL) + { + for (i = 0; i < MAX_INTERNAL_COMMAND_LEVELS - 1; i++) + plci->internal_command_queue[i] = plci->internal_command_queue[i + 1]; + plci->internal_command_queue[MAX_INTERNAL_COMMAND_LEVELS - 1] = NULL; + (*(plci->internal_command_queue[0]))(Id, plci, OK); + if (plci->internal_command != 0) + return; + plci->internal_command_queue[0] = NULL; + } +} + + +/*------------------------------------------------------------------*/ +/* NCCI allocate/remove function */ +/*------------------------------------------------------------------*/ + +static dword ncci_mapping_bug = 0; + +static word get_ncci(PLCI *plci, byte ch, word force_ncci) +{ + DIVA_CAPI_ADAPTER *a; + word ncci, i, j, k; + + a = plci->adapter; + if (!ch || a->ch_ncci[ch]) + { + ncci_mapping_bug++; + dbug(1, dprintf("NCCI mapping exists %ld %02x %02x %02x-%02x", + ncci_mapping_bug, ch, force_ncci, a->ncci_ch[a->ch_ncci[ch]], a->ch_ncci[ch])); + ncci = ch; + } + else + { + if (force_ncci) + ncci = force_ncci; + else + { + if ((ch < MAX_NCCI + 1) && !a->ncci_ch[ch]) + ncci = ch; + else + { + ncci = 1; + while ((ncci < MAX_NCCI + 1) && a->ncci_ch[ncci]) + ncci++; + if (ncci == MAX_NCCI + 1) + { + ncci_mapping_bug++; + i = 1; + do + { + j = 1; + while ((j < MAX_NCCI + 1) && (a->ncci_ch[j] != i)) + j++; + k = j; + if (j < MAX_NCCI + 1) + { + do + { + j++; + } while ((j < MAX_NCCI + 1) && (a->ncci_ch[j] != i)); + } + } while ((i < MAX_NL_CHANNEL + 1) && (j < MAX_NCCI + 1)); + if (i < MAX_NL_CHANNEL + 1) + { + dbug(1, dprintf("NCCI mapping overflow %ld %02x %02x %02x-%02x-%02x", + ncci_mapping_bug, ch, force_ncci, i, k, j)); + } + else + { + dbug(1, dprintf("NCCI mapping overflow %ld %02x %02x", + ncci_mapping_bug, ch, force_ncci)); + } + ncci = ch; + } + } + a->ncci_plci[ncci] = plci->Id; + a->ncci_state[ncci] = IDLE; + if (!plci->ncci_ring_list) + plci->ncci_ring_list = ncci; + else + a->ncci_next[ncci] = a->ncci_next[plci->ncci_ring_list]; + a->ncci_next[plci->ncci_ring_list] = (byte) ncci; + } + a->ncci_ch[ncci] = ch; + a->ch_ncci[ch] = (byte) ncci; + dbug(1, dprintf("NCCI mapping established %ld %02x %02x %02x-%02x", + ncci_mapping_bug, ch, force_ncci, ch, ncci)); + } + return (ncci); +} + + +static void ncci_free_receive_buffers(PLCI *plci, word ncci) +{ + DIVA_CAPI_ADAPTER *a; + APPL *appl; + word i, ncci_code; + dword Id; + + a = plci->adapter; + Id = (((dword) ncci) << 16) | (((word)(plci->Id)) << 8) | a->Id; + if (ncci) + { + if (a->ncci_plci[ncci] == plci->Id) + { + if (!plci->appl) + { + ncci_mapping_bug++; + dbug(1, dprintf("NCCI mapping appl expected %ld %08lx", + ncci_mapping_bug, Id)); + } + else + { + appl = plci->appl; + ncci_code = ncci | (((word) a->Id) << 8); + for (i = 0; i < appl->MaxBuffer; i++) + { + if ((appl->DataNCCI[i] == ncci_code) + && (((byte)(appl->DataFlags[i] >> 8)) == plci->Id)) + { + appl->DataNCCI[i] = 0; + } + } + } + } + } + else + { + for (ncci = 1; ncci < MAX_NCCI + 1; ncci++) + { + if (a->ncci_plci[ncci] == plci->Id) + { + if (!plci->appl) + { + ncci_mapping_bug++; + dbug(1, dprintf("NCCI mapping no appl %ld %08lx", + ncci_mapping_bug, Id)); + } + else + { + appl = plci->appl; + ncci_code = ncci | (((word) a->Id) << 8); + for (i = 0; i < appl->MaxBuffer; i++) + { + if ((appl->DataNCCI[i] == ncci_code) + && (((byte)(appl->DataFlags[i] >> 8)) == plci->Id)) + { + appl->DataNCCI[i] = 0; + } + } + } + } + } + } +} + + +static void cleanup_ncci_data(PLCI *plci, word ncci) +{ + NCCI *ncci_ptr; + + if (ncci && (plci->adapter->ncci_plci[ncci] == plci->Id)) + { + ncci_ptr = &(plci->adapter->ncci[ncci]); + if (plci->appl) + { + while (ncci_ptr->data_pending != 0) + { + if (!plci->data_sent || (ncci_ptr->DBuffer[ncci_ptr->data_out].P != plci->data_sent_ptr)) + TransmitBufferFree(plci->appl, ncci_ptr->DBuffer[ncci_ptr->data_out].P); + (ncci_ptr->data_out)++; + if (ncci_ptr->data_out == MAX_DATA_B3) + ncci_ptr->data_out = 0; + (ncci_ptr->data_pending)--; + } + } + ncci_ptr->data_out = 0; + ncci_ptr->data_pending = 0; + ncci_ptr->data_ack_out = 0; + ncci_ptr->data_ack_pending = 0; + } +} + + +static void ncci_remove(PLCI *plci, word ncci, byte preserve_ncci) +{ + DIVA_CAPI_ADAPTER *a; + dword Id; + word i; + + a = plci->adapter; + Id = (((dword) ncci) << 16) | (((word)(plci->Id)) << 8) | a->Id; + if (!preserve_ncci) + ncci_free_receive_buffers(plci, ncci); + if (ncci) + { + if (a->ncci_plci[ncci] != plci->Id) + { + ncci_mapping_bug++; + dbug(1, dprintf("NCCI mapping doesn't exist %ld %08lx %02x", + ncci_mapping_bug, Id, preserve_ncci)); + } + else + { + cleanup_ncci_data(plci, ncci); + dbug(1, dprintf("NCCI mapping released %ld %08lx %02x %02x-%02x", + ncci_mapping_bug, Id, preserve_ncci, a->ncci_ch[ncci], ncci)); + a->ch_ncci[a->ncci_ch[ncci]] = 0; + if (!preserve_ncci) + { + a->ncci_ch[ncci] = 0; + a->ncci_plci[ncci] = 0; + a->ncci_state[ncci] = IDLE; + i = plci->ncci_ring_list; + while ((i != 0) && (a->ncci_next[i] != plci->ncci_ring_list) && (a->ncci_next[i] != ncci)) + i = a->ncci_next[i]; + if ((i != 0) && (a->ncci_next[i] == ncci)) + { + if (i == ncci) + plci->ncci_ring_list = 0; + else if (plci->ncci_ring_list == ncci) + plci->ncci_ring_list = i; + a->ncci_next[i] = a->ncci_next[ncci]; + } + a->ncci_next[ncci] = 0; + } + } + } + else + { + for (ncci = 1; ncci < MAX_NCCI + 1; ncci++) + { + if (a->ncci_plci[ncci] == plci->Id) + { + cleanup_ncci_data(plci, ncci); + dbug(1, dprintf("NCCI mapping released %ld %08lx %02x %02x-%02x", + ncci_mapping_bug, Id, preserve_ncci, a->ncci_ch[ncci], ncci)); + a->ch_ncci[a->ncci_ch[ncci]] = 0; + if (!preserve_ncci) + { + a->ncci_ch[ncci] = 0; + a->ncci_plci[ncci] = 0; + a->ncci_state[ncci] = IDLE; + a->ncci_next[ncci] = 0; + } + } + } + if (!preserve_ncci) + plci->ncci_ring_list = 0; + } +} + + +/*------------------------------------------------------------------*/ +/* PLCI remove function */ +/*------------------------------------------------------------------*/ + +static void plci_free_msg_in_queue(PLCI *plci) +{ + word i; + + if (plci->appl) + { + i = plci->msg_in_read_pos; + while (i != plci->msg_in_write_pos) + { + if (i == plci->msg_in_wrap_pos) + i = 0; + if (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->header.command == _DATA_B3_R) + { + + TransmitBufferFree(plci->appl, + (byte *)(long)(((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->info.data_b3_req.Data)); + + } + + i += (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->header.length + + MSG_IN_OVERHEAD + 3) & 0xfffc; + + } + } + plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE; + plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE; + plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE; +} + + +static void plci_remove(PLCI *plci) +{ + + if (!plci) { + dbug(1, dprintf("plci_remove(no plci)")); + return; + } + init_internal_command_queue(plci); + dbug(1, dprintf("plci_remove(%x,tel=%x)", plci->Id, plci->tel)); + if (plci_remove_check(plci)) + { + return; + } + if (plci->Sig.Id == 0xff) + { + dbug(1, dprintf("D-channel X.25 plci->NL.Id:%0x", plci->NL.Id)); + if (plci->NL.Id && !plci->nl_remove_id) + { + nl_req_ncci(plci, REMOVE, 0); + send_req(plci); + } + } + else + { + if (!plci->sig_remove_id + && (plci->Sig.Id + || (plci->req_in != plci->req_out) + || (plci->nl_req || plci->sig_req))) + { + sig_req(plci, HANGUP, 0); + send_req(plci); + } + } + ncci_remove(plci, 0, false); + plci_free_msg_in_queue(plci); + + plci->channels = 0; + plci->appl = NULL; + if ((plci->State == INC_CON_PENDING) || (plci->State == INC_CON_ALERT)) + plci->State = OUTG_DIS_PENDING; +} + +/*------------------------------------------------------------------*/ +/* Application Group function helpers */ +/*------------------------------------------------------------------*/ + +static void set_group_ind_mask(PLCI *plci) +{ + word i; + + for (i = 0; i < C_IND_MASK_DWORDS; i++) + plci->group_optimization_mask_table[i] = 0xffffffffL; +} + +static void clear_group_ind_mask_bit(PLCI *plci, word b) +{ + plci->group_optimization_mask_table[b >> 5] &= ~(1L << (b & 0x1f)); +} + +static byte test_group_ind_mask_bit(PLCI *plci, word b) +{ + return ((plci->group_optimization_mask_table[b >> 5] & (1L << (b & 0x1f))) != 0); +} + +/*------------------------------------------------------------------*/ +/* c_ind_mask operations for arbitrary MAX_APPL */ +/*------------------------------------------------------------------*/ + +static void clear_c_ind_mask(PLCI *plci) +{ + word i; + + for (i = 0; i < C_IND_MASK_DWORDS; i++) + plci->c_ind_mask_table[i] = 0; +} + +static byte c_ind_mask_empty(PLCI *plci) +{ + word i; + + i = 0; + while ((i < C_IND_MASK_DWORDS) && (plci->c_ind_mask_table[i] == 0)) + i++; + return (i == C_IND_MASK_DWORDS); +} + +static void set_c_ind_mask_bit(PLCI *plci, word b) +{ + plci->c_ind_mask_table[b >> 5] |= (1L << (b & 0x1f)); +} + +static void clear_c_ind_mask_bit(PLCI *plci, word b) +{ + plci->c_ind_mask_table[b >> 5] &= ~(1L << (b & 0x1f)); +} + +static byte test_c_ind_mask_bit(PLCI *plci, word b) +{ + return ((plci->c_ind_mask_table[b >> 5] & (1L << (b & 0x1f))) != 0); +} + +static void dump_c_ind_mask(PLCI *plci) +{ + static char hex_digit_table[0x10] = + {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; + word i, j, k; + dword d; + char *p; + char buf[40]; + + for (i = 0; i < C_IND_MASK_DWORDS; i += 4) + { + p = buf + 36; + *p = '\0'; + for (j = 0; j < 4; j++) + { + if (i + j < C_IND_MASK_DWORDS) + { + d = plci->c_ind_mask_table[i + j]; + for (k = 0; k < 8; k++) + { + *(--p) = hex_digit_table[d & 0xf]; + d >>= 4; + } + } + else if (i != 0) + { + for (k = 0; k < 8; k++) + *(--p) = ' '; + } + *(--p) = ' '; + } + dbug(1, dprintf("c_ind_mask =%s", (char *) p)); + } +} + + + + + +#define dump_plcis(a) + + + +/*------------------------------------------------------------------*/ +/* translation function for each message */ +/*------------------------------------------------------------------*/ + +static byte connect_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *parms) +{ + word ch; + word i; + word Info; + byte LinkLayer; + API_PARSE *ai; + API_PARSE *bp; + API_PARSE ai_parms[5]; + word channel = 0; + dword ch_mask; + byte m; + static byte esc_chi[35] = {0x02, 0x18, 0x01}; + static byte lli[2] = {0x01, 0x00}; + byte noCh = 0; + word dir = 0; + byte *p_chi = ""; + + for (i = 0; i < 5; i++) ai_parms[i].length = 0; + + dbug(1, dprintf("connect_req(%d)", parms->length)); + Info = _WRONG_IDENTIFIER; + if (a) + { + if (a->adapter_disabled) + { + dbug(1, dprintf("adapter disabled")); + Id = ((word)1 << 8) | a->Id; + sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0); + sendf(appl, _DISCONNECT_I, Id, 0, "w", _L1_ERROR); + return false; + } + Info = _OUT_OF_PLCI; + if ((i = get_plci(a))) + { + Info = 0; + plci = &a->plci[i - 1]; + plci->appl = appl; + plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE; + /* check 'external controller' bit for codec support */ + if (Id & EXT_CONTROLLER) + { + if (AdvCodecSupport(a, plci, appl, 0)) + { + plci->Id = 0; + sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", _WRONG_IDENTIFIER); + return 2; + } + } + ai = &parms[9]; + bp = &parms[5]; + ch = 0; + if (bp->length)LinkLayer = bp->info[3]; + else LinkLayer = 0; + if (ai->length) + { + ch = 0xffff; + if (!api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms)) + { + ch = 0; + if (ai_parms[0].length) + { + ch = GET_WORD(ai_parms[0].info + 1); + if (ch > 4) ch = 0; /* safety -> ignore ChannelID */ + if (ch == 4) /* explizit CHI in message */ + { + /* check length of B-CH struct */ + if ((ai_parms[0].info)[3] >= 1) + { + if ((ai_parms[0].info)[4] == CHI) + { + p_chi = &((ai_parms[0].info)[5]); + } + else + { + p_chi = &((ai_parms[0].info)[3]); + } + if (p_chi[0] > 35) /* check length of channel ID */ + { + Info = _WRONG_MESSAGE_FORMAT; + } + } + else Info = _WRONG_MESSAGE_FORMAT; + } + + if (ch == 3 && ai_parms[0].length >= 7 && ai_parms[0].length <= 36) + { + dir = GET_WORD(ai_parms[0].info + 3); + ch_mask = 0; + m = 0x3f; + for (i = 0; i + 5 <= ai_parms[0].length; i++) + { + if (ai_parms[0].info[i + 5] != 0) + { + if ((ai_parms[0].info[i + 5] | m) != 0xff) + Info = _WRONG_MESSAGE_FORMAT; + else + { + if (ch_mask == 0) + channel = i; + ch_mask |= 1L << i; + } + } + m = 0; + } + if (ch_mask == 0) + Info = _WRONG_MESSAGE_FORMAT; + if (!Info) + { + if ((ai_parms[0].length == 36) || (ch_mask != ((dword)(1L << channel)))) + { + esc_chi[0] = (byte)(ai_parms[0].length - 2); + for (i = 0; i + 5 <= ai_parms[0].length; i++) + esc_chi[i + 3] = ai_parms[0].info[i + 5]; + } + else + esc_chi[0] = 2; + esc_chi[2] = (byte)channel; + plci->b_channel = (byte)channel; /* not correct for ETSI ch 17..31 */ + add_p(plci, LLI, lli); + add_p(plci, ESC, esc_chi); + plci->State = LOCAL_CONNECT; + if (!dir) plci->call_dir |= CALL_DIR_FORCE_OUTG_NL; /* dir 0=DTE, 1=DCE */ + } + } + } + } + else Info = _WRONG_MESSAGE_FORMAT; + } + + dbug(1, dprintf("ch=%x,dir=%x,p_ch=%d", ch, dir, channel)); + plci->command = _CONNECT_R; + plci->number = Number; + /* x.31 or D-ch free SAPI in LinkLayer? */ + if (ch == 1 && LinkLayer != 3 && LinkLayer != 12) noCh = true; + if ((ch == 0 || ch == 2 || noCh || ch == 3 || ch == 4) && !Info) + { + /* B-channel used for B3 connections (ch==0), or no B channel */ + /* is used (ch==2) or perm. connection (3) is used do a CALL */ + if (noCh) Info = add_b1(plci, &parms[5], 2, 0); /* no resource */ + else Info = add_b1(plci, &parms[5], ch, 0); + add_s(plci, OAD, &parms[2]); + add_s(plci, OSA, &parms[4]); + add_s(plci, BC, &parms[6]); + add_s(plci, LLC, &parms[7]); + add_s(plci, HLC, &parms[8]); + if (a->Info_Mask[appl->Id - 1] & 0x200) + { + /* early B3 connect (CIP mask bit 9) no release after a disc */ + add_p(plci, LLI, "\x01\x01"); + } + if (GET_WORD(parms[0].info) < 29) { + add_p(plci, BC, cip_bc[GET_WORD(parms[0].info)][a->u_law]); + add_p(plci, HLC, cip_hlc[GET_WORD(parms[0].info)]); + } + add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + sig_req(plci, ASSIGN, DSIG_ID); + } + else if (ch == 1) { + + /* D-Channel used for B3 connections */ + plci->Sig.Id = 0xff; + Info = 0; + } + + if (!Info && ch != 2 && !noCh) { + Info = add_b23(plci, &parms[5]); + if (!Info) { + if (!(plci->tel && !plci->adv_nl))nl_req_ncci(plci, ASSIGN, 0); + } + } + + if (!Info) + { + if (ch == 0 || ch == 2 || ch == 3 || noCh || ch == 4) + { + if (plci->spoofed_msg == SPOOFING_REQUIRED) + { + api_save_msg(parms, "wsssssssss", &plci->saved_msg); + plci->spoofed_msg = CALL_REQ; + plci->internal_command = BLOCK_PLCI; + plci->command = 0; + dbug(1, dprintf("Spoof")); + send_req(plci); + return false; + } + if (ch == 4)add_p(plci, CHI, p_chi); + add_s(plci, CPN, &parms[1]); + add_s(plci, DSA, &parms[3]); + if (noCh) add_p(plci, ESC, "\x02\x18\xfd"); /* D-channel, no B-L3 */ + add_ai(plci, &parms[9]); + if (!dir)sig_req(plci, CALL_REQ, 0); + else + { + plci->command = PERM_LIST_REQ; + plci->appl = appl; + sig_req(plci, LISTEN_REQ, 0); + send_req(plci); + return false; + } + } + send_req(plci); + return false; + } + plci->Id = 0; + } + } + sendf(appl, + _CONNECT_R | CONFIRM, + Id, + Number, + "w", Info); + return 2; +} + +static byte connect_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *parms) +{ + word i, Info; + word Reject; + static byte cau_t[] = {0, 0, 0x90, 0x91, 0xac, 0x9d, 0x86, 0xd8, 0x9b}; + static byte esc_t[] = {0x03, 0x08, 0x00, 0x00}; + API_PARSE *ai; + API_PARSE ai_parms[5]; + word ch = 0; + + if (!plci) { + dbug(1, dprintf("connect_res(no plci)")); + return 0; /* no plci, no send */ + } + + dbug(1, dprintf("connect_res(State=0x%x)", plci->State)); + for (i = 0; i < 5; i++) ai_parms[i].length = 0; + ai = &parms[5]; + dbug(1, dprintf("ai->length=%d", ai->length)); + + if (ai->length) + { + if (!api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms)) + { + dbug(1, dprintf("ai_parms[0].length=%d/0x%x", ai_parms[0].length, GET_WORD(ai_parms[0].info + 1))); + ch = 0; + if (ai_parms[0].length) + { + ch = GET_WORD(ai_parms[0].info + 1); + dbug(1, dprintf("BCH-I=0x%x", ch)); + } + } + } + + if (plci->State == INC_CON_CONNECTED_ALERT) + { + dbug(1, dprintf("Connected Alert Call_Res")); + if (a->Info_Mask[appl->Id - 1] & 0x200) + { + /* early B3 connect (CIP mask bit 9) no release after a disc */ + add_p(plci, LLI, "\x01\x01"); + } + add_s(plci, CONN_NR, &parms[2]); + add_s(plci, LLC, &parms[4]); + add_ai(plci, &parms[5]); + plci->State = INC_CON_ACCEPT; + sig_req(plci, CALL_RES, 0); + return 1; + } + else if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT) { + clear_c_ind_mask_bit(plci, (word)(appl->Id - 1)); + dump_c_ind_mask(plci); + Reject = GET_WORD(parms[0].info); + dbug(1, dprintf("Reject=0x%x", Reject)); + if (Reject) + { + if (c_ind_mask_empty(plci)) + { + if ((Reject & 0xff00) == 0x3400) + { + esc_t[2] = ((byte)(Reject & 0x00ff)) | 0x80; + add_p(plci, ESC, esc_t); + add_ai(plci, &parms[5]); + sig_req(plci, REJECT, 0); + } + else if (Reject == 1 || Reject >= 9) + { + add_ai(plci, &parms[5]); + sig_req(plci, HANGUP, 0); + } + else + { + esc_t[2] = cau_t[(Reject&0x000f)]; + add_p(plci, ESC, esc_t); + add_ai(plci, &parms[5]); + sig_req(plci, REJECT, 0); + } + plci->appl = appl; + } + else + { + sendf(appl, _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED); + } + } + else { + plci->appl = appl; + if (Id & EXT_CONTROLLER) { + if (AdvCodecSupport(a, plci, appl, 0)) { + dbug(1, dprintf("connect_res(error from AdvCodecSupport)")); + sig_req(plci, HANGUP, 0); + return 1; + } + if (plci->tel == ADV_VOICE && a->AdvCodecPLCI) + { + Info = add_b23(plci, &parms[1]); + if (Info) + { + dbug(1, dprintf("connect_res(error from add_b23)")); + sig_req(plci, HANGUP, 0); + return 1; + } + if (plci->adv_nl) + { + nl_req_ncci(plci, ASSIGN, 0); + } + } + } + else + { + plci->tel = 0; + if (ch != 2) + { + Info = add_b23(plci, &parms[1]); + if (Info) + { + dbug(1, dprintf("connect_res(error from add_b23 2)")); + sig_req(plci, HANGUP, 0); + return 1; + } + } + nl_req_ncci(plci, ASSIGN, 0); + } + + if (plci->spoofed_msg == SPOOFING_REQUIRED) + { + api_save_msg(parms, "wsssss", &plci->saved_msg); + plci->spoofed_msg = CALL_RES; + plci->internal_command = BLOCK_PLCI; + plci->command = 0; + dbug(1, dprintf("Spoof")); + } + else + { + add_b1(plci, &parms[1], ch, plci->B1_facilities); + if (a->Info_Mask[appl->Id - 1] & 0x200) + { + /* early B3 connect (CIP mask bit 9) no release after a disc */ + add_p(plci, LLI, "\x01\x01"); + } + add_s(plci, CONN_NR, &parms[2]); + add_s(plci, LLC, &parms[4]); + add_ai(plci, &parms[5]); + plci->State = INC_CON_ACCEPT; + sig_req(plci, CALL_RES, 0); + } + + for (i = 0; i < max_appl; i++) { + if (test_c_ind_mask_bit(plci, i)) { + sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED); + } + } + } + } + return 1; +} + +static byte connect_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *msg) +{ + dbug(1, dprintf("connect_a_res")); + return false; +} + +static byte disconnect_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *msg) +{ + word Info; + word i; + + dbug(1, dprintf("disconnect_req")); + + Info = _WRONG_IDENTIFIER; + + if (plci) + { + if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT) + { + clear_c_ind_mask_bit(plci, (word)(appl->Id - 1)); + plci->appl = appl; + for (i = 0; i < max_appl; i++) + { + if (test_c_ind_mask_bit(plci, i)) + sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0); + } + plci->State = OUTG_DIS_PENDING; + } + if (plci->Sig.Id && plci->appl) + { + Info = 0; + if (plci->Sig.Id != 0xff) + { + if (plci->State != INC_DIS_PENDING) + { + add_ai(plci, &msg[0]); + sig_req(plci, HANGUP, 0); + plci->State = OUTG_DIS_PENDING; + return 1; + } + } + else + { + if (plci->NL.Id && !plci->nl_remove_id) + { + mixer_remove(plci); + nl_req_ncci(plci, REMOVE, 0); + sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", 0); + sendf(appl, _DISCONNECT_I, Id, 0, "w", 0); + plci->State = INC_DIS_PENDING; + } + return 1; + } + } + } + + if (!appl) return false; + sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", Info); + return false; +} + +static byte disconnect_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *msg) +{ + dbug(1, dprintf("disconnect_res")); + if (plci) + { + /* clear ind mask bit, just in case of collsion of */ + /* DISCONNECT_IND and CONNECT_RES */ + clear_c_ind_mask_bit(plci, (word)(appl->Id - 1)); + ncci_free_receive_buffers(plci, 0); + if (plci_remove_check(plci)) + { + return 0; + } + if (plci->State == INC_DIS_PENDING + || plci->State == SUSPENDING) { + if (c_ind_mask_empty(plci)) { + if (plci->State != SUSPENDING) plci->State = IDLE; + dbug(1, dprintf("chs=%d", plci->channels)); + if (!plci->channels) { + plci_remove(plci); + } + } + } + } + return 0; +} + +static byte listen_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *parms) +{ + word Info; + byte i; + + dbug(1, dprintf("listen_req(Appl=0x%x)", appl->Id)); + + Info = _WRONG_IDENTIFIER; + if (a) { + Info = 0; + a->Info_Mask[appl->Id - 1] = GET_DWORD(parms[0].info); + a->CIP_Mask[appl->Id - 1] = GET_DWORD(parms[1].info); + dbug(1, dprintf("CIP_MASK=0x%lx", GET_DWORD(parms[1].info))); + if (a->Info_Mask[appl->Id - 1] & 0x200) { /* early B3 connect provides */ + a->Info_Mask[appl->Id - 1] |= 0x10; /* call progression infos */ + } + + /* check if external controller listen and switch listen on or off*/ + if (Id&EXT_CONTROLLER && GET_DWORD(parms[1].info)) { + if (a->profile.Global_Options & ON_BOARD_CODEC) { + dummy_plci.State = IDLE; + a->codec_listen[appl->Id - 1] = &dummy_plci; + a->TelOAD[0] = (byte)(parms[3].length); + for (i = 1; parms[3].length >= i && i < 22; i++) { + a->TelOAD[i] = parms[3].info[i]; + } + a->TelOAD[i] = 0; + a->TelOSA[0] = (byte)(parms[4].length); + for (i = 1; parms[4].length >= i && i < 22; i++) { + a->TelOSA[i] = parms[4].info[i]; + } + a->TelOSA[i] = 0; + } + else Info = 0x2002; /* wrong controller, codec not supported */ + } + else{ /* clear listen */ + a->codec_listen[appl->Id - 1] = (PLCI *)0; + } + } + sendf(appl, + _LISTEN_R | CONFIRM, + Id, + Number, + "w", Info); + + if (a) listen_check(a); + return false; +} + +static byte info_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *msg) +{ + word i; + API_PARSE *ai; + PLCI *rc_plci = NULL; + API_PARSE ai_parms[5]; + word Info = 0; + + dbug(1, dprintf("info_req")); + for (i = 0; i < 5; i++) ai_parms[i].length = 0; + + ai = &msg[1]; + + if (ai->length) + { + if (api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms)) + { + dbug(1, dprintf("AddInfo wrong")); + Info = _WRONG_MESSAGE_FORMAT; + } + } + if (!a) Info = _WRONG_STATE; + + if (!Info && plci) + { /* no fac, with CPN, or KEY */ + rc_plci = plci; + if (!ai_parms[3].length && plci->State && (msg[0].length || ai_parms[1].length)) + { + /* overlap sending option */ + dbug(1, dprintf("OvlSnd")); + add_s(plci, CPN, &msg[0]); + add_s(plci, KEY, &ai_parms[1]); + sig_req(plci, INFO_REQ, 0); + send_req(plci); + return false; + } + + if (plci->State && ai_parms[2].length) + { + /* User_Info option */ + dbug(1, dprintf("UUI")); + add_s(plci, UUI, &ai_parms[2]); + sig_req(plci, USER_DATA, 0); + } + else if (plci->State && ai_parms[3].length) + { + /* Facility option */ + dbug(1, dprintf("FAC")); + add_s(plci, CPN, &msg[0]); + add_ai(plci, &msg[1]); + sig_req(plci, FACILITY_REQ, 0); + } + else + { + Info = _WRONG_STATE; + } + } + else if ((ai_parms[1].length || ai_parms[2].length || ai_parms[3].length) && !Info) + { + /* NCR_Facility option -> send UUI and Keypad too */ + dbug(1, dprintf("NCR_FAC")); + if ((i = get_plci(a))) + { + rc_plci = &a->plci[i - 1]; + appl->NullCREnable = true; + rc_plci->internal_command = C_NCR_FAC_REQ; + rc_plci->appl = appl; + add_p(rc_plci, CAI, "\x01\x80"); + add_p(rc_plci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + sig_req(rc_plci, ASSIGN, DSIG_ID); + send_req(rc_plci); + } + else + { + Info = _OUT_OF_PLCI; + } + + if (!Info) + { + add_s(rc_plci, CPN, &msg[0]); + add_ai(rc_plci, &msg[1]); + sig_req(rc_plci, NCR_FACILITY, 0); + send_req(rc_plci); + return false; + /* for application controlled supplementary services */ + } + } + + if (!rc_plci) + { + Info = _WRONG_MESSAGE_FORMAT; + } + + if (!Info) + { + send_req(rc_plci); + } + else + { /* appl is not assigned to a PLCI or error condition */ + dbug(1, dprintf("localInfoCon")); + sendf(appl, + _INFO_R | CONFIRM, + Id, + Number, + "w", Info); + } + return false; +} + +static byte info_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *msg) +{ + dbug(1, dprintf("info_res")); + return false; +} + +static byte alert_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *msg) +{ + word Info; + byte ret; + + dbug(1, dprintf("alert_req")); + + Info = _WRONG_IDENTIFIER; + ret = false; + if (plci) { + Info = _ALERT_IGNORED; + if (plci->State != INC_CON_ALERT) { + Info = _WRONG_STATE; + if (plci->State == INC_CON_PENDING) { + Info = 0; + plci->State = INC_CON_ALERT; + add_ai(plci, &msg[0]); + sig_req(plci, CALL_ALERT, 0); + ret = 1; + } + } + } + sendf(appl, + _ALERT_R | CONFIRM, + Id, + Number, + "w", Info); + return ret; +} + +static byte facility_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *msg) +{ + word Info = 0; + word i = 0; + + word selector; + word SSreq; + long relatedPLCIvalue; + DIVA_CAPI_ADAPTER *relatedadapter; + byte *SSparms = ""; + byte RCparms[] = "\x05\x00\x00\x02\x00\x00"; + byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00"; + API_PARSE *parms; + API_PARSE ss_parms[11]; + PLCI *rplci; + byte cai[15]; + dword d; + API_PARSE dummy; + + dbug(1, dprintf("facility_req")); + for (i = 0; i < 9; i++) ss_parms[i].length = 0; + + parms = &msg[1]; + + if (!a) + { + dbug(1, dprintf("wrong Ctrl")); + Info = _WRONG_IDENTIFIER; + } + + selector = GET_WORD(msg[0].info); + + if (!Info) + { + switch (selector) + { + case SELECTOR_HANDSET: + Info = AdvCodecSupport(a, plci, appl, HOOK_SUPPORT); + break; + + case SELECTOR_SU_SERV: + if (!msg[1].length) + { + Info = _WRONG_MESSAGE_FORMAT; + break; + } + SSreq = GET_WORD(&(msg[1].info[1])); + PUT_WORD(&RCparms[1], SSreq); + SSparms = RCparms; + switch (SSreq) + { + case S_GET_SUPPORTED_SERVICES: + if ((i = get_plci(a))) + { + rplci = &a->plci[i - 1]; + rplci->appl = appl; + add_p(rplci, CAI, "\x01\x80"); + add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + sig_req(rplci, ASSIGN, DSIG_ID); + send_req(rplci); + } + else + { + PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY); + SSparms = (byte *)SSstruct; + break; + } + rplci->internal_command = GETSERV_REQ_PEND; + rplci->number = Number; + rplci->appl = appl; + sig_req(rplci, S_SUPPORTED, 0); + send_req(rplci); + return false; + break; + + case S_LISTEN: + if (parms->length == 7) + { + if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms)) + { + dbug(1, dprintf("format wrong")); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + } + else + { + Info = _WRONG_MESSAGE_FORMAT; + break; + } + a->Notification_Mask[appl->Id - 1] = GET_DWORD(ss_parms[2].info); + if (a->Notification_Mask[appl->Id - 1] & SMASK_MWI) /* MWI active? */ + { + if ((i = get_plci(a))) + { + rplci = &a->plci[i - 1]; + rplci->appl = appl; + add_p(rplci, CAI, "\x01\x80"); + add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + sig_req(rplci, ASSIGN, DSIG_ID); + send_req(rplci); + } + else + { + break; + } + rplci->internal_command = GET_MWI_STATE; + rplci->number = Number; + sig_req(rplci, MWI_POLL, 0); + send_req(rplci); + } + break; + + case S_HOLD: + api_parse(&parms->info[1], (word)parms->length, "ws", ss_parms); + if (plci && plci->State && plci->SuppState == IDLE) + { + plci->SuppState = HOLD_REQUEST; + plci->command = C_HOLD_REQ; + add_s(plci, CAI, &ss_parms[1]); + sig_req(plci, CALL_HOLD, 0); + send_req(plci); + return false; + } + else Info = 0x3010; /* wrong state */ + break; + case S_RETRIEVE: + if (plci && plci->State && plci->SuppState == CALL_HELD) + { + if (Id & EXT_CONTROLLER) + { + if (AdvCodecSupport(a, plci, appl, 0)) + { + Info = 0x3010; /* wrong state */ + break; + } + } + else plci->tel = 0; + + plci->SuppState = RETRIEVE_REQUEST; + plci->command = C_RETRIEVE_REQ; + if (plci->spoofed_msg == SPOOFING_REQUIRED) + { + plci->spoofed_msg = CALL_RETRIEVE; + plci->internal_command = BLOCK_PLCI; + plci->command = 0; + dbug(1, dprintf("Spoof")); + return false; + } + else + { + sig_req(plci, CALL_RETRIEVE, 0); + send_req(plci); + return false; + } + } + else Info = 0x3010; /* wrong state */ + break; + case S_SUSPEND: + if (parms->length) + { + if (api_parse(&parms->info[1], (word)parms->length, "wbs", ss_parms)) + { + dbug(1, dprintf("format wrong")); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + } + if (plci && plci->State) + { + add_s(plci, CAI, &ss_parms[2]); + plci->command = SUSPEND_REQ; + sig_req(plci, SUSPEND, 0); + plci->State = SUSPENDING; + send_req(plci); + } + else Info = 0x3010; /* wrong state */ + break; + + case S_RESUME: + if (!(i = get_plci(a))) + { + Info = _OUT_OF_PLCI; + break; + } + rplci = &a->plci[i - 1]; + rplci->appl = appl; + rplci->number = Number; + rplci->tel = 0; + rplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE; + /* check 'external controller' bit for codec support */ + if (Id & EXT_CONTROLLER) + { + if (AdvCodecSupport(a, rplci, appl, 0)) + { + rplci->Id = 0; + Info = 0x300A; + break; + } + } + if (parms->length) + { + if (api_parse(&parms->info[1], (word)parms->length, "wbs", ss_parms)) + { + dbug(1, dprintf("format wrong")); + rplci->Id = 0; + Info = _WRONG_MESSAGE_FORMAT; + break; + } + } + dummy.length = 0; + dummy.info = "\x00"; + add_b1(rplci, &dummy, 0, 0); + if (a->Info_Mask[appl->Id - 1] & 0x200) + { + /* early B3 connect (CIP mask bit 9) no release after a disc */ + add_p(rplci, LLI, "\x01\x01"); + } + add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + sig_req(rplci, ASSIGN, DSIG_ID); + send_req(rplci); + add_s(rplci, CAI, &ss_parms[2]); + rplci->command = RESUME_REQ; + sig_req(rplci, RESUME, 0); + rplci->State = RESUMING; + send_req(rplci); + break; + + case S_CONF_BEGIN: /* Request */ + case S_CONF_DROP: + case S_CONF_ISOLATE: + case S_CONF_REATTACH: + if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms)) + { + dbug(1, dprintf("format wrong")); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + if (plci && plci->State && ((plci->SuppState == IDLE) || (plci->SuppState == CALL_HELD))) + { + d = GET_DWORD(ss_parms[2].info); + if (d >= 0x80) + { + dbug(1, dprintf("format wrong")); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + plci->ptyState = (byte)SSreq; + plci->command = 0; + cai[0] = 2; + switch (SSreq) + { + case S_CONF_BEGIN: + cai[1] = CONF_BEGIN; + plci->internal_command = CONF_BEGIN_REQ_PEND; + break; + case S_CONF_DROP: + cai[1] = CONF_DROP; + plci->internal_command = CONF_DROP_REQ_PEND; + break; + case S_CONF_ISOLATE: + cai[1] = CONF_ISOLATE; + plci->internal_command = CONF_ISOLATE_REQ_PEND; + break; + case S_CONF_REATTACH: + cai[1] = CONF_REATTACH; + plci->internal_command = CONF_REATTACH_REQ_PEND; + break; + } + cai[2] = (byte)d; /* Conference Size resp. PartyId */ + add_p(plci, CAI, cai); + sig_req(plci, S_SERVICE, 0); + send_req(plci); + return false; + } + else Info = 0x3010; /* wrong state */ + break; + + case S_ECT: + case S_3PTY_BEGIN: + case S_3PTY_END: + case S_CONF_ADD: + if (parms->length == 7) + { + if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms)) + { + dbug(1, dprintf("format wrong")); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + } + else if (parms->length == 8) /* workaround for the T-View-S */ + { + if (api_parse(&parms->info[1], (word)parms->length, "wbdb", ss_parms)) + { + dbug(1, dprintf("format wrong")); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + } + else + { + Info = _WRONG_MESSAGE_FORMAT; + break; + } + if (!msg[1].length) + { + Info = _WRONG_MESSAGE_FORMAT; + break; + } + if (!plci) + { + Info = _WRONG_IDENTIFIER; + break; + } + relatedPLCIvalue = GET_DWORD(ss_parms[2].info); + relatedPLCIvalue &= 0x0000FFFF; + dbug(1, dprintf("PTY/ECT/addCONF,relPLCI=%lx", relatedPLCIvalue)); + /* controller starts with 0 up to (max_adapter - 1) */ + if (((relatedPLCIvalue & 0x7f) == 0) + || (MapController((byte)(relatedPLCIvalue & 0x7f)) == 0) + || (MapController((byte)(relatedPLCIvalue & 0x7f)) > max_adapter)) + { + if (SSreq == S_3PTY_END) + { + dbug(1, dprintf("wrong Controller use 2nd PLCI=PLCI")); + rplci = plci; + } + else + { + Info = 0x3010; /* wrong state */ + break; + } + } + else + { + relatedadapter = &adapter[MapController((byte)(relatedPLCIvalue & 0x7f)) - 1]; + relatedPLCIvalue >>= 8; + /* find PLCI PTR*/ + for (i = 0, rplci = NULL; i < relatedadapter->max_plci; i++) + { + if (relatedadapter->plci[i].Id == (byte)relatedPLCIvalue) + { + rplci = &relatedadapter->plci[i]; + } + } + if (!rplci || !relatedPLCIvalue) + { + if (SSreq == S_3PTY_END) + { + dbug(1, dprintf("use 2nd PLCI=PLCI")); + rplci = plci; + } + else + { + Info = 0x3010; /* wrong state */ + break; + } + } + } +/* + dbug(1, dprintf("rplci:%x", rplci)); + dbug(1, dprintf("plci:%x", plci)); + dbug(1, dprintf("rplci->ptyState:%x", rplci->ptyState)); + dbug(1, dprintf("plci->ptyState:%x", plci->ptyState)); + dbug(1, dprintf("SSreq:%x", SSreq)); + dbug(1, dprintf("rplci->internal_command:%x", rplci->internal_command)); + dbug(1, dprintf("rplci->appl:%x", rplci->appl)); + dbug(1, dprintf("rplci->Id:%x", rplci->Id)); +*/ + /* send PTY/ECT req, cannot check all states because of US stuff */ + if (!rplci->internal_command && rplci->appl) + { + plci->command = 0; + rplci->relatedPTYPLCI = plci; + plci->relatedPTYPLCI = rplci; + rplci->ptyState = (byte)SSreq; + if (SSreq == S_ECT) + { + rplci->internal_command = ECT_REQ_PEND; + cai[1] = ECT_EXECUTE; + + rplci->vswitchstate = 0; + rplci->vsprot = 0; + rplci->vsprotdialect = 0; + plci->vswitchstate = 0; + plci->vsprot = 0; + plci->vsprotdialect = 0; + + } + else if (SSreq == S_CONF_ADD) + { + rplci->internal_command = CONF_ADD_REQ_PEND; + cai[1] = CONF_ADD; + } + else + { + rplci->internal_command = PTY_REQ_PEND; + cai[1] = (byte)(SSreq - 3); + } + rplci->number = Number; + if (plci != rplci) /* explicit invocation */ + { + cai[0] = 2; + cai[2] = plci->Sig.Id; + dbug(1, dprintf("explicit invocation")); + } + else + { + dbug(1, dprintf("implicit invocation")); + cai[0] = 1; + } + add_p(rplci, CAI, cai); + sig_req(rplci, S_SERVICE, 0); + send_req(rplci); + return false; + } + else + { + dbug(0, dprintf("Wrong line")); + Info = 0x3010; /* wrong state */ + break; + } + break; + + case S_CALL_DEFLECTION: + if (api_parse(&parms->info[1], (word)parms->length, "wbwss", ss_parms)) + { + dbug(1, dprintf("format wrong")); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + if (!plci) + { + Info = _WRONG_IDENTIFIER; + break; + } + /* reuse unused screening indicator */ + ss_parms[3].info[3] = (byte)GET_WORD(&(ss_parms[2].info[0])); + plci->command = 0; + plci->internal_command = CD_REQ_PEND; + appl->CDEnable = true; + cai[0] = 1; + cai[1] = CALL_DEFLECTION; + add_p(plci, CAI, cai); + add_p(plci, CPN, ss_parms[3].info); + sig_req(plci, S_SERVICE, 0); + send_req(plci); + return false; + break; + + case S_CALL_FORWARDING_START: + if (api_parse(&parms->info[1], (word)parms->length, "wbdwwsss", ss_parms)) + { + dbug(1, dprintf("format wrong")); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + + if ((i = get_plci(a))) + { + rplci = &a->plci[i - 1]; + rplci->appl = appl; + add_p(rplci, CAI, "\x01\x80"); + add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + sig_req(rplci, ASSIGN, DSIG_ID); + send_req(rplci); + } + else + { + Info = _OUT_OF_PLCI; + break; + } + + /* reuse unused screening indicator */ + rplci->internal_command = CF_START_PEND; + rplci->appl = appl; + rplci->number = Number; + appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0])); + cai[0] = 2; + cai[1] = 0x70 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */ + cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */ + add_p(rplci, CAI, cai); + add_p(rplci, OAD, ss_parms[5].info); + add_p(rplci, CPN, ss_parms[6].info); + sig_req(rplci, S_SERVICE, 0); + send_req(rplci); + return false; + break; + + case S_INTERROGATE_DIVERSION: + case S_INTERROGATE_NUMBERS: + case S_CALL_FORWARDING_STOP: + case S_CCBS_REQUEST: + case S_CCBS_DEACTIVATE: + case S_CCBS_INTERROGATE: + switch (SSreq) + { + case S_INTERROGATE_NUMBERS: + if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms)) + { + dbug(0, dprintf("format wrong")); + Info = _WRONG_MESSAGE_FORMAT; + } + break; + case S_CCBS_REQUEST: + case S_CCBS_DEACTIVATE: + if (api_parse(&parms->info[1], (word)parms->length, "wbdw", ss_parms)) + { + dbug(0, dprintf("format wrong")); + Info = _WRONG_MESSAGE_FORMAT; + } + break; + case S_CCBS_INTERROGATE: + if (api_parse(&parms->info[1], (word)parms->length, "wbdws", ss_parms)) + { + dbug(0, dprintf("format wrong")); + Info = _WRONG_MESSAGE_FORMAT; + } + break; + default: + if (api_parse(&parms->info[1], (word)parms->length, "wbdwws", ss_parms)) + { + dbug(0, dprintf("format wrong")); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + break; + } + + if (Info) break; + if ((i = get_plci(a))) + { + rplci = &a->plci[i - 1]; + switch (SSreq) + { + case S_INTERROGATE_DIVERSION: /* use cai with S_SERVICE below */ + cai[1] = 0x60 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */ + rplci->internal_command = INTERR_DIVERSION_REQ_PEND; /* move to rplci if assigned */ + break; + case S_INTERROGATE_NUMBERS: /* use cai with S_SERVICE below */ + cai[1] = DIVERSION_INTERROGATE_NUM; /* Function */ + rplci->internal_command = INTERR_NUMBERS_REQ_PEND; /* move to rplci if assigned */ + break; + case S_CALL_FORWARDING_STOP: + rplci->internal_command = CF_STOP_PEND; + cai[1] = 0x80 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */ + break; + case S_CCBS_REQUEST: + cai[1] = CCBS_REQUEST; + rplci->internal_command = CCBS_REQUEST_REQ_PEND; + break; + case S_CCBS_DEACTIVATE: + cai[1] = CCBS_DEACTIVATE; + rplci->internal_command = CCBS_DEACTIVATE_REQ_PEND; + break; + case S_CCBS_INTERROGATE: + cai[1] = CCBS_INTERROGATE; + rplci->internal_command = CCBS_INTERROGATE_REQ_PEND; + break; + default: + cai[1] = 0; + break; + } + rplci->appl = appl; + rplci->number = Number; + add_p(rplci, CAI, "\x01\x80"); + add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + sig_req(rplci, ASSIGN, DSIG_ID); + send_req(rplci); + } + else + { + Info = _OUT_OF_PLCI; + break; + } + + appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0])); + switch (SSreq) + { + case S_INTERROGATE_NUMBERS: + cai[0] = 1; + add_p(rplci, CAI, cai); + break; + case S_CCBS_REQUEST: + case S_CCBS_DEACTIVATE: + cai[0] = 3; + PUT_WORD(&cai[2], GET_WORD(&(ss_parms[3].info[0]))); + add_p(rplci, CAI, cai); + break; + case S_CCBS_INTERROGATE: + cai[0] = 3; + PUT_WORD(&cai[2], GET_WORD(&(ss_parms[3].info[0]))); + add_p(rplci, CAI, cai); + add_p(rplci, OAD, ss_parms[4].info); + break; + default: + cai[0] = 2; + cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */ + add_p(rplci, CAI, cai); + add_p(rplci, OAD, ss_parms[5].info); + break; + } + + sig_req(rplci, S_SERVICE, 0); + send_req(rplci); + return false; + break; + + case S_MWI_ACTIVATE: + if (api_parse(&parms->info[1], (word)parms->length, "wbwdwwwssss", ss_parms)) + { + dbug(1, dprintf("format wrong")); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + if (!plci) + { + if ((i = get_plci(a))) + { + rplci = &a->plci[i - 1]; + rplci->appl = appl; + rplci->cr_enquiry = true; + add_p(rplci, CAI, "\x01\x80"); + add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + sig_req(rplci, ASSIGN, DSIG_ID); + send_req(rplci); + } + else + { + Info = _OUT_OF_PLCI; + break; + } + } + else + { + rplci = plci; + rplci->cr_enquiry = false; + } + + rplci->command = 0; + rplci->internal_command = MWI_ACTIVATE_REQ_PEND; + rplci->appl = appl; + rplci->number = Number; + + cai[0] = 13; + cai[1] = ACTIVATION_MWI; /* Function */ + PUT_WORD(&cai[2], GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */ + PUT_DWORD(&cai[4], GET_DWORD(&(ss_parms[3].info[0]))); /* Number of Messages */ + PUT_WORD(&cai[8], GET_WORD(&(ss_parms[4].info[0]))); /* Message Status */ + PUT_WORD(&cai[10], GET_WORD(&(ss_parms[5].info[0]))); /* Message Reference */ + PUT_WORD(&cai[12], GET_WORD(&(ss_parms[6].info[0]))); /* Invocation Mode */ + add_p(rplci, CAI, cai); + add_p(rplci, CPN, ss_parms[7].info); /* Receiving User Number */ + add_p(rplci, OAD, ss_parms[8].info); /* Controlling User Number */ + add_p(rplci, OSA, ss_parms[9].info); /* Controlling User Provided Number */ + add_p(rplci, UID, ss_parms[10].info); /* Time */ + sig_req(rplci, S_SERVICE, 0); + send_req(rplci); + return false; + + case S_MWI_DEACTIVATE: + if (api_parse(&parms->info[1], (word)parms->length, "wbwwss", ss_parms)) + { + dbug(1, dprintf("format wrong")); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + if (!plci) + { + if ((i = get_plci(a))) + { + rplci = &a->plci[i - 1]; + rplci->appl = appl; + rplci->cr_enquiry = true; + add_p(rplci, CAI, "\x01\x80"); + add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + sig_req(rplci, ASSIGN, DSIG_ID); + send_req(rplci); + } + else + { + Info = _OUT_OF_PLCI; + break; + } + } + else + { + rplci = plci; + rplci->cr_enquiry = false; + } + + rplci->command = 0; + rplci->internal_command = MWI_DEACTIVATE_REQ_PEND; + rplci->appl = appl; + rplci->number = Number; + + cai[0] = 5; + cai[1] = DEACTIVATION_MWI; /* Function */ + PUT_WORD(&cai[2], GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */ + PUT_WORD(&cai[4], GET_WORD(&(ss_parms[3].info[0]))); /* Invocation Mode */ + add_p(rplci, CAI, cai); + add_p(rplci, CPN, ss_parms[4].info); /* Receiving User Number */ + add_p(rplci, OAD, ss_parms[5].info); /* Controlling User Number */ + sig_req(rplci, S_SERVICE, 0); + send_req(rplci); + return false; + + default: + Info = 0x300E; /* not supported */ + break; + } + break; /* case SELECTOR_SU_SERV: end */ + + + case SELECTOR_DTMF: + return (dtmf_request(Id, Number, a, plci, appl, msg)); + + + + case SELECTOR_LINE_INTERCONNECT: + return (mixer_request(Id, Number, a, plci, appl, msg)); + + + + case PRIV_SELECTOR_ECHO_CANCELLER: + appl->appl_flags |= APPL_FLAG_PRIV_EC_SPEC; + return (ec_request(Id, Number, a, plci, appl, msg)); + + case SELECTOR_ECHO_CANCELLER: + appl->appl_flags &= ~APPL_FLAG_PRIV_EC_SPEC; + return (ec_request(Id, Number, a, plci, appl, msg)); + + + case SELECTOR_V42BIS: + default: + Info = _FACILITY_NOT_SUPPORTED; + break; + } /* end of switch (selector) */ + } + + dbug(1, dprintf("SendFacRc")); + sendf(appl, + _FACILITY_R | CONFIRM, + Id, + Number, + "wws", Info, selector, SSparms); + return false; +} + +static byte facility_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *msg) +{ + dbug(1, dprintf("facility_res")); + return false; +} + +static byte connect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *parms) +{ + word Info = 0; + byte req; + byte len; + word w; + word fax_control_bits, fax_feature_bits, fax_info_change; + API_PARSE *ncpi; + byte pvc[2]; + + API_PARSE fax_parms[9]; + word i; + + + dbug(1, dprintf("connect_b3_req")); + if (plci) + { + if ((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING) + || (plci->State == INC_DIS_PENDING) || (plci->SuppState != IDLE)) + { + Info = _WRONG_STATE; + } + else + { + /* local reply if assign unsuccessful + or B3 protocol allows only one layer 3 connection + and already connected + or B2 protocol not any LAPD + and connect_b3_req contradicts originate/answer direction */ + if (!plci->NL.Id + || (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE)) + && ((plci->channels != 0) + || (((plci->B2_prot != B2_SDLC) && (plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL)) + && ((plci->call_dir & CALL_DIR_ANSWER) && !(plci->call_dir & CALL_DIR_FORCE_OUTG_NL)))))) + { + dbug(1, dprintf("B3 already connected=%d or no NL.Id=0x%x, dir=%d sstate=0x%x", + plci->channels, plci->NL.Id, plci->call_dir, plci->SuppState)); + Info = _WRONG_STATE; + sendf(appl, + _CONNECT_B3_R | CONFIRM, + Id, + Number, + "w", Info); + return false; + } + plci->requested_options_conn = 0; + + req = N_CONNECT; + ncpi = &parms[0]; + if (plci->B3_prot == 2 || plci->B3_prot == 3) + { + if (ncpi->length > 2) + { + /* check for PVC */ + if (ncpi->info[2] || ncpi->info[3]) + { + pvc[0] = ncpi->info[3]; + pvc[1] = ncpi->info[2]; + add_d(plci, 2, pvc); + req = N_RESET; + } + else + { + if (ncpi->info[1] & 1) req = N_CONNECT | N_D_BIT; + add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]); + } + } + } + else if (plci->B3_prot == 5) + { + if (plci->NL.Id && !plci->nl_remove_id) + { + fax_control_bits = GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low); + fax_feature_bits = GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->feature_bits_low); + if (!(fax_control_bits & T30_CONTROL_BIT_MORE_DOCUMENTS) + || (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)) + { + len = offsetof(T30_INFO, universal_6); + fax_info_change = false; + if (ncpi->length >= 4) + { + w = GET_WORD(&ncpi->info[3]); + if ((w & 0x0001) != ((word)(((T30_INFO *)(plci->fax_connect_info_buffer))->resolution & 0x0001))) + { + ((T30_INFO *)(plci->fax_connect_info_buffer))->resolution = + (byte)((((T30_INFO *)(plci->fax_connect_info_buffer))->resolution & ~T30_RESOLUTION_R8_0770_OR_200) | + ((w & 0x0001) ? T30_RESOLUTION_R8_0770_OR_200 : 0)); + fax_info_change = true; + } + fax_control_bits &= ~(T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS); + if (w & 0x0002) /* Fax-polling request */ + fax_control_bits |= T30_CONTROL_BIT_REQUEST_POLLING; + if ((w & 0x0004) /* Request to send / poll another document */ + && (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_MORE_DOCUMENTS)) + { + fax_control_bits |= T30_CONTROL_BIT_MORE_DOCUMENTS; + } + if (ncpi->length >= 6) + { + w = GET_WORD(&ncpi->info[5]); + if (((byte) w) != ((T30_INFO *)(plci->fax_connect_info_buffer))->data_format) + { + ((T30_INFO *)(plci->fax_connect_info_buffer))->data_format = (byte) w; + fax_info_change = true; + } + + if ((a->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD)) + && (GET_WORD(&ncpi->info[5]) & 0x8000)) /* Private SEP/SUB/PWD enable */ + { + plci->requested_options_conn |= (1L << PRIVATE_FAX_SUB_SEP_PWD); + } + if ((a->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD)) + && (GET_WORD(&ncpi->info[5]) & 0x4000)) /* Private non-standard facilities enable */ + { + plci->requested_options_conn |= (1L << PRIVATE_FAX_NONSTANDARD); + } + fax_control_bits &= ~(T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_SEL_POLLING | + T30_CONTROL_BIT_ACCEPT_PASSWORD); + if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1]) + & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD))) + { + if (api_parse(&ncpi->info[1], ncpi->length, "wwwwsss", fax_parms)) + Info = _WRONG_MESSAGE_FORMAT; + else + { + if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1]) + & (1L << PRIVATE_FAX_SUB_SEP_PWD)) + { + fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD; + if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING) + fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING; + } + w = fax_parms[4].length; + if (w > 20) + w = 20; + ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = (byte) w; + for (i = 0; i < w; i++) + ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id[i] = fax_parms[4].info[1 + i]; + ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0; + len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH; + w = fax_parms[5].length; + if (w > 20) + w = 20; + plci->fax_connect_info_buffer[len++] = (byte) w; + for (i = 0; i < w; i++) + plci->fax_connect_info_buffer[len++] = fax_parms[5].info[1 + i]; + w = fax_parms[6].length; + if (w > 20) + w = 20; + plci->fax_connect_info_buffer[len++] = (byte) w; + for (i = 0; i < w; i++) + plci->fax_connect_info_buffer[len++] = fax_parms[6].info[1 + i]; + if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1]) + & (1L << PRIVATE_FAX_NONSTANDARD)) + { + if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms)) + { + dbug(1, dprintf("non-standard facilities info missing or wrong format")); + plci->fax_connect_info_buffer[len++] = 0; + } + else + { + if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2)) + plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]); + plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length); + for (i = 0; i < fax_parms[7].length; i++) + plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i]; + } + } + } + } + else + { + len = offsetof(T30_INFO, universal_6); + } + fax_info_change = true; + + } + if (fax_control_bits != GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low)) + { + PUT_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low, fax_control_bits); + fax_info_change = true; + } + } + if (Info == GOOD) + { + plci->fax_connect_info_length = len; + if (fax_info_change) + { + if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS) + { + start_internal_command(Id, plci, fax_connect_info_command); + return false; + } + else + { + start_internal_command(Id, plci, fax_adjust_b23_command); + return false; + } + } + } + } + else Info = _WRONG_STATE; + } + else Info = _WRONG_STATE; + } + + else if (plci->B3_prot == B3_RTP) + { + plci->internal_req_buffer[0] = ncpi->length + 1; + plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE; + for (w = 0; w < ncpi->length; w++) + plci->internal_req_buffer[2 + w] = ncpi->info[1 + w]; + start_internal_command(Id, plci, rtp_connect_b3_req_command); + return false; + } + + if (!Info) + { + nl_req_ncci(plci, req, 0); + return 1; + } + } + } + else Info = _WRONG_IDENTIFIER; + + sendf(appl, + _CONNECT_B3_R | CONFIRM, + Id, + Number, + "w", Info); + return false; +} + +static byte connect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *parms) +{ + word ncci; + API_PARSE *ncpi; + byte req; + + word w; + + + API_PARSE fax_parms[9]; + word i; + byte len; + + + dbug(1, dprintf("connect_b3_res")); + + ncci = (word)(Id >> 16); + if (plci && ncci) { + if (a->ncci_state[ncci] == INC_CON_PENDING) { + if (GET_WORD(&parms[0].info[0]) != 0) + { + a->ncci_state[ncci] = OUTG_REJ_PENDING; + channel_request_xon(plci, a->ncci_ch[ncci]); + channel_xmit_xon(plci); + cleanup_ncci_data(plci, ncci); + nl_req_ncci(plci, N_DISC, (byte)ncci); + return 1; + } + a->ncci_state[ncci] = INC_ACT_PENDING; + + req = N_CONNECT_ACK; + ncpi = &parms[1]; + if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7)) + { + + if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1]) + & (1L << PRIVATE_FAX_NONSTANDARD)) + { + if (((plci->B3_prot == 4) || (plci->B3_prot == 5)) + && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF) + && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP)) + { + len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH; + if (plci->fax_connect_info_length < len) + { + ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0; + ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0; + } + if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms)) + { + dbug(1, dprintf("non-standard facilities info missing or wrong format")); + } + else + { + if (plci->fax_connect_info_length <= len) + plci->fax_connect_info_buffer[len] = 0; + len += 1 + plci->fax_connect_info_buffer[len]; + if (plci->fax_connect_info_length <= len) + plci->fax_connect_info_buffer[len] = 0; + len += 1 + plci->fax_connect_info_buffer[len]; + if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2)) + plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]); + plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length); + for (i = 0; i < fax_parms[7].length; i++) + plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i]; + } + plci->fax_connect_info_length = len; + ((T30_INFO *)(plci->fax_connect_info_buffer))->code = 0; + start_internal_command(Id, plci, fax_connect_ack_command); + return false; + } + } + + nl_req_ncci(plci, req, (byte)ncci); + if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT) + && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT)) + { + if (plci->B3_prot == 4) + sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", ""); + else + sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer); + plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT; + } + } + + else if (plci->B3_prot == B3_RTP) + { + plci->internal_req_buffer[0] = ncpi->length + 1; + plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE; + for (w = 0; w < ncpi->length; w++) + plci->internal_req_buffer[2 + w] = ncpi->info[1+w]; + start_internal_command(Id, plci, rtp_connect_b3_res_command); + return false; + } + + else + { + if (ncpi->length > 2) { + if (ncpi->info[1] & 1) req = N_CONNECT_ACK | N_D_BIT; + add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]); + } + nl_req_ncci(plci, req, (byte)ncci); + sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", ""); + if (plci->adjust_b_restore) + { + plci->adjust_b_restore = false; + start_internal_command(Id, plci, adjust_b_restore); + } + } + return 1; + } + } + return false; +} + +static byte connect_b3_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *parms) +{ + word ncci; + + ncci = (word)(Id >> 16); + dbug(1, dprintf("connect_b3_a_res(ncci=0x%x)", ncci)); + + if (plci && ncci && (plci->State != IDLE) && (plci->State != INC_DIS_PENDING) + && (plci->State != OUTG_DIS_PENDING)) + { + if (a->ncci_state[ncci] == INC_ACT_PENDING) { + a->ncci_state[ncci] = CONNECTED; + if (plci->State != INC_CON_CONNECTED_ALERT) plci->State = CONNECTED; + channel_request_xon(plci, a->ncci_ch[ncci]); + channel_xmit_xon(plci); + } + } + return false; +} + +static byte disconnect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *parms) +{ + word Info; + word ncci; + API_PARSE *ncpi; + + dbug(1, dprintf("disconnect_b3_req")); + + Info = _WRONG_IDENTIFIER; + ncci = (word)(Id >> 16); + if (plci && ncci) + { + Info = _WRONG_STATE; + if ((a->ncci_state[ncci] == CONNECTED) + || (a->ncci_state[ncci] == OUTG_CON_PENDING) + || (a->ncci_state[ncci] == INC_CON_PENDING) + || (a->ncci_state[ncci] == INC_ACT_PENDING)) + { + a->ncci_state[ncci] = OUTG_DIS_PENDING; + channel_request_xon(plci, a->ncci_ch[ncci]); + channel_xmit_xon(plci); + + if (a->ncci[ncci].data_pending + && ((plci->B3_prot == B3_TRANSPARENT) + || (plci->B3_prot == B3_T30) + || (plci->B3_prot == B3_T30_WITH_EXTENSIONS))) + { + plci->send_disc = (byte)ncci; + plci->command = 0; + return false; + } + else + { + cleanup_ncci_data(plci, ncci); + + if (plci->B3_prot == 2 || plci->B3_prot == 3) + { + ncpi = &parms[0]; + if (ncpi->length > 3) + { + add_d(plci, (word)(ncpi->length - 3), (byte *)&(ncpi->info[4])); + } + } + nl_req_ncci(plci, N_DISC, (byte)ncci); + } + return 1; + } + } + sendf(appl, + _DISCONNECT_B3_R | CONFIRM, + Id, + Number, + "w", Info); + return false; +} + +static byte disconnect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *parms) +{ + word ncci; + word i; + + ncci = (word)(Id >> 16); + dbug(1, dprintf("disconnect_b3_res(ncci=0x%x", ncci)); + if (plci && ncci) { + plci->requested_options_conn = 0; + plci->fax_connect_info_length = 0; + plci->ncpi_state = 0x00; + if (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE)) + && ((plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL))) + { + plci->call_dir |= CALL_DIR_FORCE_OUTG_NL; + } + for (i = 0; i < MAX_CHANNELS_PER_PLCI && plci->inc_dis_ncci_table[i] != (byte)ncci; i++); + if (i < MAX_CHANNELS_PER_PLCI) { + if (plci->channels)plci->channels--; + for (; i < MAX_CHANNELS_PER_PLCI - 1; i++) plci->inc_dis_ncci_table[i] = plci->inc_dis_ncci_table[i + 1]; + plci->inc_dis_ncci_table[MAX_CHANNELS_PER_PLCI - 1] = 0; + + ncci_free_receive_buffers(plci, ncci); + + if ((plci->State == IDLE || plci->State == SUSPENDING) && !plci->channels) { + if (plci->State == SUSPENDING) { + sendf(plci->appl, + _FACILITY_I, + Id & 0xffffL, + 0, + "ws", (word)3, "\x03\x04\x00\x00"); + sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0); + } + plci_remove(plci); + plci->State = IDLE; + } + } + else + { + if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS) + && ((plci->B3_prot == 4) || (plci->B3_prot == 5)) + && (a->ncci_state[ncci] == INC_DIS_PENDING)) + { + ncci_free_receive_buffers(plci, ncci); + + nl_req_ncci(plci, N_EDATA, (byte)ncci); + + plci->adapter->ncci_state[ncci] = IDLE; + start_internal_command(Id, plci, fax_disconnect_command); + return 1; + } + } + } + return false; +} + +static byte data_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *parms) +{ + NCCI *ncci_ptr; + DATA_B3_DESC *data; + word Info; + word ncci; + word i; + + dbug(1, dprintf("data_b3_req")); + + Info = _WRONG_IDENTIFIER; + ncci = (word)(Id >> 16); + dbug(1, dprintf("ncci=0x%x, plci=0x%x", ncci, plci)); + + if (plci && ncci) + { + Info = _WRONG_STATE; + if ((a->ncci_state[ncci] == CONNECTED) + || (a->ncci_state[ncci] == INC_ACT_PENDING)) + { + /* queue data */ + ncci_ptr = &(a->ncci[ncci]); + i = ncci_ptr->data_out + ncci_ptr->data_pending; + if (i >= MAX_DATA_B3) + i -= MAX_DATA_B3; + data = &(ncci_ptr->DBuffer[i]); + data->Number = Number; + if ((((byte *)(parms[0].info)) >= ((byte *)(plci->msg_in_queue))) + && (((byte *)(parms[0].info)) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue))) + { + + data->P = (byte *)(long)(*((dword *)(parms[0].info))); + + } + else + data->P = TransmitBufferSet(appl, *(dword *)parms[0].info); + data->Length = GET_WORD(parms[1].info); + data->Handle = GET_WORD(parms[2].info); + data->Flags = GET_WORD(parms[3].info); + (ncci_ptr->data_pending)++; + + /* check for delivery confirmation */ + if (data->Flags & 0x0004) + { + i = ncci_ptr->data_ack_out + ncci_ptr->data_ack_pending; + if (i >= MAX_DATA_ACK) + i -= MAX_DATA_ACK; + ncci_ptr->DataAck[i].Number = data->Number; + ncci_ptr->DataAck[i].Handle = data->Handle; + (ncci_ptr->data_ack_pending)++; + } + + send_data(plci); + return false; + } + } + if (appl) + { + if (plci) + { + if ((((byte *)(parms[0].info)) >= ((byte *)(plci->msg_in_queue))) + && (((byte *)(parms[0].info)) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue))) + { + + TransmitBufferFree(appl, (byte *)(long)(*((dword *)(parms[0].info)))); + + } + } + sendf(appl, + _DATA_B3_R | CONFIRM, + Id, + Number, + "ww", GET_WORD(parms[2].info), Info); + } + return false; +} + +static byte data_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *parms) +{ + word n; + word ncci; + word NCCIcode; + + dbug(1, dprintf("data_b3_res")); + + ncci = (word)(Id >> 16); + if (plci && ncci) { + n = GET_WORD(parms[0].info); + dbug(1, dprintf("free(%d)", n)); + NCCIcode = ncci | (((word) a->Id) << 8); + if (n < appl->MaxBuffer && + appl->DataNCCI[n] == NCCIcode && + (byte)(appl->DataFlags[n] >> 8) == plci->Id) { + dbug(1, dprintf("found")); + appl->DataNCCI[n] = 0; + + if (channel_can_xon(plci, a->ncci_ch[ncci])) { + channel_request_xon(plci, a->ncci_ch[ncci]); + } + channel_xmit_xon(plci); + + if (appl->DataFlags[n] & 4) { + nl_req_ncci(plci, N_DATA_ACK, (byte)ncci); + return 1; + } + } + } + return false; +} + +static byte reset_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *parms) +{ + word Info; + word ncci; + + dbug(1, dprintf("reset_b3_req")); + + Info = _WRONG_IDENTIFIER; + ncci = (word)(Id >> 16); + if (plci && ncci) + { + Info = _WRONG_STATE; + switch (plci->B3_prot) + { + case B3_ISO8208: + case B3_X25_DCE: + if (a->ncci_state[ncci] == CONNECTED) + { + nl_req_ncci(plci, N_RESET, (byte)ncci); + send_req(plci); + Info = GOOD; + } + break; + case B3_TRANSPARENT: + if (a->ncci_state[ncci] == CONNECTED) + { + start_internal_command(Id, plci, reset_b3_command); + Info = GOOD; + } + break; + } + } + /* reset_b3 must result in a reset_b3_con & reset_b3_Ind */ + sendf(appl, + _RESET_B3_R | CONFIRM, + Id, + Number, + "w", Info); + return false; +} + +static byte reset_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *parms) +{ + word ncci; + + dbug(1, dprintf("reset_b3_res")); + + ncci = (word)(Id >> 16); + if (plci && ncci) { + switch (plci->B3_prot) + { + case B3_ISO8208: + case B3_X25_DCE: + if (a->ncci_state[ncci] == INC_RES_PENDING) + { + a->ncci_state[ncci] = CONNECTED; + nl_req_ncci(plci, N_RESET_ACK, (byte)ncci); + return true; + } + break; + } + } + return false; +} + +static byte connect_b3_t90_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *parms) +{ + word ncci; + API_PARSE *ncpi; + byte req; + + dbug(1, dprintf("connect_b3_t90_a_res")); + + ncci = (word)(Id >> 16); + if (plci && ncci) { + if (a->ncci_state[ncci] == INC_ACT_PENDING) { + a->ncci_state[ncci] = CONNECTED; + } + else if (a->ncci_state[ncci] == INC_CON_PENDING) { + a->ncci_state[ncci] = CONNECTED; + + req = N_CONNECT_ACK; + + /* parms[0]==0 for CAPI original message definition! */ + if (parms[0].info) { + ncpi = &parms[1]; + if (ncpi->length > 2) { + if (ncpi->info[1] & 1) req = N_CONNECT_ACK | N_D_BIT; + add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]); + } + } + nl_req_ncci(plci, req, (byte)ncci); + return 1; + } + } + return false; +} + + +static byte select_b_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *msg) +{ + word Info = 0; + word i; + byte tel; + API_PARSE bp_parms[7]; + + if (!plci || !msg) + { + Info = _WRONG_IDENTIFIER; + } + else + { + dbug(1, dprintf("select_b_req[%d],PLCI=0x%x,Tel=0x%x,NL=0x%x,appl=0x%x,sstate=0x%x", + msg->length, plci->Id, plci->tel, plci->NL.Id, plci->appl, plci->SuppState)); + dbug(1, dprintf("PlciState=0x%x", plci->State)); + for (i = 0; i < 7; i++) bp_parms[i].length = 0; + + /* check if no channel is open, no B3 connected only */ + if ((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING) || (plci->State == INC_DIS_PENDING) + || (plci->SuppState != IDLE) || plci->channels || plci->nl_remove_id) + { + Info = _WRONG_STATE; + } + /* check message format and fill bp_parms pointer */ + else if (msg->length && api_parse(&msg->info[1], (word)msg->length, "wwwsss", bp_parms)) + { + Info = _WRONG_MESSAGE_FORMAT; + } + else + { + if ((plci->State == INC_CON_PENDING) || (plci->State == INC_CON_ALERT)) /* send alert tone inband to the network, */ + { /* e.g. Qsig or RBS or Cornet-N or xess PRI */ + if (Id & EXT_CONTROLLER) + { + sendf(appl, _SELECT_B_REQ | CONFIRM, Id, Number, "w", 0x2002); /* wrong controller */ + return 0; + } + plci->State = INC_CON_CONNECTED_ALERT; + plci->appl = appl; + clear_c_ind_mask_bit(plci, (word)(appl->Id - 1)); + dump_c_ind_mask(plci); + for (i = 0; i < max_appl; i++) /* disconnect the other appls */ + { /* its quasi a connect */ + if (test_c_ind_mask_bit(plci, i)) + sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED); + } + } + + api_save_msg(msg, "s", &plci->saved_msg); + tel = plci->tel; + if (Id & EXT_CONTROLLER) + { + if (tel) /* external controller in use by this PLCI */ + { + if (a->AdvSignalAppl && a->AdvSignalAppl != appl) + { + dbug(1, dprintf("Ext_Ctrl in use 1")); + Info = _WRONG_STATE; + } + } + else /* external controller NOT in use by this PLCI ? */ + { + if (a->AdvSignalPLCI) + { + dbug(1, dprintf("Ext_Ctrl in use 2")); + Info = _WRONG_STATE; + } + else /* activate the codec */ + { + dbug(1, dprintf("Ext_Ctrl start")); + if (AdvCodecSupport(a, plci, appl, 0)) + { + dbug(1, dprintf("Error in codec procedures")); + Info = _WRONG_STATE; + } + else if (plci->spoofed_msg == SPOOFING_REQUIRED) /* wait until codec is active */ + { + plci->spoofed_msg = AWAITING_SELECT_B; + plci->internal_command = BLOCK_PLCI; /* lock other commands */ + plci->command = 0; + dbug(1, dprintf("continue if codec loaded")); + return false; + } + } + } + } + else /* external controller bit is OFF */ + { + if (tel) /* external controller in use, need to switch off */ + { + if (a->AdvSignalAppl == appl) + { + CodecIdCheck(a, plci); + plci->tel = 0; + plci->adv_nl = 0; + dbug(1, dprintf("Ext_Ctrl disable")); + } + else + { + dbug(1, dprintf("Ext_Ctrl not requested")); + } + } + } + if (!Info) + { + if (plci->call_dir & CALL_DIR_OUT) + plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE; + else if (plci->call_dir & CALL_DIR_IN) + plci->call_dir = CALL_DIR_IN | CALL_DIR_ANSWER; + start_internal_command(Id, plci, select_b_command); + return false; + } + } + } + sendf(appl, _SELECT_B_REQ | CONFIRM, Id, Number, "w", Info); + return false; +} + +static byte manufacturer_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *parms) +{ + word command; + word i; + word ncci; + API_PARSE *m; + API_PARSE m_parms[5]; + word codec; + byte req; + byte ch; + byte dir; + static byte chi[2] = {0x01, 0x00}; + static byte lli[2] = {0x01, 0x00}; + static byte codec_cai[2] = {0x01, 0x01}; + static byte null_msg = {0}; + static API_PARSE null_parms = { 0, &null_msg }; + PLCI *v_plci; + word Info = 0; + + dbug(1, dprintf("manufacturer_req")); + for (i = 0; i < 5; i++) m_parms[i].length = 0; + + if (GET_DWORD(parms[0].info) != _DI_MANU_ID) { + Info = _WRONG_MESSAGE_FORMAT; + } + command = GET_WORD(parms[1].info); + m = &parms[2]; + if (!Info) + { + switch (command) { + case _DI_ASSIGN_PLCI: + if (api_parse(&m->info[1], (word)m->length, "wbbs", m_parms)) { + Info = _WRONG_MESSAGE_FORMAT; + break; + } + codec = GET_WORD(m_parms[0].info); + ch = m_parms[1].info[0]; + dir = m_parms[2].info[0]; + if ((i = get_plci(a))) { + plci = &a->plci[i - 1]; + plci->appl = appl; + plci->command = _MANUFACTURER_R; + plci->m_command = command; + plci->number = Number; + plci->State = LOCAL_CONNECT; + Id = (((word)plci->Id << 8) | plci->adapter->Id | 0x80); + dbug(1, dprintf("ManCMD,plci=0x%x", Id)); + + if ((ch == 1 || ch == 2) && (dir <= 2)) { + chi[1] = (byte)(0x80 | ch); + lli[1] = 0; + plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE; + switch (codec) + { + case 0: + Info = add_b1(plci, &m_parms[3], 0, 0); + break; + case 1: + add_p(plci, CAI, codec_cai); + break; + /* manual 'swich on' to the codec support without signalling */ + /* first 'assign plci' with this function, then use */ + case 2: + if (AdvCodecSupport(a, plci, appl, 0)) { + Info = _RESOURCE_ERROR; + } + else { + Info = add_b1(plci, &null_parms, 0, B1_FACILITY_LOCAL); + lli[1] = 0x10; /* local call codec stream */ + } + break; + } + + plci->State = LOCAL_CONNECT; + plci->manufacturer = true; + plci->command = _MANUFACTURER_R; + plci->m_command = command; + plci->number = Number; + + if (!Info) + { + add_p(plci, LLI, lli); + add_p(plci, CHI, chi); + add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + sig_req(plci, ASSIGN, DSIG_ID); + + if (!codec) + { + Info = add_b23(plci, &m_parms[3]); + if (!Info) + { + nl_req_ncci(plci, ASSIGN, 0); + send_req(plci); + } + } + if (!Info) + { + dbug(1, dprintf("dir=0x%x,spoof=0x%x", dir, plci->spoofed_msg)); + if (plci->spoofed_msg == SPOOFING_REQUIRED) + { + api_save_msg(m_parms, "wbbs", &plci->saved_msg); + plci->spoofed_msg = AWAITING_MANUF_CON; + plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */ + plci->command = 0; + send_req(plci); + return false; + } + if (dir == 1) { + sig_req(plci, CALL_REQ, 0); + } + else if (!dir) { + sig_req(plci, LISTEN_REQ, 0); + } + send_req(plci); + } + else + { + sendf(appl, + _MANUFACTURER_R | CONFIRM, + Id, + Number, + "dww", _DI_MANU_ID, command, Info); + return 2; + } + } + } + } + else Info = _OUT_OF_PLCI; + break; + + case _DI_IDI_CTRL: + if (!plci) + { + Info = _WRONG_IDENTIFIER; + break; + } + if (api_parse(&m->info[1], (word)m->length, "bs", m_parms)) { + Info = _WRONG_MESSAGE_FORMAT; + break; + } + req = m_parms[0].info[0]; + plci->command = _MANUFACTURER_R; + plci->m_command = command; + plci->number = Number; + if (req == CALL_REQ) + { + plci->b_channel = getChannel(&m_parms[1]); + mixer_set_bchannel_id_esc(plci, plci->b_channel); + if (plci->spoofed_msg == SPOOFING_REQUIRED) + { + plci->spoofed_msg = CALL_REQ | AWAITING_MANUF_CON; + plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */ + plci->command = 0; + break; + } + } + else if (req == LAW_REQ) + { + plci->cr_enquiry = true; + } + add_ss(plci, FTY, &m_parms[1]); + sig_req(plci, req, 0); + send_req(plci); + if (req == HANGUP) + { + if (plci->NL.Id && !plci->nl_remove_id) + { + if (plci->channels) + { + for (ncci = 1; ncci < MAX_NCCI + 1; ncci++) + { + if ((a->ncci_plci[ncci] == plci->Id) && (a->ncci_state[ncci] == CONNECTED)) + { + a->ncci_state[ncci] = OUTG_DIS_PENDING; + cleanup_ncci_data(plci, ncci); + nl_req_ncci(plci, N_DISC, (byte)ncci); + } + } + } + mixer_remove(plci); + nl_req_ncci(plci, REMOVE, 0); + send_req(plci); + } + } + break; + + case _DI_SIG_CTRL: + /* signalling control for loop activation B-channel */ + if (!plci) + { + Info = _WRONG_IDENTIFIER; + break; + } + if (m->length) { + plci->command = _MANUFACTURER_R; + plci->number = Number; + add_ss(plci, FTY, m); + sig_req(plci, SIG_CTRL, 0); + send_req(plci); + } + else Info = _WRONG_MESSAGE_FORMAT; + break; + + case _DI_RXT_CTRL: + /* activation control for receiver/transmitter B-channel */ + if (!plci) + { + Info = _WRONG_IDENTIFIER; + break; + } + if (m->length) { + plci->command = _MANUFACTURER_R; + plci->number = Number; + add_ss(plci, FTY, m); + sig_req(plci, DSP_CTRL, 0); + send_req(plci); + } + else Info = _WRONG_MESSAGE_FORMAT; + break; + + case _DI_ADV_CODEC: + case _DI_DSP_CTRL: + /* TEL_CTRL commands to support non standard adjustments: */ + /* Ring on/off, Handset micro volume, external micro vol. */ + /* handset+external speaker volume, receiver+transm. gain,*/ + /* handsfree on (hookinfo off), set mixer command */ + + if (command == _DI_ADV_CODEC) + { + if (!a->AdvCodecPLCI) { + Info = _WRONG_STATE; + break; + } + v_plci = a->AdvCodecPLCI; + } + else + { + if (plci + && (m->length >= 3) + && (m->info[1] == 0x1c) + && (m->info[2] >= 1)) + { + if (m->info[3] == DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS) + { + if ((plci->tel != ADV_VOICE) || (plci != a->AdvSignalPLCI)) + { + Info = _WRONG_STATE; + break; + } + a->adv_voice_coef_length = m->info[2] - 1; + if (a->adv_voice_coef_length > m->length - 3) + a->adv_voice_coef_length = (byte)(m->length - 3); + if (a->adv_voice_coef_length > ADV_VOICE_COEF_BUFFER_SIZE) + a->adv_voice_coef_length = ADV_VOICE_COEF_BUFFER_SIZE; + for (i = 0; i < a->adv_voice_coef_length; i++) + a->adv_voice_coef_buffer[i] = m->info[4 + i]; + if (plci->B1_facilities & B1_FACILITY_VOICE) + adv_voice_write_coefs(plci, ADV_VOICE_WRITE_UPDATE); + break; + } + else if (m->info[3] == DSP_CTRL_SET_DTMF_PARAMETERS) + { + if (!(a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_PARAMETERS)) + { + Info = _FACILITY_NOT_SUPPORTED; + break; + } + + plci->dtmf_parameter_length = m->info[2] - 1; + if (plci->dtmf_parameter_length > m->length - 3) + plci->dtmf_parameter_length = (byte)(m->length - 3); + if (plci->dtmf_parameter_length > DTMF_PARAMETER_BUFFER_SIZE) + plci->dtmf_parameter_length = DTMF_PARAMETER_BUFFER_SIZE; + for (i = 0; i < plci->dtmf_parameter_length; i++) + plci->dtmf_parameter_buffer[i] = m->info[4 + i]; + if (plci->B1_facilities & B1_FACILITY_DTMFR) + dtmf_parameter_write(plci); + break; + + } + } + v_plci = plci; + } + + if (!v_plci) + { + Info = _WRONG_IDENTIFIER; + break; + } + if (m->length) { + add_ss(v_plci, FTY, m); + sig_req(v_plci, TEL_CTRL, 0); + send_req(v_plci); + } + else Info = _WRONG_MESSAGE_FORMAT; + + break; + + case _DI_OPTIONS_REQUEST: + if (api_parse(&m->info[1], (word)m->length, "d", m_parms)) { + Info = _WRONG_MESSAGE_FORMAT; + break; + } + if (GET_DWORD(m_parms[0].info) & ~a->man_profile.private_options) + { + Info = _FACILITY_NOT_SUPPORTED; + break; + } + a->requested_options_table[appl->Id - 1] = GET_DWORD(m_parms[0].info); + break; + + + + default: + Info = _WRONG_MESSAGE_FORMAT; + break; + } + } + + sendf(appl, + _MANUFACTURER_R | CONFIRM, + Id, + Number, + "dww", _DI_MANU_ID, command, Info); + return false; +} + + +static byte manufacturer_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a, + PLCI *plci, APPL *appl, API_PARSE *msg) +{ + word indication; + + API_PARSE m_parms[3]; + API_PARSE *ncpi; + API_PARSE fax_parms[9]; + word i; + byte len; + + + dbug(1, dprintf("manufacturer_res")); + + if ((msg[0].length == 0) + || (msg[1].length == 0) + || (GET_DWORD(msg[0].info) != _DI_MANU_ID)) + { + return false; + } + indication = GET_WORD(msg[1].info); + switch (indication) + { + + case _DI_NEGOTIATE_B3: + if (!plci) + break; + if (((plci->B3_prot != 4) && (plci->B3_prot != 5)) + || !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT)) + { + dbug(1, dprintf("wrong state for NEGOTIATE_B3 parameters")); + break; + } + if (api_parse(&msg[2].info[1], msg[2].length, "ws", m_parms)) + { + dbug(1, dprintf("wrong format in NEGOTIATE_B3 parameters")); + break; + } + ncpi = &m_parms[1]; + len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH; + if (plci->fax_connect_info_length < len) + { + ((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0; + ((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0; + } + if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms)) + { + dbug(1, dprintf("non-standard facilities info missing or wrong format")); + } + else + { + if (plci->fax_connect_info_length <= len) + plci->fax_connect_info_buffer[len] = 0; + len += 1 + plci->fax_connect_info_buffer[len]; + if (plci->fax_connect_info_length <= len) + plci->fax_connect_info_buffer[len] = 0; + len += 1 + plci->fax_connect_info_buffer[len]; + if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2)) + plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]); + plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length); + for (i = 0; i < fax_parms[7].length; i++) + plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i]; + } + plci->fax_connect_info_length = len; + plci->fax_edata_ack_length = plci->fax_connect_info_length; + start_internal_command(Id, plci, fax_edata_ack_command); + break; + + } + return false; +} + +/*------------------------------------------------------------------*/ +/* IDI callback function */ +/*------------------------------------------------------------------*/ + +void callback(ENTITY *e) +{ + DIVA_CAPI_ADAPTER *a; + APPL *appl; + PLCI *plci; + CAPI_MSG *m; + word i, j; + byte rc; + byte ch; + byte req; + byte global_req; + int no_cancel_rc; + + dbug(1, dprintf("%x:CB(%x:Req=%x,Rc=%x,Ind=%x)", + (e->user[0] + 1) & 0x7fff, e->Id, e->Req, e->Rc, e->Ind)); + + a = &(adapter[(byte)e->user[0]]); + plci = &(a->plci[e->user[1]]); + no_cancel_rc = DIVA_CAPI_SUPPORTS_NO_CANCEL(a); + + /* + If new protocol code and new XDI is used then CAPI should work + fully in accordance with IDI cpec an look on callback field instead + of Rc field for return codes. + */ + if (((e->complete == 0xff) && no_cancel_rc) || + (e->Rc && !no_cancel_rc)) { + rc = e->Rc; + ch = e->RcCh; + req = e->Req; + e->Rc = 0; + + if (e->user[0] & 0x8000) + { + /* + If REMOVE request was sent then we have to wait until + return code with Id set to zero arrives. + All other return codes should be ignored. + */ + if (req == REMOVE) + { + if (e->Id) + { + dbug(1, dprintf("cancel RC in REMOVE state")); + return; + } + channel_flow_control_remove(plci); + for (i = 0; i < 256; i++) + { + if (a->FlowControlIdTable[i] == plci->nl_remove_id) + a->FlowControlIdTable[i] = 0; + } + plci->nl_remove_id = 0; + if (plci->rx_dma_descriptor > 0) { + diva_free_dma_descriptor(plci, plci->rx_dma_descriptor - 1); + plci->rx_dma_descriptor = 0; + } + } + if (rc == OK_FC) + { + a->FlowControlIdTable[ch] = e->Id; + a->FlowControlSkipTable[ch] = 0; + + a->ch_flow_control[ch] |= N_OK_FC_PENDING; + a->ch_flow_plci[ch] = plci->Id; + plci->nl_req = 0; + } + else + { + /* + Cancel return codes self, if feature was requested + */ + if (no_cancel_rc && (a->FlowControlIdTable[ch] == e->Id) && e->Id) { + a->FlowControlIdTable[ch] = 0; + if ((rc == OK) && a->FlowControlSkipTable[ch]) { + dbug(3, dprintf("XDI CAPI: RC cancelled Id:0x02, Ch:%02x", e->Id, ch)); + return; + } + } + + if (a->ch_flow_control[ch] & N_OK_FC_PENDING) + { + a->ch_flow_control[ch] &= ~N_OK_FC_PENDING; + if (ch == e->ReqCh) + plci->nl_req = 0; + } + else + plci->nl_req = 0; + } + if (plci->nl_req) + control_rc(plci, 0, rc, ch, 0, true); + else + { + if (req == N_XON) + { + channel_x_on(plci, ch); + if (plci->internal_command) + control_rc(plci, req, rc, ch, 0, true); + } + else + { + if (plci->nl_global_req) + { + global_req = plci->nl_global_req; + plci->nl_global_req = 0; + if (rc != ASSIGN_OK) { + e->Id = 0; + if (plci->rx_dma_descriptor > 0) { + diva_free_dma_descriptor(plci, plci->rx_dma_descriptor - 1); + plci->rx_dma_descriptor = 0; + } + } + channel_xmit_xon(plci); + control_rc(plci, 0, rc, ch, global_req, true); + } + else if (plci->data_sent) + { + channel_xmit_xon(plci); + plci->data_sent = false; + plci->NL.XNum = 1; + data_rc(plci, ch); + if (plci->internal_command) + control_rc(plci, req, rc, ch, 0, true); + } + else + { + channel_xmit_xon(plci); + control_rc(plci, req, rc, ch, 0, true); + } + } + } + } + else + { + /* + If REMOVE request was sent then we have to wait until + return code with Id set to zero arrives. + All other return codes should be ignored. + */ + if (req == REMOVE) + { + if (e->Id) + { + dbug(1, dprintf("cancel RC in REMOVE state")); + return; + } + plci->sig_remove_id = 0; + } + plci->sig_req = 0; + if (plci->sig_global_req) + { + global_req = plci->sig_global_req; + plci->sig_global_req = 0; + if (rc != ASSIGN_OK) + e->Id = 0; + channel_xmit_xon(plci); + control_rc(plci, 0, rc, ch, global_req, false); + } + else + { + channel_xmit_xon(plci); + control_rc(plci, req, rc, ch, 0, false); + } + } + /* + Again: in accordance with IDI spec Rc and Ind can't be delivered in the + same callback. Also if new XDI and protocol code used then jump + direct to finish. + */ + if (no_cancel_rc) { + channel_xmit_xon(plci); + goto capi_callback_suffix; + } + } + + channel_xmit_xon(plci); + + if (e->Ind) { + if (e->user[0] & 0x8000) { + byte Ind = e->Ind & 0x0f; + byte Ch = e->IndCh; + if (((Ind == N_DISC) || (Ind == N_DISC_ACK)) && + (a->ch_flow_plci[Ch] == plci->Id)) { + if (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK) { + dbug(3, dprintf("XDI CAPI: I: pending N-XON Ch:%02x", Ch)); + } + a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK; + } + nl_ind(plci); + if ((e->RNR != 1) && + (a->ch_flow_plci[Ch] == plci->Id) && + (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK)) { + a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK; + dbug(3, dprintf("XDI CAPI: I: remove faked N-XON Ch:%02x", Ch)); + } + } else { + sig_ind(plci); + } + e->Ind = 0; + } + +capi_callback_suffix: + + while (!plci->req_in + && !plci->internal_command + && (plci->msg_in_write_pos != plci->msg_in_read_pos)) + { + j = (plci->msg_in_read_pos == plci->msg_in_wrap_pos) ? 0 : plci->msg_in_read_pos; + + i = (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]))->header.length + 3) & 0xfffc; + + m = (CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]); + appl = *((APPL **)(&((byte *)(plci->msg_in_queue))[j + i])); + dbug(1, dprintf("dequeue msg(0x%04x) - write=%d read=%d wrap=%d", + m->header.command, plci->msg_in_write_pos, plci->msg_in_read_pos, plci->msg_in_wrap_pos)); + if (plci->msg_in_read_pos == plci->msg_in_wrap_pos) + { + plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE; + plci->msg_in_read_pos = i + MSG_IN_OVERHEAD; + } + else + { + plci->msg_in_read_pos = j + i + MSG_IN_OVERHEAD; + } + if (plci->msg_in_read_pos == plci->msg_in_write_pos) + { + plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE; + plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE; + } + else if (plci->msg_in_read_pos == plci->msg_in_wrap_pos) + { + plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE; + plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE; + } + i = api_put(appl, m); + if (i != 0) + { + if (m->header.command == _DATA_B3_R) + + TransmitBufferFree(appl, (byte *)(long)(m->info.data_b3_req.Data)); + + dbug(1, dprintf("Error 0x%04x from msg(0x%04x)", i, m->header.command)); + break; + } + + if (plci->li_notify_update) + { + plci->li_notify_update = false; + mixer_notify_update(plci, false); + } + + } + send_data(plci); + send_req(plci); +} + + +static void control_rc(PLCI *plci, byte req, byte rc, byte ch, byte global_req, + byte nl_rc) +{ + dword Id; + dword rId; + word Number; + word Info = 0; + word i; + word ncci; + DIVA_CAPI_ADAPTER *a; + APPL *appl; + PLCI *rplci; + byte SSparms[] = "\x05\x00\x00\x02\x00\x00"; + byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00"; + + if (!plci) { + dbug(0, dprintf("A: control_rc, no plci %02x:%02x:%02x:%02x:%02x", req, rc, ch, global_req, nl_rc)); + return; + } + dbug(1, dprintf("req0_in/out=%d/%d", plci->req_in, plci->req_out)); + if (plci->req_in != plci->req_out) + { + if (nl_rc || (global_req != ASSIGN) || (rc == ASSIGN_OK)) + { + dbug(1, dprintf("req_1return")); + return; + } + /* cancel outstanding request on the PLCI after SIG ASSIGN failure */ + } + plci->req_in = plci->req_in_start = plci->req_out = 0; + dbug(1, dprintf("control_rc")); + + appl = plci->appl; + a = plci->adapter; + ncci = a->ch_ncci[ch]; + if (appl) + { + Id = (((dword)(ncci ? ncci : ch)) << 16) | ((word)plci->Id << 8) | a->Id; + if (plci->tel && plci->SuppState != CALL_HELD) Id |= EXT_CONTROLLER; + Number = plci->number; + dbug(1, dprintf("Contr_RC-Id=%08lx,plci=%x,tel=%x, entity=0x%x, command=0x%x, int_command=0x%x", Id, plci->Id, plci->tel, plci->Sig.Id, plci->command, plci->internal_command)); + dbug(1, dprintf("channels=0x%x", plci->channels)); + if (plci_remove_check(plci)) + return; + if (req == REMOVE && rc == ASSIGN_OK) + { + sig_req(plci, HANGUP, 0); + sig_req(plci, REMOVE, 0); + send_req(plci); + } + if (plci->command) + { + switch (plci->command) + { + case C_HOLD_REQ: + dbug(1, dprintf("HoldRC=0x%x", rc)); + SSparms[1] = (byte)S_HOLD; + if (rc != OK) + { + plci->SuppState = IDLE; + Info = 0x2001; + } + sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", Info, 3, SSparms); + break; + + case C_RETRIEVE_REQ: + dbug(1, dprintf("RetrieveRC=0x%x", rc)); + SSparms[1] = (byte)S_RETRIEVE; + if (rc != OK) + { + plci->SuppState = CALL_HELD; + Info = 0x2001; + } + sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", Info, 3, SSparms); + break; + + case _INFO_R: + dbug(1, dprintf("InfoRC=0x%x", rc)); + if (rc != OK) Info = _WRONG_STATE; + sendf(appl, _INFO_R | CONFIRM, Id, Number, "w", Info); + break; + + case _CONNECT_R: + dbug(1, dprintf("Connect_R=0x%x/0x%x/0x%x/0x%x", req, rc, global_req, nl_rc)); + if (plci->State == INC_DIS_PENDING) + break; + if (plci->Sig.Id != 0xff) + { + if (((global_req == ASSIGN) && (rc != ASSIGN_OK)) + || (!nl_rc && (req == CALL_REQ) && (rc != OK))) + { + dbug(1, dprintf("No more IDs/Call_Req failed")); + sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI); + plci_remove(plci); + plci->State = IDLE; + break; + } + if (plci->State != LOCAL_CONNECT) plci->State = OUTG_CON_PENDING; + sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0); + } + else /* D-ch activation */ + { + if (rc != ASSIGN_OK) + { + dbug(1, dprintf("No more IDs/X.25 Call_Req failed")); + sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI); + plci_remove(plci); + plci->State = IDLE; + break; + } + sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0); + sendf(plci->appl, _CONNECT_ACTIVE_I, Id, 0, "sss", "", "", ""); + plci->State = INC_ACT_PENDING; + } + break; + + case _CONNECT_I | RESPONSE: + if (plci->State != INC_DIS_PENDING) + plci->State = INC_CON_ACCEPT; + break; + + case _DISCONNECT_R: + if (plci->State == INC_DIS_PENDING) + break; + if (plci->Sig.Id != 0xff) + { + plci->State = OUTG_DIS_PENDING; + sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", 0); + } + break; + + case SUSPEND_REQ: + break; + + case RESUME_REQ: + break; + + case _CONNECT_B3_R: + if (rc != OK) + { + sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", _WRONG_IDENTIFIER); + break; + } + ncci = get_ncci(plci, ch, 0); + Id = (Id & 0xffff) | (((dword) ncci) << 16); + plci->channels++; + if (req == N_RESET) + { + a->ncci_state[ncci] = INC_ACT_PENDING; + sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", 0); + sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", ""); + } + else + { + a->ncci_state[ncci] = OUTG_CON_PENDING; + sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", 0); + } + break; + + case _CONNECT_B3_I | RESPONSE: + break; + + case _RESET_B3_R: +/* sendf(appl, _RESET_B3_R | CONFIRM, Id, Number, "w", 0);*/ + break; + + case _DISCONNECT_B3_R: + sendf(appl, _DISCONNECT_B3_R | CONFIRM, Id, Number, "w", 0); + break; + + case _MANUFACTURER_R: + break; + + case PERM_LIST_REQ: + if (rc != OK) + { + Info = _WRONG_IDENTIFIER; + sendf(plci->appl, _CONNECT_R | CONFIRM, Id, Number, "w", Info); + plci_remove(plci); + } + else + sendf(plci->appl, _CONNECT_R | CONFIRM, Id, Number, "w", Info); + break; + + default: + break; + } + plci->command = 0; + } + else if (plci->internal_command) + { + switch (plci->internal_command) + { + case BLOCK_PLCI: + return; + + case GET_MWI_STATE: + if (rc == OK) /* command supported, wait for indication */ + { + return; + } + plci_remove(plci); + break; + + /* Get Supported Services */ + case GETSERV_REQ_PEND: + if (rc == OK) /* command supported, wait for indication */ + { + break; + } + PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY); + sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", 0, 3, SSstruct); + plci_remove(plci); + break; + + case INTERR_DIVERSION_REQ_PEND: /* Interrogate Parameters */ + case INTERR_NUMBERS_REQ_PEND: + case CF_START_PEND: /* Call Forwarding Start pending */ + case CF_STOP_PEND: /* Call Forwarding Stop pending */ + case CCBS_REQUEST_REQ_PEND: + case CCBS_DEACTIVATE_REQ_PEND: + case CCBS_INTERROGATE_REQ_PEND: + switch (plci->internal_command) + { + case INTERR_DIVERSION_REQ_PEND: + SSparms[1] = S_INTERROGATE_DIVERSION; + break; + case INTERR_NUMBERS_REQ_PEND: + SSparms[1] = S_INTERROGATE_NUMBERS; + break; + case CF_START_PEND: + SSparms[1] = S_CALL_FORWARDING_START; + break; + case CF_STOP_PEND: + SSparms[1] = S_CALL_FORWARDING_STOP; + break; + case CCBS_REQUEST_REQ_PEND: + SSparms[1] = S_CCBS_REQUEST; + break; + case CCBS_DEACTIVATE_REQ_PEND: + SSparms[1] = S_CCBS_DEACTIVATE; + break; + case CCBS_INTERROGATE_REQ_PEND: + SSparms[1] = S_CCBS_INTERROGATE; + break; + } + if (global_req == ASSIGN) + { + dbug(1, dprintf("AssignDiversion_RC=0x%x/0x%x", req, rc)); + return; + } + if (!plci->appl) break; + if (rc == ISDN_GUARD_REJ) + { + Info = _CAPI_GUARD_ERROR; + } + else if (rc != OK) + { + Info = _SUPPLEMENTARY_SERVICE_NOT_SUPPORTED; + } + sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0x7, + plci->number, "wws", Info, (word)3, SSparms); + if (Info) plci_remove(plci); + break; + + /* 3pty conference pending */ + case PTY_REQ_PEND: + if (!plci->relatedPTYPLCI) break; + rplci = plci->relatedPTYPLCI; + SSparms[1] = plci->ptyState; + rId = ((word)rplci->Id << 8) | rplci->adapter->Id; + if (rplci->tel) rId |= EXT_CONTROLLER; + if (rc != OK) + { + Info = 0x300E; /* not supported */ + plci->relatedPTYPLCI = NULL; + plci->ptyState = 0; + } + sendf(rplci->appl, + _FACILITY_R | CONFIRM, + rId, + plci->number, + "wws", Info, (word)3, SSparms); + break; + + /* Explicit Call Transfer pending */ + case ECT_REQ_PEND: + dbug(1, dprintf("ECT_RC=0x%x/0x%x", req, rc)); + if (!plci->relatedPTYPLCI) break; + rplci = plci->relatedPTYPLCI; + SSparms[1] = S_ECT; + rId = ((word)rplci->Id << 8) | rplci->adapter->Id; + if (rplci->tel) rId |= EXT_CONTROLLER; + if (rc != OK) + { + Info = 0x300E; /* not supported */ + plci->relatedPTYPLCI = NULL; + plci->ptyState = 0; + } + sendf(rplci->appl, + _FACILITY_R | CONFIRM, + rId, + plci->number, + "wws", Info, (word)3, SSparms); + break; + + case _MANUFACTURER_R: + dbug(1, dprintf("_Manufacturer_R=0x%x/0x%x", req, rc)); + if ((global_req == ASSIGN) && (rc != ASSIGN_OK)) + { + dbug(1, dprintf("No more IDs")); + sendf(appl, _MANUFACTURER_R | CONFIRM, Id, Number, "dww", _DI_MANU_ID, _MANUFACTURER_R, _OUT_OF_PLCI); + plci_remove(plci); /* after codec init, internal codec commands pending */ + } + break; + + case _CONNECT_R: + dbug(1, dprintf("_Connect_R=0x%x/0x%x", req, rc)); + if ((global_req == ASSIGN) && (rc != ASSIGN_OK)) + { + dbug(1, dprintf("No more IDs")); + sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI); + plci_remove(plci); /* after codec init, internal codec commands pending */ + } + break; + + case PERM_COD_HOOK: /* finished with Hook_Ind */ + return; + + case PERM_COD_CALL: + dbug(1, dprintf("***Codec Connect_Pending A, Rc = 0x%x", rc)); + plci->internal_command = PERM_COD_CONN_PEND; + return; + + case PERM_COD_ASSIGN: + dbug(1, dprintf("***Codec Assign A, Rc = 0x%x", rc)); + if (rc != ASSIGN_OK) break; + sig_req(plci, CALL_REQ, 0); + send_req(plci); + plci->internal_command = PERM_COD_CALL; + return; + + /* Null Call Reference Request pending */ + case C_NCR_FAC_REQ: + dbug(1, dprintf("NCR_FAC=0x%x/0x%x", req, rc)); + if (global_req == ASSIGN) + { + if (rc == ASSIGN_OK) + { + return; + } + else + { + sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", _WRONG_STATE); + appl->NullCREnable = false; + plci_remove(plci); + } + } + else if (req == NCR_FACILITY) + { + if (rc == OK) + { + sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", 0); + } + else + { + sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", _WRONG_STATE); + appl->NullCREnable = false; + } + plci_remove(plci); + } + break; + + case HOOK_ON_REQ: + if (plci->channels) + { + if (a->ncci_state[ncci] == CONNECTED) + { + a->ncci_state[ncci] = OUTG_DIS_PENDING; + cleanup_ncci_data(plci, ncci); + nl_req_ncci(plci, N_DISC, (byte)ncci); + } + break; + } + break; + + case HOOK_OFF_REQ: + if (plci->State == INC_DIS_PENDING) + break; + sig_req(plci, CALL_REQ, 0); + send_req(plci); + plci->State = OUTG_CON_PENDING; + break; + + + case MWI_ACTIVATE_REQ_PEND: + case MWI_DEACTIVATE_REQ_PEND: + if (global_req == ASSIGN && rc == ASSIGN_OK) + { + dbug(1, dprintf("MWI_REQ assigned")); + return; + } + else if (rc != OK) + { + if (rc == WRONG_IE) + { + Info = 0x2007; /* Illegal message parameter coding */ + dbug(1, dprintf("MWI_REQ invalid parameter")); + } + else + { + Info = 0x300B; /* not supported */ + dbug(1, dprintf("MWI_REQ not supported")); + } + /* 0x3010: Request not allowed in this state */ + PUT_WORD(&SSparms[4], 0x300E); /* SS not supported */ + + } + if (plci->internal_command == MWI_ACTIVATE_REQ_PEND) + { + PUT_WORD(&SSparms[1], S_MWI_ACTIVATE); + } + else PUT_WORD(&SSparms[1], S_MWI_DEACTIVATE); + + if (plci->cr_enquiry) + { + sendf(plci->appl, + _FACILITY_R | CONFIRM, + Id & 0xf, + plci->number, + "wws", Info, (word)3, SSparms); + if (rc != OK) plci_remove(plci); + } + else + { + sendf(plci->appl, + _FACILITY_R | CONFIRM, + Id, + plci->number, + "wws", Info, (word)3, SSparms); + } + break; + + case CONF_BEGIN_REQ_PEND: + case CONF_ADD_REQ_PEND: + case CONF_SPLIT_REQ_PEND: + case CONF_DROP_REQ_PEND: + case CONF_ISOLATE_REQ_PEND: + case CONF_REATTACH_REQ_PEND: + dbug(1, dprintf("CONF_RC=0x%x/0x%x", req, rc)); + if ((plci->internal_command == CONF_ADD_REQ_PEND) && (!plci->relatedPTYPLCI)) break; + rplci = plci; + rId = Id; + switch (plci->internal_command) + { + case CONF_BEGIN_REQ_PEND: + SSparms[1] = S_CONF_BEGIN; + break; + case CONF_ADD_REQ_PEND: + SSparms[1] = S_CONF_ADD; + rplci = plci->relatedPTYPLCI; + rId = ((word)rplci->Id << 8) | rplci->adapter->Id; + break; + case CONF_SPLIT_REQ_PEND: + SSparms[1] = S_CONF_SPLIT; + break; + case CONF_DROP_REQ_PEND: + SSparms[1] = S_CONF_DROP; + break; + case CONF_ISOLATE_REQ_PEND: + SSparms[1] = S_CONF_ISOLATE; + break; + case CONF_REATTACH_REQ_PEND: + SSparms[1] = S_CONF_REATTACH; + break; + } + + if (rc != OK) + { + Info = 0x300E; /* not supported */ + plci->relatedPTYPLCI = NULL; + plci->ptyState = 0; + } + sendf(rplci->appl, + _FACILITY_R | CONFIRM, + rId, + plci->number, + "wws", Info, (word)3, SSparms); + break; + + case VSWITCH_REQ_PEND: + if (rc != OK) + { + if (plci->relatedPTYPLCI) + { + plci->relatedPTYPLCI->vswitchstate = 0; + plci->relatedPTYPLCI->vsprot = 0; + plci->relatedPTYPLCI->vsprotdialect = 0; + } + plci->vswitchstate = 0; + plci->vsprot = 0; + plci->vsprotdialect = 0; + } + else + { + if (plci->relatedPTYPLCI && + plci->vswitchstate == 1 && + plci->relatedPTYPLCI->vswitchstate == 3) /* join complete */ + plci->vswitchstate = 3; + } + break; + + /* Call Deflection Request pending (SSCT) */ + case CD_REQ_PEND: + SSparms[1] = S_CALL_DEFLECTION; + if (rc != OK) + { + Info = 0x300E; /* not supported */ + plci->appl->CDEnable = 0; + } + sendf(plci->appl, _FACILITY_R | CONFIRM, Id, + plci->number, "wws", Info, (word)3, SSparms); + break; + + case RTP_CONNECT_B3_REQ_COMMAND_2: + if (rc == OK) + { + ncci = get_ncci(plci, ch, 0); + Id = (Id & 0xffff) | (((dword) ncci) << 16); + plci->channels++; + a->ncci_state[ncci] = OUTG_CON_PENDING; + } + + default: + if (plci->internal_command_queue[0]) + { + (*(plci->internal_command_queue[0]))(Id, plci, rc); + if (plci->internal_command) + return; + } + break; + } + next_internal_command(Id, plci); + } + } + else /* appl==0 */ + { + Id = ((word)plci->Id << 8) | plci->adapter->Id; + if (plci->tel) Id |= EXT_CONTROLLER; + + switch (plci->internal_command) + { + case BLOCK_PLCI: + return; + + case START_L1_SIG_ASSIGN_PEND: + case REM_L1_SIG_ASSIGN_PEND: + if (global_req == ASSIGN) + { + break; + } + else + { + dbug(1, dprintf("***L1 Req rem PLCI")); + plci->internal_command = 0; + sig_req(plci, REMOVE, 0); + send_req(plci); + } + break; + + /* Call Deflection Request pending, just no appl ptr assigned */ + case CD_REQ_PEND: + SSparms[1] = S_CALL_DEFLECTION; + if (rc != OK) + { + Info = 0x300E; /* not supported */ + } + for (i = 0; i < max_appl; i++) + { + if (application[i].CDEnable) + { + if (!application[i].Id) application[i].CDEnable = 0; + else + { + sendf(&application[i], _FACILITY_R | CONFIRM, Id, + plci->number, "wws", Info, (word)3, SSparms); + if (Info) application[i].CDEnable = 0; + } + } + } + plci->internal_command = 0; + break; + + case PERM_COD_HOOK: /* finished with Hook_Ind */ + return; + + case PERM_COD_CALL: + plci->internal_command = PERM_COD_CONN_PEND; + dbug(1, dprintf("***Codec Connect_Pending, Rc = 0x%x", rc)); + return; + + case PERM_COD_ASSIGN: + dbug(1, dprintf("***Codec Assign, Rc = 0x%x", rc)); + plci->internal_command = 0; + if (rc != ASSIGN_OK) break; + plci->internal_command = PERM_COD_CALL; + sig_req(plci, CALL_REQ, 0); + send_req(plci); + return; + + case LISTEN_SIG_ASSIGN_PEND: + if (rc == ASSIGN_OK) + { + plci->internal_command = 0; + dbug(1, dprintf("ListenCheck, new SIG_ID = 0x%x", plci->Sig.Id)); + add_p(plci, ESC, "\x02\x18\x00"); /* support call waiting */ + sig_req(plci, INDICATE_REQ, 0); + send_req(plci); + } + else + { + dbug(1, dprintf("ListenCheck failed (assignRc=0x%x)", rc)); + a->listen_active--; + plci_remove(plci); + plci->State = IDLE; + } + break; + + case USELAW_REQ: + if (global_req == ASSIGN) + { + if (rc == ASSIGN_OK) + { + sig_req(plci, LAW_REQ, 0); + send_req(plci); + dbug(1, dprintf("Auto-Law assigned")); + } + else + { + dbug(1, dprintf("Auto-Law assign failed")); + a->automatic_law = 3; + plci->internal_command = 0; + a->automatic_lawPLCI = NULL; + } + break; + } + else if (req == LAW_REQ && rc == OK) + { + dbug(1, dprintf("Auto-Law initiated")); + a->automatic_law = 2; + plci->internal_command = 0; + } + else + { + dbug(1, dprintf("Auto-Law not supported")); + a->automatic_law = 3; + plci->internal_command = 0; + sig_req(plci, REMOVE, 0); + send_req(plci); + a->automatic_lawPLCI = NULL; + } + break; + } + plci_remove_check(plci); + } +} + +static void data_rc(PLCI *plci, byte ch) +{ + dword Id; + DIVA_CAPI_ADAPTER *a; + NCCI *ncci_ptr; + DATA_B3_DESC *data; + word ncci; + + if (plci->appl) + { + TransmitBufferFree(plci->appl, plci->data_sent_ptr); + a = plci->adapter; + ncci = a->ch_ncci[ch]; + if (ncci && (a->ncci_plci[ncci] == plci->Id)) + { + ncci_ptr = &(a->ncci[ncci]); + dbug(1, dprintf("data_out=%d, data_pending=%d", ncci_ptr->data_out, ncci_ptr->data_pending)); + if (ncci_ptr->data_pending) + { + data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]); + if (!(data->Flags & 4) && a->ncci_state[ncci]) + { + Id = (((dword)ncci) << 16) | ((word)plci->Id << 8) | a->Id; + if (plci->tel) Id |= EXT_CONTROLLER; + sendf(plci->appl, _DATA_B3_R | CONFIRM, Id, data->Number, + "ww", data->Handle, 0); + } + (ncci_ptr->data_out)++; + if (ncci_ptr->data_out == MAX_DATA_B3) + ncci_ptr->data_out = 0; + (ncci_ptr->data_pending)--; + } + } + } +} + +static void data_ack(PLCI *plci, byte ch) +{ + dword Id; + DIVA_CAPI_ADAPTER *a; + NCCI *ncci_ptr; + word ncci; + + a = plci->adapter; + ncci = a->ch_ncci[ch]; + ncci_ptr = &(a->ncci[ncci]); + if (ncci_ptr->data_ack_pending) + { + if (a->ncci_state[ncci] && (a->ncci_plci[ncci] == plci->Id)) + { + Id = (((dword)ncci) << 16) | ((word)plci->Id << 8) | a->Id; + if (plci->tel) Id |= EXT_CONTROLLER; + sendf(plci->appl, _DATA_B3_R | CONFIRM, Id, ncci_ptr->DataAck[ncci_ptr->data_ack_out].Number, + "ww", ncci_ptr->DataAck[ncci_ptr->data_ack_out].Handle, 0); + } + (ncci_ptr->data_ack_out)++; + if (ncci_ptr->data_ack_out == MAX_DATA_ACK) + ncci_ptr->data_ack_out = 0; + (ncci_ptr->data_ack_pending)--; + } +} + +static void sig_ind(PLCI *plci) +{ + dword x_Id; + dword Id; + dword rId; + word i; + word cip; + dword cip_mask; + byte *ie; + DIVA_CAPI_ADAPTER *a; + API_PARSE saved_parms[MAX_MSG_PARMS + 1]; +#define MAXPARMSIDS 31 + byte *parms[MAXPARMSIDS]; + byte *add_i[4]; + byte *multi_fac_parms[MAX_MULTI_IE]; + byte *multi_pi_parms[MAX_MULTI_IE]; + byte *multi_ssext_parms[MAX_MULTI_IE]; + byte *multi_CiPN_parms[MAX_MULTI_IE]; + + byte *multi_vswitch_parms[MAX_MULTI_IE]; + + byte ai_len; + byte *esc_chi = ""; + byte *esc_law = ""; + byte *pty_cai = ""; + byte *esc_cr = ""; + byte *esc_profile = ""; + + byte facility[256]; + PLCI *tplci = NULL; + byte chi[] = "\x02\x18\x01"; + byte voice_cai[] = "\x06\x14\x00\x00\x00\x00\x08"; + byte resume_cau[] = "\x05\x05\x00\x02\x00\x00"; + /* ESC_MSGTYPE must be the last but one message, a new IE has to be */ + /* included before the ESC_MSGTYPE and MAXPARMSIDS has to be incremented */ + /* SMSG is situated at the end because its 0 (for compatibility reasons */ + /* (see Info_Mask Bit 4, first IE. then the message type) */ + word parms_id[] = + {MAXPARMSIDS, CPN, 0xff, DSA, OSA, BC, LLC, HLC, ESC_CAUSE, DSP, DT, CHA, + UUI, CONG_RR, CONG_RNR, ESC_CHI, KEY, CHI, CAU, ESC_LAW, + RDN, RDX, CONN_NR, RIN, NI, CAI, ESC_CR, + CST, ESC_PROFILE, 0xff, ESC_MSGTYPE, SMSG}; + /* 14 FTY repl by ESC_CHI */ + /* 18 PI repl by ESC_LAW */ + /* removed OAD changed to 0xff for future use, OAD is multiIE now */ + word multi_fac_id[] = {1, FTY}; + word multi_pi_id[] = {1, PI}; + word multi_CiPN_id[] = {1, OAD}; + word multi_ssext_id[] = {1, ESC_SSEXT}; + + word multi_vswitch_id[] = {1, ESC_VSWITCH}; + + byte *cau; + word ncci; + byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/ + byte CF_Ind[] = "\x09\x02\x00\x06\x00\x00\x00\x00\x00\x00"; + byte Interr_Err_Ind[] = "\x0a\x02\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"; + byte CONF_Ind[] = "\x09\x16\x00\x06\x00\x00\x00\x00\x00\x00"; + byte force_mt_info = false; + byte dir; + dword d; + word w; + + a = plci->adapter; + Id = ((word)plci->Id << 8) | a->Id; + PUT_WORD(&SS_Ind[4], 0x0000); + + if (plci->sig_remove_id) + { + plci->Sig.RNR = 2; /* discard */ + dbug(1, dprintf("SIG discard while remove pending")); + return; + } + if (plci->tel && plci->SuppState != CALL_HELD) Id |= EXT_CONTROLLER; + dbug(1, dprintf("SigInd-Id=%08lx,plci=%x,tel=%x,state=0x%x,channels=%d,Discflowcl=%d", + Id, plci->Id, plci->tel, plci->State, plci->channels, plci->hangup_flow_ctrl_timer)); + if (plci->Sig.Ind == CALL_HOLD_ACK && plci->channels) + { + plci->Sig.RNR = 1; + return; + } + if (plci->Sig.Ind == HANGUP && plci->channels) + { + plci->Sig.RNR = 1; + plci->hangup_flow_ctrl_timer++; + /* recover the network layer after timeout */ + if (plci->hangup_flow_ctrl_timer == 100) + { + dbug(1, dprintf("Exceptional disc")); + plci->Sig.RNR = 0; + plci->hangup_flow_ctrl_timer = 0; + for (ncci = 1; ncci < MAX_NCCI + 1; ncci++) + { + if (a->ncci_plci[ncci] == plci->Id) + { + cleanup_ncci_data(plci, ncci); + if (plci->channels)plci->channels--; + if (plci->appl) + sendf(plci->appl, _DISCONNECT_B3_I, (((dword) ncci) << 16) | Id, 0, "ws", 0, ""); + } + } + if (plci->appl) + sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0); + plci_remove(plci); + plci->State = IDLE; + } + return; + } + + /* do first parse the info with no OAD in, because OAD will be converted */ + /* first the multiple facility IE, then mult. progress ind. */ + /* then the parameters for the info_ind + conn_ind */ + IndParse(plci, multi_fac_id, multi_fac_parms, MAX_MULTI_IE); + IndParse(plci, multi_pi_id, multi_pi_parms, MAX_MULTI_IE); + IndParse(plci, multi_ssext_id, multi_ssext_parms, MAX_MULTI_IE); + + IndParse(plci, multi_vswitch_id, multi_vswitch_parms, MAX_MULTI_IE); + + IndParse(plci, parms_id, parms, 0); + IndParse(plci, multi_CiPN_id, multi_CiPN_parms, MAX_MULTI_IE); + esc_chi = parms[14]; + esc_law = parms[18]; + pty_cai = parms[24]; + esc_cr = parms[25]; + esc_profile = parms[27]; + if (esc_cr[0] && plci) + { + if (plci->cr_enquiry && plci->appl) + { + plci->cr_enquiry = false; + /* d = MANU_ID */ + /* w = m_command */ + /* b = total length */ + /* b = indication type */ + /* b = length of all IEs */ + /* b = IE1 */ + /* S = IE1 length + cont. */ + /* b = IE2 */ + /* S = IE2 length + cont. */ + sendf(plci->appl, + _MANUFACTURER_I, + Id, + 0, + "dwbbbbSbS", _DI_MANU_ID, plci->m_command, + 2 + 1 + 1 + esc_cr[0] + 1 + 1 + esc_law[0], plci->Sig.Ind, 1 + 1 + esc_cr[0] + 1 + 1 + esc_law[0], ESC, esc_cr, ESC, esc_law); + } + } + /* create the additional info structure */ + add_i[1] = parms[15]; /* KEY of additional info */ + add_i[2] = parms[11]; /* UUI of additional info */ + ai_len = AddInfo(add_i, multi_fac_parms, esc_chi, facility); + + /* the ESC_LAW indicates if u-Law or a-Law is actually used by the card */ + /* indication returns by the card if requested by the function */ + /* AutomaticLaw() after driver init */ + if (a->automatic_law < 4) + { + if (esc_law[0]) { + if (esc_law[2]) { + dbug(0, dprintf("u-Law selected")); + a->u_law = 1; + } + else { + dbug(0, dprintf("a-Law selected")); + a->u_law = 0; + } + a->automatic_law = 4; + if (plci == a->automatic_lawPLCI) { + plci->internal_command = 0; + sig_req(plci, REMOVE, 0); + send_req(plci); + a->automatic_lawPLCI = NULL; + } + } + if (esc_profile[0]) + { + dbug(1, dprintf("[%06x] CardProfile: %lx %lx %lx %lx %lx", + UnMapController(a->Id), GET_DWORD(&esc_profile[6]), + GET_DWORD(&esc_profile[10]), GET_DWORD(&esc_profile[14]), + GET_DWORD(&esc_profile[18]), GET_DWORD(&esc_profile[46]))); + + a->profile.Global_Options &= 0x000000ffL; + a->profile.B1_Protocols &= 0x000003ffL; + a->profile.B2_Protocols &= 0x00001fdfL; + a->profile.B3_Protocols &= 0x000000b7L; + + a->profile.Global_Options &= GET_DWORD(&esc_profile[6]) | + GL_BCHANNEL_OPERATION_SUPPORTED; + a->profile.B1_Protocols &= GET_DWORD(&esc_profile[10]); + a->profile.B2_Protocols &= GET_DWORD(&esc_profile[14]); + a->profile.B3_Protocols &= GET_DWORD(&esc_profile[18]); + a->manufacturer_features = GET_DWORD(&esc_profile[46]); + a->man_profile.private_options = 0; + + if (a->manufacturer_features & MANUFACTURER_FEATURE_ECHO_CANCELLER) + { + a->man_profile.private_options |= 1L << PRIVATE_ECHO_CANCELLER; + a->profile.Global_Options |= GL_ECHO_CANCELLER_SUPPORTED; + } + + + if (a->manufacturer_features & MANUFACTURER_FEATURE_RTP) + a->man_profile.private_options |= 1L << PRIVATE_RTP; + a->man_profile.rtp_primary_payloads = GET_DWORD(&esc_profile[50]); + a->man_profile.rtp_additional_payloads = GET_DWORD(&esc_profile[54]); + + + if (a->manufacturer_features & MANUFACTURER_FEATURE_T38) + a->man_profile.private_options |= 1L << PRIVATE_T38; + + + if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_SUB_SEP_PWD) + a->man_profile.private_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD; + + + if (a->manufacturer_features & MANUFACTURER_FEATURE_V18) + a->man_profile.private_options |= 1L << PRIVATE_V18; + + + if (a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_TONE) + a->man_profile.private_options |= 1L << PRIVATE_DTMF_TONE; + + + if (a->manufacturer_features & MANUFACTURER_FEATURE_PIAFS) + a->man_profile.private_options |= 1L << PRIVATE_PIAFS; + + + if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS) + a->man_profile.private_options |= 1L << PRIVATE_FAX_PAPER_FORMATS; + + + if (a->manufacturer_features & MANUFACTURER_FEATURE_VOWN) + a->man_profile.private_options |= 1L << PRIVATE_VOWN; + + + if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_NONSTANDARD) + a->man_profile.private_options |= 1L << PRIVATE_FAX_NONSTANDARD; + + } + else + { + a->profile.Global_Options &= 0x0000007fL; + a->profile.B1_Protocols &= 0x000003dfL; + a->profile.B2_Protocols &= 0x00001adfL; + a->profile.B3_Protocols &= 0x000000b7L; + a->manufacturer_features &= MANUFACTURER_FEATURE_HARDDTMF; + } + if (a->manufacturer_features & (MANUFACTURER_FEATURE_HARDDTMF | + MANUFACTURER_FEATURE_SOFTDTMF_SEND | MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)) + { + a->profile.Global_Options |= GL_DTMF_SUPPORTED; + } + a->manufacturer_features &= ~MANUFACTURER_FEATURE_OOB_CHANNEL; + dbug(1, dprintf("[%06x] Profile: %lx %lx %lx %lx %lx", + UnMapController(a->Id), a->profile.Global_Options, + a->profile.B1_Protocols, a->profile.B2_Protocols, + a->profile.B3_Protocols, a->manufacturer_features)); + } + /* codec plci for the handset/hook state support is just an internal id */ + if (plci != a->AdvCodecPLCI) + { + force_mt_info = SendMultiIE(plci, Id, multi_fac_parms, FTY, 0x20, 0); + force_mt_info |= SendMultiIE(plci, Id, multi_pi_parms, PI, 0x210, 0); + SendSSExtInd(NULL, plci, Id, multi_ssext_parms); + SendInfo(plci, Id, parms, force_mt_info); + + VSwitchReqInd(plci, Id, multi_vswitch_parms); + + } + + /* switch the codec to the b-channel */ + if (esc_chi[0] && plci && !plci->SuppState) { + plci->b_channel = esc_chi[esc_chi[0]]&0x1f; + mixer_set_bchannel_id_esc(plci, plci->b_channel); + dbug(1, dprintf("storeChannel=0x%x", plci->b_channel)); + if (plci->tel == ADV_VOICE && plci->appl) { + SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a); + } + } + + if (plci->appl) plci->appl->Number++; + + switch (plci->Sig.Ind) { + /* Response to Get_Supported_Services request */ + case S_SUPPORTED: + dbug(1, dprintf("S_Supported")); + if (!plci->appl) break; + if (pty_cai[0] == 4) + { + PUT_DWORD(&CF_Ind[6], GET_DWORD(&pty_cai[1])); + } + else + { + PUT_DWORD(&CF_Ind[6], MASK_TERMINAL_PORTABILITY | MASK_HOLD_RETRIEVE); + } + PUT_WORD(&CF_Ind[1], 0); + PUT_WORD(&CF_Ind[4], 0); + sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0x7, plci->number, "wws", 0, 3, CF_Ind); + plci_remove(plci); + break; + + /* Supplementary Service rejected */ + case S_SERVICE_REJ: + dbug(1, dprintf("S_Reject=0x%x", pty_cai[5])); + if (!pty_cai[0]) break; + switch (pty_cai[5]) + { + case ECT_EXECUTE: + case THREE_PTY_END: + case THREE_PTY_BEGIN: + if (!plci->relatedPTYPLCI) break; + tplci = plci->relatedPTYPLCI; + rId = ((word)tplci->Id << 8) | tplci->adapter->Id; + if (tplci->tel) rId |= EXT_CONTROLLER; + if (pty_cai[5] == ECT_EXECUTE) + { + PUT_WORD(&SS_Ind[1], S_ECT); + + plci->vswitchstate = 0; + plci->relatedPTYPLCI->vswitchstate = 0; + + } + else + { + PUT_WORD(&SS_Ind[1], pty_cai[5] + 3); + } + if (pty_cai[2] != 0xff) + { + PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]); + } + else + { + PUT_WORD(&SS_Ind[4], 0x300E); + } + plci->relatedPTYPLCI = NULL; + plci->ptyState = 0; + sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind); + break; + + case CALL_DEFLECTION: + if (pty_cai[2] != 0xff) + { + PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]); + } + else + { + PUT_WORD(&SS_Ind[4], 0x300E); + } + PUT_WORD(&SS_Ind[1], pty_cai[5]); + for (i = 0; i < max_appl; i++) + { + if (application[i].CDEnable) + { + if (application[i].Id) sendf(&application[i], _FACILITY_I, Id, 0, "ws", 3, SS_Ind); + application[i].CDEnable = false; + } + } + break; + + case DEACTIVATION_DIVERSION: + case ACTIVATION_DIVERSION: + case DIVERSION_INTERROGATE_CFU: + case DIVERSION_INTERROGATE_CFB: + case DIVERSION_INTERROGATE_CFNR: + case DIVERSION_INTERROGATE_NUM: + case CCBS_REQUEST: + case CCBS_DEACTIVATE: + case CCBS_INTERROGATE: + if (!plci->appl) break; + if (pty_cai[2] != 0xff) + { + PUT_WORD(&Interr_Err_Ind[4], 0x3600 | (word)pty_cai[2]); + } + else + { + PUT_WORD(&Interr_Err_Ind[4], 0x300E); + } + switch (pty_cai[5]) + { + case DEACTIVATION_DIVERSION: + dbug(1, dprintf("Deact_Div")); + Interr_Err_Ind[0] = 0x9; + Interr_Err_Ind[3] = 0x6; + PUT_WORD(&Interr_Err_Ind[1], S_CALL_FORWARDING_STOP); + break; + case ACTIVATION_DIVERSION: + dbug(1, dprintf("Act_Div")); + Interr_Err_Ind[0] = 0x9; + Interr_Err_Ind[3] = 0x6; + PUT_WORD(&Interr_Err_Ind[1], S_CALL_FORWARDING_START); + break; + case DIVERSION_INTERROGATE_CFU: + case DIVERSION_INTERROGATE_CFB: + case DIVERSION_INTERROGATE_CFNR: + dbug(1, dprintf("Interr_Div")); + Interr_Err_Ind[0] = 0xa; + Interr_Err_Ind[3] = 0x7; + PUT_WORD(&Interr_Err_Ind[1], S_INTERROGATE_DIVERSION); + break; + case DIVERSION_INTERROGATE_NUM: + dbug(1, dprintf("Interr_Num")); + Interr_Err_Ind[0] = 0xa; + Interr_Err_Ind[3] = 0x7; + PUT_WORD(&Interr_Err_Ind[1], S_INTERROGATE_NUMBERS); + break; + case CCBS_REQUEST: + dbug(1, dprintf("CCBS Request")); + Interr_Err_Ind[0] = 0xd; + Interr_Err_Ind[3] = 0xa; + PUT_WORD(&Interr_Err_Ind[1], S_CCBS_REQUEST); + break; + case CCBS_DEACTIVATE: + dbug(1, dprintf("CCBS Deactivate")); + Interr_Err_Ind[0] = 0x9; + Interr_Err_Ind[3] = 0x6; + PUT_WORD(&Interr_Err_Ind[1], S_CCBS_DEACTIVATE); + break; + case CCBS_INTERROGATE: + dbug(1, dprintf("CCBS Interrogate")); + Interr_Err_Ind[0] = 0xb; + Interr_Err_Ind[3] = 0x8; + PUT_WORD(&Interr_Err_Ind[1], S_CCBS_INTERROGATE); + break; + } + PUT_DWORD(&Interr_Err_Ind[6], plci->appl->S_Handle); + sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "ws", 3, Interr_Err_Ind); + plci_remove(plci); + break; + case ACTIVATION_MWI: + case DEACTIVATION_MWI: + if (pty_cai[5] == ACTIVATION_MWI) + { + PUT_WORD(&SS_Ind[1], S_MWI_ACTIVATE); + } + else PUT_WORD(&SS_Ind[1], S_MWI_DEACTIVATE); + + if (pty_cai[2] != 0xff) + { + PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]); + } + else + { + PUT_WORD(&SS_Ind[4], 0x300E); + } + + if (plci->cr_enquiry) + { + sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "ws", 3, SS_Ind); + plci_remove(plci); + } + else + { + sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind); + } + break; + case CONF_ADD: /* ERROR */ + case CONF_BEGIN: + case CONF_DROP: + case CONF_ISOLATE: + case CONF_REATTACH: + CONF_Ind[0] = 9; + CONF_Ind[3] = 6; + switch (pty_cai[5]) + { + case CONF_BEGIN: + PUT_WORD(&CONF_Ind[1], S_CONF_BEGIN); + plci->ptyState = 0; + break; + case CONF_DROP: + CONF_Ind[0] = 5; + CONF_Ind[3] = 2; + PUT_WORD(&CONF_Ind[1], S_CONF_DROP); + plci->ptyState = CONNECTED; + break; + case CONF_ISOLATE: + CONF_Ind[0] = 5; + CONF_Ind[3] = 2; + PUT_WORD(&CONF_Ind[1], S_CONF_ISOLATE); + plci->ptyState = CONNECTED; + break; + case CONF_REATTACH: + CONF_Ind[0] = 5; + CONF_Ind[3] = 2; + PUT_WORD(&CONF_Ind[1], S_CONF_REATTACH); + plci->ptyState = CONNECTED; + break; + case CONF_ADD: + PUT_WORD(&CONF_Ind[1], S_CONF_ADD); + plci->relatedPTYPLCI = NULL; + tplci = plci->relatedPTYPLCI; + if (tplci) tplci->ptyState = CONNECTED; + plci->ptyState = CONNECTED; + break; + } + + if (pty_cai[2] != 0xff) + { + PUT_WORD(&CONF_Ind[4], 0x3600 | (word)pty_cai[2]); + } + else + { + PUT_WORD(&CONF_Ind[4], 0x3303); /* Time-out: network did not respond + within the required time */ + } + + PUT_DWORD(&CONF_Ind[6], 0x0); + sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind); + break; + } + break; + + /* Supplementary Service indicates success */ + case S_SERVICE: + dbug(1, dprintf("Service_Ind")); + PUT_WORD(&CF_Ind[4], 0); + switch (pty_cai[5]) + { + case THREE_PTY_END: + case THREE_PTY_BEGIN: + case ECT_EXECUTE: + if (!plci->relatedPTYPLCI) break; + tplci = plci->relatedPTYPLCI; + rId = ((word)tplci->Id << 8) | tplci->adapter->Id; + if (tplci->tel) rId |= EXT_CONTROLLER; + if (pty_cai[5] == ECT_EXECUTE) + { + PUT_WORD(&SS_Ind[1], S_ECT); + + if (plci->vswitchstate != 3) + { + + plci->ptyState = IDLE; + plci->relatedPTYPLCI = NULL; + plci->ptyState = 0; + + } + + dbug(1, dprintf("ECT OK")); + sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind); + + + + } + else + { + switch (plci->ptyState) + { + case S_3PTY_BEGIN: + plci->ptyState = CONNECTED; + dbug(1, dprintf("3PTY ON")); + break; + + case S_3PTY_END: + plci->ptyState = IDLE; + plci->relatedPTYPLCI = NULL; + plci->ptyState = 0; + dbug(1, dprintf("3PTY OFF")); + break; + } + PUT_WORD(&SS_Ind[1], pty_cai[5] + 3); + sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind); + } + break; + + case CALL_DEFLECTION: + PUT_WORD(&SS_Ind[1], pty_cai[5]); + for (i = 0; i < max_appl; i++) + { + if (application[i].CDEnable) + { + if (application[i].Id) sendf(&application[i], _FACILITY_I, Id, 0, "ws", 3, SS_Ind); + application[i].CDEnable = false; + } + } + break; + + case DEACTIVATION_DIVERSION: + case ACTIVATION_DIVERSION: + if (!plci->appl) break; + PUT_WORD(&CF_Ind[1], pty_cai[5] + 2); + PUT_DWORD(&CF_Ind[6], plci->appl->S_Handle); + sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "ws", 3, CF_Ind); + plci_remove(plci); + break; + + case DIVERSION_INTERROGATE_CFU: + case DIVERSION_INTERROGATE_CFB: + case DIVERSION_INTERROGATE_CFNR: + case DIVERSION_INTERROGATE_NUM: + case CCBS_REQUEST: + case CCBS_DEACTIVATE: + case CCBS_INTERROGATE: + if (!plci->appl) break; + switch (pty_cai[5]) + { + case DIVERSION_INTERROGATE_CFU: + case DIVERSION_INTERROGATE_CFB: + case DIVERSION_INTERROGATE_CFNR: + dbug(1, dprintf("Interr_Div")); + PUT_WORD(&pty_cai[1], S_INTERROGATE_DIVERSION); + pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */ + break; + case DIVERSION_INTERROGATE_NUM: + dbug(1, dprintf("Interr_Num")); + PUT_WORD(&pty_cai[1], S_INTERROGATE_NUMBERS); + pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */ + break; + case CCBS_REQUEST: + dbug(1, dprintf("CCBS Request")); + PUT_WORD(&pty_cai[1], S_CCBS_REQUEST); + pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */ + break; + case CCBS_DEACTIVATE: + dbug(1, dprintf("CCBS Deactivate")); + PUT_WORD(&pty_cai[1], S_CCBS_DEACTIVATE); + pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */ + break; + case CCBS_INTERROGATE: + dbug(1, dprintf("CCBS Interrogate")); + PUT_WORD(&pty_cai[1], S_CCBS_INTERROGATE); + pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */ + break; + } + PUT_WORD(&pty_cai[4], 0); /* Supplementary Service Reason */ + PUT_DWORD(&pty_cai[6], plci->appl->S_Handle); + sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "wS", 3, pty_cai); + plci_remove(plci); + break; + + case ACTIVATION_MWI: + case DEACTIVATION_MWI: + if (pty_cai[5] == ACTIVATION_MWI) + { + PUT_WORD(&SS_Ind[1], S_MWI_ACTIVATE); + } + else PUT_WORD(&SS_Ind[1], S_MWI_DEACTIVATE); + if (plci->cr_enquiry) + { + sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "ws", 3, SS_Ind); + plci_remove(plci); + } + else + { + sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind); + } + break; + case MWI_INDICATION: + if (pty_cai[0] >= 0x12) + { + PUT_WORD(&pty_cai[3], S_MWI_INDICATE); + pty_cai[2] = pty_cai[0] - 2; /* len Parameter */ + pty_cai[5] = pty_cai[0] - 5; /* Supplementary Service-specific parameter len */ + if (plci->appl && (a->Notification_Mask[plci->appl->Id - 1] & SMASK_MWI)) + { + if (plci->internal_command == GET_MWI_STATE) /* result on Message Waiting Listen */ + { + sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "wS", 3, &pty_cai[2]); + plci_remove(plci); + return; + } + else sendf(plci->appl, _FACILITY_I, Id, 0, "wS", 3, &pty_cai[2]); + pty_cai[0] = 0; + } + else + { + for (i = 0; i < max_appl; i++) + { + if (a->Notification_Mask[i]&SMASK_MWI) + { + sendf(&application[i], _FACILITY_I, Id & 0x7, 0, "wS", 3, &pty_cai[2]); + pty_cai[0] = 0; + } + } + } + + if (!pty_cai[0]) + { /* acknowledge */ + facility[2] = 0; /* returncode */ + } + else facility[2] = 0xff; + } + else + { + /* reject */ + facility[2] = 0xff; /* returncode */ + } + facility[0] = 2; + facility[1] = MWI_RESPONSE; /* Function */ + add_p(plci, CAI, facility); + add_p(plci, ESC, multi_ssext_parms[0]); /* remembered parameter -> only one possible */ + sig_req(plci, S_SERVICE, 0); + send_req(plci); + plci->command = 0; + next_internal_command(Id, plci); + break; + case CONF_ADD: /* OK */ + case CONF_BEGIN: + case CONF_DROP: + case CONF_ISOLATE: + case CONF_REATTACH: + case CONF_PARTYDISC: + CONF_Ind[0] = 9; + CONF_Ind[3] = 6; + switch (pty_cai[5]) + { + case CONF_BEGIN: + PUT_WORD(&CONF_Ind[1], S_CONF_BEGIN); + if (pty_cai[0] == 6) + { + d = pty_cai[6]; + PUT_DWORD(&CONF_Ind[6], d); /* PartyID */ + } + else + { + PUT_DWORD(&CONF_Ind[6], 0x0); + } + break; + case CONF_ISOLATE: + PUT_WORD(&CONF_Ind[1], S_CONF_ISOLATE); + CONF_Ind[0] = 5; + CONF_Ind[3] = 2; + break; + case CONF_REATTACH: + PUT_WORD(&CONF_Ind[1], S_CONF_REATTACH); + CONF_Ind[0] = 5; + CONF_Ind[3] = 2; + break; + case CONF_DROP: + PUT_WORD(&CONF_Ind[1], S_CONF_DROP); + CONF_Ind[0] = 5; + CONF_Ind[3] = 2; + break; + case CONF_ADD: + PUT_WORD(&CONF_Ind[1], S_CONF_ADD); + d = pty_cai[6]; + PUT_DWORD(&CONF_Ind[6], d); /* PartyID */ + tplci = plci->relatedPTYPLCI; + if (tplci) tplci->ptyState = CONNECTED; + break; + case CONF_PARTYDISC: + CONF_Ind[0] = 7; + CONF_Ind[3] = 4; + PUT_WORD(&CONF_Ind[1], S_CONF_PARTYDISC); + d = pty_cai[6]; + PUT_DWORD(&CONF_Ind[4], d); /* PartyID */ + break; + } + plci->ptyState = CONNECTED; + sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind); + break; + case CCBS_INFO_RETAIN: + case CCBS_ERASECALLLINKAGEID: + case CCBS_STOP_ALERTING: + CONF_Ind[0] = 5; + CONF_Ind[3] = 2; + switch (pty_cai[5]) + { + case CCBS_INFO_RETAIN: + PUT_WORD(&CONF_Ind[1], S_CCBS_INFO_RETAIN); + break; + case CCBS_STOP_ALERTING: + PUT_WORD(&CONF_Ind[1], S_CCBS_STOP_ALERTING); + break; + case CCBS_ERASECALLLINKAGEID: + PUT_WORD(&CONF_Ind[1], S_CCBS_ERASECALLLINKAGEID); + CONF_Ind[0] = 7; + CONF_Ind[3] = 4; + CONF_Ind[6] = 0; + CONF_Ind[7] = 0; + break; + } + w = pty_cai[6]; + PUT_WORD(&CONF_Ind[4], w); /* PartyID */ + + if (plci->appl && (a->Notification_Mask[plci->appl->Id - 1] & SMASK_CCBS)) + { + sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind); + } + else + { + for (i = 0; i < max_appl; i++) + if (a->Notification_Mask[i] & SMASK_CCBS) + sendf(&application[i], _FACILITY_I, Id & 0x7, 0, "ws", 3, CONF_Ind); + } + break; + } + break; + case CALL_HOLD_REJ: + cau = parms[7]; + if (cau) + { + i = _L3_CAUSE | cau[2]; + if (cau[2] == 0) i = 0x3603; + } + else + { + i = 0x3603; + } + PUT_WORD(&SS_Ind[1], S_HOLD); + PUT_WORD(&SS_Ind[4], i); + if (plci->SuppState == HOLD_REQUEST) + { + plci->SuppState = IDLE; + sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind); + } + break; + + case CALL_HOLD_ACK: + if (plci->SuppState == HOLD_REQUEST) + { + plci->SuppState = CALL_HELD; + CodecIdCheck(a, plci); + start_internal_command(Id, plci, hold_save_command); + } + break; + + case CALL_RETRIEVE_REJ: + cau = parms[7]; + if (cau) + { + i = _L3_CAUSE | cau[2]; + if (cau[2] == 0) i = 0x3603; + } + else + { + i = 0x3603; + } + PUT_WORD(&SS_Ind[1], S_RETRIEVE); + PUT_WORD(&SS_Ind[4], i); + if (plci->SuppState == RETRIEVE_REQUEST) + { + plci->SuppState = CALL_HELD; + CodecIdCheck(a, plci); + sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind); + } + break; + + case CALL_RETRIEVE_ACK: + PUT_WORD(&SS_Ind[1], S_RETRIEVE); + if (plci->SuppState == RETRIEVE_REQUEST) + { + plci->SuppState = IDLE; + plci->call_dir |= CALL_DIR_FORCE_OUTG_NL; + plci->b_channel = esc_chi[esc_chi[0]]&0x1f; + if (plci->tel) + { + mixer_set_bchannel_id_esc(plci, plci->b_channel); + dbug(1, dprintf("RetrChannel=0x%x", plci->b_channel)); + SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a); + if (plci->B2_prot == B2_TRANSPARENT && plci->B3_prot == B3_TRANSPARENT) + { + dbug(1, dprintf("Get B-ch")); + start_internal_command(Id, plci, retrieve_restore_command); + } + else + sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind); + } + else + start_internal_command(Id, plci, retrieve_restore_command); + } + break; + + case INDICATE_IND: + if (plci->State != LISTENING) { + sig_req(plci, HANGUP, 0); + send_req(plci); + break; + } + cip = find_cip(a, parms[4], parms[6]); + cip_mask = 1L << cip; + dbug(1, dprintf("cip=%d,cip_mask=%lx", cip, cip_mask)); + clear_c_ind_mask(plci); + if (!remove_started && !a->adapter_disabled) + { + set_c_ind_mask_bit(plci, MAX_APPL); + group_optimization(a, plci); + for (i = 0; i < max_appl; i++) { + if (application[i].Id + && (a->CIP_Mask[i] & 1 || a->CIP_Mask[i] & cip_mask) + && CPN_filter_ok(parms[0], a, i) + && test_group_ind_mask_bit(plci, i)) { + dbug(1, dprintf("storedcip_mask[%d]=0x%lx", i, a->CIP_Mask[i])); + set_c_ind_mask_bit(plci, i); + dump_c_ind_mask(plci); + plci->State = INC_CON_PENDING; + plci->call_dir = (plci->call_dir & ~(CALL_DIR_OUT | CALL_DIR_ORIGINATE)) | + CALL_DIR_IN | CALL_DIR_ANSWER; + if (esc_chi[0]) { + plci->b_channel = esc_chi[esc_chi[0]] & 0x1f; + mixer_set_bchannel_id_esc(plci, plci->b_channel); + } + /* if a listen on the ext controller is done, check if hook states */ + /* are supported or if just a on board codec must be activated */ + if (a->codec_listen[i] && !a->AdvSignalPLCI) { + if (a->profile.Global_Options & HANDSET) + plci->tel = ADV_VOICE; + else if (a->profile.Global_Options & ON_BOARD_CODEC) + plci->tel = CODEC; + if (plci->tel) Id |= EXT_CONTROLLER; + a->codec_listen[i] = plci; + } + + sendf(&application[i], _CONNECT_I, Id, 0, + "wSSSSSSSbSSSSS", cip, /* CIP */ + parms[0], /* CalledPartyNumber */ + multi_CiPN_parms[0], /* CallingPartyNumber */ + parms[2], /* CalledPartySubad */ + parms[3], /* CallingPartySubad */ + parms[4], /* BearerCapability */ + parms[5], /* LowLC */ + parms[6], /* HighLC */ + ai_len, /* nested struct add_i */ + add_i[0], /* B channel info */ + add_i[1], /* keypad facility */ + add_i[2], /* user user data */ + add_i[3], /* nested facility */ + multi_CiPN_parms[1] /* second CiPN(SCR) */ + ); + SendSSExtInd(&application[i], + plci, + Id, + multi_ssext_parms); + SendSetupInfo(&application[i], + plci, + Id, + parms, + SendMultiIE(plci, Id, multi_pi_parms, PI, 0x210, true)); + } + } + clear_c_ind_mask_bit(plci, MAX_APPL); + dump_c_ind_mask(plci); + } + if (c_ind_mask_empty(plci)) { + sig_req(plci, HANGUP, 0); + send_req(plci); + plci->State = IDLE; + } + plci->notifiedcall = 0; + a->listen_active--; + listen_check(a); + break; + + case CALL_PEND_NOTIFY: + plci->notifiedcall = 1; + listen_check(a); + break; + + case CALL_IND: + case CALL_CON: + if (plci->State == ADVANCED_VOICE_SIG || plci->State == ADVANCED_VOICE_NOSIG) + { + if (plci->internal_command == PERM_COD_CONN_PEND) + { + if (plci->State == ADVANCED_VOICE_NOSIG) + { + dbug(1, dprintf("***Codec OK")); + if (a->AdvSignalPLCI) + { + tplci = a->AdvSignalPLCI; + if (tplci->spoofed_msg) + { + dbug(1, dprintf("***Spoofed Msg(0x%x)", tplci->spoofed_msg)); + tplci->command = 0; + tplci->internal_command = 0; + x_Id = ((word)tplci->Id << 8) | tplci->adapter->Id | 0x80; + switch (tplci->spoofed_msg) + { + case CALL_RES: + tplci->command = _CONNECT_I | RESPONSE; + api_load_msg(&tplci->saved_msg, saved_parms); + add_b1(tplci, &saved_parms[1], 0, tplci->B1_facilities); + if (tplci->adapter->Info_Mask[tplci->appl->Id - 1] & 0x200) + { + /* early B3 connect (CIP mask bit 9) no release after a disc */ + add_p(tplci, LLI, "\x01\x01"); + } + add_s(tplci, CONN_NR, &saved_parms[2]); + add_s(tplci, LLC, &saved_parms[4]); + add_ai(tplci, &saved_parms[5]); + tplci->State = INC_CON_ACCEPT; + sig_req(tplci, CALL_RES, 0); + send_req(tplci); + break; + + case AWAITING_SELECT_B: + dbug(1, dprintf("Select_B continue")); + start_internal_command(x_Id, tplci, select_b_command); + break; + + case AWAITING_MANUF_CON: /* Get_Plci per Manufacturer_Req to ext controller */ + if (!tplci->Sig.Id) + { + dbug(1, dprintf("No SigID!")); + sendf(tplci->appl, _MANUFACTURER_R | CONFIRM, x_Id, tplci->number, "dww", _DI_MANU_ID, _MANUFACTURER_R, _OUT_OF_PLCI); + plci_remove(tplci); + break; + } + tplci->command = _MANUFACTURER_R; + api_load_msg(&tplci->saved_msg, saved_parms); + dir = saved_parms[2].info[0]; + if (dir == 1) { + sig_req(tplci, CALL_REQ, 0); + } + else if (!dir) { + sig_req(tplci, LISTEN_REQ, 0); + } + send_req(tplci); + sendf(tplci->appl, _MANUFACTURER_R | CONFIRM, x_Id, tplci->number, "dww", _DI_MANU_ID, _MANUFACTURER_R, 0); + break; + + case (CALL_REQ | AWAITING_MANUF_CON): + sig_req(tplci, CALL_REQ, 0); + send_req(tplci); + break; + + case CALL_REQ: + if (!tplci->Sig.Id) + { + dbug(1, dprintf("No SigID!")); + sendf(tplci->appl, _CONNECT_R | CONFIRM, tplci->adapter->Id, 0, "w", _OUT_OF_PLCI); + plci_remove(tplci); + break; + } + tplci->command = _CONNECT_R; + api_load_msg(&tplci->saved_msg, saved_parms); + add_s(tplci, CPN, &saved_parms[1]); + add_s(tplci, DSA, &saved_parms[3]); + add_ai(tplci, &saved_parms[9]); + sig_req(tplci, CALL_REQ, 0); + send_req(tplci); + break; + + case CALL_RETRIEVE: + tplci->command = C_RETRIEVE_REQ; + sig_req(tplci, CALL_RETRIEVE, 0); + send_req(tplci); + break; + } + tplci->spoofed_msg = 0; + if (tplci->internal_command == 0) + next_internal_command(x_Id, tplci); + } + } + next_internal_command(Id, plci); + break; + } + dbug(1, dprintf("***Codec Hook Init Req")); + plci->internal_command = PERM_COD_HOOK; + add_p(plci, FTY, "\x01\x09"); /* Get Hook State*/ + sig_req(plci, TEL_CTRL, 0); + send_req(plci); + } + } + else if (plci->command != _MANUFACTURER_R /* old style permanent connect */ + && plci->State != INC_ACT_PENDING) + { + mixer_set_bchannel_id_esc(plci, plci->b_channel); + if (plci->tel == ADV_VOICE && plci->SuppState == IDLE) /* with permanent codec switch on immediately */ + { + chi[2] = plci->b_channel; + SetVoiceChannel(a->AdvCodecPLCI, chi, a); + } + sendf(plci->appl, _CONNECT_ACTIVE_I, Id, 0, "Sss", parms[21], "", ""); + plci->State = INC_ACT_PENDING; + } + break; + + case TEL_CTRL: + ie = multi_fac_parms[0]; /* inspect the facility hook indications */ + if (plci->State == ADVANCED_VOICE_SIG && ie[0]) { + switch (ie[1] & 0x91) { + case 0x80: /* hook off */ + case 0x81: + if (plci->internal_command == PERM_COD_HOOK) + { + dbug(1, dprintf("init:hook_off")); + plci->hook_state = ie[1]; + next_internal_command(Id, plci); + break; + } + else /* ignore doubled hook indications */ + { + if (((plci->hook_state) & 0xf0) == 0x80) + { + dbug(1, dprintf("ignore hook")); + break; + } + plci->hook_state = ie[1]&0x91; + } + /* check for incoming call pending */ + /* and signal '+'.Appl must decide */ + /* with connect_res if call must */ + /* accepted or not */ + for (i = 0, tplci = NULL; i < max_appl; i++) { + if (a->codec_listen[i] + && (a->codec_listen[i]->State == INC_CON_PENDING + || a->codec_listen[i]->State == INC_CON_ALERT)) { + tplci = a->codec_listen[i]; + tplci->appl = &application[i]; + } + } + /* no incoming call, do outgoing call */ + /* and signal '+' if outg. setup */ + if (!a->AdvSignalPLCI && !tplci) { + if ((i = get_plci(a))) { + a->AdvSignalPLCI = &a->plci[i - 1]; + tplci = a->AdvSignalPLCI; + tplci->tel = ADV_VOICE; + PUT_WORD(&voice_cai[5], a->AdvSignalAppl->MaxDataLength); + if (a->Info_Mask[a->AdvSignalAppl->Id - 1] & 0x200) { + /* early B3 connect (CIP mask bit 9) no release after a disc */ + add_p(tplci, LLI, "\x01\x01"); + } + add_p(tplci, CAI, voice_cai); + add_p(tplci, OAD, a->TelOAD); + add_p(tplci, OSA, a->TelOSA); + add_p(tplci, SHIFT | 6, NULL); + add_p(tplci, SIN, "\x02\x01\x00"); + add_p(tplci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + sig_req(tplci, ASSIGN, DSIG_ID); + a->AdvSignalPLCI->internal_command = HOOK_OFF_REQ; + a->AdvSignalPLCI->command = 0; + tplci->appl = a->AdvSignalAppl; + tplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE; + send_req(tplci); + } + + } + + if (!tplci) break; + Id = ((word)tplci->Id << 8) | a->Id; + Id |= EXT_CONTROLLER; + sendf(tplci->appl, + _FACILITY_I, + Id, + 0, + "ws", (word)0, "\x01+"); + break; + + case 0x90: /* hook on */ + case 0x91: + if (plci->internal_command == PERM_COD_HOOK) + { + dbug(1, dprintf("init:hook_on")); + plci->hook_state = ie[1] & 0x91; + next_internal_command(Id, plci); + break; + } + else /* ignore doubled hook indications */ + { + if (((plci->hook_state) & 0xf0) == 0x90) break; + plci->hook_state = ie[1] & 0x91; + } + /* hangup the adv. voice call and signal '-' to the appl */ + if (a->AdvSignalPLCI) { + Id = ((word)a->AdvSignalPLCI->Id << 8) | a->Id; + if (plci->tel) Id |= EXT_CONTROLLER; + sendf(a->AdvSignalAppl, + _FACILITY_I, + Id, + 0, + "ws", (word)0, "\x01-"); + a->AdvSignalPLCI->internal_command = HOOK_ON_REQ; + a->AdvSignalPLCI->command = 0; + sig_req(a->AdvSignalPLCI, HANGUP, 0); + send_req(a->AdvSignalPLCI); + } + break; + } + } + break; + + case RESUME: + clear_c_ind_mask_bit(plci, (word)(plci->appl->Id - 1)); + PUT_WORD(&resume_cau[4], GOOD); + sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, resume_cau); + break; + + case SUSPEND: + clear_c_ind_mask(plci); + + if (plci->NL.Id && !plci->nl_remove_id) { + mixer_remove(plci); + nl_req_ncci(plci, REMOVE, 0); + } + if (!plci->sig_remove_id) { + plci->internal_command = 0; + sig_req(plci, REMOVE, 0); + } + send_req(plci); + if (!plci->channels) { + sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, "\x05\x04\x00\x02\x00\x00"); + sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0); + } + break; + + case SUSPEND_REJ: + break; + + case HANGUP: + plci->hangup_flow_ctrl_timer = 0; + if (plci->manufacturer && plci->State == LOCAL_CONNECT) break; + cau = parms[7]; + if (cau) { + i = _L3_CAUSE | cau[2]; + if (cau[2] == 0) i = 0; + else if (cau[2] == 8) i = _L1_ERROR; + else if (cau[2] == 9 || cau[2] == 10) i = _L2_ERROR; + else if (cau[2] == 5) i = _CAPI_GUARD_ERROR; + } + else { + i = _L3_ERROR; + } + + if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT) + { + for (i = 0; i < max_appl; i++) + { + if (test_c_ind_mask_bit(plci, i)) + sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0); + } + } + else + { + clear_c_ind_mask(plci); + } + if (!plci->appl) + { + if (plci->State == LISTENING) + { + plci->notifiedcall = 0; + a->listen_active--; + } + plci->State = INC_DIS_PENDING; + if (c_ind_mask_empty(plci)) + { + plci->State = IDLE; + if (plci->NL.Id && !plci->nl_remove_id) + { + mixer_remove(plci); + nl_req_ncci(plci, REMOVE, 0); + } + if (!plci->sig_remove_id) + { + plci->internal_command = 0; + sig_req(plci, REMOVE, 0); + } + send_req(plci); + } + } + else + { + /* collision of DISCONNECT or CONNECT_RES with HANGUP can */ + /* result in a second HANGUP! Don't generate another */ + /* DISCONNECT */ + if (plci->State != IDLE && plci->State != INC_DIS_PENDING) + { + if (plci->State == RESUMING) + { + PUT_WORD(&resume_cau[4], i); + sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, resume_cau); + } + plci->State = INC_DIS_PENDING; + sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", i); + } + } + break; + + case SSEXT_IND: + SendSSExtInd(NULL, plci, Id, multi_ssext_parms); + break; + + case VSWITCH_REQ: + VSwitchReqInd(plci, Id, multi_vswitch_parms); + break; + case VSWITCH_IND: + if (plci->relatedPTYPLCI && + plci->vswitchstate == 3 && + plci->relatedPTYPLCI->vswitchstate == 3 && + parms[MAXPARMSIDS - 1][0]) + { + add_p(plci->relatedPTYPLCI, SMSG, parms[MAXPARMSIDS - 1]); + sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0); + send_req(plci->relatedPTYPLCI); + } + else VSwitchReqInd(plci, Id, multi_vswitch_parms); + break; + + } +} + + +static void SendSetupInfo(APPL *appl, PLCI *plci, dword Id, byte **parms, byte Info_Sent_Flag) +{ + word i; + byte *ie; + word Info_Number; + byte *Info_Element; + word Info_Mask = 0; + + dbug(1, dprintf("SetupInfo")); + + for (i = 0; i < MAXPARMSIDS; i++) { + ie = parms[i]; + Info_Number = 0; + Info_Element = ie; + if (ie[0]) { + switch (i) { + case 0: + dbug(1, dprintf("CPN ")); + Info_Number = 0x0070; + Info_Mask = 0x80; + Info_Sent_Flag = true; + break; + case 8: /* display */ + dbug(1, dprintf("display(%d)", i)); + Info_Number = 0x0028; + Info_Mask = 0x04; + Info_Sent_Flag = true; + break; + case 16: /* Channel Id */ + dbug(1, dprintf("CHI")); + Info_Number = 0x0018; + Info_Mask = 0x100; + Info_Sent_Flag = true; + mixer_set_bchannel_id(plci, Info_Element); + break; + case 19: /* Redirected Number */ + dbug(1, dprintf("RDN")); + Info_Number = 0x0074; + Info_Mask = 0x400; + Info_Sent_Flag = true; + break; + case 20: /* Redirected Number extended */ + dbug(1, dprintf("RDX")); + Info_Number = 0x0073; + Info_Mask = 0x400; + Info_Sent_Flag = true; + break; + case 22: /* Redirecing Number */ + dbug(1, dprintf("RIN")); + Info_Number = 0x0076; + Info_Mask = 0x400; + Info_Sent_Flag = true; + break; + default: + Info_Number = 0; + break; + } + } + + if (i == MAXPARMSIDS - 2) { /* to indicate the message type "Setup" */ + Info_Number = 0x8000 | 5; + Info_Mask = 0x10; + Info_Element = ""; + } + + if (Info_Sent_Flag && Info_Number) { + if (plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask) { + sendf(appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element); + } + } + } +} + + +static void SendInfo(PLCI *plci, dword Id, byte **parms, byte iesent) +{ + word i; + word j; + word k; + byte *ie; + word Info_Number; + byte *Info_Element; + word Info_Mask = 0; + static byte charges[5] = {4, 0, 0, 0, 0}; + static byte cause[] = {0x02, 0x80, 0x00}; + APPL *appl; + + dbug(1, dprintf("InfoParse ")); + + if ( + !plci->appl + && !plci->State + && plci->Sig.Ind != NCR_FACILITY + ) + { + dbug(1, dprintf("NoParse ")); + return; + } + cause[2] = 0; + for (i = 0; i < MAXPARMSIDS; i++) { + ie = parms[i]; + Info_Number = 0; + Info_Element = ie; + if (ie[0]) { + switch (i) { + case 0: + dbug(1, dprintf("CPN ")); + Info_Number = 0x0070; + Info_Mask = 0x80; + break; + case 7: /* ESC_CAU */ + dbug(1, dprintf("cau(0x%x)", ie[2])); + Info_Number = 0x0008; + Info_Mask = 0x00; + cause[2] = ie[2]; + Info_Element = NULL; + break; + case 8: /* display */ + dbug(1, dprintf("display(%d)", i)); + Info_Number = 0x0028; + Info_Mask = 0x04; + break; + case 9: /* Date display */ + dbug(1, dprintf("date(%d)", i)); + Info_Number = 0x0029; + Info_Mask = 0x02; + break; + case 10: /* charges */ + for (j = 0; j < 4; j++) charges[1 + j] = 0; + for (j = 0; j < ie[0] && !(ie[1 + j] & 0x80); j++); + for (k = 1, j++; j < ie[0] && k <= 4; j++, k++) charges[k] = ie[1 + j]; + Info_Number = 0x4000; + Info_Mask = 0x40; + Info_Element = charges; + break; + case 11: /* user user info */ + dbug(1, dprintf("uui")); + Info_Number = 0x007E; + Info_Mask = 0x08; + break; + case 12: /* congestion receiver ready */ + dbug(1, dprintf("clRDY")); + Info_Number = 0x00B0; + Info_Mask = 0x08; + Info_Element = ""; + break; + case 13: /* congestion receiver not ready */ + dbug(1, dprintf("clNRDY")); + Info_Number = 0x00BF; + Info_Mask = 0x08; + Info_Element = ""; + break; + case 15: /* Keypad Facility */ + dbug(1, dprintf("KEY")); + Info_Number = 0x002C; + Info_Mask = 0x20; + break; + case 16: /* Channel Id */ + dbug(1, dprintf("CHI")); + Info_Number = 0x0018; + Info_Mask = 0x100; + mixer_set_bchannel_id(plci, Info_Element); + break; + case 17: /* if no 1tr6 cause, send full cause, else esc_cause */ + dbug(1, dprintf("q9cau(0x%x)", ie[2])); + if (!cause[2] || cause[2] < 0x80) break; /* eg. layer 1 error */ + Info_Number = 0x0008; + Info_Mask = 0x01; + if (cause[2] != ie[2]) Info_Element = cause; + break; + case 19: /* Redirected Number */ + dbug(1, dprintf("RDN")); + Info_Number = 0x0074; + Info_Mask = 0x400; + break; + case 22: /* Redirecing Number */ + dbug(1, dprintf("RIN")); + Info_Number = 0x0076; + Info_Mask = 0x400; + break; + case 23: /* Notification Indicator */ + dbug(1, dprintf("NI")); + Info_Number = (word)NI; + Info_Mask = 0x210; + break; + case 26: /* Call State */ + dbug(1, dprintf("CST")); + Info_Number = (word)CST; + Info_Mask = 0x01; /* do with cause i.e. for now */ + break; + case MAXPARMSIDS - 2: /* Escape Message Type, must be the last indication */ + dbug(1, dprintf("ESC/MT[0x%x]", ie[3])); + Info_Number = 0x8000 | ie[3]; + if (iesent) Info_Mask = 0xffff; + else Info_Mask = 0x10; + Info_Element = ""; + break; + default: + Info_Number = 0; + Info_Mask = 0; + Info_Element = ""; + break; + } + } + + if (plci->Sig.Ind == NCR_FACILITY) /* check controller broadcast */ + { + for (j = 0; j < max_appl; j++) + { + appl = &application[j]; + if (Info_Number + && appl->Id + && plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask) + { + dbug(1, dprintf("NCR_Ind")); + iesent = true; + sendf(&application[j], _INFO_I, Id & 0x0f, 0, "wS", Info_Number, Info_Element); + } + } + } + else if (!plci->appl) + { /* overlap receiving broadcast */ + if (Info_Number == CPN + || Info_Number == KEY + || Info_Number == NI + || Info_Number == DSP + || Info_Number == UUI) + { + for (j = 0; j < max_appl; j++) + { + if (test_c_ind_mask_bit(plci, j)) + { + dbug(1, dprintf("Ovl_Ind")); + iesent = true; + sendf(&application[j], _INFO_I, Id, 0, "wS", Info_Number, Info_Element); + } + } + } + } /* all other signalling states */ + else if (Info_Number + && plci->adapter->Info_Mask[plci->appl->Id - 1] & Info_Mask) + { + dbug(1, dprintf("Std_Ind")); + iesent = true; + sendf(plci->appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element); + } + } +} + + +static byte SendMultiIE(PLCI *plci, dword Id, byte **parms, byte ie_type, + dword info_mask, byte setupParse) +{ + word i; + word j; + byte *ie; + word Info_Number; + byte *Info_Element; + APPL *appl; + word Info_Mask = 0; + byte iesent = 0; + + if ( + !plci->appl + && !plci->State + && plci->Sig.Ind != NCR_FACILITY + && !setupParse + ) + { + dbug(1, dprintf("NoM-IEParse ")); + return 0; + } + dbug(1, dprintf("M-IEParse ")); + + for (i = 0; i < MAX_MULTI_IE; i++) + { + ie = parms[i]; + Info_Number = 0; + Info_Element = ie; + if (ie[0]) + { + dbug(1, dprintf("[Ind0x%x]:IE=0x%x", plci->Sig.Ind, ie_type)); + Info_Number = (word)ie_type; + Info_Mask = (word)info_mask; + } + + if (plci->Sig.Ind == NCR_FACILITY) /* check controller broadcast */ + { + for (j = 0; j < max_appl; j++) + { + appl = &application[j]; + if (Info_Number + && appl->Id + && plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask) + { + iesent = true; + dbug(1, dprintf("Mlt_NCR_Ind")); + sendf(&application[j], _INFO_I, Id & 0x0f, 0, "wS", Info_Number, Info_Element); + } + } + } + else if (!plci->appl && Info_Number) + { /* overlap receiving broadcast */ + for (j = 0; j < max_appl; j++) + { + if (test_c_ind_mask_bit(plci, j)) + { + iesent = true; + dbug(1, dprintf("Mlt_Ovl_Ind")); + sendf(&application[j] , _INFO_I, Id, 0, "wS", Info_Number, Info_Element); + } + } + } /* all other signalling states */ + else if (Info_Number + && plci->adapter->Info_Mask[plci->appl->Id - 1] & Info_Mask) + { + iesent = true; + dbug(1, dprintf("Mlt_Std_Ind")); + sendf(plci->appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element); + } + } + return iesent; +} + +static void SendSSExtInd(APPL *appl, PLCI *plci, dword Id, byte **parms) +{ + word i; + /* Format of multi_ssext_parms[i][]: + 0 byte length + 1 byte SSEXTIE + 2 byte SSEXT_REQ/SSEXT_IND + 3 byte length + 4 word SSExtCommand + 6... Params + */ + if ( + plci + && plci->State + && plci->Sig.Ind != NCR_FACILITY + ) + for (i = 0; i < MAX_MULTI_IE; i++) + { + if (parms[i][0] < 6) continue; + if (parms[i][2] == SSEXT_REQ) continue; + + if (appl) + { + parms[i][0] = 0; /* kill it */ + sendf(appl, _MANUFACTURER_I, + Id, + 0, + "dwS", + _DI_MANU_ID, + _DI_SSEXT_CTRL, + &parms[i][3]); + } + else if (plci->appl) + { + parms[i][0] = 0; /* kill it */ + sendf(plci->appl, _MANUFACTURER_I, + Id, + 0, + "dwS", + _DI_MANU_ID, + _DI_SSEXT_CTRL, + &parms[i][3]); + } + } +}; + +static void nl_ind(PLCI *plci) +{ + byte ch; + word ncci; + dword Id; + DIVA_CAPI_ADAPTER *a; + word NCCIcode; + APPL *APPLptr; + word count; + word Num; + word i, ncpi_state; + byte len, ncci_state; + word msg; + word info = 0; + word fax_feature_bits; + byte fax_send_edata_ack; + static byte v120_header_buffer[2 + 3]; + static word fax_info[] = { + 0, /* T30_SUCCESS */ + _FAX_NO_CONNECTION, /* T30_ERR_NO_DIS_RECEIVED */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_NO_RESPONSE */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_RESPONSE */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_TOO_MANY_REPEATS */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_UNEXPECTED_MESSAGE */ + _FAX_REMOTE_ABORT, /* T30_ERR_UNEXPECTED_DCN */ + _FAX_LOCAL_ABORT, /* T30_ERR_DTC_UNSUPPORTED */ + _FAX_TRAINING_ERROR, /* T30_ERR_ALL_RATES_FAILED */ + _FAX_TRAINING_ERROR, /* T30_ERR_TOO_MANY_TRAINS */ + _FAX_PARAMETER_ERROR, /* T30_ERR_RECEIVE_CORRUPTED */ + _FAX_REMOTE_ABORT, /* T30_ERR_UNEXPECTED_DISC */ + _FAX_LOCAL_ABORT, /* T30_ERR_APPLICATION_DISC */ + _FAX_REMOTE_REJECT, /* T30_ERR_INCOMPATIBLE_DIS */ + _FAX_LOCAL_ABORT, /* T30_ERR_INCOMPATIBLE_DCS */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_NO_COMMAND */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_COMMAND */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_COMMAND_TOO_LONG */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_RESPONSE_TOO_LONG */ + _FAX_NO_CONNECTION, /* T30_ERR_NOT_IDENTIFIED */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_SUPERVISORY_TIMEOUT */ + _FAX_PARAMETER_ERROR, /* T30_ERR_TOO_LONG_SCAN_LINE */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_PAGE_AFTER_MPS */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_PAGE_AFTER_CFR */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_FTT */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_EOM */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_MPS */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCN_AFTER_MCF */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCN_AFTER_RTN */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_CFR */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_EOP */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_EOM */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_MPS */ + 0x331d, /* T30_ERR_SUB_SEP_UNSUPPORTED */ + 0x331e, /* T30_ERR_PWD_UNSUPPORTED */ + 0x331f, /* T30_ERR_SUB_SEP_PWD_UNSUPPORTED */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_INVALID_COMMAND_FRAME */ + _FAX_PARAMETER_ERROR, /* T30_ERR_UNSUPPORTED_PAGE_CODING */ + _FAX_PARAMETER_ERROR, /* T30_ERR_INVALID_PAGE_CODING */ + _FAX_REMOTE_REJECT, /* T30_ERR_INCOMPATIBLE_PAGE_CONFIG */ + _FAX_LOCAL_ABORT, /* T30_ERR_TIMEOUT_FROM_APPLICATION */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_NO_REACTION_ON_MARK */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_TRAINING_TIMEOUT */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_UNEXPECTED_V21 */ + _FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_PRIMARY_CTS_ON */ + _FAX_LOCAL_ABORT, /* T30_ERR_V34FAX_TURNAROUND_POLLING */ + _FAX_LOCAL_ABORT /* T30_ERR_V34FAX_V8_INCOMPATIBILITY */ + }; + + byte dtmf_code_buffer[CAPIDTMF_RECV_DIGIT_BUFFER_SIZE + 1]; + + + static word rtp_info[] = { + GOOD, /* RTP_SUCCESS */ + 0x3600 /* RTP_ERR_SSRC_OR_PAYLOAD_CHANGE */ + }; + + static dword udata_forwarding_table[0x100 / sizeof(dword)] = + { + 0x0020301e, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000 + }; + + ch = plci->NL.IndCh; + a = plci->adapter; + ncci = a->ch_ncci[ch]; + Id = (((dword)(ncci ? ncci : ch)) << 16) | (((word) plci->Id) << 8) | a->Id; + if (plci->tel) Id |= EXT_CONTROLLER; + APPLptr = plci->appl; + dbug(1, dprintf("NL_IND-Id(NL:0x%x)=0x%08lx,plci=%x,tel=%x,state=0x%x,ch=0x%x,chs=%d,Ind=%x", + plci->NL.Id, Id, plci->Id, plci->tel, plci->State, ch, plci->channels, plci->NL.Ind & 0x0f)); + + /* in the case if no connect_active_Ind was sent to the appl we wait for */ + + if (plci->nl_remove_id) + { + plci->NL.RNR = 2; /* discard */ + dbug(1, dprintf("NL discard while remove pending")); + return; + } + if ((plci->NL.Ind & 0x0f) == N_CONNECT) + { + if (plci->State == INC_DIS_PENDING + || plci->State == OUTG_DIS_PENDING + || plci->State == IDLE) + { + plci->NL.RNR = 2; /* discard */ + dbug(1, dprintf("discard n_connect")); + return; + } + if (plci->State < INC_ACT_PENDING) + { + plci->NL.RNR = 1; /* flow control */ + channel_x_off(plci, ch, N_XON_CONNECT_IND); + return; + } + } + + if (!APPLptr) /* no application or invalid data */ + { /* while reloading the DSP */ + dbug(1, dprintf("discard1")); + plci->NL.RNR = 2; + return; + } + + if (((plci->NL.Ind & 0x0f) == N_UDATA) + && (((plci->B2_prot != B2_SDLC) && ((plci->B1_resource == 17) || (plci->B1_resource == 18))) + || (plci->B2_prot == 7) + || (plci->B3_prot == 7))) + { + plci->ncpi_buffer[0] = 0; + + ncpi_state = plci->ncpi_state; + if (plci->NL.complete == 1) + { + byte *data = &plci->NL.RBuffer->P[0]; + + if ((plci->NL.RBuffer->length >= 12) + && ((*data == DSP_UDATA_INDICATION_DCD_ON) + || (*data == DSP_UDATA_INDICATION_CTS_ON))) + { + word conn_opt, ncpi_opt = 0x00; +/* HexDump ("MDM N_UDATA:", plci->NL.RBuffer->length, data); */ + + if (*data == DSP_UDATA_INDICATION_DCD_ON) + plci->ncpi_state |= NCPI_MDM_DCD_ON_RECEIVED; + if (*data == DSP_UDATA_INDICATION_CTS_ON) + plci->ncpi_state |= NCPI_MDM_CTS_ON_RECEIVED; + + data++; /* indication code */ + data += 2; /* timestamp */ + if ((*data == DSP_CONNECTED_NORM_V18) || (*data == DSP_CONNECTED_NORM_VOWN)) + ncpi_state &= ~(NCPI_MDM_DCD_ON_RECEIVED | NCPI_MDM_CTS_ON_RECEIVED); + data++; /* connected norm */ + conn_opt = GET_WORD(data); + data += 2; /* connected options */ + + PUT_WORD(&(plci->ncpi_buffer[1]), (word)(GET_DWORD(data) & 0x0000FFFF)); + + if (conn_opt & DSP_CONNECTED_OPTION_MASK_V42) + { + ncpi_opt |= MDM_NCPI_ECM_V42; + } + else if (conn_opt & DSP_CONNECTED_OPTION_MASK_MNP) + { + ncpi_opt |= MDM_NCPI_ECM_MNP; + } + else + { + ncpi_opt |= MDM_NCPI_TRANSPARENT; + } + if (conn_opt & DSP_CONNECTED_OPTION_MASK_COMPRESSION) + { + ncpi_opt |= MDM_NCPI_COMPRESSED; + } + PUT_WORD(&(plci->ncpi_buffer[3]), ncpi_opt); + plci->ncpi_buffer[0] = 4; + + plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND | NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND; + } + } + if (plci->B3_prot == 7) + { + if (((a->ncci_state[ncci] == INC_ACT_PENDING) || (a->ncci_state[ncci] == OUTG_CON_PENDING)) + && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT) + && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT)) + { + a->ncci_state[ncci] = INC_ACT_PENDING; + sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer); + plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT; + } + } + + if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1]) + & ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN))) + || !(ncpi_state & NCPI_MDM_DCD_ON_RECEIVED) + || !(ncpi_state & NCPI_MDM_CTS_ON_RECEIVED)) + + { + plci->NL.RNR = 2; + return; + } + } + + if (plci->NL.complete == 2) + { + if (((plci->NL.Ind & 0x0f) == N_UDATA) + && !(udata_forwarding_table[plci->RData[0].P[0] >> 5] & (1L << (plci->RData[0].P[0] & 0x1f)))) + { + switch (plci->RData[0].P[0]) + { + + case DTMF_UDATA_INDICATION_FAX_CALLING_TONE: + if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG) + sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", SELECTOR_DTMF, "\x01X"); + break; + case DTMF_UDATA_INDICATION_ANSWER_TONE: + if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG) + sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", SELECTOR_DTMF, "\x01Y"); + break; + case DTMF_UDATA_INDICATION_DIGITS_RECEIVED: + dtmf_indication(Id, plci, plci->RData[0].P, plci->RData[0].PLength); + break; + case DTMF_UDATA_INDICATION_DIGITS_SENT: + dtmf_confirmation(Id, plci); + break; + + + case UDATA_INDICATION_MIXER_TAP_DATA: + capidtmf_recv_process_block(&(plci->capidtmf_state), plci->RData[0].P + 1, (word)(plci->RData[0].PLength - 1)); + i = capidtmf_indication(&(plci->capidtmf_state), dtmf_code_buffer + 1); + if (i != 0) + { + dtmf_code_buffer[0] = DTMF_UDATA_INDICATION_DIGITS_RECEIVED; + dtmf_indication(Id, plci, dtmf_code_buffer, (word)(i + 1)); + } + break; + + + case UDATA_INDICATION_MIXER_COEFS_SET: + mixer_indication_coefs_set(Id, plci); + break; + case UDATA_INDICATION_XCONNECT_FROM: + mixer_indication_xconnect_from(Id, plci, plci->RData[0].P, plci->RData[0].PLength); + break; + case UDATA_INDICATION_XCONNECT_TO: + mixer_indication_xconnect_to(Id, plci, plci->RData[0].P, plci->RData[0].PLength); + break; + + + case LEC_UDATA_INDICATION_DISABLE_DETECT: + ec_indication(Id, plci, plci->RData[0].P, plci->RData[0].PLength); + break; + + + + default: + break; + } + } + else + { + if ((plci->RData[0].PLength != 0) + && ((plci->B2_prot == B2_V120_ASYNC) + || (plci->B2_prot == B2_V120_ASYNC_V42BIS) + || (plci->B2_prot == B2_V120_BIT_TRANSPARENT))) + { + + sendf(plci->appl, _DATA_B3_I, Id, 0, + "dwww", + plci->RData[1].P, + (plci->NL.RNum < 2) ? 0 : plci->RData[1].PLength, + plci->RNum, + plci->RFlags); + + } + else + { + + sendf(plci->appl, _DATA_B3_I, Id, 0, + "dwww", + plci->RData[0].P, + plci->RData[0].PLength, + plci->RNum, + plci->RFlags); + + } + } + return; + } + + fax_feature_bits = 0; + if ((plci->NL.Ind & 0x0f) == N_CONNECT || + (plci->NL.Ind & 0x0f) == N_CONNECT_ACK || + (plci->NL.Ind & 0x0f) == N_DISC || + (plci->NL.Ind & 0x0f) == N_EDATA || + (plci->NL.Ind & 0x0f) == N_DISC_ACK) + { + info = 0; + plci->ncpi_buffer[0] = 0; + switch (plci->B3_prot) { + case 0: /*XPARENT*/ + case 1: /*T.90 NL*/ + break; /* no network control protocol info - jfr */ + case 2: /*ISO8202*/ + case 3: /*X25 DCE*/ + for (i = 0; i < plci->NL.RLength; i++) plci->ncpi_buffer[4 + i] = plci->NL.RBuffer->P[i]; + plci->ncpi_buffer[0] = (byte)(i + 3); + plci->ncpi_buffer[1] = (byte)(plci->NL.Ind & N_D_BIT ? 1 : 0); + plci->ncpi_buffer[2] = 0; + plci->ncpi_buffer[3] = 0; + break; + case 4: /*T.30 - FAX*/ + case 5: /*T.30 - FAX*/ + if (plci->NL.RLength >= sizeof(T30_INFO)) + { + dbug(1, dprintf("FaxStatus %04x", ((T30_INFO *)plci->NL.RBuffer->P)->code)); + len = 9; + PUT_WORD(&(plci->ncpi_buffer[1]), ((T30_INFO *)plci->NL.RBuffer->P)->rate_div_2400 * 2400); + fax_feature_bits = GET_WORD(&((T30_INFO *)plci->NL.RBuffer->P)->feature_bits_low); + i = (((T30_INFO *)plci->NL.RBuffer->P)->resolution & T30_RESOLUTION_R8_0770_OR_200) ? 0x0001 : 0x0000; + if (plci->B3_prot == 5) + { + if (!(fax_feature_bits & T30_FEATURE_BIT_ECM)) + i |= 0x8000; /* This is not an ECM connection */ + if (fax_feature_bits & T30_FEATURE_BIT_T6_CODING) + i |= 0x4000; /* This is a connection with MMR compression */ + if (fax_feature_bits & T30_FEATURE_BIT_2D_CODING) + i |= 0x2000; /* This is a connection with MR compression */ + if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS) + i |= 0x0004; /* More documents */ + if (fax_feature_bits & T30_FEATURE_BIT_POLLING) + i |= 0x0002; /* Fax-polling indication */ + } + dbug(1, dprintf("FAX Options %04x %04x", fax_feature_bits, i)); + PUT_WORD(&(plci->ncpi_buffer[3]), i); + PUT_WORD(&(plci->ncpi_buffer[5]), ((T30_INFO *)plci->NL.RBuffer->P)->data_format); + plci->ncpi_buffer[7] = ((T30_INFO *)plci->NL.RBuffer->P)->pages_low; + plci->ncpi_buffer[8] = ((T30_INFO *)plci->NL.RBuffer->P)->pages_high; + plci->ncpi_buffer[len] = 0; + if (((T30_INFO *)plci->NL.RBuffer->P)->station_id_len) + { + plci->ncpi_buffer[len] = 20; + for (i = 0; i < T30_MAX_STATION_ID_LENGTH; i++) + plci->ncpi_buffer[++len] = ((T30_INFO *)plci->NL.RBuffer->P)->station_id[i]; + } + if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK)) + { + if (((T30_INFO *)plci->NL.RBuffer->P)->code < ARRAY_SIZE(fax_info)) + info = fax_info[((T30_INFO *)plci->NL.RBuffer->P)->code]; + else + info = _FAX_PROTOCOL_ERROR; + } + + if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1]) + & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD))) + { + i = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + ((T30_INFO *)plci->NL.RBuffer->P)->head_line_len; + while (i < plci->NL.RBuffer->length) + plci->ncpi_buffer[++len] = plci->NL.RBuffer->P[i++]; + } + + plci->ncpi_buffer[0] = len; + fax_feature_bits = GET_WORD(&((T30_INFO *)plci->NL.RBuffer->P)->feature_bits_low); + PUT_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->feature_bits_low, fax_feature_bits); + + plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND; + if (((plci->NL.Ind & 0x0f) == N_CONNECT_ACK) + || (((plci->NL.Ind & 0x0f) == N_CONNECT) + && (fax_feature_bits & T30_FEATURE_BIT_POLLING)) + || (((plci->NL.Ind & 0x0f) == N_EDATA) + && ((((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_TRAIN_OK) + || (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS) + || (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DTC)))) + { + plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT; + } + if (((plci->NL.Ind & 0x0f) == N_DISC) + || ((plci->NL.Ind & 0x0f) == N_DISC_ACK) + || (((plci->NL.Ind & 0x0f) == N_EDATA) + && (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_EOP_CAPI))) + { + plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND; + } + } + break; + + case B3_RTP: + if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK)) + { + if (plci->NL.RLength != 0) + { + info = rtp_info[plci->NL.RBuffer->P[0]]; + plci->ncpi_buffer[0] = plci->NL.RLength - 1; + for (i = 1; i < plci->NL.RLength; i++) + plci->ncpi_buffer[i] = plci->NL.RBuffer->P[i]; + } + } + break; + + } + plci->NL.RNR = 2; + } + switch (plci->NL.Ind & 0x0f) { + case N_EDATA: + if ((plci->B3_prot == 4) || (plci->B3_prot == 5)) + { + dbug(1, dprintf("EDATA ncci=0x%x state=%d code=%02x", ncci, a->ncci_state[ncci], + ((T30_INFO *)plci->NL.RBuffer->P)->code)); + fax_send_edata_ack = (((T30_INFO *)(plci->fax_connect_info_buffer))->operating_mode == T30_OPERATING_MODE_CAPI_NEG); + + if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF) + && (plci->nsf_control_bits & (T30_NSF_CONTROL_BIT_NEGOTIATE_IND | T30_NSF_CONTROL_BIT_NEGOTIATE_RESP)) + && (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS) + && (a->ncci_state[ncci] == OUTG_CON_PENDING) + && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT) + && !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT)) + { + ((T30_INFO *)(plci->fax_connect_info_buffer))->code = ((T30_INFO *)plci->NL.RBuffer->P)->code; + sendf(plci->appl, _MANUFACTURER_I, Id, 0, "dwbS", _DI_MANU_ID, _DI_NEGOTIATE_B3, + (byte)(plci->ncpi_buffer[0] + 1), plci->ncpi_buffer); + plci->ncpi_state |= NCPI_NEGOTIATE_B3_SENT; + if (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP) + fax_send_edata_ack = false; + } + + if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS) + { + switch (((T30_INFO *)plci->NL.RBuffer->P)->code) + { + case EDATA_T30_DIS: + if ((a->ncci_state[ncci] == OUTG_CON_PENDING) + && !(GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low) & T30_CONTROL_BIT_REQUEST_POLLING) + && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT) + && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT)) + { + a->ncci_state[ncci] = INC_ACT_PENDING; + if (plci->B3_prot == 4) + sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", ""); + else + sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer); + plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT; + } + break; + + case EDATA_T30_TRAIN_OK: + if ((a->ncci_state[ncci] == INC_ACT_PENDING) + && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT) + && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT)) + { + if (plci->B3_prot == 4) + sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", ""); + else + sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer); + plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT; + } + break; + + case EDATA_T30_EOP_CAPI: + if (a->ncci_state[ncci] == CONNECTED) + { + sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", GOOD, plci->ncpi_buffer); + a->ncci_state[ncci] = INC_DIS_PENDING; + plci->ncpi_state = 0; + fax_send_edata_ack = false; + } + break; + } + } + else + { + switch (((T30_INFO *)plci->NL.RBuffer->P)->code) + { + case EDATA_T30_TRAIN_OK: + if ((a->ncci_state[ncci] == INC_ACT_PENDING) + && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT) + && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT)) + { + if (plci->B3_prot == 4) + sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", ""); + else + sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer); + plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT; + } + break; + } + } + if (fax_send_edata_ack) + { + ((T30_INFO *)(plci->fax_connect_info_buffer))->code = ((T30_INFO *)plci->NL.RBuffer->P)->code; + plci->fax_edata_ack_length = 1; + start_internal_command(Id, plci, fax_edata_ack_command); + } + } + else + { + dbug(1, dprintf("EDATA ncci=0x%x state=%d", ncci, a->ncci_state[ncci])); + } + break; + case N_CONNECT: + if (!a->ch_ncci[ch]) + { + ncci = get_ncci(plci, ch, 0); + Id = (Id & 0xffff) | (((dword) ncci) << 16); + } + dbug(1, dprintf("N_CONNECT: ch=%d state=%d plci=%lx plci_Id=%lx plci_State=%d", + ch, a->ncci_state[ncci], a->ncci_plci[ncci], plci->Id, plci->State)); + + msg = _CONNECT_B3_I; + if (a->ncci_state[ncci] == IDLE) + plci->channels++; + else if (plci->B3_prot == 1) + msg = _CONNECT_B3_T90_ACTIVE_I; + + a->ncci_state[ncci] = INC_CON_PENDING; + if (plci->B3_prot == 4) + sendf(plci->appl, msg, Id, 0, "s", ""); + else + sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer); + break; + case N_CONNECT_ACK: + dbug(1, dprintf("N_connect_Ack")); + if (plci->internal_command_queue[0] + && ((plci->adjust_b_state == ADJUST_B_CONNECT_2) + || (plci->adjust_b_state == ADJUST_B_CONNECT_3) + || (plci->adjust_b_state == ADJUST_B_CONNECT_4))) + { + (*(plci->internal_command_queue[0]))(Id, plci, 0); + if (!plci->internal_command) + next_internal_command(Id, plci); + break; + } + msg = _CONNECT_B3_ACTIVE_I; + if (plci->B3_prot == 1) + { + if (a->ncci_state[ncci] != OUTG_CON_PENDING) + msg = _CONNECT_B3_T90_ACTIVE_I; + a->ncci_state[ncci] = INC_ACT_PENDING; + sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer); + } + else if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7)) + { + if ((a->ncci_state[ncci] == OUTG_CON_PENDING) + && (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT) + && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT)) + { + a->ncci_state[ncci] = INC_ACT_PENDING; + if (plci->B3_prot == 4) + sendf(plci->appl, msg, Id, 0, "s", ""); + else + sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer); + plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT; + } + } + else + { + a->ncci_state[ncci] = INC_ACT_PENDING; + sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer); + } + if (plci->adjust_b_restore) + { + plci->adjust_b_restore = false; + start_internal_command(Id, plci, adjust_b_restore); + } + break; + case N_DISC: + case N_DISC_ACK: + if (plci->internal_command_queue[0] + && ((plci->internal_command == FAX_DISCONNECT_COMMAND_1) + || (plci->internal_command == FAX_DISCONNECT_COMMAND_2) + || (plci->internal_command == FAX_DISCONNECT_COMMAND_3))) + { + (*(plci->internal_command_queue[0]))(Id, plci, 0); + if (!plci->internal_command) + next_internal_command(Id, plci); + } + ncci_state = a->ncci_state[ncci]; + ncci_remove(plci, ncci, false); + + /* with N_DISC or N_DISC_ACK the IDI frees the respective */ + /* channel, so we cannot store the state in ncci_state! The */ + /* information which channel we received a N_DISC is thus */ + /* stored in the inc_dis_ncci_table buffer. */ + for (i = 0; plci->inc_dis_ncci_table[i]; i++); + plci->inc_dis_ncci_table[i] = (byte) ncci; + + /* need a connect_b3_ind before a disconnect_b3_ind with FAX */ + if (!plci->channels + && (plci->B1_resource == 16) + && (plci->State <= CONNECTED)) + { + len = 9; + i = ((T30_INFO *)plci->fax_connect_info_buffer)->rate_div_2400 * 2400; + PUT_WORD(&plci->ncpi_buffer[1], i); + PUT_WORD(&plci->ncpi_buffer[3], 0); + i = ((T30_INFO *)plci->fax_connect_info_buffer)->data_format; + PUT_WORD(&plci->ncpi_buffer[5], i); + PUT_WORD(&plci->ncpi_buffer[7], 0); + plci->ncpi_buffer[len] = 0; + plci->ncpi_buffer[0] = len; + if (plci->B3_prot == 4) + sendf(plci->appl, _CONNECT_B3_I, Id, 0, "s", ""); + else + { + + if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1]) + & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD))) + { + plci->ncpi_buffer[++len] = 0; + plci->ncpi_buffer[++len] = 0; + plci->ncpi_buffer[++len] = 0; + plci->ncpi_buffer[0] = len; + } + + sendf(plci->appl, _CONNECT_B3_I, Id, 0, "S", plci->ncpi_buffer); + } + sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", info, plci->ncpi_buffer); + plci->ncpi_state = 0; + sig_req(plci, HANGUP, 0); + send_req(plci); + plci->State = OUTG_DIS_PENDING; + /* disc here */ + } + else if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS) + && ((plci->B3_prot == 4) || (plci->B3_prot == 5)) + && ((ncci_state == INC_DIS_PENDING) || (ncci_state == IDLE))) + { + if (ncci_state == IDLE) + { + if (plci->channels) + plci->channels--; + if ((plci->State == IDLE || plci->State == SUSPENDING) && !plci->channels) { + if (plci->State == SUSPENDING) { + sendf(plci->appl, + _FACILITY_I, + Id & 0xffffL, + 0, + "ws", (word)3, "\x03\x04\x00\x00"); + sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0); + } + plci_remove(plci); + plci->State = IDLE; + } + } + } + else if (plci->channels) + { + sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", info, plci->ncpi_buffer); + plci->ncpi_state = 0; + if ((ncci_state == OUTG_REJ_PENDING) + && ((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))) + { + sig_req(plci, HANGUP, 0); + send_req(plci); + plci->State = OUTG_DIS_PENDING; + } + } + break; + case N_RESET: + a->ncci_state[ncci] = INC_RES_PENDING; + sendf(plci->appl, _RESET_B3_I, Id, 0, "S", plci->ncpi_buffer); + break; + case N_RESET_ACK: + a->ncci_state[ncci] = CONNECTED; + sendf(plci->appl, _RESET_B3_I, Id, 0, "S", plci->ncpi_buffer); + break; + + case N_UDATA: + if (!(udata_forwarding_table[plci->NL.RBuffer->P[0] >> 5] & (1L << (plci->NL.RBuffer->P[0] & 0x1f)))) + { + plci->RData[0].P = plci->internal_ind_buffer + (-((int)(long)(plci->internal_ind_buffer)) & 3); + plci->RData[0].PLength = INTERNAL_IND_BUFFER_SIZE; + plci->NL.R = plci->RData; + plci->NL.RNum = 1; + return; + } + case N_BDATA: + case N_DATA: + if (((a->ncci_state[ncci] != CONNECTED) && (plci->B2_prot == 1)) /* transparent */ + || (a->ncci_state[ncci] == IDLE) + || (a->ncci_state[ncci] == INC_DIS_PENDING)) + { + plci->NL.RNR = 2; + break; + } + if ((a->ncci_state[ncci] != CONNECTED) + && (a->ncci_state[ncci] != OUTG_DIS_PENDING) + && (a->ncci_state[ncci] != OUTG_REJ_PENDING)) + { + dbug(1, dprintf("flow control")); + plci->NL.RNR = 1; /* flow control */ + channel_x_off(plci, ch, 0); + break; + } + + NCCIcode = ncci | (((word)a->Id) << 8); + + /* count all buffers within the Application pool */ + /* belonging to the same NCCI. If this is below the */ + /* number of buffers available per NCCI we accept */ + /* this packet, otherwise we reject it */ + count = 0; + Num = 0xffff; + for (i = 0; i < APPLptr->MaxBuffer; i++) { + if (NCCIcode == APPLptr->DataNCCI[i]) count++; + if (!APPLptr->DataNCCI[i] && Num == 0xffff) Num = i; + } + + if (count >= APPLptr->MaxNCCIData || Num == 0xffff) + { + dbug(3, dprintf("Flow-Control")); + plci->NL.RNR = 1; + if (++(APPLptr->NCCIDataFlowCtrlTimer) >= + (word)((a->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL) ? 40 : 2000)) + { + plci->NL.RNR = 2; + dbug(3, dprintf("DiscardData")); + } else { + channel_x_off(plci, ch, 0); + } + break; + } + else + { + APPLptr->NCCIDataFlowCtrlTimer = 0; + } + + plci->RData[0].P = ReceiveBufferGet(APPLptr, Num); + if (!plci->RData[0].P) { + plci->NL.RNR = 1; + channel_x_off(plci, ch, 0); + break; + } + + APPLptr->DataNCCI[Num] = NCCIcode; + APPLptr->DataFlags[Num] = (plci->Id << 8) | (plci->NL.Ind >> 4); + dbug(3, dprintf("Buffer(%d), Max = %d", Num, APPLptr->MaxBuffer)); + + plci->RNum = Num; + plci->RFlags = plci->NL.Ind >> 4; + plci->RData[0].PLength = APPLptr->MaxDataLength; + plci->NL.R = plci->RData; + if ((plci->NL.RLength != 0) + && ((plci->B2_prot == B2_V120_ASYNC) + || (plci->B2_prot == B2_V120_ASYNC_V42BIS) + || (plci->B2_prot == B2_V120_BIT_TRANSPARENT))) + { + plci->RData[1].P = plci->RData[0].P; + plci->RData[1].PLength = plci->RData[0].PLength; + plci->RData[0].P = v120_header_buffer + (-((unsigned long)v120_header_buffer) & 3); + if ((plci->NL.RBuffer->P[0] & V120_HEADER_EXTEND_BIT) || (plci->NL.RLength == 1)) + plci->RData[0].PLength = 1; + else + plci->RData[0].PLength = 2; + if (plci->NL.RBuffer->P[0] & V120_HEADER_BREAK_BIT) + plci->RFlags |= 0x0010; + if (plci->NL.RBuffer->P[0] & (V120_HEADER_C1_BIT | V120_HEADER_C2_BIT)) + plci->RFlags |= 0x8000; + plci->NL.RNum = 2; + } + else + { + if ((plci->NL.Ind & 0x0f) == N_UDATA) + plci->RFlags |= 0x0010; + + else if ((plci->B3_prot == B3_RTP) && ((plci->NL.Ind & 0x0f) == N_BDATA)) + plci->RFlags |= 0x0001; + + plci->NL.RNum = 1; + } + break; + case N_DATA_ACK: + data_ack(plci, ch); + break; + default: + plci->NL.RNR = 2; + break; + } +} + +/*------------------------------------------------------------------*/ +/* find a free PLCI */ +/*------------------------------------------------------------------*/ + +static word get_plci(DIVA_CAPI_ADAPTER *a) +{ + word i, j; + PLCI *plci; + + dump_plcis(a); + for (i = 0; i < a->max_plci && a->plci[i].Id; i++); + if (i == a->max_plci) { + dbug(1, dprintf("get_plci: out of PLCIs")); + return 0; + } + plci = &a->plci[i]; + plci->Id = (byte)(i + 1); + + plci->Sig.Id = 0; + plci->NL.Id = 0; + plci->sig_req = 0; + plci->nl_req = 0; + + plci->appl = NULL; + plci->relatedPTYPLCI = NULL; + plci->State = IDLE; + plci->SuppState = IDLE; + plci->channels = 0; + plci->tel = 0; + plci->B1_resource = 0; + plci->B2_prot = 0; + plci->B3_prot = 0; + + plci->command = 0; + plci->m_command = 0; + init_internal_command_queue(plci); + plci->number = 0; + plci->req_in_start = 0; + plci->req_in = 0; + plci->req_out = 0; + plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE; + plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE; + plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE; + + plci->data_sent = false; + plci->send_disc = 0; + plci->sig_global_req = 0; + plci->sig_remove_id = 0; + plci->nl_global_req = 0; + plci->nl_remove_id = 0; + plci->adv_nl = 0; + plci->manufacturer = false; + plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE; + plci->spoofed_msg = 0; + plci->ptyState = 0; + plci->cr_enquiry = false; + plci->hangup_flow_ctrl_timer = 0; + + plci->ncci_ring_list = 0; + for (j = 0; j < MAX_CHANNELS_PER_PLCI; j++) plci->inc_dis_ncci_table[j] = 0; + clear_c_ind_mask(plci); + set_group_ind_mask(plci); + plci->fax_connect_info_length = 0; + plci->nsf_control_bits = 0; + plci->ncpi_state = 0x00; + plci->ncpi_buffer[0] = 0; + + plci->requested_options_conn = 0; + plci->requested_options = 0; + plci->notifiedcall = 0; + plci->vswitchstate = 0; + plci->vsprot = 0; + plci->vsprotdialect = 0; + init_b1_config(plci); + dbug(1, dprintf("get_plci(%x)", plci->Id)); + return i + 1; +} + +/*------------------------------------------------------------------*/ +/* put a parameter in the parameter buffer */ +/*------------------------------------------------------------------*/ + +static void add_p(PLCI *plci, byte code, byte *p) +{ + word p_length; + + p_length = 0; + if (p) p_length = p[0]; + add_ie(plci, code, p, p_length); +} + +/*------------------------------------------------------------------*/ +/* put a structure in the parameter buffer */ +/*------------------------------------------------------------------*/ +static void add_s(PLCI *plci, byte code, API_PARSE *p) +{ + if (p) add_ie(plci, code, p->info, (word)p->length); +} + +/*------------------------------------------------------------------*/ +/* put multiple structures in the parameter buffer */ +/*------------------------------------------------------------------*/ +static void add_ss(PLCI *plci, byte code, API_PARSE *p) +{ + byte i; + + if (p) { + dbug(1, dprintf("add_ss(%x,len=%d)", code, p->length)); + for (i = 2; i < (byte)p->length; i += p->info[i] + 2) { + dbug(1, dprintf("add_ss_ie(%x,len=%d)", p->info[i - 1], p->info[i])); + add_ie(plci, p->info[i - 1], (byte *)&(p->info[i]), (word)p->info[i]); + } + } +} + +/*------------------------------------------------------------------*/ +/* return the channel number sent by the application in a esc_chi */ +/*------------------------------------------------------------------*/ +static byte getChannel(API_PARSE *p) +{ + byte i; + + if (p) { + for (i = 2; i < (byte)p->length; i += p->info[i] + 2) { + if (p->info[i] == 2) { + if (p->info[i - 1] == ESC && p->info[i + 1] == CHI) return (p->info[i + 2]); + } + } + } + return 0; +} + + +/*------------------------------------------------------------------*/ +/* put an information element in the parameter buffer */ +/*------------------------------------------------------------------*/ + +static void add_ie(PLCI *plci, byte code, byte *p, word p_length) +{ + word i; + + if (!(code & 0x80) && !p_length) return; + + if (plci->req_in == plci->req_in_start) { + plci->req_in += 2; + } + else { + plci->req_in--; + } + plci->RBuffer[plci->req_in++] = code; + + if (p) { + plci->RBuffer[plci->req_in++] = (byte)p_length; + for (i = 0; i < p_length; i++) plci->RBuffer[plci->req_in++] = p[1 + i]; + } + + plci->RBuffer[plci->req_in++] = 0; +} + +/*------------------------------------------------------------------*/ +/* put a unstructured data into the buffer */ +/*------------------------------------------------------------------*/ + +static void add_d(PLCI *plci, word length, byte *p) +{ + word i; + + if (plci->req_in == plci->req_in_start) { + plci->req_in += 2; + } + else { + plci->req_in--; + } + for (i = 0; i < length; i++) plci->RBuffer[plci->req_in++] = p[i]; +} + +/*------------------------------------------------------------------*/ +/* put parameters from the Additional Info parameter in the */ +/* parameter buffer */ +/*------------------------------------------------------------------*/ + +static void add_ai(PLCI *plci, API_PARSE *ai) +{ + word i; + API_PARSE ai_parms[5]; + + for (i = 0; i < 5; i++) ai_parms[i].length = 0; + + if (!ai->length) + return; + if (api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms)) + return; + + add_s(plci, KEY, &ai_parms[1]); + add_s(plci, UUI, &ai_parms[2]); + add_ss(plci, FTY, &ai_parms[3]); +} + +/*------------------------------------------------------------------*/ +/* put parameter for b1 protocol in the parameter buffer */ +/*------------------------------------------------------------------*/ + +static word add_b1(PLCI *plci, API_PARSE *bp, word b_channel_info, + word b1_facilities) +{ + API_PARSE bp_parms[8]; + API_PARSE mdm_cfg[9]; + API_PARSE global_config[2]; + byte cai[256]; + byte resource[] = {5, 9, 13, 12, 16, 39, 9, 17, 17, 18}; + byte voice_cai[] = "\x06\x14\x00\x00\x00\x00\x08"; + word i; + + API_PARSE mdm_cfg_v18[4]; + word j, n, w; + dword d; + + + for (i = 0; i < 8; i++) bp_parms[i].length = 0; + for (i = 0; i < 2; i++) global_config[i].length = 0; + + dbug(1, dprintf("add_b1")); + api_save_msg(bp, "s", &plci->B_protocol); + + if (b_channel_info == 2) { + plci->B1_resource = 0; + adjust_b1_facilities(plci, plci->B1_resource, b1_facilities); + add_p(plci, CAI, "\x01\x00"); + dbug(1, dprintf("Cai=1,0 (no resource)")); + return 0; + } + + if (plci->tel == CODEC_PERMANENT) return 0; + else if (plci->tel == CODEC) { + plci->B1_resource = 1; + adjust_b1_facilities(plci, plci->B1_resource, b1_facilities); + add_p(plci, CAI, "\x01\x01"); + dbug(1, dprintf("Cai=1,1 (Codec)")); + return 0; + } + else if (plci->tel == ADV_VOICE) { + plci->B1_resource = add_b1_facilities(plci, 9, (word)(b1_facilities | B1_FACILITY_VOICE)); + adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities | B1_FACILITY_VOICE)); + voice_cai[1] = plci->B1_resource; + PUT_WORD(&voice_cai[5], plci->appl->MaxDataLength); + add_p(plci, CAI, voice_cai); + dbug(1, dprintf("Cai=1,0x%x (AdvVoice)", voice_cai[1])); + return 0; + } + plci->call_dir &= ~(CALL_DIR_ORIGINATE | CALL_DIR_ANSWER); + if (plci->call_dir & CALL_DIR_OUT) + plci->call_dir |= CALL_DIR_ORIGINATE; + else if (plci->call_dir & CALL_DIR_IN) + plci->call_dir |= CALL_DIR_ANSWER; + + if (!bp->length) { + plci->B1_resource = 0x5; + adjust_b1_facilities(plci, plci->B1_resource, b1_facilities); + add_p(plci, CAI, "\x01\x05"); + return 0; + } + + dbug(1, dprintf("b_prot_len=%d", (word)bp->length)); + if (bp->length > 256) return _WRONG_MESSAGE_FORMAT; + if (api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms)) + { + bp_parms[6].length = 0; + if (api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms)) + { + dbug(1, dprintf("b-form.!")); + return _WRONG_MESSAGE_FORMAT; + } + } + else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms)) + { + dbug(1, dprintf("b-form.!")); + return _WRONG_MESSAGE_FORMAT; + } + + if (bp_parms[6].length) + { + if (api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config)) + { + return _WRONG_MESSAGE_FORMAT; + } + switch (GET_WORD(global_config[0].info)) + { + case 1: + plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE; + break; + case 2: + plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER; + break; + } + } + dbug(1, dprintf("call_dir=%04x", plci->call_dir)); + + + if ((GET_WORD(bp_parms[0].info) == B1_RTP) + && (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP))) + { + plci->B1_resource = add_b1_facilities(plci, 31, (word)(b1_facilities & ~B1_FACILITY_VOICE)); + adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE)); + cai[1] = plci->B1_resource; + cai[2] = 0; + cai[3] = 0; + cai[4] = 0; + PUT_WORD(&cai[5], plci->appl->MaxDataLength); + for (i = 0; i < bp_parms[3].length; i++) + cai[7 + i] = bp_parms[3].info[1 + i]; + cai[0] = 6 + bp_parms[3].length; + add_p(plci, CAI, cai); + return 0; + } + + + if ((GET_WORD(bp_parms[0].info) == B1_PIAFS) + && (plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS))) + { + plci->B1_resource = add_b1_facilities(plci, 35/* PIAFS HARDWARE FACILITY */, (word)(b1_facilities & ~B1_FACILITY_VOICE)); + adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE)); + cai[1] = plci->B1_resource; + cai[2] = 0; + cai[3] = 0; + cai[4] = 0; + PUT_WORD(&cai[5], plci->appl->MaxDataLength); + cai[0] = 6; + add_p(plci, CAI, cai); + return 0; + } + + + if ((GET_WORD(bp_parms[0].info) >= 32) + || (!((1L << GET_WORD(bp_parms[0].info)) & plci->adapter->profile.B1_Protocols) + && ((GET_WORD(bp_parms[0].info) != 3) + || !((1L << B1_HDLC) & plci->adapter->profile.B1_Protocols) + || ((bp_parms[3].length != 0) && (GET_WORD(&bp_parms[3].info[1]) != 0) && (GET_WORD(&bp_parms[3].info[1]) != 56000))))) + { + return _B1_NOT_SUPPORTED; + } + plci->B1_resource = add_b1_facilities(plci, resource[GET_WORD(bp_parms[0].info)], + (word)(b1_facilities & ~B1_FACILITY_VOICE)); + adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE)); + cai[0] = 6; + cai[1] = plci->B1_resource; + for (i = 2; i < sizeof(cai); i++) cai[i] = 0; + + if ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE) + || (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC) + || (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC)) + { /* B1 - modem */ + for (i = 0; i < 7; i++) mdm_cfg[i].length = 0; + + if (bp_parms[3].length) + { + if (api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwww", mdm_cfg)) + { + return (_WRONG_MESSAGE_FORMAT); + } + + cai[2] = 0; /* Bit rate for adaptation */ + + dbug(1, dprintf("MDM Max Bit Rate:<%d>", GET_WORD(mdm_cfg[0].info))); + + PUT_WORD(&cai[13], 0); /* Min Tx speed */ + PUT_WORD(&cai[15], GET_WORD(mdm_cfg[0].info)); /* Max Tx speed */ + PUT_WORD(&cai[17], 0); /* Min Rx speed */ + PUT_WORD(&cai[19], GET_WORD(mdm_cfg[0].info)); /* Max Rx speed */ + + cai[3] = 0; /* Async framing parameters */ + switch (GET_WORD(mdm_cfg[2].info)) + { /* Parity */ + case 1: /* odd parity */ + cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD); + dbug(1, dprintf("MDM: odd parity")); + break; + + case 2: /* even parity */ + cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN); + dbug(1, dprintf("MDM: even parity")); + break; + + default: + dbug(1, dprintf("MDM: no parity")); + break; + } + + switch (GET_WORD(mdm_cfg[3].info)) + { /* stop bits */ + case 1: /* 2 stop bits */ + cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS; + dbug(1, dprintf("MDM: 2 stop bits")); + break; + + default: + dbug(1, dprintf("MDM: 1 stop bit")); + break; + } + + switch (GET_WORD(mdm_cfg[1].info)) + { /* char length */ + case 5: + cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5; + dbug(1, dprintf("MDM: 5 bits")); + break; + + case 6: + cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6; + dbug(1, dprintf("MDM: 6 bits")); + break; + + case 7: + cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7; + dbug(1, dprintf("MDM: 7 bits")); + break; + + default: + dbug(1, dprintf("MDM: 8 bits")); + break; + } + + cai[7] = 0; /* Line taking options */ + cai[8] = 0; /* Modulation negotiation options */ + cai[9] = 0; /* Modulation options */ + + if (((plci->call_dir & CALL_DIR_ORIGINATE) != 0) ^ ((plci->call_dir & CALL_DIR_OUT) != 0)) + { + cai[9] |= DSP_CAI_MODEM_REVERSE_DIRECTION; + dbug(1, dprintf("MDM: Reverse direction")); + } + + if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_DISABLE_RETRAIN) + { + cai[9] |= DSP_CAI_MODEM_DISABLE_RETRAIN; + dbug(1, dprintf("MDM: Disable retrain")); + } + + if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_DISABLE_RING_TONE) + { + cai[7] |= DSP_CAI_MODEM_DISABLE_CALLING_TONE | DSP_CAI_MODEM_DISABLE_ANSWER_TONE; + dbug(1, dprintf("MDM: Disable ring tone")); + } + + if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_GUARD_1800) + { + cai[8] |= DSP_CAI_MODEM_GUARD_TONE_1800HZ; + dbug(1, dprintf("MDM: 1800 guard tone")); + } + else if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_GUARD_550) + { + cai[8] |= DSP_CAI_MODEM_GUARD_TONE_550HZ; + dbug(1, dprintf("MDM: 550 guard tone")); + } + + if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_V100) + { + cai[8] |= DSP_CAI_MODEM_NEGOTIATE_V100; + dbug(1, dprintf("MDM: V100")); + } + else if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_MOD_CLASS) + { + cai[8] |= DSP_CAI_MODEM_NEGOTIATE_IN_CLASS; + dbug(1, dprintf("MDM: IN CLASS")); + } + else if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_DISABLED) + { + cai[8] |= DSP_CAI_MODEM_NEGOTIATE_DISABLED; + dbug(1, dprintf("MDM: DISABLED")); + } + cai[0] = 20; + + if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_V18)) + && (GET_WORD(mdm_cfg[5].info) & 0x8000)) /* Private V.18 enable */ + { + plci->requested_options |= 1L << PRIVATE_V18; + } + if (GET_WORD(mdm_cfg[5].info) & 0x4000) /* Private VOWN enable */ + plci->requested_options |= 1L << PRIVATE_VOWN; + + if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1]) + & ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN))) + { + if (!api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwwws", mdm_cfg)) + { + i = 27; + if (mdm_cfg[6].length >= 4) + { + d = GET_DWORD(&mdm_cfg[6].info[1]); + cai[7] |= (byte) d; /* line taking options */ + cai[9] |= (byte)(d >> 8); /* modulation options */ + cai[++i] = (byte)(d >> 16); /* vown modulation options */ + cai[++i] = (byte)(d >> 24); + if (mdm_cfg[6].length >= 8) + { + d = GET_DWORD(&mdm_cfg[6].info[5]); + cai[10] |= (byte) d; /* disabled modulations mask */ + cai[11] |= (byte)(d >> 8); + if (mdm_cfg[6].length >= 12) + { + d = GET_DWORD(&mdm_cfg[6].info[9]); + cai[12] = (byte) d; /* enabled modulations mask */ + cai[++i] = (byte)(d >> 8); /* vown enabled modulations */ + cai[++i] = (byte)(d >> 16); + cai[++i] = (byte)(d >> 24); + cai[++i] = 0; + if (mdm_cfg[6].length >= 14) + { + w = GET_WORD(&mdm_cfg[6].info[13]); + if (w != 0) + PUT_WORD(&cai[13], w); /* min tx speed */ + if (mdm_cfg[6].length >= 16) + { + w = GET_WORD(&mdm_cfg[6].info[15]); + if (w != 0) + PUT_WORD(&cai[15], w); /* max tx speed */ + if (mdm_cfg[6].length >= 18) + { + w = GET_WORD(&mdm_cfg[6].info[17]); + if (w != 0) + PUT_WORD(&cai[17], w); /* min rx speed */ + if (mdm_cfg[6].length >= 20) + { + w = GET_WORD(&mdm_cfg[6].info[19]); + if (w != 0) + PUT_WORD(&cai[19], w); /* max rx speed */ + if (mdm_cfg[6].length >= 22) + { + w = GET_WORD(&mdm_cfg[6].info[21]); + cai[23] = (byte)(-((short) w)); /* transmit level */ + if (mdm_cfg[6].length >= 24) + { + w = GET_WORD(&mdm_cfg[6].info[23]); + cai[22] |= (byte) w; /* info options mask */ + cai[21] |= (byte)(w >> 8); /* disabled symbol rates */ + } + } + } + } + } + } + } + } + } + cai[27] = i - 27; + i++; + if (!api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwwwss", mdm_cfg)) + { + if (!api_parse(&mdm_cfg[7].info[1], (word)mdm_cfg[7].length, "sss", mdm_cfg_v18)) + { + for (n = 0; n < 3; n++) + { + cai[i] = (byte)(mdm_cfg_v18[n].length); + for (j = 1; j < ((word)(cai[i] + 1)); j++) + cai[i + j] = mdm_cfg_v18[n].info[j]; + i += cai[i] + 1; + } + } + } + cai[0] = (byte)(i - 1); + } + } + + } + } + if (GET_WORD(bp_parms[0].info) == 2 || /* V.110 async */ + GET_WORD(bp_parms[0].info) == 3) /* V.110 sync */ + { + if (bp_parms[3].length) { + dbug(1, dprintf("V.110,%d", GET_WORD(&bp_parms[3].info[1]))); + switch (GET_WORD(&bp_parms[3].info[1])) { /* Rate */ + case 0: + case 56000: + if (GET_WORD(bp_parms[0].info) == 3) { /* V.110 sync 56k */ + dbug(1, dprintf("56k sync HSCX")); + cai[1] = 8; + cai[2] = 0; + cai[3] = 0; + } + else if (GET_WORD(bp_parms[0].info) == 2) { + dbug(1, dprintf("56k async DSP")); + cai[2] = 9; + } + break; + case 50: cai[2] = 1; break; + case 75: cai[2] = 1; break; + case 110: cai[2] = 1; break; + case 150: cai[2] = 1; break; + case 200: cai[2] = 1; break; + case 300: cai[2] = 1; break; + case 600: cai[2] = 1; break; + case 1200: cai[2] = 2; break; + case 2400: cai[2] = 3; break; + case 4800: cai[2] = 4; break; + case 7200: cai[2] = 10; break; + case 9600: cai[2] = 5; break; + case 12000: cai[2] = 13; break; + case 24000: cai[2] = 0; break; + case 14400: cai[2] = 11; break; + case 19200: cai[2] = 6; break; + case 28800: cai[2] = 12; break; + case 38400: cai[2] = 7; break; + case 48000: cai[2] = 8; break; + case 76: cai[2] = 15; break; /* 75/1200 */ + case 1201: cai[2] = 14; break; /* 1200/75 */ + case 56001: cai[2] = 9; break; /* V.110 56000 */ + + default: + return _B1_PARM_NOT_SUPPORTED; + } + cai[3] = 0; + if (cai[1] == 13) /* v.110 async */ + { + if (bp_parms[3].length >= 8) + { + switch (GET_WORD(&bp_parms[3].info[3])) + { /* char length */ + case 5: + cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5; + break; + case 6: + cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6; + break; + case 7: + cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7; + break; + } + switch (GET_WORD(&bp_parms[3].info[5])) + { /* Parity */ + case 1: /* odd parity */ + cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD); + break; + case 2: /* even parity */ + cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN); + break; + } + switch (GET_WORD(&bp_parms[3].info[7])) + { /* stop bits */ + case 1: /* 2 stop bits */ + cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS; + break; + } + } + } + } + else if (cai[1] == 8 || GET_WORD(bp_parms[0].info) == 3) { + dbug(1, dprintf("V.110 default 56k sync")); + cai[1] = 8; + cai[2] = 0; + cai[3] = 0; + } + else { + dbug(1, dprintf("V.110 default 9600 async")); + cai[2] = 5; + } + } + PUT_WORD(&cai[5], plci->appl->MaxDataLength); + dbug(1, dprintf("CAI[%d]=%x,%x,%x,%x,%x,%x", cai[0], cai[1], cai[2], cai[3], cai[4], cai[5], cai[6])); +/* HexDump ("CAI", sizeof(cai), &cai[0]); */ + + add_p(plci, CAI, cai); + return 0; +} + +/*------------------------------------------------------------------*/ +/* put parameter for b2 and B3 protocol in the parameter buffer */ +/*------------------------------------------------------------------*/ + +static word add_b23(PLCI *plci, API_PARSE *bp) +{ + word i, fax_control_bits; + byte pos, len; + byte SAPI = 0x40; /* default SAPI 16 for x.31 */ + API_PARSE bp_parms[8]; + API_PARSE *b1_config; + API_PARSE *b2_config; + API_PARSE b2_config_parms[8]; + API_PARSE *b3_config; + API_PARSE b3_config_parms[6]; + API_PARSE global_config[2]; + + static byte llc[3] = {2,0,0}; + static byte dlc[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + static byte nlc[256]; + static byte lli[12] = {1,1}; + + const byte llc2_out[] = {1,2,4,6,2,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6}; + const byte llc2_in[] = {1,3,4,6,3,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6}; + + const byte llc3[] = {4,3,2,2,6,6,0}; + const byte header[] = {0,2,3,3,0,0,0}; + + for (i = 0; i < 8; i++) bp_parms[i].length = 0; + for (i = 0; i < 6; i++) b2_config_parms[i].length = 0; + for (i = 0; i < 5; i++) b3_config_parms[i].length = 0; + + lli[0] = 1; + lli[1] = 1; + if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL) + lli[1] |= 2; + if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL) + lli[1] |= 4; + + if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) { + lli[1] |= 0x10; + if (plci->rx_dma_descriptor <= 0) { + plci->rx_dma_descriptor = diva_get_dma_descriptor(plci, &plci->rx_dma_magic); + if (plci->rx_dma_descriptor >= 0) + plci->rx_dma_descriptor++; + } + if (plci->rx_dma_descriptor > 0) { + lli[0] = 6; + lli[1] |= 0x40; + lli[2] = (byte)(plci->rx_dma_descriptor - 1); + lli[3] = (byte)plci->rx_dma_magic; + lli[4] = (byte)(plci->rx_dma_magic >> 8); + lli[5] = (byte)(plci->rx_dma_magic >> 16); + lli[6] = (byte)(plci->rx_dma_magic >> 24); + } + } + + if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) { + lli[1] |= 0x20; + } + + dbug(1, dprintf("add_b23")); + api_save_msg(bp, "s", &plci->B_protocol); + + if (!bp->length && plci->tel) + { + plci->adv_nl = true; + dbug(1, dprintf("Default adv.Nl")); + add_p(plci, LLI, lli); + plci->B2_prot = 1 /*XPARENT*/; + plci->B3_prot = 0 /*XPARENT*/; + llc[1] = 2; + llc[2] = 4; + add_p(plci, LLC, llc); + dlc[0] = 2; + PUT_WORD(&dlc[1], plci->appl->MaxDataLength); + add_p(plci, DLC, dlc); + return 0; + } + + if (!bp->length) /*default*/ + { + dbug(1, dprintf("ret default")); + add_p(plci, LLI, lli); + plci->B2_prot = 0 /*X.75 */; + plci->B3_prot = 0 /*XPARENT*/; + llc[1] = 1; + llc[2] = 4; + add_p(plci, LLC, llc); + dlc[0] = 2; + PUT_WORD(&dlc[1], plci->appl->MaxDataLength); + add_p(plci, DLC, dlc); + return 0; + } + dbug(1, dprintf("b_prot_len=%d", (word)bp->length)); + if ((word)bp->length > 256) return _WRONG_MESSAGE_FORMAT; + + if (api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms)) + { + bp_parms[6].length = 0; + if (api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms)) + { + dbug(1, dprintf("b-form.!")); + return _WRONG_MESSAGE_FORMAT; + } + } + else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms)) + { + dbug(1, dprintf("b-form.!")); + return _WRONG_MESSAGE_FORMAT; + } + + if (plci->tel == ADV_VOICE) /* transparent B on advanced voice */ + { + if (GET_WORD(bp_parms[1].info) != 1 + || GET_WORD(bp_parms[2].info) != 0) return _B2_NOT_SUPPORTED; + plci->adv_nl = true; + } + else if (plci->tel) return _B2_NOT_SUPPORTED; + + + if ((GET_WORD(bp_parms[1].info) == B2_RTP) + && (GET_WORD(bp_parms[2].info) == B3_RTP) + && (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP))) + { + add_p(plci, LLI, lli); + plci->B2_prot = (byte) GET_WORD(bp_parms[1].info); + plci->B3_prot = (byte) GET_WORD(bp_parms[2].info); + llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ? 14 : 13; + llc[2] = 4; + add_p(plci, LLC, llc); + dlc[0] = 2; + PUT_WORD(&dlc[1], plci->appl->MaxDataLength); + dlc[3] = 3; /* Addr A */ + dlc[4] = 1; /* Addr B */ + dlc[5] = 7; /* modulo mode */ + dlc[6] = 7; /* window size */ + dlc[7] = 0; /* XID len Lo */ + dlc[8] = 0; /* XID len Hi */ + for (i = 0; i < bp_parms[4].length; i++) + dlc[9 + i] = bp_parms[4].info[1 + i]; + dlc[0] = (byte)(8 + bp_parms[4].length); + add_p(plci, DLC, dlc); + for (i = 0; i < bp_parms[5].length; i++) + nlc[1 + i] = bp_parms[5].info[1 + i]; + nlc[0] = (byte)(bp_parms[5].length); + add_p(plci, NLC, nlc); + return 0; + } + + + + if ((GET_WORD(bp_parms[1].info) >= 32) + || (!((1L << GET_WORD(bp_parms[1].info)) & plci->adapter->profile.B2_Protocols) + && ((GET_WORD(bp_parms[1].info) != B2_PIAFS) + || !(plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS))))) + + { + return _B2_NOT_SUPPORTED; + } + if ((GET_WORD(bp_parms[2].info) >= 32) + || !((1L << GET_WORD(bp_parms[2].info)) & plci->adapter->profile.B3_Protocols)) + { + return _B3_NOT_SUPPORTED; + } + if ((GET_WORD(bp_parms[1].info) != B2_SDLC) + && ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE) + || (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC) + || (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC))) + { + return (add_modem_b23(plci, bp_parms)); + } + + add_p(plci, LLI, lli); + + plci->B2_prot = (byte)GET_WORD(bp_parms[1].info); + plci->B3_prot = (byte)GET_WORD(bp_parms[2].info); + if (plci->B2_prot == 12) SAPI = 0; /* default SAPI D-channel */ + + if (bp_parms[6].length) + { + if (api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config)) + { + return _WRONG_MESSAGE_FORMAT; + } + switch (GET_WORD(global_config[0].info)) + { + case 1: + plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE; + break; + case 2: + plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER; + break; + } + } + dbug(1, dprintf("call_dir=%04x", plci->call_dir)); + + + if (plci->B2_prot == B2_PIAFS) + llc[1] = PIAFS_CRC; + else +/* IMPLEMENT_PIAFS */ + { + llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ? + llc2_out[GET_WORD(bp_parms[1].info)] : llc2_in[GET_WORD(bp_parms[1].info)]; + } + llc[2] = llc3[GET_WORD(bp_parms[2].info)]; + + add_p(plci, LLC, llc); + + dlc[0] = 2; + PUT_WORD(&dlc[1], plci->appl->MaxDataLength + + header[GET_WORD(bp_parms[2].info)]); + + b1_config = &bp_parms[3]; + nlc[0] = 0; + if (plci->B3_prot == 4 + || plci->B3_prot == 5) + { + for (i = 0; i < sizeof(T30_INFO); i++) nlc[i] = 0; + nlc[0] = sizeof(T30_INFO); + if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS) + ((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI; + ((T30_INFO *)&nlc[1])->rate_div_2400 = 0xff; + if (b1_config->length >= 2) + { + ((T30_INFO *)&nlc[1])->rate_div_2400 = (byte)(GET_WORD(&b1_config->info[1]) / 2400); + } + } + b2_config = &bp_parms[4]; + + + if (llc[1] == PIAFS_CRC) + { + if (plci->B3_prot != B3_TRANSPARENT) + { + return _B_STACK_NOT_SUPPORTED; + } + if (b2_config->length && api_parse(&b2_config->info[1], (word)b2_config->length, "bwww", b2_config_parms)) { + return _WRONG_MESSAGE_FORMAT; + } + PUT_WORD(&dlc[1], plci->appl->MaxDataLength); + dlc[3] = 0; /* Addr A */ + dlc[4] = 0; /* Addr B */ + dlc[5] = 0; /* modulo mode */ + dlc[6] = 0; /* window size */ + if (b2_config->length >= 7) { + dlc[7] = 7; + dlc[8] = 0; + dlc[9] = b2_config_parms[0].info[0]; /* PIAFS protocol Speed configuration */ + dlc[10] = b2_config_parms[1].info[0]; /* V.42bis P0 */ + dlc[11] = b2_config_parms[1].info[1]; /* V.42bis P0 */ + dlc[12] = b2_config_parms[2].info[0]; /* V.42bis P1 */ + dlc[13] = b2_config_parms[2].info[1]; /* V.42bis P1 */ + dlc[14] = b2_config_parms[3].info[0]; /* V.42bis P2 */ + dlc[15] = b2_config_parms[3].info[1]; /* V.42bis P2 */ + dlc[0] = 15; + if (b2_config->length >= 8) { /* PIAFS control abilities */ + dlc[7] = 10; + dlc[16] = 2; /* Length of PIAFS extension */ + dlc[17] = PIAFS_UDATA_ABILITIES; /* control (UDATA) ability */ + dlc[18] = b2_config_parms[4].info[0]; /* value */ + dlc[0] = 18; + } + } + else /* default values, 64K, variable, no compression */ + { + dlc[7] = 7; + dlc[8] = 0; + dlc[9] = 0x03; /* PIAFS protocol Speed configuration */ + dlc[10] = 0x03; /* V.42bis P0 */ + dlc[11] = 0; /* V.42bis P0 */ + dlc[12] = 0; /* V.42bis P1 */ + dlc[13] = 0; /* V.42bis P1 */ + dlc[14] = 0; /* V.42bis P2 */ + dlc[15] = 0; /* V.42bis P2 */ + dlc[0] = 15; + } + add_p(plci, DLC, dlc); + } + else + + if ((llc[1] == V120_L2) || (llc[1] == V120_V42BIS)) + { + if (plci->B3_prot != B3_TRANSPARENT) + return _B_STACK_NOT_SUPPORTED; + + dlc[0] = 6; + PUT_WORD(&dlc[1], GET_WORD(&dlc[1]) + 2); + dlc[3] = 0x08; + dlc[4] = 0x01; + dlc[5] = 127; + dlc[6] = 7; + if (b2_config->length != 0) + { + if ((llc[1] == V120_V42BIS) && api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms)) { + return _WRONG_MESSAGE_FORMAT; + } + dlc[3] = (byte)((b2_config->info[2] << 3) | ((b2_config->info[1] >> 5) & 0x04)); + dlc[4] = (byte)((b2_config->info[1] << 1) | 0x01); + if (b2_config->info[3] != 128) + { + dbug(1, dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4])); + return _B2_PARM_NOT_SUPPORTED; + } + dlc[5] = (byte)(b2_config->info[3] - 1); + dlc[6] = b2_config->info[4]; + if (llc[1] == V120_V42BIS) { + if (b2_config->length >= 10) { + dlc[7] = 6; + dlc[8] = 0; + dlc[9] = b2_config_parms[4].info[0]; + dlc[10] = b2_config_parms[4].info[1]; + dlc[11] = b2_config_parms[5].info[0]; + dlc[12] = b2_config_parms[5].info[1]; + dlc[13] = b2_config_parms[6].info[0]; + dlc[14] = b2_config_parms[6].info[1]; + dlc[0] = 14; + dbug(1, dprintf("b2_config_parms[4].info[0] [1]: %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1])); + dbug(1, dprintf("b2_config_parms[5].info[0] [1]: %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1])); + dbug(1, dprintf("b2_config_parms[6].info[0] [1]: %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1])); + } + else { + dlc[6] = 14; + } + } + } + } + else + { + if (b2_config->length) + { + dbug(1, dprintf("B2-Config")); + if (llc[1] == X75_V42BIS) { + if (api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms)) + { + return _WRONG_MESSAGE_FORMAT; + } + } + else { + if (api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbs", b2_config_parms)) + { + return _WRONG_MESSAGE_FORMAT; + } + } + /* if B2 Protocol is LAPD, b2_config structure is different */ + if (llc[1] == 6) + { + dlc[0] = 4; + if (b2_config->length >= 1) dlc[2] = b2_config->info[1]; /* TEI */ + else dlc[2] = 0x01; + if ((b2_config->length >= 2) && (plci->B2_prot == 12)) + { + SAPI = b2_config->info[2]; /* SAPI */ + } + dlc[1] = SAPI; + if ((b2_config->length >= 3) && (b2_config->info[3] == 128)) + { + dlc[3] = 127; /* Mode */ + } + else + { + dlc[3] = 7; /* Mode */ + } + + if (b2_config->length >= 4) dlc[4] = b2_config->info[4]; /* Window */ + else dlc[4] = 1; + dbug(1, dprintf("D-dlc[%d]=%x,%x,%x,%x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4])); + if (b2_config->length > 5) return _B2_PARM_NOT_SUPPORTED; + } + else + { + dlc[0] = (byte)(b2_config_parms[4].length + 6); + dlc[3] = b2_config->info[1]; + dlc[4] = b2_config->info[2]; + if (b2_config->info[3] != 8 && b2_config->info[3] != 128) { + dbug(1, dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4])); + return _B2_PARM_NOT_SUPPORTED; + } + + dlc[5] = (byte)(b2_config->info[3] - 1); + dlc[6] = b2_config->info[4]; + if (dlc[6] > dlc[5]) { + dbug(1, dprintf("2D-dlc= %x %x %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4], dlc[5], dlc[6])); + return _B2_PARM_NOT_SUPPORTED; + } + + if (llc[1] == X75_V42BIS) { + if (b2_config->length >= 10) { + dlc[7] = 6; + dlc[8] = 0; + dlc[9] = b2_config_parms[4].info[0]; + dlc[10] = b2_config_parms[4].info[1]; + dlc[11] = b2_config_parms[5].info[0]; + dlc[12] = b2_config_parms[5].info[1]; + dlc[13] = b2_config_parms[6].info[0]; + dlc[14] = b2_config_parms[6].info[1]; + dlc[0] = 14; + dbug(1, dprintf("b2_config_parms[4].info[0] [1]: %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1])); + dbug(1, dprintf("b2_config_parms[5].info[0] [1]: %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1])); + dbug(1, dprintf("b2_config_parms[6].info[0] [1]: %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1])); + } + else { + dlc[6] = 14; + } + + } + else { + PUT_WORD(&dlc[7], (word)b2_config_parms[4].length); + for (i = 0; i < b2_config_parms[4].length; i++) + dlc[11 + i] = b2_config_parms[4].info[1 + i]; + } + } + } + } + add_p(plci, DLC, dlc); + + b3_config = &bp_parms[5]; + if (b3_config->length) + { + if (plci->B3_prot == 4 + || plci->B3_prot == 5) + { + if (api_parse(&b3_config->info[1], (word)b3_config->length, "wwss", b3_config_parms)) + { + return _WRONG_MESSAGE_FORMAT; + } + i = GET_WORD((byte *)(b3_config_parms[0].info)); + ((T30_INFO *)&nlc[1])->resolution = (byte)(((i & 0x0001) || + ((plci->B3_prot == 4) && (((byte)(GET_WORD((byte *)b3_config_parms[1].info))) != 5))) ? T30_RESOLUTION_R8_0770_OR_200 : 0); + ((T30_INFO *)&nlc[1])->data_format = (byte)(GET_WORD((byte *)b3_config_parms[1].info)); + fax_control_bits = T30_CONTROL_BIT_ALL_FEATURES; + if ((((T30_INFO *)&nlc[1])->rate_div_2400 != 0) && (((T30_INFO *)&nlc[1])->rate_div_2400 <= 6)) + fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_V34FAX; + if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS) + { + + if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1]) + & (1L << PRIVATE_FAX_PAPER_FORMATS)) + { + ((T30_INFO *)&nlc[1])->resolution |= T30_RESOLUTION_R8_1540 | + T30_RESOLUTION_R16_1540_OR_400 | T30_RESOLUTION_300_300 | + T30_RESOLUTION_INCH_BASED | T30_RESOLUTION_METRIC_BASED; + } + + ((T30_INFO *)&nlc[1])->recording_properties = + T30_RECORDING_WIDTH_ISO_A3 | + (T30_RECORDING_LENGTH_UNLIMITED << 2) | + (T30_MIN_SCANLINE_TIME_00_00_00 << 4); + } + if (plci->B3_prot == 5) + { + if (i & 0x0002) /* Accept incoming fax-polling requests */ + fax_control_bits |= T30_CONTROL_BIT_ACCEPT_POLLING; + if (i & 0x2000) /* Do not use MR compression */ + fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_2D_CODING; + if (i & 0x4000) /* Do not use MMR compression */ + fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_T6_CODING; + if (i & 0x8000) /* Do not use ECM */ + fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_ECM; + if (plci->fax_connect_info_length != 0) + { + ((T30_INFO *)&nlc[1])->resolution = ((T30_INFO *)plci->fax_connect_info_buffer)->resolution; + ((T30_INFO *)&nlc[1])->data_format = ((T30_INFO *)plci->fax_connect_info_buffer)->data_format; + ((T30_INFO *)&nlc[1])->recording_properties = ((T30_INFO *)plci->fax_connect_info_buffer)->recording_properties; + fax_control_bits |= GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low) & + (T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS); + } + } + /* copy station id to NLC */ + for (i = 0; i < T30_MAX_STATION_ID_LENGTH; i++) + { + if (i < b3_config_parms[2].length) + { + ((T30_INFO *)&nlc[1])->station_id[i] = ((byte *)b3_config_parms[2].info)[1 + i]; + } + else + { + ((T30_INFO *)&nlc[1])->station_id[i] = ' '; + } + } + ((T30_INFO *)&nlc[1])->station_id_len = T30_MAX_STATION_ID_LENGTH; + /* copy head line to NLC */ + if (b3_config_parms[3].length) + { + + pos = (byte)(fax_head_line_time(&(((T30_INFO *)&nlc[1])->station_id[T30_MAX_STATION_ID_LENGTH]))); + if (pos != 0) + { + if (CAPI_MAX_DATE_TIME_LENGTH + 2 + b3_config_parms[3].length > CAPI_MAX_HEAD_LINE_SPACE) + pos = 0; + else + { + nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' '; + nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' '; + len = (byte)b3_config_parms[2].length; + if (len > 20) + len = 20; + if (CAPI_MAX_DATE_TIME_LENGTH + 2 + len + 2 + b3_config_parms[3].length <= CAPI_MAX_HEAD_LINE_SPACE) + { + for (i = 0; i < len; i++) + nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ((byte *)b3_config_parms[2].info)[1 + i]; + nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' '; + nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' '; + } + } + } + + len = (byte)b3_config_parms[3].length; + if (len > CAPI_MAX_HEAD_LINE_SPACE - pos) + len = (byte)(CAPI_MAX_HEAD_LINE_SPACE - pos); + ((T30_INFO *)&nlc[1])->head_line_len = (byte)(pos + len); + nlc[0] += (byte)(pos + len); + for (i = 0; i < len; i++) + nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ((byte *)b3_config_parms[3].info)[1 + i]; + } else + ((T30_INFO *)&nlc[1])->head_line_len = 0; + + plci->nsf_control_bits = 0; + if (plci->B3_prot == 5) + { + if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD)) + && (GET_WORD((byte *)b3_config_parms[1].info) & 0x8000)) /* Private SUB/SEP/PWD enable */ + { + plci->requested_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD; + } + if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD)) + && (GET_WORD((byte *)b3_config_parms[1].info) & 0x4000)) /* Private non-standard facilities enable */ + { + plci->requested_options |= 1L << PRIVATE_FAX_NONSTANDARD; + } + if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1]) + & ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD))) + { + if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1]) + & (1L << PRIVATE_FAX_SUB_SEP_PWD)) + { + fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD; + if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING) + fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING; + } + len = nlc[0]; + pos = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH; + if (pos < plci->fax_connect_info_length) + { + for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--) + nlc[++len] = plci->fax_connect_info_buffer[pos++]; + } + else + nlc[++len] = 0; + if (pos < plci->fax_connect_info_length) + { + for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--) + nlc[++len] = plci->fax_connect_info_buffer[pos++]; + } + else + nlc[++len] = 0; + if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1]) + & (1L << PRIVATE_FAX_NONSTANDARD)) + { + if ((pos < plci->fax_connect_info_length) && (plci->fax_connect_info_buffer[pos] != 0)) + { + if ((plci->fax_connect_info_buffer[pos] >= 3) && (plci->fax_connect_info_buffer[pos + 1] >= 2)) + plci->nsf_control_bits = GET_WORD(&plci->fax_connect_info_buffer[pos + 2]); + for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--) + nlc[++len] = plci->fax_connect_info_buffer[pos++]; + } + else + { + if (api_parse(&b3_config->info[1], (word)b3_config->length, "wwsss", b3_config_parms)) + { + dbug(1, dprintf("non-standard facilities info missing or wrong format")); + nlc[++len] = 0; + } + else + { + if ((b3_config_parms[4].length >= 3) && (b3_config_parms[4].info[1] >= 2)) + plci->nsf_control_bits = GET_WORD(&b3_config_parms[4].info[2]); + nlc[++len] = (byte)(b3_config_parms[4].length); + for (i = 0; i < b3_config_parms[4].length; i++) + nlc[++len] = b3_config_parms[4].info[1 + i]; + } + } + } + nlc[0] = len; + if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF) + && (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP)) + { + ((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI_NEG; + } + } + } + + PUT_WORD(&(((T30_INFO *)&nlc[1])->control_bits_low), fax_control_bits); + len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH; + for (i = 0; i < len; i++) + plci->fax_connect_info_buffer[i] = nlc[1 + i]; + ((T30_INFO *) plci->fax_connect_info_buffer)->head_line_len = 0; + i += ((T30_INFO *)&nlc[1])->head_line_len; + while (i < nlc[0]) + plci->fax_connect_info_buffer[len++] = nlc[++i]; + plci->fax_connect_info_length = len; + } + else + { + nlc[0] = 14; + if (b3_config->length != 16) + return _B3_PARM_NOT_SUPPORTED; + for (i = 0; i < 12; i++) nlc[1 + i] = b3_config->info[1 + i]; + if (GET_WORD(&b3_config->info[13]) != 8 && GET_WORD(&b3_config->info[13]) != 128) + return _B3_PARM_NOT_SUPPORTED; + nlc[13] = b3_config->info[13]; + if (GET_WORD(&b3_config->info[15]) >= nlc[13]) + return _B3_PARM_NOT_SUPPORTED; + nlc[14] = b3_config->info[15]; + } + } + else + { + if (plci->B3_prot == 4 + || plci->B3_prot == 5 /*T.30 - FAX*/) return _B3_PARM_NOT_SUPPORTED; + } + add_p(plci, NLC, nlc); + return 0; +} + +/*----------------------------------------------------------------*/ +/* make the same as add_b23, but only for the modem related */ +/* L2 and L3 B-Chan protocol. */ +/* */ +/* Enabled L2 and L3 Configurations: */ +/* If L1 == Modem all negotiation */ +/* only L2 == Modem with full negotiation is allowed */ +/* If L1 == Modem async or sync */ +/* only L2 == Transparent is allowed */ +/* L3 == Modem or L3 == Transparent are allowed */ +/* B2 Configuration for modem: */ +/* word : enable/disable compression, bitoptions */ +/* B3 Configuration for modem: */ +/* empty */ +/*----------------------------------------------------------------*/ +static word add_modem_b23(PLCI *plci, API_PARSE *bp_parms) +{ + static byte lli[12] = {1,1}; + static byte llc[3] = {2,0,0}; + static byte dlc[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + API_PARSE mdm_config[2]; + word i; + word b2_config = 0; + + for (i = 0; i < 2; i++) mdm_config[i].length = 0; + for (i = 0; i < sizeof(dlc); i++) dlc[i] = 0; + + if (((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE) + && (GET_WORD(bp_parms[1].info) != B2_MODEM_EC_COMPRESSION)) + || ((GET_WORD(bp_parms[0].info) != B1_MODEM_ALL_NEGOTIATE) + && (GET_WORD(bp_parms[1].info) != B2_TRANSPARENT))) + { + return (_B_STACK_NOT_SUPPORTED); + } + if ((GET_WORD(bp_parms[2].info) != B3_MODEM) + && (GET_WORD(bp_parms[2].info) != B3_TRANSPARENT)) + { + return (_B_STACK_NOT_SUPPORTED); + } + + plci->B2_prot = (byte) GET_WORD(bp_parms[1].info); + plci->B3_prot = (byte) GET_WORD(bp_parms[2].info); + + if ((GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION) && bp_parms[4].length) + { + if (api_parse(&bp_parms[4].info[1], + (word)bp_parms[4].length, "w", + mdm_config)) + { + return (_WRONG_MESSAGE_FORMAT); + } + b2_config = GET_WORD(mdm_config[0].info); + } + + /* OK, L2 is modem */ + + lli[0] = 1; + lli[1] = 1; + if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL) + lli[1] |= 2; + if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL) + lli[1] |= 4; + + if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) { + lli[1] |= 0x10; + if (plci->rx_dma_descriptor <= 0) { + plci->rx_dma_descriptor = diva_get_dma_descriptor(plci, &plci->rx_dma_magic); + if (plci->rx_dma_descriptor >= 0) + plci->rx_dma_descriptor++; + } + if (plci->rx_dma_descriptor > 0) { + lli[1] |= 0x40; + lli[0] = 6; + lli[2] = (byte)(plci->rx_dma_descriptor - 1); + lli[3] = (byte)plci->rx_dma_magic; + lli[4] = (byte)(plci->rx_dma_magic >> 8); + lli[5] = (byte)(plci->rx_dma_magic >> 16); + lli[6] = (byte)(plci->rx_dma_magic >> 24); + } + } + + if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) { + lli[1] |= 0x20; + } + + llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ? + /*V42*/ 10 : /*V42_IN*/ 9; + llc[2] = 4; /* pass L3 always transparent */ + add_p(plci, LLI, lli); + add_p(plci, LLC, llc); + i = 1; + PUT_WORD(&dlc[i], plci->appl->MaxDataLength); + i += 2; + if (GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION) + { + if (bp_parms[4].length) + { + dbug(1, dprintf("MDM b2_config=%02x", b2_config)); + dlc[i++] = 3; /* Addr A */ + dlc[i++] = 1; /* Addr B */ + dlc[i++] = 7; /* modulo mode */ + dlc[i++] = 7; /* window size */ + dlc[i++] = 0; /* XID len Lo */ + dlc[i++] = 0; /* XID len Hi */ + + if (b2_config & MDM_B2_DISABLE_V42bis) + { + dlc[i] |= DLC_MODEMPROT_DISABLE_V42_V42BIS; + } + if (b2_config & MDM_B2_DISABLE_MNP) + { + dlc[i] |= DLC_MODEMPROT_DISABLE_MNP_MNP5; + } + if (b2_config & MDM_B2_DISABLE_TRANS) + { + dlc[i] |= DLC_MODEMPROT_REQUIRE_PROTOCOL; + } + if (b2_config & MDM_B2_DISABLE_V42) + { + dlc[i] |= DLC_MODEMPROT_DISABLE_V42_DETECT; + } + if (b2_config & MDM_B2_DISABLE_COMP) + { + dlc[i] |= DLC_MODEMPROT_DISABLE_COMPRESSION; + } + i++; + } + } + else + { + dlc[i++] = 3; /* Addr A */ + dlc[i++] = 1; /* Addr B */ + dlc[i++] = 7; /* modulo mode */ + dlc[i++] = 7; /* window size */ + dlc[i++] = 0; /* XID len Lo */ + dlc[i++] = 0; /* XID len Hi */ + dlc[i++] = DLC_MODEMPROT_DISABLE_V42_V42BIS | + DLC_MODEMPROT_DISABLE_MNP_MNP5 | + DLC_MODEMPROT_DISABLE_V42_DETECT | + DLC_MODEMPROT_DISABLE_COMPRESSION; + } + dlc[0] = (byte)(i - 1); +/* HexDump ("DLC", sizeof(dlc), &dlc[0]); */ + add_p(plci, DLC, dlc); + return (0); +} + + +/*------------------------------------------------------------------*/ +/* send a request for the signaling entity */ +/*------------------------------------------------------------------*/ + +static void sig_req(PLCI *plci, byte req, byte Id) +{ + if (!plci) return; + if (plci->adapter->adapter_disabled) return; + dbug(1, dprintf("sig_req(%x)", req)); + if (req == REMOVE) + plci->sig_remove_id = plci->Sig.Id; + if (plci->req_in == plci->req_in_start) { + plci->req_in += 2; + plci->RBuffer[plci->req_in++] = 0; + } + PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start - 2); + plci->RBuffer[plci->req_in++] = Id; /* sig/nl flag */ + plci->RBuffer[plci->req_in++] = req; /* request */ + plci->RBuffer[plci->req_in++] = 0; /* channel */ + plci->req_in_start = plci->req_in; +} + +/*------------------------------------------------------------------*/ +/* send a request for the network layer entity */ +/*------------------------------------------------------------------*/ + +static void nl_req_ncci(PLCI *plci, byte req, byte ncci) +{ + if (!plci) return; + if (plci->adapter->adapter_disabled) return; + dbug(1, dprintf("nl_req %02x %02x %02x", plci->Id, req, ncci)); + if (req == REMOVE) + { + plci->nl_remove_id = plci->NL.Id; + ncci_remove(plci, 0, (byte)(ncci != 0)); + ncci = 0; + } + if (plci->req_in == plci->req_in_start) { + plci->req_in += 2; + plci->RBuffer[plci->req_in++] = 0; + } + PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start - 2); + plci->RBuffer[plci->req_in++] = 1; /* sig/nl flag */ + plci->RBuffer[plci->req_in++] = req; /* request */ + plci->RBuffer[plci->req_in++] = plci->adapter->ncci_ch[ncci]; /* channel */ + plci->req_in_start = plci->req_in; +} + +static void send_req(PLCI *plci) +{ + ENTITY *e; + word l; +/* word i; */ + + if (!plci) return; + if (plci->adapter->adapter_disabled) return; + channel_xmit_xon(plci); + + /* if nothing to do, return */ + if (plci->req_in == plci->req_out) return; + dbug(1, dprintf("send_req(in=%d,out=%d)", plci->req_in, plci->req_out)); + + if (plci->nl_req || plci->sig_req) return; + + l = GET_WORD(&plci->RBuffer[plci->req_out]); + plci->req_out += 2; + plci->XData[0].P = &plci->RBuffer[plci->req_out]; + plci->req_out += l; + if (plci->RBuffer[plci->req_out] == 1) + { + e = &plci->NL; + plci->req_out++; + e->Req = plci->nl_req = plci->RBuffer[plci->req_out++]; + e->ReqCh = plci->RBuffer[plci->req_out++]; + if (!(e->Id & 0x1f)) + { + e->Id = NL_ID; + plci->RBuffer[plci->req_out - 4] = CAI; + plci->RBuffer[plci->req_out - 3] = 1; + plci->RBuffer[plci->req_out - 2] = (plci->Sig.Id == 0xff) ? 0 : plci->Sig.Id; + plci->RBuffer[plci->req_out - 1] = 0; + l += 3; + plci->nl_global_req = plci->nl_req; + } + dbug(1, dprintf("%x:NLREQ(%x:%x:%x)", plci->adapter->Id, e->Id, e->Req, e->ReqCh)); + } + else + { + e = &plci->Sig; + if (plci->RBuffer[plci->req_out]) + e->Id = plci->RBuffer[plci->req_out]; + plci->req_out++; + e->Req = plci->sig_req = plci->RBuffer[plci->req_out++]; + e->ReqCh = plci->RBuffer[plci->req_out++]; + if (!(e->Id & 0x1f)) + plci->sig_global_req = plci->sig_req; + dbug(1, dprintf("%x:SIGREQ(%x:%x:%x)", plci->adapter->Id, e->Id, e->Req, e->ReqCh)); + } + plci->XData[0].PLength = l; + e->X = plci->XData; + plci->adapter->request(e); + dbug(1, dprintf("send_ok")); +} + +static void send_data(PLCI *plci) +{ + DIVA_CAPI_ADAPTER *a; + DATA_B3_DESC *data; + NCCI *ncci_ptr; + word ncci; + + if (!plci->nl_req && plci->ncci_ring_list) + { + a = plci->adapter; + ncci = plci->ncci_ring_list; + do + { + ncci = a->ncci_next[ncci]; + ncci_ptr = &(a->ncci[ncci]); + if (!(a->ncci_ch[ncci] + && (a->ch_flow_control[a->ncci_ch[ncci]] & N_OK_FC_PENDING))) + { + if (ncci_ptr->data_pending) + { + if ((a->ncci_state[ncci] == CONNECTED) + || (a->ncci_state[ncci] == INC_ACT_PENDING) + || (plci->send_disc == ncci)) + { + data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]); + if ((plci->B2_prot == B2_V120_ASYNC) + || (plci->B2_prot == B2_V120_ASYNC_V42BIS) + || (plci->B2_prot == B2_V120_BIT_TRANSPARENT)) + { + plci->NData[1].P = TransmitBufferGet(plci->appl, data->P); + plci->NData[1].PLength = data->Length; + if (data->Flags & 0x10) + plci->NData[0].P = v120_break_header; + else + plci->NData[0].P = v120_default_header; + plci->NData[0].PLength = 1; + plci->NL.XNum = 2; + plci->NL.Req = plci->nl_req = (byte)((data->Flags & 0x07) << 4 | N_DATA); + } + else + { + plci->NData[0].P = TransmitBufferGet(plci->appl, data->P); + plci->NData[0].PLength = data->Length; + if (data->Flags & 0x10) + plci->NL.Req = plci->nl_req = (byte)N_UDATA; + + else if ((plci->B3_prot == B3_RTP) && (data->Flags & 0x01)) + plci->NL.Req = plci->nl_req = (byte)N_BDATA; + + else + plci->NL.Req = plci->nl_req = (byte)((data->Flags & 0x07) << 4 | N_DATA); + } + plci->NL.X = plci->NData; + plci->NL.ReqCh = a->ncci_ch[ncci]; + dbug(1, dprintf("%x:DREQ(%x:%x)", a->Id, plci->NL.Id, plci->NL.Req)); + plci->data_sent = true; + plci->data_sent_ptr = data->P; + a->request(&plci->NL); + } + else { + cleanup_ncci_data(plci, ncci); + } + } + else if (plci->send_disc == ncci) + { + /* dprintf("N_DISC"); */ + plci->NData[0].PLength = 0; + plci->NL.ReqCh = a->ncci_ch[ncci]; + plci->NL.Req = plci->nl_req = N_DISC; + a->request(&plci->NL); + plci->command = _DISCONNECT_B3_R; + plci->send_disc = 0; + } + } + } while (!plci->nl_req && (ncci != plci->ncci_ring_list)); + plci->ncci_ring_list = ncci; + } +} + +static void listen_check(DIVA_CAPI_ADAPTER *a) +{ + word i, j; + PLCI *plci; + byte activnotifiedcalls = 0; + + dbug(1, dprintf("listen_check(%d,%d)", a->listen_active, a->max_listen)); + if (!remove_started && !a->adapter_disabled) + { + for (i = 0; i < a->max_plci; i++) + { + plci = &(a->plci[i]); + if (plci->notifiedcall) activnotifiedcalls++; + } + dbug(1, dprintf("listen_check(%d)", activnotifiedcalls)); + + for (i = a->listen_active; i < ((word)(a->max_listen + activnotifiedcalls)); i++) { + if ((j = get_plci(a))) { + a->listen_active++; + plci = &a->plci[j - 1]; + plci->State = LISTENING; + + add_p(plci, OAD, "\x01\xfd"); + + add_p(plci, KEY, "\x04\x43\x41\x32\x30"); + + add_p(plci, CAI, "\x01\xc0"); + add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + add_p(plci, LLI, "\x01\xc4"); /* support Dummy CR FAC + MWI + SpoofNotify */ + add_p(plci, SHIFT | 6, NULL); + add_p(plci, SIN, "\x02\x00\x00"); + plci->internal_command = LISTEN_SIG_ASSIGN_PEND; /* do indicate_req if OK */ + sig_req(plci, ASSIGN, DSIG_ID); + send_req(plci); + } + } + } +} + +/*------------------------------------------------------------------*/ +/* functions for all parameters sent in INDs */ +/*------------------------------------------------------------------*/ + +static void IndParse(PLCI *plci, word *parms_id, byte **parms, byte multiIEsize) +{ + word ploc; /* points to current location within packet */ + byte w; + byte wlen; + byte codeset, lock; + byte *in; + word i; + word code; + word mIEindex = 0; + ploc = 0; + codeset = 0; + lock = 0; + + in = plci->Sig.RBuffer->P; + for (i = 0; i < parms_id[0]; i++) /* multiIE parms_id contains just the 1st */ + { /* element but parms array is larger */ + parms[i] = (byte *)""; + } + for (i = 0; i < multiIEsize; i++) + { + parms[i] = (byte *)""; + } + + while (ploc < plci->Sig.RBuffer->length - 1) { + + /* read information element id and length */ + w = in[ploc]; + + if (w & 0x80) { +/* w &=0xf0; removed, cannot detect congestion levels */ +/* upper 4 bit masked with w==SHIFT now */ + wlen = 0; + } + else { + wlen = (byte)(in[ploc + 1] + 1); + } + /* check if length valid (not exceeding end of packet) */ + if ((ploc + wlen) > 270) return; + if (lock & 0x80) lock &= 0x7f; + else codeset = lock; + + if ((w & 0xf0) == SHIFT) { + codeset = in[ploc]; + if (!(codeset & 0x08)) lock = (byte)(codeset & 7); + codeset &= 7; + lock |= 0x80; + } + else { + if (w == ESC && wlen >= 3) code = in[ploc + 2] | 0x800; + else code = w; + code |= (codeset << 8); + + for (i = 1; i < parms_id[0] + 1 && parms_id[i] != code; i++); + + if (i < parms_id[0] + 1) { + if (!multiIEsize) { /* with multiIEs use next field index, */ + mIEindex = i - 1; /* with normal IEs use same index like parms_id */ + } + + parms[mIEindex] = &in[ploc + 1]; + dbug(1, dprintf("mIE[%d]=0x%x", *parms[mIEindex], in[ploc])); + if (parms_id[i] == OAD + || parms_id[i] == CONN_NR + || parms_id[i] == CAD) { + if (in[ploc + 2] & 0x80) { + in[ploc + 0] = (byte)(in[ploc + 1] + 1); + in[ploc + 1] = (byte)(in[ploc + 2] & 0x7f); + in[ploc + 2] = 0x80; + parms[mIEindex] = &in[ploc]; + } + } + mIEindex++; /* effects multiIEs only */ + } + } + + ploc += (wlen + 1); + } + return; +} + +/*------------------------------------------------------------------*/ +/* try to match a cip from received BC and HLC */ +/*------------------------------------------------------------------*/ + +static byte ie_compare(byte *ie1, byte *ie2) +{ + word i; + if (!ie1 || !ie2) return false; + if (!ie1[0]) return false; + for (i = 0; i < (word)(ie1[0] + 1); i++) if (ie1[i] != ie2[i]) return false; + return true; +} + +static word find_cip(DIVA_CAPI_ADAPTER *a, byte *bc, byte *hlc) +{ + word i; + word j; + + for (i = 9; i && !ie_compare(bc, cip_bc[i][a->u_law]); i--); + + for (j = 16; j < 29 && + (!ie_compare(bc, cip_bc[j][a->u_law]) || !ie_compare(hlc, cip_hlc[j])); j++); + if (j == 29) return i; + return j; +} + + +static byte AddInfo(byte **add_i, + byte **fty_i, + byte *esc_chi, + byte *facility) +{ + byte i; + byte j; + byte k; + byte flen; + byte len = 0; + /* facility is a nested structure */ + /* FTY can be more than once */ + + if (esc_chi[0] && !(esc_chi[esc_chi[0]] & 0x7f)) + { + add_i[0] = (byte *)"\x02\x02\x00"; /* use neither b nor d channel */ + } + + else + { + add_i[0] = (byte *)""; + } + if (!fty_i[0][0]) + { + add_i[3] = (byte *)""; + } + else + { /* facility array found */ + for (i = 0, j = 1; i < MAX_MULTI_IE && fty_i[i][0]; i++) + { + dbug(1, dprintf("AddIFac[%d]", fty_i[i][0])); + len += fty_i[i][0]; + len += 2; + flen = fty_i[i][0]; + facility[j++] = 0x1c; /* copy fac IE */ + for (k = 0; k <= flen; k++, j++) + { + facility[j] = fty_i[i][k]; +/* dbug(1, dprintf("%x ",facility[j])); */ + } + } + facility[0] = len; + add_i[3] = facility; + } +/* dbug(1, dprintf("FacArrLen=%d ",len)); */ + len = add_i[0][0] + add_i[1][0] + add_i[2][0] + add_i[3][0]; + len += 4; /* calculate length of all */ + return (len); +} + +/*------------------------------------------------------------------*/ +/* voice and codec features */ +/*------------------------------------------------------------------*/ + +static void SetVoiceChannel(PLCI *plci, byte *chi, DIVA_CAPI_ADAPTER *a) +{ + byte voice_chi[] = "\x02\x18\x01"; + byte channel; + + channel = chi[chi[0]] & 0x3; + dbug(1, dprintf("ExtDevON(Ch=0x%x)", channel)); + voice_chi[2] = (channel) ? channel : 1; + add_p(plci, FTY, "\x02\x01\x07"); /* B On, default on 1 */ + add_p(plci, ESC, voice_chi); /* Channel */ + sig_req(plci, TEL_CTRL, 0); + send_req(plci); + if (a->AdvSignalPLCI) + { + adv_voice_write_coefs(a->AdvSignalPLCI, ADV_VOICE_WRITE_ACTIVATION); + } +} + +static void VoiceChannelOff(PLCI *plci) +{ + dbug(1, dprintf("ExtDevOFF")); + add_p(plci, FTY, "\x02\x01\x08"); /* B Off */ + sig_req(plci, TEL_CTRL, 0); + send_req(plci); + if (plci->adapter->AdvSignalPLCI) + { + adv_voice_clear_config(plci->adapter->AdvSignalPLCI); + } +} + + +static word AdvCodecSupport(DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, + byte hook_listen) +{ + word j; + PLCI *splci; + + /* check if hardware supports handset with hook states (adv.codec) */ + /* or if just a on board codec is supported */ + /* the advanced codec plci is just for internal use */ + + /* diva Pro with on-board codec: */ + if (a->profile.Global_Options & HANDSET) + { + /* new call, but hook states are already signalled */ + if (a->AdvCodecFLAG) + { + if (a->AdvSignalAppl != appl || a->AdvSignalPLCI) + { + dbug(1, dprintf("AdvSigPlci=0x%x", a->AdvSignalPLCI)); + return 0x2001; /* codec in use by another application */ + } + if (plci != NULL) + { + a->AdvSignalPLCI = plci; + plci->tel = ADV_VOICE; + } + return 0; /* adv codec still used */ + } + if ((j = get_plci(a))) + { + splci = &a->plci[j - 1]; + splci->tel = CODEC_PERMANENT; + /* hook_listen indicates if a facility_req with handset/hook support */ + /* was sent. Otherwise if just a call on an external device was made */ + /* the codec will be used but the hook info will be discarded (just */ + /* the external controller is in use */ + if (hook_listen) splci->State = ADVANCED_VOICE_SIG; + else + { + splci->State = ADVANCED_VOICE_NOSIG; + if (plci) + { + plci->spoofed_msg = SPOOFING_REQUIRED; + } + /* indicate D-ch connect if */ + } /* codec is connected OK */ + if (plci != NULL) + { + a->AdvSignalPLCI = plci; + plci->tel = ADV_VOICE; + } + a->AdvSignalAppl = appl; + a->AdvCodecFLAG = true; + a->AdvCodecPLCI = splci; + add_p(splci, CAI, "\x01\x15"); + add_p(splci, LLI, "\x01\x00"); + add_p(splci, ESC, "\x02\x18\x00"); + add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + splci->internal_command = PERM_COD_ASSIGN; + dbug(1, dprintf("Codec Assign")); + sig_req(splci, ASSIGN, DSIG_ID); + send_req(splci); + } + else + { + return 0x2001; /* wrong state, no more plcis */ + } + } + else if (a->profile.Global_Options & ON_BOARD_CODEC) + { + if (hook_listen) return 0x300B; /* Facility not supported */ + /* no hook with SCOM */ + if (plci != NULL) plci->tel = CODEC; + dbug(1, dprintf("S/SCOM codec")); + /* first time we use the scom-s codec we must shut down the internal */ + /* handset application of the card. This can be done by an assign with */ + /* a cai with the 0x80 bit set. Assign return code is 'out of resource'*/ + if (!a->scom_appl_disable) { + if ((j = get_plci(a))) { + splci = &a->plci[j - 1]; + add_p(splci, CAI, "\x01\x80"); + add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + sig_req(splci, ASSIGN, 0xC0); /* 0xc0 is the TEL_ID */ + send_req(splci); + a->scom_appl_disable = true; + } + else{ + return 0x2001; /* wrong state, no more plcis */ + } + } + } + else return 0x300B; /* Facility not supported */ + + return 0; +} + + +static void CodecIdCheck(DIVA_CAPI_ADAPTER *a, PLCI *plci) +{ + + dbug(1, dprintf("CodecIdCheck")); + + if (a->AdvSignalPLCI == plci) + { + dbug(1, dprintf("PLCI owns codec")); + VoiceChannelOff(a->AdvCodecPLCI); + if (a->AdvCodecPLCI->State == ADVANCED_VOICE_NOSIG) + { + dbug(1, dprintf("remove temp codec PLCI")); + plci_remove(a->AdvCodecPLCI); + a->AdvCodecFLAG = 0; + a->AdvCodecPLCI = NULL; + a->AdvSignalAppl = NULL; + } + a->AdvSignalPLCI = NULL; + } +} + +/* ------------------------------------------------------------------- + Ask for physical address of card on PCI bus + ------------------------------------------------------------------- */ +static void diva_ask_for_xdi_sdram_bar(DIVA_CAPI_ADAPTER *a, + IDI_SYNC_REQ *preq) { + a->sdram_bar = 0; + if (diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR) { + ENTITY *e = (ENTITY *)preq; + + e->user[0] = a->Id - 1; + preq->xdi_sdram_bar.info.bar = 0; + preq->xdi_sdram_bar.Req = 0; + preq->xdi_sdram_bar.Rc = IDI_SYNC_REQ_XDI_GET_ADAPTER_SDRAM_BAR; + + (*(a->request))(e); + + a->sdram_bar = preq->xdi_sdram_bar.info.bar; + dbug(3, dprintf("A(%d) SDRAM BAR = %08x", a->Id, a->sdram_bar)); + } +} + +/* ------------------------------------------------------------------- + Ask XDI about extended features + ------------------------------------------------------------------- */ +static void diva_get_extended_adapter_features(DIVA_CAPI_ADAPTER *a) { + IDI_SYNC_REQ *preq; + char buffer[((sizeof(preq->xdi_extended_features) + 4) > sizeof(ENTITY)) ? (sizeof(preq->xdi_extended_features) + 4) : sizeof(ENTITY)]; + + char features[4]; + preq = (IDI_SYNC_REQ *)&buffer[0]; + + if (!diva_xdi_extended_features) { + ENTITY *e = (ENTITY *)preq; + diva_xdi_extended_features |= 0x80000000; + + e->user[0] = a->Id - 1; + preq->xdi_extended_features.Req = 0; + preq->xdi_extended_features.Rc = IDI_SYNC_REQ_XDI_GET_EXTENDED_FEATURES; + preq->xdi_extended_features.info.buffer_length_in_bytes = sizeof(features); + preq->xdi_extended_features.info.features = &features[0]; + + (*(a->request))(e); + + if (features[0] & DIVA_XDI_EXTENDED_FEATURES_VALID) { + /* + Check features located in the byte '0' + */ + if (features[0] & DIVA_XDI_EXTENDED_FEATURE_CMA) { + diva_xdi_extended_features |= DIVA_CAPI_USE_CMA; + } + if (features[0] & DIVA_XDI_EXTENDED_FEATURE_RX_DMA) { + diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_RX_DMA; + dbug(1, dprintf("XDI provides RxDMA")); + } + if (features[0] & DIVA_XDI_EXTENDED_FEATURE_SDRAM_BAR) { + diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR; + } + if (features[0] & DIVA_XDI_EXTENDED_FEATURE_NO_CANCEL_RC) { + diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_NO_CANCEL; + dbug(3, dprintf("XDI provides NO_CANCEL_RC feature")); + } + + } + } + + diva_ask_for_xdi_sdram_bar(a, preq); +} + +/*------------------------------------------------------------------*/ +/* automatic law */ +/*------------------------------------------------------------------*/ +/* called from OS specific part after init time to get the Law */ +/* a-law (Euro) and u-law (us,japan) use different BCs in the Setup message */ +void AutomaticLaw(DIVA_CAPI_ADAPTER *a) +{ + word j; + PLCI *splci; + + if (a->automatic_law) { + return; + } + if ((j = get_plci(a))) { + diva_get_extended_adapter_features(a); + splci = &a->plci[j - 1]; + a->automatic_lawPLCI = splci; + a->automatic_law = 1; + add_p(splci, CAI, "\x01\x80"); + add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + splci->internal_command = USELAW_REQ; + splci->command = 0; + splci->number = 0; + sig_req(splci, ASSIGN, DSIG_ID); + send_req(splci); + } +} + +/* called from OS specific part if an application sends an Capi20Release */ +word CapiRelease(word Id) +{ + word i, j, appls_found; + PLCI *plci; + APPL *this; + DIVA_CAPI_ADAPTER *a; + + if (!Id) + { + dbug(0, dprintf("A: CapiRelease(Id==0)")); + return (_WRONG_APPL_ID); + } + + this = &application[Id - 1]; /* get application pointer */ + + for (i = 0, appls_found = 0; i < max_appl; i++) + { + if (application[i].Id) /* an application has been found */ + { + appls_found++; + } + } + + for (i = 0; i < max_adapter; i++) /* scan all adapters... */ + { + a = &adapter[i]; + if (a->request) + { + a->Info_Mask[Id - 1] = 0; + a->CIP_Mask[Id - 1] = 0; + a->Notification_Mask[Id - 1] = 0; + a->codec_listen[Id - 1] = NULL; + a->requested_options_table[Id - 1] = 0; + for (j = 0; j < a->max_plci; j++) /* and all PLCIs connected */ + { /* with this application */ + plci = &a->plci[j]; + if (plci->Id) /* if plci owns no application */ + { /* it may be not jet connected */ + if (plci->State == INC_CON_PENDING + || plci->State == INC_CON_ALERT) + { + if (test_c_ind_mask_bit(plci, (word)(Id - 1))) + { + clear_c_ind_mask_bit(plci, (word)(Id - 1)); + if (c_ind_mask_empty(plci)) + { + sig_req(plci, HANGUP, 0); + send_req(plci); + plci->State = OUTG_DIS_PENDING; + } + } + } + if (test_c_ind_mask_bit(plci, (word)(Id - 1))) + { + clear_c_ind_mask_bit(plci, (word)(Id - 1)); + if (c_ind_mask_empty(plci)) + { + if (!plci->appl) + { + plci_remove(plci); + plci->State = IDLE; + } + } + } + if (plci->appl == this) + { + plci->appl = NULL; + plci_remove(plci); + plci->State = IDLE; + } + } + } + listen_check(a); + + if (a->flag_dynamic_l1_down) + { + if (appls_found == 1) /* last application does a capi release */ + { + if ((j = get_plci(a))) + { + plci = &a->plci[j - 1]; + plci->command = 0; + add_p(plci, OAD, "\x01\xfd"); + add_p(plci, CAI, "\x01\x80"); + add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + add_p(plci, SHIFT | 6, NULL); + add_p(plci, SIN, "\x02\x00\x00"); + plci->internal_command = REM_L1_SIG_ASSIGN_PEND; + sig_req(plci, ASSIGN, DSIG_ID); + add_p(plci, FTY, "\x02\xff\x06"); /* l1 down */ + sig_req(plci, SIG_CTRL, 0); + send_req(plci); + } + } + } + if (a->AdvSignalAppl == this) + { + this->NullCREnable = false; + if (a->AdvCodecPLCI) + { + plci_remove(a->AdvCodecPLCI); + a->AdvCodecPLCI->tel = 0; + a->AdvCodecPLCI->adv_nl = 0; + } + a->AdvSignalAppl = NULL; + a->AdvSignalPLCI = NULL; + a->AdvCodecFLAG = 0; + a->AdvCodecPLCI = NULL; + } + } + } + + this->Id = 0; + + return GOOD; +} + +static word plci_remove_check(PLCI *plci) +{ + if (!plci) return true; + if (!plci->NL.Id && c_ind_mask_empty(plci)) + { + if (plci->Sig.Id == 0xff) + plci->Sig.Id = 0; + if (!plci->Sig.Id) + { + dbug(1, dprintf("plci_remove_complete(%x)", plci->Id)); + dbug(1, dprintf("tel=0x%x,Sig=0x%x", plci->tel, plci->Sig.Id)); + if (plci->Id) + { + CodecIdCheck(plci->adapter, plci); + clear_b1_config(plci); + ncci_remove(plci, 0, false); + plci_free_msg_in_queue(plci); + channel_flow_control_remove(plci); + plci->Id = 0; + plci->State = IDLE; + plci->channels = 0; + plci->appl = NULL; + plci->notifiedcall = 0; + } + listen_check(plci->adapter); + return true; + } + } + return false; +} + + +/*------------------------------------------------------------------*/ + +static byte plci_nl_busy(PLCI *plci) +{ + /* only applicable for non-multiplexed protocols */ + return (plci->nl_req + || (plci->ncci_ring_list + && plci->adapter->ncci_ch[plci->ncci_ring_list] + && (plci->adapter->ch_flow_control[plci->adapter->ncci_ch[plci->ncci_ring_list]] & N_OK_FC_PENDING))); +} + + +/*------------------------------------------------------------------*/ +/* DTMF facilities */ +/*------------------------------------------------------------------*/ + + +static struct +{ + byte send_mask; + byte listen_mask; + byte character; + byte code; +} dtmf_digit_map[] = +{ + { 0x01, 0x01, 0x23, DTMF_DIGIT_TONE_CODE_HASHMARK }, + { 0x01, 0x01, 0x2a, DTMF_DIGIT_TONE_CODE_STAR }, + { 0x01, 0x01, 0x30, DTMF_DIGIT_TONE_CODE_0 }, + { 0x01, 0x01, 0x31, DTMF_DIGIT_TONE_CODE_1 }, + { 0x01, 0x01, 0x32, DTMF_DIGIT_TONE_CODE_2 }, + { 0x01, 0x01, 0x33, DTMF_DIGIT_TONE_CODE_3 }, + { 0x01, 0x01, 0x34, DTMF_DIGIT_TONE_CODE_4 }, + { 0x01, 0x01, 0x35, DTMF_DIGIT_TONE_CODE_5 }, + { 0x01, 0x01, 0x36, DTMF_DIGIT_TONE_CODE_6 }, + { 0x01, 0x01, 0x37, DTMF_DIGIT_TONE_CODE_7 }, + { 0x01, 0x01, 0x38, DTMF_DIGIT_TONE_CODE_8 }, + { 0x01, 0x01, 0x39, DTMF_DIGIT_TONE_CODE_9 }, + { 0x01, 0x01, 0x41, DTMF_DIGIT_TONE_CODE_A }, + { 0x01, 0x01, 0x42, DTMF_DIGIT_TONE_CODE_B }, + { 0x01, 0x01, 0x43, DTMF_DIGIT_TONE_CODE_C }, + { 0x01, 0x01, 0x44, DTMF_DIGIT_TONE_CODE_D }, + { 0x01, 0x00, 0x61, DTMF_DIGIT_TONE_CODE_A }, + { 0x01, 0x00, 0x62, DTMF_DIGIT_TONE_CODE_B }, + { 0x01, 0x00, 0x63, DTMF_DIGIT_TONE_CODE_C }, + { 0x01, 0x00, 0x64, DTMF_DIGIT_TONE_CODE_D }, + + { 0x04, 0x04, 0x80, DTMF_SIGNAL_NO_TONE }, + { 0x00, 0x04, 0x81, DTMF_SIGNAL_UNIDENTIFIED_TONE }, + { 0x04, 0x04, 0x82, DTMF_SIGNAL_DIAL_TONE }, + { 0x04, 0x04, 0x83, DTMF_SIGNAL_PABX_INTERNAL_DIAL_TONE }, + { 0x04, 0x04, 0x84, DTMF_SIGNAL_SPECIAL_DIAL_TONE }, + { 0x04, 0x04, 0x85, DTMF_SIGNAL_SECOND_DIAL_TONE }, + { 0x04, 0x04, 0x86, DTMF_SIGNAL_RINGING_TONE }, + { 0x04, 0x04, 0x87, DTMF_SIGNAL_SPECIAL_RINGING_TONE }, + { 0x04, 0x04, 0x88, DTMF_SIGNAL_BUSY_TONE }, + { 0x04, 0x04, 0x89, DTMF_SIGNAL_CONGESTION_TONE }, + { 0x04, 0x04, 0x8a, DTMF_SIGNAL_SPECIAL_INFORMATION_TONE }, + { 0x04, 0x04, 0x8b, DTMF_SIGNAL_COMFORT_TONE }, + { 0x04, 0x04, 0x8c, DTMF_SIGNAL_HOLD_TONE }, + { 0x04, 0x04, 0x8d, DTMF_SIGNAL_RECORD_TONE }, + { 0x04, 0x04, 0x8e, DTMF_SIGNAL_CALLER_WAITING_TONE }, + { 0x04, 0x04, 0x8f, DTMF_SIGNAL_CALL_WAITING_TONE }, + { 0x04, 0x04, 0x90, DTMF_SIGNAL_PAY_TONE }, + { 0x04, 0x04, 0x91, DTMF_SIGNAL_POSITIVE_INDICATION_TONE }, + { 0x04, 0x04, 0x92, DTMF_SIGNAL_NEGATIVE_INDICATION_TONE }, + { 0x04, 0x04, 0x93, DTMF_SIGNAL_WARNING_TONE }, + { 0x04, 0x04, 0x94, DTMF_SIGNAL_INTRUSION_TONE }, + { 0x04, 0x04, 0x95, DTMF_SIGNAL_CALLING_CARD_SERVICE_TONE }, + { 0x04, 0x04, 0x96, DTMF_SIGNAL_PAYPHONE_RECOGNITION_TONE }, + { 0x04, 0x04, 0x97, DTMF_SIGNAL_CPE_ALERTING_SIGNAL }, + { 0x04, 0x04, 0x98, DTMF_SIGNAL_OFF_HOOK_WARNING_TONE }, + { 0x04, 0x04, 0xbf, DTMF_SIGNAL_INTERCEPT_TONE }, + { 0x04, 0x04, 0xc0, DTMF_SIGNAL_MODEM_CALLING_TONE }, + { 0x04, 0x04, 0xc1, DTMF_SIGNAL_FAX_CALLING_TONE }, + { 0x04, 0x04, 0xc2, DTMF_SIGNAL_ANSWER_TONE }, + { 0x04, 0x04, 0xc3, DTMF_SIGNAL_REVERSED_ANSWER_TONE }, + { 0x04, 0x04, 0xc4, DTMF_SIGNAL_ANSAM_TONE }, + { 0x04, 0x04, 0xc5, DTMF_SIGNAL_REVERSED_ANSAM_TONE }, + { 0x04, 0x04, 0xc6, DTMF_SIGNAL_BELL103_ANSWER_TONE }, + { 0x04, 0x04, 0xc7, DTMF_SIGNAL_FAX_FLAGS }, + { 0x04, 0x04, 0xc8, DTMF_SIGNAL_G2_FAX_GROUP_ID }, + { 0x00, 0x04, 0xc9, DTMF_SIGNAL_HUMAN_SPEECH }, + { 0x04, 0x04, 0xca, DTMF_SIGNAL_ANSWERING_MACHINE_390 }, + { 0x02, 0x02, 0xf1, DTMF_MF_DIGIT_TONE_CODE_1 }, + { 0x02, 0x02, 0xf2, DTMF_MF_DIGIT_TONE_CODE_2 }, + { 0x02, 0x02, 0xf3, DTMF_MF_DIGIT_TONE_CODE_3 }, + { 0x02, 0x02, 0xf4, DTMF_MF_DIGIT_TONE_CODE_4 }, + { 0x02, 0x02, 0xf5, DTMF_MF_DIGIT_TONE_CODE_5 }, + { 0x02, 0x02, 0xf6, DTMF_MF_DIGIT_TONE_CODE_6 }, + { 0x02, 0x02, 0xf7, DTMF_MF_DIGIT_TONE_CODE_7 }, + { 0x02, 0x02, 0xf8, DTMF_MF_DIGIT_TONE_CODE_8 }, + { 0x02, 0x02, 0xf9, DTMF_MF_DIGIT_TONE_CODE_9 }, + { 0x02, 0x02, 0xfa, DTMF_MF_DIGIT_TONE_CODE_0 }, + { 0x02, 0x02, 0xfb, DTMF_MF_DIGIT_TONE_CODE_K1 }, + { 0x02, 0x02, 0xfc, DTMF_MF_DIGIT_TONE_CODE_K2 }, + { 0x02, 0x02, 0xfd, DTMF_MF_DIGIT_TONE_CODE_KP }, + { 0x02, 0x02, 0xfe, DTMF_MF_DIGIT_TONE_CODE_S1 }, + { 0x02, 0x02, 0xff, DTMF_MF_DIGIT_TONE_CODE_ST }, + +}; + +#define DTMF_DIGIT_MAP_ENTRIES ARRAY_SIZE(dtmf_digit_map) + + +static void dtmf_enable_receiver(PLCI *plci, byte enable_mask) +{ + word min_digit_duration, min_gap_duration; + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_enable_receiver %02x", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__, enable_mask)); + + if (enable_mask != 0) + { + min_digit_duration = (plci->dtmf_rec_pulse_ms == 0) ? 40 : plci->dtmf_rec_pulse_ms; + min_gap_duration = (plci->dtmf_rec_pause_ms == 0) ? 40 : plci->dtmf_rec_pause_ms; + plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_ENABLE_RECEIVER; + PUT_WORD(&plci->internal_req_buffer[1], min_digit_duration); + PUT_WORD(&plci->internal_req_buffer[3], min_gap_duration); + plci->NData[0].PLength = 5; + + PUT_WORD(&plci->internal_req_buffer[5], INTERNAL_IND_BUFFER_SIZE); + plci->NData[0].PLength += 2; + capidtmf_recv_enable(&(plci->capidtmf_state), min_digit_duration, min_gap_duration); + + } + else + { + plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_DISABLE_RECEIVER; + plci->NData[0].PLength = 1; + + capidtmf_recv_disable(&(plci->capidtmf_state)); + + } + plci->NData[0].P = plci->internal_req_buffer; + plci->NL.X = plci->NData; + plci->NL.ReqCh = 0; + plci->NL.Req = plci->nl_req = (byte) N_UDATA; + plci->adapter->request(&plci->NL); +} + + +static void dtmf_send_digits(PLCI *plci, byte *digit_buffer, word digit_count) +{ + word w, i; + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_send_digits %d", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__, digit_count)); + + plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_SEND_DIGITS; + w = (plci->dtmf_send_pulse_ms == 0) ? 40 : plci->dtmf_send_pulse_ms; + PUT_WORD(&plci->internal_req_buffer[1], w); + w = (plci->dtmf_send_pause_ms == 0) ? 40 : plci->dtmf_send_pause_ms; + PUT_WORD(&plci->internal_req_buffer[3], w); + for (i = 0; i < digit_count; i++) + { + w = 0; + while ((w < DTMF_DIGIT_MAP_ENTRIES) + && (digit_buffer[i] != dtmf_digit_map[w].character)) + { + w++; + } + plci->internal_req_buffer[5 + i] = (w < DTMF_DIGIT_MAP_ENTRIES) ? + dtmf_digit_map[w].code : DTMF_DIGIT_TONE_CODE_STAR; + } + plci->NData[0].PLength = 5 + digit_count; + plci->NData[0].P = plci->internal_req_buffer; + plci->NL.X = plci->NData; + plci->NL.ReqCh = 0; + plci->NL.Req = plci->nl_req = (byte) N_UDATA; + plci->adapter->request(&plci->NL); +} + + +static void dtmf_rec_clear_config(PLCI *plci) +{ + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_rec_clear_config", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + + plci->dtmf_rec_active = 0; + plci->dtmf_rec_pulse_ms = 0; + plci->dtmf_rec_pause_ms = 0; + + capidtmf_init(&(plci->capidtmf_state), plci->adapter->u_law); + +} + + +static void dtmf_send_clear_config(PLCI *plci) +{ + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_send_clear_config", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + + plci->dtmf_send_requests = 0; + plci->dtmf_send_pulse_ms = 0; + plci->dtmf_send_pause_ms = 0; +} + + +static void dtmf_prepare_switch(dword Id, PLCI *plci) +{ + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_prepare_switch", + UnMapId(Id), (char *)(FILE_), __LINE__)); + + while (plci->dtmf_send_requests != 0) + dtmf_confirmation(Id, plci); +} + + +static word dtmf_save_config(dword Id, PLCI *plci, byte Rc) +{ + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_save_config %02x %d", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state)); + + return (GOOD); +} + + +static word dtmf_restore_config(dword Id, PLCI *plci, byte Rc) +{ + word Info; + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_restore_config %02x %d", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state)); + + Info = GOOD; + if (plci->B1_facilities & B1_FACILITY_DTMFR) + { + switch (plci->adjust_b_state) + { + case ADJUST_B_RESTORE_DTMF_1: + plci->internal_command = plci->adjust_b_command; + if (plci_nl_busy(plci)) + { + plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1; + break; + } + dtmf_enable_receiver(plci, plci->dtmf_rec_active); + plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_2; + break; + case ADJUST_B_RESTORE_DTMF_2: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: Reenable DTMF receiver failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + Info = _WRONG_STATE; + break; + } + break; + } + } + return (Info); +} + + +static void dtmf_command(dword Id, PLCI *plci, byte Rc) +{ + word internal_command, Info; + byte mask; + byte result[4]; + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_command %02x %04x %04x %d %d %d %d", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command, + plci->dtmf_cmd, plci->dtmf_rec_pulse_ms, plci->dtmf_rec_pause_ms, + plci->dtmf_send_pulse_ms, plci->dtmf_send_pause_ms)); + + Info = GOOD; + result[0] = 2; + PUT_WORD(&result[1], DTMF_SUCCESS); + internal_command = plci->internal_command; + plci->internal_command = 0; + mask = 0x01; + switch (plci->dtmf_cmd) + { + + case DTMF_LISTEN_TONE_START: + mask <<= 1; + case DTMF_LISTEN_MF_START: + mask <<= 1; + + case DTMF_LISTEN_START: + switch (internal_command) + { + default: + adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities | + B1_FACILITY_DTMFR), DTMF_COMMAND_1); + case DTMF_COMMAND_1: + if (adjust_b_process(Id, plci, Rc) != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: Load DTMF failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _FACILITY_NOT_SUPPORTED; + break; + } + if (plci->internal_command) + return; + case DTMF_COMMAND_2: + if (plci_nl_busy(plci)) + { + plci->internal_command = DTMF_COMMAND_2; + return; + } + plci->internal_command = DTMF_COMMAND_3; + dtmf_enable_receiver(plci, (byte)(plci->dtmf_rec_active | mask)); + return; + case DTMF_COMMAND_3: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: Enable DTMF receiver failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + Info = _FACILITY_NOT_SUPPORTED; + break; + } + + plci->tone_last_indication_code = DTMF_SIGNAL_NO_TONE; + + plci->dtmf_rec_active |= mask; + break; + } + break; + + + case DTMF_LISTEN_TONE_STOP: + mask <<= 1; + case DTMF_LISTEN_MF_STOP: + mask <<= 1; + + case DTMF_LISTEN_STOP: + switch (internal_command) + { + default: + plci->dtmf_rec_active &= ~mask; + if (plci->dtmf_rec_active) + break; +/* + case DTMF_COMMAND_1: + if (plci->dtmf_rec_active) + { + if (plci_nl_busy (plci)) + { + plci->internal_command = DTMF_COMMAND_1; + return; + } + plci->dtmf_rec_active &= ~mask; + plci->internal_command = DTMF_COMMAND_2; + dtmf_enable_receiver (plci, false); + return; + } + Rc = OK; + case DTMF_COMMAND_2: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug (1, dprintf("[%06lx] %s,%d: Disable DTMF receiver failed %02x", + UnMapId (Id), (char far *)(FILE_), __LINE__, Rc)); + Info = _FACILITY_NOT_SUPPORTED; + break; + } +*/ + adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities & + ~(B1_FACILITY_DTMFX | B1_FACILITY_DTMFR)), DTMF_COMMAND_3); + case DTMF_COMMAND_3: + if (adjust_b_process(Id, plci, Rc) != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: Unload DTMF failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _FACILITY_NOT_SUPPORTED; + break; + } + if (plci->internal_command) + return; + break; + } + break; + + + case DTMF_SEND_TONE: + mask <<= 1; + case DTMF_SEND_MF: + mask <<= 1; + + case DTMF_DIGITS_SEND: + switch (internal_command) + { + default: + adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities | + ((plci->dtmf_parameter_length != 0) ? B1_FACILITY_DTMFX | B1_FACILITY_DTMFR : B1_FACILITY_DTMFX)), + DTMF_COMMAND_1); + case DTMF_COMMAND_1: + if (adjust_b_process(Id, plci, Rc) != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: Load DTMF failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _FACILITY_NOT_SUPPORTED; + break; + } + if (plci->internal_command) + return; + case DTMF_COMMAND_2: + if (plci_nl_busy(plci)) + { + plci->internal_command = DTMF_COMMAND_2; + return; + } + plci->dtmf_msg_number_queue[(plci->dtmf_send_requests)++] = plci->number; + plci->internal_command = DTMF_COMMAND_3; + dtmf_send_digits(plci, &plci->saved_msg.parms[3].info[1], plci->saved_msg.parms[3].length); + return; + case DTMF_COMMAND_3: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: Send DTMF digits failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + if (plci->dtmf_send_requests != 0) + (plci->dtmf_send_requests)--; + Info = _FACILITY_NOT_SUPPORTED; + break; + } + return; + } + break; + } + sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number, + "wws", Info, SELECTOR_DTMF, result); +} + + +static byte dtmf_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg) +{ + word Info; + word i, j; + byte mask; + API_PARSE dtmf_parms[5]; + byte result[40]; + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_request", + UnMapId(Id), (char *)(FILE_), __LINE__)); + + Info = GOOD; + result[0] = 2; + PUT_WORD(&result[1], DTMF_SUCCESS); + if (!(a->profile.Global_Options & GL_DTMF_SUPPORTED)) + { + dbug(1, dprintf("[%06lx] %s,%d: Facility not supported", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _FACILITY_NOT_SUPPORTED; + } + else if (api_parse(&msg[1].info[1], msg[1].length, "w", dtmf_parms)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong message format", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_MESSAGE_FORMAT; + } + + else if ((GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES) + || (GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_SEND_CODES)) + { + if (!((a->requested_options_table[appl->Id - 1]) + & (1L << PRIVATE_DTMF_TONE))) + { + dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info))); + PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST); + } + else + { + for (i = 0; i < 32; i++) + result[4 + i] = 0; + if (GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES) + { + for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++) + { + if (dtmf_digit_map[i].listen_mask != 0) + result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7)); + } + } + else + { + for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++) + { + if (dtmf_digit_map[i].send_mask != 0) + result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7)); + } + } + result[0] = 3 + 32; + result[3] = 32; + } + } + + else if (plci == NULL) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_IDENTIFIER; + } + else + { + if (!plci->State + || !plci->NL.Id || plci->nl_remove_id) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong state", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_STATE; + } + else + { + plci->command = 0; + plci->dtmf_cmd = GET_WORD(dtmf_parms[0].info); + mask = 0x01; + switch (plci->dtmf_cmd) + { + + case DTMF_LISTEN_TONE_START: + case DTMF_LISTEN_TONE_STOP: + mask <<= 1; + case DTMF_LISTEN_MF_START: + case DTMF_LISTEN_MF_STOP: + mask <<= 1; + if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id - 1]) + & (1L << PRIVATE_DTMF_TONE))) + { + dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info))); + PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST); + break; + } + + case DTMF_LISTEN_START: + case DTMF_LISTEN_STOP: + if (!(a->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF) + && !(a->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)) + { + dbug(1, dprintf("[%06lx] %s,%d: Facility not supported", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _FACILITY_NOT_SUPPORTED; + break; + } + if (mask & DTMF_LISTEN_ACTIVE_FLAG) + { + if (api_parse(&msg[1].info[1], msg[1].length, "wwws", dtmf_parms)) + { + plci->dtmf_rec_pulse_ms = 0; + plci->dtmf_rec_pause_ms = 0; + } + else + { + plci->dtmf_rec_pulse_ms = GET_WORD(dtmf_parms[1].info); + plci->dtmf_rec_pause_ms = GET_WORD(dtmf_parms[2].info); + } + } + start_internal_command(Id, plci, dtmf_command); + return (false); + + + case DTMF_SEND_TONE: + mask <<= 1; + case DTMF_SEND_MF: + mask <<= 1; + if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id - 1]) + & (1L << PRIVATE_DTMF_TONE))) + { + dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info))); + PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST); + break; + } + + case DTMF_DIGITS_SEND: + if (api_parse(&msg[1].info[1], msg[1].length, "wwws", dtmf_parms)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong message format", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + if (mask & DTMF_LISTEN_ACTIVE_FLAG) + { + plci->dtmf_send_pulse_ms = GET_WORD(dtmf_parms[1].info); + plci->dtmf_send_pause_ms = GET_WORD(dtmf_parms[2].info); + } + i = 0; + j = 0; + while ((i < dtmf_parms[3].length) && (j < DTMF_DIGIT_MAP_ENTRIES)) + { + j = 0; + while ((j < DTMF_DIGIT_MAP_ENTRIES) + && ((dtmf_parms[3].info[i + 1] != dtmf_digit_map[j].character) + || ((dtmf_digit_map[j].send_mask & mask) == 0))) + { + j++; + } + i++; + } + if (j == DTMF_DIGIT_MAP_ENTRIES) + { + dbug(1, dprintf("[%06lx] %s,%d: Incorrect DTMF digit %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, dtmf_parms[3].info[i])); + PUT_WORD(&result[1], DTMF_INCORRECT_DIGIT); + break; + } + if (plci->dtmf_send_requests >= ARRAY_SIZE(plci->dtmf_msg_number_queue)) + { + dbug(1, dprintf("[%06lx] %s,%d: DTMF request overrun", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_STATE; + break; + } + api_save_msg(dtmf_parms, "wwws", &plci->saved_msg); + start_internal_command(Id, plci, dtmf_command); + return (false); + + default: + dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, plci->dtmf_cmd)); + PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST); + } + } + } + sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number, + "wws", Info, SELECTOR_DTMF, result); + return (false); +} + + +static void dtmf_confirmation(dword Id, PLCI *plci) +{ + word i; + byte result[4]; + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_confirmation", + UnMapId(Id), (char *)(FILE_), __LINE__)); + + result[0] = 2; + PUT_WORD(&result[1], DTMF_SUCCESS); + if (plci->dtmf_send_requests != 0) + { + sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->dtmf_msg_number_queue[0], + "wws", GOOD, SELECTOR_DTMF, result); + (plci->dtmf_send_requests)--; + for (i = 0; i < plci->dtmf_send_requests; i++) + plci->dtmf_msg_number_queue[i] = plci->dtmf_msg_number_queue[i + 1]; + } +} + + +static void dtmf_indication(dword Id, PLCI *plci, byte *msg, word length) +{ + word i, j, n; + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_indication", + UnMapId(Id), (char *)(FILE_), __LINE__)); + + n = 0; + for (i = 1; i < length; i++) + { + j = 0; + while ((j < DTMF_DIGIT_MAP_ENTRIES) + && ((msg[i] != dtmf_digit_map[j].code) + || ((dtmf_digit_map[j].listen_mask & plci->dtmf_rec_active) == 0))) + { + j++; + } + if (j < DTMF_DIGIT_MAP_ENTRIES) + { + + if ((dtmf_digit_map[j].listen_mask & DTMF_TONE_LISTEN_ACTIVE_FLAG) + && (plci->tone_last_indication_code == DTMF_SIGNAL_NO_TONE) + && (dtmf_digit_map[j].character != DTMF_SIGNAL_UNIDENTIFIED_TONE)) + { + if (n + 1 == i) + { + for (i = length; i > n + 1; i--) + msg[i] = msg[i - 1]; + length++; + i++; + } + msg[++n] = DTMF_SIGNAL_UNIDENTIFIED_TONE; + } + plci->tone_last_indication_code = dtmf_digit_map[j].character; + + msg[++n] = dtmf_digit_map[j].character; + } + } + if (n != 0) + { + msg[0] = (byte) n; + sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "wS", SELECTOR_DTMF, msg); + } +} + + +/*------------------------------------------------------------------*/ +/* DTMF parameters */ +/*------------------------------------------------------------------*/ + +static void dtmf_parameter_write(PLCI *plci) +{ + word i; + byte parameter_buffer[DTMF_PARAMETER_BUFFER_SIZE + 2]; + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_write", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + + parameter_buffer[0] = plci->dtmf_parameter_length + 1; + parameter_buffer[1] = DSP_CTRL_SET_DTMF_PARAMETERS; + for (i = 0; i < plci->dtmf_parameter_length; i++) + parameter_buffer[2 + i] = plci->dtmf_parameter_buffer[i]; + add_p(plci, FTY, parameter_buffer); + sig_req(plci, TEL_CTRL, 0); + send_req(plci); +} + + +static void dtmf_parameter_clear_config(PLCI *plci) +{ + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_clear_config", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + + plci->dtmf_parameter_length = 0; +} + + +static void dtmf_parameter_prepare_switch(dword Id, PLCI *plci) +{ + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_prepare_switch", + UnMapId(Id), (char *)(FILE_), __LINE__)); + +} + + +static word dtmf_parameter_save_config(dword Id, PLCI *plci, byte Rc) +{ + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_save_config %02x %d", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state)); + + return (GOOD); +} + + +static word dtmf_parameter_restore_config(dword Id, PLCI *plci, byte Rc) +{ + word Info; + + dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_restore_config %02x %d", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state)); + + Info = GOOD; + if ((plci->B1_facilities & B1_FACILITY_DTMFR) + && (plci->dtmf_parameter_length != 0)) + { + switch (plci->adjust_b_state) + { + case ADJUST_B_RESTORE_DTMF_PARAMETER_1: + plci->internal_command = plci->adjust_b_command; + if (plci->sig_req) + { + plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1; + break; + } + dtmf_parameter_write(plci); + plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_2; + break; + case ADJUST_B_RESTORE_DTMF_PARAMETER_2: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: Restore DTMF parameters failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + Info = _WRONG_STATE; + break; + } + break; + } + } + return (Info); +} + + +/*------------------------------------------------------------------*/ +/* Line interconnect facilities */ +/*------------------------------------------------------------------*/ + + +LI_CONFIG *li_config_table; +word li_total_channels; + + +/*------------------------------------------------------------------*/ +/* translate a CHI information element to a channel number */ +/* returns 0xff - any channel */ +/* 0xfe - chi wrong coding */ +/* 0xfd - D-channel */ +/* 0x00 - no channel */ +/* else channel number / PRI: timeslot */ +/* if channels is provided we accept more than one channel. */ +/*------------------------------------------------------------------*/ + +static byte chi_to_channel(byte *chi, dword *pchannelmap) +{ + int p; + int i; + dword map; + byte excl; + byte ofs; + byte ch; + + if (pchannelmap) *pchannelmap = 0; + if (!chi[0]) return 0xff; + excl = 0; + + if (chi[1] & 0x20) { + if (chi[0] == 1 && chi[1] == 0xac) return 0xfd; /* exclusive d-channel */ + for (i = 1; i < chi[0] && !(chi[i] & 0x80); i++); + if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe; + if ((chi[1] | 0xc8) != 0xe9) return 0xfe; + if (chi[1] & 0x08) excl = 0x40; + + /* int. id present */ + if (chi[1] & 0x40) { + p = i + 1; + for (i = p; i < chi[0] && !(chi[i] & 0x80); i++); + if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe; + } + + /* coding standard, Number/Map, Channel Type */ + p = i + 1; + for (i = p; i < chi[0] && !(chi[i] & 0x80); i++); + if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe; + if ((chi[p] | 0xd0) != 0xd3) return 0xfe; + + /* Number/Map */ + if (chi[p] & 0x10) { + + /* map */ + if ((chi[0] - p) == 4) ofs = 0; + else if ((chi[0] - p) == 3) ofs = 1; + else return 0xfe; + ch = 0; + map = 0; + for (i = 0; i < 4 && p < chi[0]; i++) { + p++; + ch += 8; + map <<= 8; + if (chi[p]) { + for (ch = 0; !(chi[p] & (1 << ch)); ch++); + map |= chi[p]; + } + } + ch += ofs; + map <<= ofs; + } + else { + + /* number */ + p = i + 1; + ch = chi[p] & 0x3f; + if (pchannelmap) { + if ((byte)(chi[0] - p) > 30) return 0xfe; + map = 0; + for (i = p; i <= chi[0]; i++) { + if ((chi[i] & 0x7f) > 31) return 0xfe; + map |= (1L << (chi[i] & 0x7f)); + } + } + else { + if (p != chi[0]) return 0xfe; + if (ch > 31) return 0xfe; + map = (1L << ch); + } + if (chi[p] & 0x40) return 0xfe; + } + if (pchannelmap) *pchannelmap = map; + else if (map != ((dword)(1L << ch))) return 0xfe; + return (byte)(excl | ch); + } + else { /* not PRI */ + for (i = 1; i < chi[0] && !(chi[i] & 0x80); i++); + if (i != chi[0] || !(chi[i] & 0x80)) return 0xfe; + if (chi[1] & 0x08) excl = 0x40; + + switch (chi[1] | 0x98) { + case 0x98: return 0; + case 0x99: + if (pchannelmap) *pchannelmap = 2; + return excl | 1; + case 0x9a: + if (pchannelmap) *pchannelmap = 4; + return excl | 2; + case 0x9b: return 0xff; + case 0x9c: return 0xfd; /* d-ch */ + default: return 0xfe; + } + } +} + + +static void mixer_set_bchannel_id_esc(PLCI *plci, byte bchannel_id) +{ + DIVA_CAPI_ADAPTER *a; + PLCI *splci; + byte old_id; + + a = plci->adapter; + old_id = plci->li_bchannel_id; + if (a->li_pri) + { + if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci)) + li_config_table[a->li_base + (old_id - 1)].plci = NULL; + plci->li_bchannel_id = (bchannel_id & 0x1f) + 1; + if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL) + li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci; + } + else + { + if (((bchannel_id & 0x03) == 1) || ((bchannel_id & 0x03) == 2)) + { + if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci)) + li_config_table[a->li_base + (old_id - 1)].plci = NULL; + plci->li_bchannel_id = bchannel_id & 0x03; + if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE)) + { + splci = a->AdvSignalPLCI; + if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL) + { + if ((splci->li_bchannel_id != 0) + && (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci)) + { + li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL; + } + splci->li_bchannel_id = 3 - plci->li_bchannel_id; + li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci; + dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id_esc %d", + (dword)((splci->Id << 8) | UnMapController(splci->adapter->Id)), + (char *)(FILE_), __LINE__, splci->li_bchannel_id)); + } + } + if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL) + li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci; + } + } + if ((old_id == 0) && (plci->li_bchannel_id != 0) + && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci)) + { + mixer_clear_config(plci); + } + dbug(1, dprintf("[%06lx] %s,%d: mixer_set_bchannel_id_esc %d %d", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__, bchannel_id, plci->li_bchannel_id)); +} + + +static void mixer_set_bchannel_id(PLCI *plci, byte *chi) +{ + DIVA_CAPI_ADAPTER *a; + PLCI *splci; + byte ch, old_id; + + a = plci->adapter; + old_id = plci->li_bchannel_id; + ch = chi_to_channel(chi, NULL); + if (!(ch & 0x80)) + { + if (a->li_pri) + { + if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci)) + li_config_table[a->li_base + (old_id - 1)].plci = NULL; + plci->li_bchannel_id = (ch & 0x1f) + 1; + if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL) + li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci; + } + else + { + if (((ch & 0x1f) == 1) || ((ch & 0x1f) == 2)) + { + if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci)) + li_config_table[a->li_base + (old_id - 1)].plci = NULL; + plci->li_bchannel_id = ch & 0x1f; + if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE)) + { + splci = a->AdvSignalPLCI; + if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL) + { + if ((splci->li_bchannel_id != 0) + && (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci)) + { + li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL; + } + splci->li_bchannel_id = 3 - plci->li_bchannel_id; + li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci; + dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d", + (dword)((splci->Id << 8) | UnMapController(splci->adapter->Id)), + (char *)(FILE_), __LINE__, splci->li_bchannel_id)); + } + } + if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL) + li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci; + } + } + } + if ((old_id == 0) && (plci->li_bchannel_id != 0) + && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci)) + { + mixer_clear_config(plci); + } + dbug(1, dprintf("[%06lx] %s,%d: mixer_set_bchannel_id %02x %d", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__, ch, plci->li_bchannel_id)); +} + + +#define MIXER_MAX_DUMP_CHANNELS 34 + +static void mixer_calculate_coefs(DIVA_CAPI_ADAPTER *a) +{ + static char hex_digit_table[0x10] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; + word n, i, j; + char *p; + char hex_line[2 * MIXER_MAX_DUMP_CHANNELS + MIXER_MAX_DUMP_CHANNELS / 8 + 4]; + + dbug(1, dprintf("[%06lx] %s,%d: mixer_calculate_coefs", + (dword)(UnMapController(a->Id)), (char *)(FILE_), __LINE__)); + + for (i = 0; i < li_total_channels; i++) + { + li_config_table[i].channel &= LI_CHANNEL_ADDRESSES_SET; + if (li_config_table[i].chflags != 0) + li_config_table[i].channel |= LI_CHANNEL_INVOLVED; + else + { + for (j = 0; j < li_total_channels; j++) + { + if (((li_config_table[i].flag_table[j]) != 0) + || ((li_config_table[j].flag_table[i]) != 0)) + { + li_config_table[i].channel |= LI_CHANNEL_INVOLVED; + } + if (((li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE) != 0) + || ((li_config_table[j].flag_table[i] & LI_FLAG_CONFERENCE) != 0)) + { + li_config_table[i].channel |= LI_CHANNEL_CONFERENCE; + } + } + } + } + for (i = 0; i < li_total_channels; i++) + { + for (j = 0; j < li_total_channels; j++) + { + li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC); + if (li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE) + li_config_table[i].coef_table[j] |= LI_COEF_CH_CH; + } + } + for (n = 0; n < li_total_channels; n++) + { + if (li_config_table[n].channel & LI_CHANNEL_CONFERENCE) + { + for (i = 0; i < li_total_channels; i++) + { + if (li_config_table[i].channel & LI_CHANNEL_CONFERENCE) + { + for (j = 0; j < li_total_channels; j++) + { + li_config_table[i].coef_table[j] |= + li_config_table[i].coef_table[n] & li_config_table[n].coef_table[j]; + } + } + } + } + } + for (i = 0; i < li_total_channels; i++) + { + if (li_config_table[i].channel & LI_CHANNEL_INVOLVED) + { + li_config_table[i].coef_table[i] &= ~LI_COEF_CH_CH; + for (j = 0; j < li_total_channels; j++) + { + if (li_config_table[i].coef_table[j] & LI_COEF_CH_CH) + li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE; + } + if (li_config_table[i].flag_table[i] & LI_FLAG_CONFERENCE) + li_config_table[i].coef_table[i] |= LI_COEF_CH_CH; + } + } + for (i = 0; i < li_total_channels; i++) + { + if (li_config_table[i].channel & LI_CHANNEL_INVOLVED) + { + for (j = 0; j < li_total_channels; j++) + { + if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT) + li_config_table[i].coef_table[j] |= LI_COEF_CH_CH; + if (li_config_table[i].flag_table[j] & LI_FLAG_MONITOR) + li_config_table[i].coef_table[j] |= LI_COEF_CH_PC; + if (li_config_table[i].flag_table[j] & LI_FLAG_MIX) + li_config_table[i].coef_table[j] |= LI_COEF_PC_CH; + if (li_config_table[i].flag_table[j] & LI_FLAG_PCCONNECT) + li_config_table[i].coef_table[j] |= LI_COEF_PC_PC; + } + if (li_config_table[i].chflags & LI_CHFLAG_MONITOR) + { + for (j = 0; j < li_total_channels; j++) + { + if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT) + { + li_config_table[i].coef_table[j] |= LI_COEF_CH_PC; + if (li_config_table[j].chflags & LI_CHFLAG_MIX) + li_config_table[i].coef_table[j] |= LI_COEF_PC_CH | LI_COEF_PC_PC; + } + } + } + if (li_config_table[i].chflags & LI_CHFLAG_MIX) + { + for (j = 0; j < li_total_channels; j++) + { + if (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT) + li_config_table[j].coef_table[i] |= LI_COEF_PC_CH; + } + } + if (li_config_table[i].chflags & LI_CHFLAG_LOOP) + { + for (j = 0; j < li_total_channels; j++) + { + if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT) + { + for (n = 0; n < li_total_channels; n++) + { + if (li_config_table[n].flag_table[i] & LI_FLAG_INTERCONNECT) + { + li_config_table[n].coef_table[j] |= LI_COEF_CH_CH; + if (li_config_table[j].chflags & LI_CHFLAG_MIX) + { + li_config_table[n].coef_table[j] |= LI_COEF_PC_CH; + if (li_config_table[n].chflags & LI_CHFLAG_MONITOR) + li_config_table[n].coef_table[j] |= LI_COEF_CH_PC | LI_COEF_PC_PC; + } + else if (li_config_table[n].chflags & LI_CHFLAG_MONITOR) + li_config_table[n].coef_table[j] |= LI_COEF_CH_PC; + } + } + } + } + } + } + } + for (i = 0; i < li_total_channels; i++) + { + if (li_config_table[i].channel & LI_CHANNEL_INVOLVED) + { + if (li_config_table[i].chflags & (LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP)) + li_config_table[i].channel |= LI_CHANNEL_ACTIVE; + if (li_config_table[i].chflags & LI_CHFLAG_MONITOR) + li_config_table[i].channel |= LI_CHANNEL_RX_DATA; + if (li_config_table[i].chflags & LI_CHFLAG_MIX) + li_config_table[i].channel |= LI_CHANNEL_TX_DATA; + for (j = 0; j < li_total_channels; j++) + { + if ((li_config_table[i].flag_table[j] & + (LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_MONITOR)) + || (li_config_table[j].flag_table[i] & + (LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX))) + { + li_config_table[i].channel |= LI_CHANNEL_ACTIVE; + } + if (li_config_table[i].flag_table[j] & (LI_FLAG_PCCONNECT | LI_FLAG_MONITOR)) + li_config_table[i].channel |= LI_CHANNEL_RX_DATA; + if (li_config_table[j].flag_table[i] & (LI_FLAG_PCCONNECT | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX)) + li_config_table[i].channel |= LI_CHANNEL_TX_DATA; + } + if (!(li_config_table[i].channel & LI_CHANNEL_ACTIVE)) + { + li_config_table[i].coef_table[i] |= LI_COEF_PC_CH | LI_COEF_CH_PC; + li_config_table[i].channel |= LI_CHANNEL_TX_DATA | LI_CHANNEL_RX_DATA; + } + } + } + for (i = 0; i < li_total_channels; i++) + { + if (li_config_table[i].channel & LI_CHANNEL_INVOLVED) + { + j = 0; + while ((j < li_total_channels) && !(li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT)) + j++; + if (j < li_total_channels) + { + for (j = 0; j < li_total_channels; j++) + { + li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_PC_CH); + if (li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT) + li_config_table[i].coef_table[j] |= LI_COEF_PC_CH; + } + } + } + } + n = li_total_channels; + if (n > MIXER_MAX_DUMP_CHANNELS) + n = MIXER_MAX_DUMP_CHANNELS; + p = hex_line; + for (j = 0; j < n; j++) + { + if ((j & 0x7) == 0) + *(p++) = ' '; + *(p++) = hex_digit_table[li_config_table[j].curchnl >> 4]; + *(p++) = hex_digit_table[li_config_table[j].curchnl & 0xf]; + } + *p = '\0'; + dbug(1, dprintf("[%06lx] CURRENT %s", + (dword)(UnMapController(a->Id)), (char *)hex_line)); + p = hex_line; + for (j = 0; j < n; j++) + { + if ((j & 0x7) == 0) + *(p++) = ' '; + *(p++) = hex_digit_table[li_config_table[j].channel >> 4]; + *(p++) = hex_digit_table[li_config_table[j].channel & 0xf]; + } + *p = '\0'; + dbug(1, dprintf("[%06lx] CHANNEL %s", + (dword)(UnMapController(a->Id)), (char *)hex_line)); + p = hex_line; + for (j = 0; j < n; j++) + { + if ((j & 0x7) == 0) + *(p++) = ' '; + *(p++) = hex_digit_table[li_config_table[j].chflags >> 4]; + *(p++) = hex_digit_table[li_config_table[j].chflags & 0xf]; + } + *p = '\0'; + dbug(1, dprintf("[%06lx] CHFLAG %s", + (dword)(UnMapController(a->Id)), (char *)hex_line)); + for (i = 0; i < n; i++) + { + p = hex_line; + for (j = 0; j < n; j++) + { + if ((j & 0x7) == 0) + *(p++) = ' '; + *(p++) = hex_digit_table[li_config_table[i].flag_table[j] >> 4]; + *(p++) = hex_digit_table[li_config_table[i].flag_table[j] & 0xf]; + } + *p = '\0'; + dbug(1, dprintf("[%06lx] FLAG[%02x]%s", + (dword)(UnMapController(a->Id)), i, (char *)hex_line)); + } + for (i = 0; i < n; i++) + { + p = hex_line; + for (j = 0; j < n; j++) + { + if ((j & 0x7) == 0) + *(p++) = ' '; + *(p++) = hex_digit_table[li_config_table[i].coef_table[j] >> 4]; + *(p++) = hex_digit_table[li_config_table[i].coef_table[j] & 0xf]; + } + *p = '\0'; + dbug(1, dprintf("[%06lx] COEF[%02x]%s", + (dword)(UnMapController(a->Id)), i, (char *)hex_line)); + } +} + + +static struct +{ + byte mask; + byte line_flags; +} mixer_write_prog_pri[] = +{ + { LI_COEF_CH_CH, 0 }, + { LI_COEF_CH_PC, MIXER_COEF_LINE_TO_PC_FLAG }, + { LI_COEF_PC_CH, MIXER_COEF_LINE_FROM_PC_FLAG }, + { LI_COEF_PC_PC, MIXER_COEF_LINE_TO_PC_FLAG | MIXER_COEF_LINE_FROM_PC_FLAG } +}; + +static struct +{ + byte from_ch; + byte to_ch; + byte mask; + byte xconnect_override; +} mixer_write_prog_bri[] = +{ + { 0, 0, LI_COEF_CH_CH, 0x01 }, /* B to B */ + { 1, 0, LI_COEF_CH_CH, 0x01 }, /* Alt B to B */ + { 0, 0, LI_COEF_PC_CH, 0x80 }, /* PC to B */ + { 1, 0, LI_COEF_PC_CH, 0x01 }, /* Alt PC to B */ + { 2, 0, LI_COEF_CH_CH, 0x00 }, /* IC to B */ + { 3, 0, LI_COEF_CH_CH, 0x00 }, /* Alt IC to B */ + { 0, 0, LI_COEF_CH_PC, 0x80 }, /* B to PC */ + { 1, 0, LI_COEF_CH_PC, 0x01 }, /* Alt B to PC */ + { 0, 0, LI_COEF_PC_PC, 0x01 }, /* PC to PC */ + { 1, 0, LI_COEF_PC_PC, 0x01 }, /* Alt PC to PC */ + { 2, 0, LI_COEF_CH_PC, 0x00 }, /* IC to PC */ + { 3, 0, LI_COEF_CH_PC, 0x00 }, /* Alt IC to PC */ + { 0, 2, LI_COEF_CH_CH, 0x00 }, /* B to IC */ + { 1, 2, LI_COEF_CH_CH, 0x00 }, /* Alt B to IC */ + { 0, 2, LI_COEF_PC_CH, 0x00 }, /* PC to IC */ + { 1, 2, LI_COEF_PC_CH, 0x00 }, /* Alt PC to IC */ + { 2, 2, LI_COEF_CH_CH, 0x00 }, /* IC to IC */ + { 3, 2, LI_COEF_CH_CH, 0x00 }, /* Alt IC to IC */ + { 1, 1, LI_COEF_CH_CH, 0x01 }, /* Alt B to Alt B */ + { 0, 1, LI_COEF_CH_CH, 0x01 }, /* B to Alt B */ + { 1, 1, LI_COEF_PC_CH, 0x80 }, /* Alt PC to Alt B */ + { 0, 1, LI_COEF_PC_CH, 0x01 }, /* PC to Alt B */ + { 3, 1, LI_COEF_CH_CH, 0x00 }, /* Alt IC to Alt B */ + { 2, 1, LI_COEF_CH_CH, 0x00 }, /* IC to Alt B */ + { 1, 1, LI_COEF_CH_PC, 0x80 }, /* Alt B to Alt PC */ + { 0, 1, LI_COEF_CH_PC, 0x01 }, /* B to Alt PC */ + { 1, 1, LI_COEF_PC_PC, 0x01 }, /* Alt PC to Alt PC */ + { 0, 1, LI_COEF_PC_PC, 0x01 }, /* PC to Alt PC */ + { 3, 1, LI_COEF_CH_PC, 0x00 }, /* Alt IC to Alt PC */ + { 2, 1, LI_COEF_CH_PC, 0x00 }, /* IC to Alt PC */ + { 1, 3, LI_COEF_CH_CH, 0x00 }, /* Alt B to Alt IC */ + { 0, 3, LI_COEF_CH_CH, 0x00 }, /* B to Alt IC */ + { 1, 3, LI_COEF_PC_CH, 0x00 }, /* Alt PC to Alt IC */ + { 0, 3, LI_COEF_PC_CH, 0x00 }, /* PC to Alt IC */ + { 3, 3, LI_COEF_CH_CH, 0x00 }, /* Alt IC to Alt IC */ + { 2, 3, LI_COEF_CH_CH, 0x00 } /* IC to Alt IC */ +}; + +static byte mixer_swapped_index_bri[] = +{ + 18, /* B to B */ + 19, /* Alt B to B */ + 20, /* PC to B */ + 21, /* Alt PC to B */ + 22, /* IC to B */ + 23, /* Alt IC to B */ + 24, /* B to PC */ + 25, /* Alt B to PC */ + 26, /* PC to PC */ + 27, /* Alt PC to PC */ + 28, /* IC to PC */ + 29, /* Alt IC to PC */ + 30, /* B to IC */ + 31, /* Alt B to IC */ + 32, /* PC to IC */ + 33, /* Alt PC to IC */ + 34, /* IC to IC */ + 35, /* Alt IC to IC */ + 0, /* Alt B to Alt B */ + 1, /* B to Alt B */ + 2, /* Alt PC to Alt B */ + 3, /* PC to Alt B */ + 4, /* Alt IC to Alt B */ + 5, /* IC to Alt B */ + 6, /* Alt B to Alt PC */ + 7, /* B to Alt PC */ + 8, /* Alt PC to Alt PC */ + 9, /* PC to Alt PC */ + 10, /* Alt IC to Alt PC */ + 11, /* IC to Alt PC */ + 12, /* Alt B to Alt IC */ + 13, /* B to Alt IC */ + 14, /* Alt PC to Alt IC */ + 15, /* PC to Alt IC */ + 16, /* Alt IC to Alt IC */ + 17 /* IC to Alt IC */ +}; + +static struct +{ + byte mask; + byte from_pc; + byte to_pc; +} xconnect_write_prog[] = +{ + { LI_COEF_CH_CH, false, false }, + { LI_COEF_CH_PC, false, true }, + { LI_COEF_PC_CH, true, false }, + { LI_COEF_PC_PC, true, true } +}; + + +static void xconnect_query_addresses(PLCI *plci) +{ + DIVA_CAPI_ADAPTER *a; + word w, ch; + byte *p; + + dbug(1, dprintf("[%06lx] %s,%d: xconnect_query_addresses", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + + a = plci->adapter; + if (a->li_pri && ((plci->li_bchannel_id == 0) + || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))) + { + dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + return; + } + p = plci->internal_req_buffer; + ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0; + *(p++) = UDATA_REQUEST_XCONNECT_FROM; + w = ch; + *(p++) = (byte) w; + *(p++) = (byte)(w >> 8); + w = ch | XCONNECT_CHANNEL_PORT_PC; + *(p++) = (byte) w; + *(p++) = (byte)(w >> 8); + plci->NData[0].P = plci->internal_req_buffer; + plci->NData[0].PLength = p - plci->internal_req_buffer; + plci->NL.X = plci->NData; + plci->NL.ReqCh = 0; + plci->NL.Req = plci->nl_req = (byte) N_UDATA; + plci->adapter->request(&plci->NL); +} + + +static void xconnect_write_coefs(PLCI *plci, word internal_command) +{ + + dbug(1, dprintf("[%06lx] %s,%d: xconnect_write_coefs %04x", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__, internal_command)); + + plci->li_write_command = internal_command; + plci->li_write_channel = 0; +} + + +static byte xconnect_write_coefs_process(dword Id, PLCI *plci, byte Rc) +{ + DIVA_CAPI_ADAPTER *a; + word w, n, i, j, r, s, to_ch; + dword d; + byte *p; + struct xconnect_transfer_address_s *transfer_address; + byte ch_map[MIXER_CHANNELS_BRI]; + + dbug(1, dprintf("[%06x] %s,%d: xconnect_write_coefs_process %02x %d", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->li_write_channel)); + + a = plci->adapter; + if ((plci->li_bchannel_id == 0) + || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci)) + { + dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out", + UnMapId(Id), (char *)(FILE_), __LINE__)); + return (true); + } + i = a->li_base + (plci->li_bchannel_id - 1); + j = plci->li_write_channel; + p = plci->internal_req_buffer; + if (j != 0) + { + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: LI write coefs failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + return (false); + } + } + if (li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT) + { + r = 0; + s = 0; + if (j < li_total_channels) + { + if (li_config_table[i].channel & LI_CHANNEL_ADDRESSES_SET) + { + s = ((li_config_table[i].send_b.card_address.low | li_config_table[i].send_b.card_address.high) ? + (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_PC | LI_COEF_PC_PC)) & + ((li_config_table[i].send_pc.card_address.low | li_config_table[i].send_pc.card_address.high) ? + (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_PC_CH)); + } + r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4)); + while ((j < li_total_channels) + && ((r == 0) + || (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET)) + || (!li_config_table[j].adapter->li_pri + && (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI)) + || (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low) + || (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high)) + && (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT) + || !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT))) + || ((li_config_table[j].adapter->li_base != a->li_base) + && !(r & s & + ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ? + (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) & + ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ? + (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC)))))) + { + j++; + if (j < li_total_channels) + r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4)); + } + } + if (j < li_total_channels) + { + plci->internal_command = plci->li_write_command; + if (plci_nl_busy(plci)) + return (true); + to_ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0; + *(p++) = UDATA_REQUEST_XCONNECT_TO; + do + { + if (li_config_table[j].adapter->li_base != a->li_base) + { + r &= s & + ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ? + (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) & + ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ? + (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC)); + } + n = 0; + do + { + if (r & xconnect_write_prog[n].mask) + { + if (xconnect_write_prog[n].from_pc) + transfer_address = &(li_config_table[j].send_pc); + else + transfer_address = &(li_config_table[j].send_b); + d = transfer_address->card_address.low; + *(p++) = (byte) d; + *(p++) = (byte)(d >> 8); + *(p++) = (byte)(d >> 16); + *(p++) = (byte)(d >> 24); + d = transfer_address->card_address.high; + *(p++) = (byte) d; + *(p++) = (byte)(d >> 8); + *(p++) = (byte)(d >> 16); + *(p++) = (byte)(d >> 24); + d = transfer_address->offset; + *(p++) = (byte) d; + *(p++) = (byte)(d >> 8); + *(p++) = (byte)(d >> 16); + *(p++) = (byte)(d >> 24); + w = xconnect_write_prog[n].to_pc ? to_ch | XCONNECT_CHANNEL_PORT_PC : to_ch; + *(p++) = (byte) w; + *(p++) = (byte)(w >> 8); + w = ((li_config_table[i].coef_table[j] & xconnect_write_prog[n].mask) == 0) ? 0x01 : + (li_config_table[i].adapter->u_law ? + (li_config_table[j].adapter->u_law ? 0x80 : 0x86) : + (li_config_table[j].adapter->u_law ? 0x7a : 0x80)); + *(p++) = (byte) w; + *(p++) = (byte) 0; + li_config_table[i].coef_table[j] ^= xconnect_write_prog[n].mask << 4; + } + n++; + } while ((n < ARRAY_SIZE(xconnect_write_prog)) + && ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE)); + if (n == ARRAY_SIZE(xconnect_write_prog)) + { + do + { + j++; + if (j < li_total_channels) + r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4)); + } while ((j < li_total_channels) + && ((r == 0) + || (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET)) + || (!li_config_table[j].adapter->li_pri + && (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI)) + || (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low) + || (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high)) + && (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT) + || !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT))) + || ((li_config_table[j].adapter->li_base != a->li_base) + && !(r & s & + ((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ? + (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) & + ((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ? + (LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC)))))); + } + } while ((j < li_total_channels) + && ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE)); + } + else if (j == li_total_channels) + { + plci->internal_command = plci->li_write_command; + if (plci_nl_busy(plci)) + return (true); + if (a->li_pri) + { + *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC; + w = 0; + if (li_config_table[i].channel & LI_CHANNEL_TX_DATA) + w |= MIXER_FEATURE_ENABLE_TX_DATA; + if (li_config_table[i].channel & LI_CHANNEL_RX_DATA) + w |= MIXER_FEATURE_ENABLE_RX_DATA; + *(p++) = (byte) w; + *(p++) = (byte)(w >> 8); + } + else + { + *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI; + w = 0; + if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI) + && (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length)) + { + w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE); + } + if (li_config_table[i].channel & LI_CHANNEL_TX_DATA) + w |= MIXER_FEATURE_ENABLE_TX_DATA; + if (li_config_table[i].channel & LI_CHANNEL_RX_DATA) + w |= MIXER_FEATURE_ENABLE_RX_DATA; + *(p++) = (byte) w; + *(p++) = (byte)(w >> 8); + for (j = 0; j < sizeof(ch_map); j += 2) + { + if (plci->li_bchannel_id == 2) + { + ch_map[j] = (byte)(j + 1); + ch_map[j + 1] = (byte) j; + } + else + { + ch_map[j] = (byte) j; + ch_map[j + 1] = (byte)(j + 1); + } + } + for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++) + { + i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch]; + j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch]; + if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED) + { + *p = (mixer_write_prog_bri[n].xconnect_override != 0) ? + mixer_write_prog_bri[n].xconnect_override : + ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01); + if ((i >= a->li_base + MIXER_BCHANNELS_BRI) || (j >= a->li_base + MIXER_BCHANNELS_BRI)) + { + w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4)); + li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4; + } + } + else + { + *p = 0x00; + if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE)) + { + w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n]; + if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length) + *p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w]; + } + } + p++; + } + } + j = li_total_channels + 1; + } + } + else + { + if (j <= li_total_channels) + { + plci->internal_command = plci->li_write_command; + if (plci_nl_busy(plci)) + return (true); + if (j < a->li_base) + j = a->li_base; + if (a->li_pri) + { + *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC; + w = 0; + if (li_config_table[i].channel & LI_CHANNEL_TX_DATA) + w |= MIXER_FEATURE_ENABLE_TX_DATA; + if (li_config_table[i].channel & LI_CHANNEL_RX_DATA) + w |= MIXER_FEATURE_ENABLE_RX_DATA; + *(p++) = (byte) w; + *(p++) = (byte)(w >> 8); + for (n = 0; n < ARRAY_SIZE(mixer_write_prog_pri); n++) + { + *(p++) = (byte)((plci->li_bchannel_id - 1) | mixer_write_prog_pri[n].line_flags); + for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++) + { + w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4)); + if (w & mixer_write_prog_pri[n].mask) + { + *(p++) = (li_config_table[i].coef_table[j] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01; + li_config_table[i].coef_table[j] ^= mixer_write_prog_pri[n].mask << 4; + } + else + *(p++) = 0x00; + } + *(p++) = (byte)((plci->li_bchannel_id - 1) | MIXER_COEF_LINE_ROW_FLAG | mixer_write_prog_pri[n].line_flags); + for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++) + { + w = ((li_config_table[j].coef_table[i] & 0xf) ^ (li_config_table[j].coef_table[i] >> 4)); + if (w & mixer_write_prog_pri[n].mask) + { + *(p++) = (li_config_table[j].coef_table[i] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01; + li_config_table[j].coef_table[i] ^= mixer_write_prog_pri[n].mask << 4; + } + else + *(p++) = 0x00; + } + } + } + else + { + *(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI; + w = 0; + if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI) + && (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length)) + { + w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE); + } + if (li_config_table[i].channel & LI_CHANNEL_TX_DATA) + w |= MIXER_FEATURE_ENABLE_TX_DATA; + if (li_config_table[i].channel & LI_CHANNEL_RX_DATA) + w |= MIXER_FEATURE_ENABLE_RX_DATA; + *(p++) = (byte) w; + *(p++) = (byte)(w >> 8); + for (j = 0; j < sizeof(ch_map); j += 2) + { + if (plci->li_bchannel_id == 2) + { + ch_map[j] = (byte)(j + 1); + ch_map[j + 1] = (byte) j; + } + else + { + ch_map[j] = (byte) j; + ch_map[j + 1] = (byte)(j + 1); + } + } + for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++) + { + i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch]; + j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch]; + if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED) + { + *p = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01); + w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4)); + li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4; + } + else + { + *p = 0x00; + if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE)) + { + w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n]; + if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length) + *p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w]; + } + } + p++; + } + } + j = li_total_channels + 1; + } + } + plci->li_write_channel = j; + if (p != plci->internal_req_buffer) + { + plci->NData[0].P = plci->internal_req_buffer; + plci->NData[0].PLength = p - plci->internal_req_buffer; + plci->NL.X = plci->NData; + plci->NL.ReqCh = 0; + plci->NL.Req = plci->nl_req = (byte) N_UDATA; + plci->adapter->request(&plci->NL); + } + return (true); +} + + +static void mixer_notify_update(PLCI *plci, byte others) +{ + DIVA_CAPI_ADAPTER *a; + word i, w; + PLCI *notify_plci; + byte msg[sizeof(CAPI_MSG_HEADER) + 6]; + + dbug(1, dprintf("[%06lx] %s,%d: mixer_notify_update %d", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__, others)); + + a = plci->adapter; + if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED) + { + if (others) + plci->li_notify_update = true; + i = 0; + do + { + notify_plci = NULL; + if (others) + { + while ((i < li_total_channels) && (li_config_table[i].plci == NULL)) + i++; + if (i < li_total_channels) + notify_plci = li_config_table[i++].plci; + } + else + { + if ((plci->li_bchannel_id != 0) + && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci)) + { + notify_plci = plci; + } + } + if ((notify_plci != NULL) + && !notify_plci->li_notify_update + && (notify_plci->appl != NULL) + && (notify_plci->State) + && notify_plci->NL.Id && !notify_plci->nl_remove_id) + { + notify_plci->li_notify_update = true; + ((CAPI_MSG *) msg)->header.length = 18; + ((CAPI_MSG *) msg)->header.appl_id = notify_plci->appl->Id; + ((CAPI_MSG *) msg)->header.command = _FACILITY_R; + ((CAPI_MSG *) msg)->header.number = 0; + ((CAPI_MSG *) msg)->header.controller = notify_plci->adapter->Id; + ((CAPI_MSG *) msg)->header.plci = notify_plci->Id; + ((CAPI_MSG *) msg)->header.ncci = 0; + ((CAPI_MSG *) msg)->info.facility_req.Selector = SELECTOR_LINE_INTERCONNECT; + ((CAPI_MSG *) msg)->info.facility_req.structs[0] = 3; + PUT_WORD(&(((CAPI_MSG *) msg)->info.facility_req.structs[1]), LI_REQ_SILENT_UPDATE); + ((CAPI_MSG *) msg)->info.facility_req.structs[3] = 0; + w = api_put(notify_plci->appl, (CAPI_MSG *) msg); + if (w != _QUEUE_FULL) + { + if (w != 0) + { + dbug(1, dprintf("[%06lx] %s,%d: Interconnect notify failed %06x %d", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__, + (dword)((notify_plci->Id << 8) | UnMapController(notify_plci->adapter->Id)), w)); + } + notify_plci->li_notify_update = false; + } + } + } while (others && (notify_plci != NULL)); + if (others) + plci->li_notify_update = false; + } +} + + +static void mixer_clear_config(PLCI *plci) +{ + DIVA_CAPI_ADAPTER *a; + word i, j; + + dbug(1, dprintf("[%06lx] %s,%d: mixer_clear_config", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + + plci->li_notify_update = false; + plci->li_plci_b_write_pos = 0; + plci->li_plci_b_read_pos = 0; + plci->li_plci_b_req_pos = 0; + a = plci->adapter; + if ((plci->li_bchannel_id != 0) + && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci)) + { + i = a->li_base + (plci->li_bchannel_id - 1); + li_config_table[i].curchnl = 0; + li_config_table[i].channel = 0; + li_config_table[i].chflags = 0; + for (j = 0; j < li_total_channels; j++) + { + li_config_table[j].flag_table[i] = 0; + li_config_table[i].flag_table[j] = 0; + li_config_table[i].coef_table[j] = 0; + li_config_table[j].coef_table[i] = 0; + } + if (!a->li_pri) + { + li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET; + if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)) + { + i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1); + li_config_table[i].curchnl = 0; + li_config_table[i].channel = 0; + li_config_table[i].chflags = 0; + for (j = 0; j < li_total_channels; j++) + { + li_config_table[i].flag_table[j] = 0; + li_config_table[j].flag_table[i] = 0; + li_config_table[i].coef_table[j] = 0; + li_config_table[j].coef_table[i] = 0; + } + if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) + { + i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id); + li_config_table[i].curchnl = 0; + li_config_table[i].channel = 0; + li_config_table[i].chflags = 0; + for (j = 0; j < li_total_channels; j++) + { + li_config_table[i].flag_table[j] = 0; + li_config_table[j].flag_table[i] = 0; + li_config_table[i].coef_table[j] = 0; + li_config_table[j].coef_table[i] = 0; + } + } + } + } + } +} + + +static void mixer_prepare_switch(dword Id, PLCI *plci) +{ + + dbug(1, dprintf("[%06lx] %s,%d: mixer_prepare_switch", + UnMapId(Id), (char *)(FILE_), __LINE__)); + + do + { + mixer_indication_coefs_set(Id, plci); + } while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos); +} + + +static word mixer_save_config(dword Id, PLCI *plci, byte Rc) +{ + DIVA_CAPI_ADAPTER *a; + word i, j; + + dbug(1, dprintf("[%06lx] %s,%d: mixer_save_config %02x %d", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state)); + + a = plci->adapter; + if ((plci->li_bchannel_id != 0) + && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci)) + { + i = a->li_base + (plci->li_bchannel_id - 1); + for (j = 0; j < li_total_channels; j++) + { + li_config_table[i].coef_table[j] &= 0xf; + li_config_table[j].coef_table[i] &= 0xf; + } + if (!a->li_pri) + li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET; + } + return (GOOD); +} + + +static word mixer_restore_config(dword Id, PLCI *plci, byte Rc) +{ + DIVA_CAPI_ADAPTER *a; + word Info; + + dbug(1, dprintf("[%06lx] %s,%d: mixer_restore_config %02x %d", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state)); + + Info = GOOD; + a = plci->adapter; + if ((plci->B1_facilities & B1_FACILITY_MIXER) + && (plci->li_bchannel_id != 0) + && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci)) + { + switch (plci->adjust_b_state) + { + case ADJUST_B_RESTORE_MIXER_1: + if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT) + { + plci->internal_command = plci->adjust_b_command; + if (plci_nl_busy(plci)) + { + plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1; + break; + } + xconnect_query_addresses(plci); + plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_2; + break; + } + plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5; + Rc = OK; + case ADJUST_B_RESTORE_MIXER_2: + case ADJUST_B_RESTORE_MIXER_3: + case ADJUST_B_RESTORE_MIXER_4: + if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0)) + { + dbug(1, dprintf("[%06lx] %s,%d: Adjust B query addresses failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + Info = _WRONG_STATE; + break; + } + if (Rc == OK) + { + if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2) + plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_3; + else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4) + plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5; + } + else if (Rc == 0) + { + if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2) + plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_4; + else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3) + plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5; + } + if (plci->adjust_b_state != ADJUST_B_RESTORE_MIXER_5) + { + plci->internal_command = plci->adjust_b_command; + break; + } + case ADJUST_B_RESTORE_MIXER_5: + xconnect_write_coefs(plci, plci->adjust_b_command); + plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_6; + Rc = OK; + case ADJUST_B_RESTORE_MIXER_6: + if (!xconnect_write_coefs_process(Id, plci, Rc)) + { + dbug(1, dprintf("[%06lx] %s,%d: Write mixer coefs failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _FACILITY_NOT_SUPPORTED; + break; + } + if (plci->internal_command) + break; + plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_7; + case ADJUST_B_RESTORE_MIXER_7: + break; + } + } + return (Info); +} + + +static void mixer_command(dword Id, PLCI *plci, byte Rc) +{ + DIVA_CAPI_ADAPTER *a; + word i, internal_command; + + dbug(1, dprintf("[%06lx] %s,%d: mixer_command %02x %04x %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command, + plci->li_cmd)); + + a = plci->adapter; + internal_command = plci->internal_command; + plci->internal_command = 0; + switch (plci->li_cmd) + { + case LI_REQ_CONNECT: + case LI_REQ_DISCONNECT: + case LI_REQ_SILENT_UPDATE: + switch (internal_command) + { + default: + if (plci->li_channel_bits & LI_CHANNEL_INVOLVED) + { + adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities | + B1_FACILITY_MIXER), MIXER_COMMAND_1); + } + case MIXER_COMMAND_1: + if (plci->li_channel_bits & LI_CHANNEL_INVOLVED) + { + if (adjust_b_process(Id, plci, Rc) != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: Load mixer failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + break; + } + if (plci->internal_command) + return; + } + plci->li_plci_b_req_pos = plci->li_plci_b_write_pos; + if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED) + || ((get_b1_facilities(plci, plci->B1_resource) & B1_FACILITY_MIXER) + && (add_b1_facilities(plci, plci->B1_resource, (word)(plci->B1_facilities & + ~B1_FACILITY_MIXER)) == plci->B1_resource))) + { + xconnect_write_coefs(plci, MIXER_COMMAND_2); + } + else + { + do + { + mixer_indication_coefs_set(Id, plci); + } while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos); + } + case MIXER_COMMAND_2: + if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED) + || ((get_b1_facilities(plci, plci->B1_resource) & B1_FACILITY_MIXER) + && (add_b1_facilities(plci, plci->B1_resource, (word)(plci->B1_facilities & + ~B1_FACILITY_MIXER)) == plci->B1_resource))) + { + if (!xconnect_write_coefs_process(Id, plci, Rc)) + { + dbug(1, dprintf("[%06lx] %s,%d: Write mixer coefs failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + if (plci->li_plci_b_write_pos != plci->li_plci_b_req_pos) + { + do + { + plci->li_plci_b_write_pos = (plci->li_plci_b_write_pos == 0) ? + LI_PLCI_B_QUEUE_ENTRIES - 1 : plci->li_plci_b_write_pos - 1; + i = (plci->li_plci_b_write_pos == 0) ? + LI_PLCI_B_QUEUE_ENTRIES - 1 : plci->li_plci_b_write_pos - 1; + } while ((plci->li_plci_b_write_pos != plci->li_plci_b_req_pos) + && !(plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG)); + } + break; + } + if (plci->internal_command) + return; + } + if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED)) + { + adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities & + ~B1_FACILITY_MIXER), MIXER_COMMAND_3); + } + case MIXER_COMMAND_3: + if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED)) + { + if (adjust_b_process(Id, plci, Rc) != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: Unload mixer failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + break; + } + if (plci->internal_command) + return; + } + break; + } + break; + } + if ((plci->li_bchannel_id == 0) + || (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci)) + { + dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out %d", + UnMapId(Id), (char *)(FILE_), __LINE__, (int)(plci->li_bchannel_id))); + } + else + { + i = a->li_base + (plci->li_bchannel_id - 1); + li_config_table[i].curchnl = plci->li_channel_bits; + if (!a->li_pri && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)) + { + i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1); + li_config_table[i].curchnl = plci->li_channel_bits; + if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) + { + i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id); + li_config_table[i].curchnl = plci->li_channel_bits; + } + } + } +} + + +static void li_update_connect(dword Id, DIVA_CAPI_ADAPTER *a, PLCI *plci, + dword plci_b_id, byte connect, dword li_flags) +{ + word i, ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s; + PLCI *plci_b; + DIVA_CAPI_ADAPTER *a_b; + + a_b = &(adapter[MapController((byte)(plci_b_id & 0x7f)) - 1]); + plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]); + ch_a = a->li_base + (plci->li_bchannel_id - 1); + if (!a->li_pri && (plci->tel == ADV_VOICE) + && (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER)) + { + ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE; + ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ? + a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v; + } + else + { + ch_a_v = ch_a; + ch_a_s = ch_a; + } + ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1); + if (!a_b->li_pri && (plci_b->tel == ADV_VOICE) + && (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER)) + { + ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE; + ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ? + a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v; + } + else + { + ch_b_v = ch_b; + ch_b_s = ch_b; + } + if (connect) + { + li_config_table[ch_a].flag_table[ch_a_v] &= ~LI_FLAG_MONITOR; + li_config_table[ch_a].flag_table[ch_a_s] &= ~LI_FLAG_MONITOR; + li_config_table[ch_a_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX); + li_config_table[ch_a_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX); + } + li_config_table[ch_a].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR; + li_config_table[ch_a].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR; + li_config_table[ch_b_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX); + li_config_table[ch_b_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX); + if (ch_a_v == ch_b_v) + { + li_config_table[ch_a_v].flag_table[ch_b_v] &= ~LI_FLAG_CONFERENCE; + li_config_table[ch_a_s].flag_table[ch_b_s] &= ~LI_FLAG_CONFERENCE; + } + else + { + if (li_config_table[ch_a_v].flag_table[ch_b_v] & LI_FLAG_CONFERENCE) + { + for (i = 0; i < li_total_channels; i++) + { + if (i != ch_a_v) + li_config_table[ch_a_v].flag_table[i] &= ~LI_FLAG_CONFERENCE; + } + } + if (li_config_table[ch_a_s].flag_table[ch_b_v] & LI_FLAG_CONFERENCE) + { + for (i = 0; i < li_total_channels; i++) + { + if (i != ch_a_s) + li_config_table[ch_a_s].flag_table[i] &= ~LI_FLAG_CONFERENCE; + } + } + if (li_config_table[ch_b_v].flag_table[ch_a_v] & LI_FLAG_CONFERENCE) + { + for (i = 0; i < li_total_channels; i++) + { + if (i != ch_a_v) + li_config_table[i].flag_table[ch_a_v] &= ~LI_FLAG_CONFERENCE; + } + } + if (li_config_table[ch_b_v].flag_table[ch_a_s] & LI_FLAG_CONFERENCE) + { + for (i = 0; i < li_total_channels; i++) + { + if (i != ch_a_s) + li_config_table[i].flag_table[ch_a_s] &= ~LI_FLAG_CONFERENCE; + } + } + } + if (li_flags & LI_FLAG_CONFERENCE_A_B) + { + li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE; + li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE; + li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE; + li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE; + } + if (li_flags & LI_FLAG_CONFERENCE_B_A) + { + li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE; + li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE; + li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE; + li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE; + } + if (li_flags & LI_FLAG_MONITOR_A) + { + li_config_table[ch_a].flag_table[ch_a_v] |= LI_FLAG_MONITOR; + li_config_table[ch_a].flag_table[ch_a_s] |= LI_FLAG_MONITOR; + } + if (li_flags & LI_FLAG_MONITOR_B) + { + li_config_table[ch_a].flag_table[ch_b_v] |= LI_FLAG_MONITOR; + li_config_table[ch_a].flag_table[ch_b_s] |= LI_FLAG_MONITOR; + } + if (li_flags & LI_FLAG_ANNOUNCEMENT_A) + { + li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT; + li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT; + } + if (li_flags & LI_FLAG_ANNOUNCEMENT_B) + { + li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT; + li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT; + } + if (li_flags & LI_FLAG_MIX_A) + { + li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_MIX; + li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_MIX; + } + if (li_flags & LI_FLAG_MIX_B) + { + li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_MIX; + li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_MIX; + } + if (ch_a_v != ch_a_s) + { + li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE; + li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE; + } + if (ch_b_v != ch_b_s) + { + li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE; + li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE; + } +} + + +static void li2_update_connect(dword Id, DIVA_CAPI_ADAPTER *a, PLCI *plci, + dword plci_b_id, byte connect, dword li_flags) +{ + word ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s; + PLCI *plci_b; + DIVA_CAPI_ADAPTER *a_b; + + a_b = &(adapter[MapController((byte)(plci_b_id & 0x7f)) - 1]); + plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]); + ch_a = a->li_base + (plci->li_bchannel_id - 1); + if (!a->li_pri && (plci->tel == ADV_VOICE) + && (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER)) + { + ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE; + ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ? + a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v; + } + else + { + ch_a_v = ch_a; + ch_a_s = ch_a; + } + ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1); + if (!a_b->li_pri && (plci_b->tel == ADV_VOICE) + && (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER)) + { + ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE; + ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ? + a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v; + } + else + { + ch_b_v = ch_b; + ch_b_s = ch_b; + } + if (connect) + { + li_config_table[ch_b].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR; + li_config_table[ch_b].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR; + li_config_table[ch_b_v].flag_table[ch_b] &= ~LI_FLAG_MIX; + li_config_table[ch_b_s].flag_table[ch_b] &= ~LI_FLAG_MIX; + li_config_table[ch_b].flag_table[ch_b] &= ~LI_FLAG_PCCONNECT; + li_config_table[ch_b].chflags &= ~(LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP); + } + li_config_table[ch_b_v].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE); + li_config_table[ch_b_s].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE); + li_config_table[ch_b_v].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE); + li_config_table[ch_b_s].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE); + li_config_table[ch_a_v].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE); + li_config_table[ch_a_v].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE); + li_config_table[ch_a_s].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE); + li_config_table[ch_a_s].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE); + if (li_flags & LI2_FLAG_INTERCONNECT_A_B) + { + li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT; + li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT; + li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT; + li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT; + } + if (li_flags & LI2_FLAG_INTERCONNECT_B_A) + { + li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT; + li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT; + li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT; + li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT; + } + if (li_flags & LI2_FLAG_MONITOR_B) + { + li_config_table[ch_b].flag_table[ch_b_v] |= LI_FLAG_MONITOR; + li_config_table[ch_b].flag_table[ch_b_s] |= LI_FLAG_MONITOR; + } + if (li_flags & LI2_FLAG_MIX_B) + { + li_config_table[ch_b_v].flag_table[ch_b] |= LI_FLAG_MIX; + li_config_table[ch_b_s].flag_table[ch_b] |= LI_FLAG_MIX; + } + if (li_flags & LI2_FLAG_MONITOR_X) + li_config_table[ch_b].chflags |= LI_CHFLAG_MONITOR; + if (li_flags & LI2_FLAG_MIX_X) + li_config_table[ch_b].chflags |= LI_CHFLAG_MIX; + if (li_flags & LI2_FLAG_LOOP_B) + { + li_config_table[ch_b_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT; + li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT; + li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT; + li_config_table[ch_b_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT; + } + if (li_flags & LI2_FLAG_LOOP_PC) + li_config_table[ch_b].flag_table[ch_b] |= LI_FLAG_PCCONNECT; + if (li_flags & LI2_FLAG_LOOP_X) + li_config_table[ch_b].chflags |= LI_CHFLAG_LOOP; + if (li_flags & LI2_FLAG_PCCONNECT_A_B) + li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_PCCONNECT; + if (li_flags & LI2_FLAG_PCCONNECT_B_A) + li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_PCCONNECT; + if (ch_a_v != ch_a_s) + { + li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE; + li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE; + } + if (ch_b_v != ch_b_s) + { + li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE; + li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE; + } +} + + +static word li_check_main_plci(dword Id, PLCI *plci) +{ + if (plci == NULL) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI", + UnMapId(Id), (char *)(FILE_), __LINE__)); + return (_WRONG_IDENTIFIER); + } + if (!plci->State + || !plci->NL.Id || plci->nl_remove_id + || (plci->li_bchannel_id == 0)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong state", + UnMapId(Id), (char *)(FILE_), __LINE__)); + return (_WRONG_STATE); + } + li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = plci; + return (GOOD); +} + + +static PLCI *li_check_plci_b(dword Id, PLCI *plci, + dword plci_b_id, word plci_b_write_pos, byte *p_result) +{ + byte ctlr_b; + PLCI *plci_b; + + if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos : + LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2) + { + dbug(1, dprintf("[%06lx] %s,%d: LI request overrun", + UnMapId(Id), (char *)(FILE_), __LINE__)); + PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE); + return (NULL); + } + ctlr_b = 0; + if ((plci_b_id & 0x7f) != 0) + { + ctlr_b = MapController((byte)(plci_b_id & 0x7f)); + if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL))) + ctlr_b = 0; + } + if ((ctlr_b == 0) + || (((plci_b_id >> 8) & 0xff) == 0) + || (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci)) + { + dbug(1, dprintf("[%06lx] %s,%d: LI invalid second PLCI %08lx", + UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id)); + PUT_WORD(p_result, _WRONG_IDENTIFIER); + return (NULL); + } + plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]); + if (!plci_b->State + || !plci_b->NL.Id || plci_b->nl_remove_id + || (plci_b->li_bchannel_id == 0)) + { + dbug(1, dprintf("[%06lx] %s,%d: LI peer in wrong state %08lx", + UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id)); + PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE); + return (NULL); + } + li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci = plci_b; + if (((byte)(plci_b_id & ~EXT_CONTROLLER)) != + ((byte)(UnMapController(plci->adapter->Id) & ~EXT_CONTROLLER)) + && (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT) + || !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT))) + { + dbug(1, dprintf("[%06lx] %s,%d: LI not on same ctrl %08lx", + UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id)); + PUT_WORD(p_result, _WRONG_IDENTIFIER); + return (NULL); + } + if (!(get_b1_facilities(plci_b, add_b1_facilities(plci_b, plci_b->B1_resource, + (word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER)) + { + dbug(1, dprintf("[%06lx] %s,%d: Interconnect peer cannot mix %d", + UnMapId(Id), (char *)(FILE_), __LINE__, plci_b->B1_resource)); + PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE); + return (NULL); + } + return (plci_b); +} + + +static PLCI *li2_check_plci_b(dword Id, PLCI *plci, + dword plci_b_id, word plci_b_write_pos, byte *p_result) +{ + byte ctlr_b; + PLCI *plci_b; + + if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos : + LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2) + { + dbug(1, dprintf("[%06lx] %s,%d: LI request overrun", + UnMapId(Id), (char *)(FILE_), __LINE__)); + PUT_WORD(p_result, _WRONG_STATE); + return (NULL); + } + ctlr_b = 0; + if ((plci_b_id & 0x7f) != 0) + { + ctlr_b = MapController((byte)(plci_b_id & 0x7f)); + if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL))) + ctlr_b = 0; + } + if ((ctlr_b == 0) + || (((plci_b_id >> 8) & 0xff) == 0) + || (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci)) + { + dbug(1, dprintf("[%06lx] %s,%d: LI invalid second PLCI %08lx", + UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id)); + PUT_WORD(p_result, _WRONG_IDENTIFIER); + return (NULL); + } + plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]); + if (!plci_b->State + || !plci_b->NL.Id || plci_b->nl_remove_id + || (plci_b->li_bchannel_id == 0) + || (li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci != plci_b)) + { + dbug(1, dprintf("[%06lx] %s,%d: LI peer in wrong state %08lx", + UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id)); + PUT_WORD(p_result, _WRONG_STATE); + return (NULL); + } + if (((byte)(plci_b_id & ~EXT_CONTROLLER)) != + ((byte)(UnMapController(plci->adapter->Id) & ~EXT_CONTROLLER)) + && (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT) + || !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT))) + { + dbug(1, dprintf("[%06lx] %s,%d: LI not on same ctrl %08lx", + UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id)); + PUT_WORD(p_result, _WRONG_IDENTIFIER); + return (NULL); + } + if (!(get_b1_facilities(plci_b, add_b1_facilities(plci_b, plci_b->B1_resource, + (word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER)) + { + dbug(1, dprintf("[%06lx] %s,%d: Interconnect peer cannot mix %d", + UnMapId(Id), (char *)(FILE_), __LINE__, plci_b->B1_resource)); + PUT_WORD(p_result, _WRONG_STATE); + return (NULL); + } + return (plci_b); +} + + +static byte mixer_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg) +{ + word Info; + word i; + dword d, li_flags, plci_b_id; + PLCI *plci_b; + API_PARSE li_parms[3]; + API_PARSE li_req_parms[3]; + API_PARSE li_participant_struct[2]; + API_PARSE li_participant_parms[3]; + word participant_parms_pos; + byte result_buffer[32]; + byte *result; + word result_pos; + word plci_b_write_pos; + + dbug(1, dprintf("[%06lx] %s,%d: mixer_request", + UnMapId(Id), (char *)(FILE_), __LINE__)); + + Info = GOOD; + result = result_buffer; + result_buffer[0] = 0; + if (!(a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)) + { + dbug(1, dprintf("[%06lx] %s,%d: Facility not supported", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _FACILITY_NOT_SUPPORTED; + } + else if (api_parse(&msg[1].info[1], msg[1].length, "ws", li_parms)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong message format", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_MESSAGE_FORMAT; + } + else + { + result_buffer[0] = 3; + PUT_WORD(&result_buffer[1], GET_WORD(li_parms[0].info)); + result_buffer[3] = 0; + switch (GET_WORD(li_parms[0].info)) + { + case LI_GET_SUPPORTED_SERVICES: + if (appl->appl_flags & APPL_FLAG_OLD_LI_SPEC) + { + result_buffer[0] = 17; + result_buffer[3] = 14; + PUT_WORD(&result_buffer[4], GOOD); + d = 0; + if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_CH) + d |= LI_CONFERENCING_SUPPORTED; + if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC) + d |= LI_MONITORING_SUPPORTED; + if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH) + d |= LI_ANNOUNCEMENTS_SUPPORTED | LI_MIXING_SUPPORTED; + if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT) + d |= LI_CROSS_CONTROLLER_SUPPORTED; + PUT_DWORD(&result_buffer[6], d); + if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT) + { + d = 0; + for (i = 0; i < li_total_channels; i++) + { + if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT) + && (li_config_table[i].adapter->li_pri + || (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI))) + { + d++; + } + } + } + else + { + d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI; + } + PUT_DWORD(&result_buffer[10], d / 2); + PUT_DWORD(&result_buffer[14], d); + } + else + { + result_buffer[0] = 25; + result_buffer[3] = 22; + PUT_WORD(&result_buffer[4], GOOD); + d = LI2_ASYMMETRIC_SUPPORTED | LI2_B_LOOPING_SUPPORTED | LI2_X_LOOPING_SUPPORTED; + if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC) + d |= LI2_MONITORING_SUPPORTED | LI2_REMOTE_MONITORING_SUPPORTED; + if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH) + d |= LI2_MIXING_SUPPORTED | LI2_REMOTE_MIXING_SUPPORTED; + if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_PC) + d |= LI2_PC_LOOPING_SUPPORTED; + if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT) + d |= LI2_CROSS_CONTROLLER_SUPPORTED; + PUT_DWORD(&result_buffer[6], d); + d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI; + PUT_DWORD(&result_buffer[10], d / 2); + PUT_DWORD(&result_buffer[14], d - 1); + if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT) + { + d = 0; + for (i = 0; i < li_total_channels; i++) + { + if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT) + && (li_config_table[i].adapter->li_pri + || (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI))) + { + d++; + } + } + } + PUT_DWORD(&result_buffer[18], d / 2); + PUT_DWORD(&result_buffer[22], d - 1); + } + break; + + case LI_REQ_CONNECT: + if (li_parms[1].length == 8) + { + appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC; + if (api_parse(&li_parms[1].info[1], li_parms[1].length, "dd", li_req_parms)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong message format", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + plci_b_id = GET_DWORD(li_req_parms[0].info) & 0xffff; + li_flags = GET_DWORD(li_req_parms[1].info); + Info = li_check_main_plci(Id, plci); + result_buffer[0] = 9; + result_buffer[3] = 6; + PUT_DWORD(&result_buffer[4], plci_b_id); + PUT_WORD(&result_buffer[8], GOOD); + if (Info != GOOD) + break; + result = plci->saved_msg.info; + for (i = 0; i <= result_buffer[0]; i++) + result[i] = result_buffer[i]; + plci_b_write_pos = plci->li_plci_b_write_pos; + plci_b = li_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[8]); + if (plci_b == NULL) + break; + li_update_connect(Id, a, plci, plci_b_id, true, li_flags); + plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_LAST_FLAG; + plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1; + plci->li_plci_b_write_pos = plci_b_write_pos; + } + else + { + appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC; + if (api_parse(&li_parms[1].info[1], li_parms[1].length, "ds", li_req_parms)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong message format", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + li_flags = GET_DWORD(li_req_parms[0].info) & ~(LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A); + Info = li_check_main_plci(Id, plci); + result_buffer[0] = 7; + result_buffer[3] = 4; + PUT_WORD(&result_buffer[4], Info); + result_buffer[6] = 0; + if (Info != GOOD) + break; + result = plci->saved_msg.info; + for (i = 0; i <= result_buffer[0]; i++) + result[i] = result_buffer[i]; + plci_b_write_pos = plci->li_plci_b_write_pos; + participant_parms_pos = 0; + result_pos = 7; + li2_update_connect(Id, a, plci, UnMapId(Id), true, li_flags); + while (participant_parms_pos < li_req_parms[1].length) + { + result[result_pos] = 6; + result_pos += 7; + PUT_DWORD(&result[result_pos - 6], 0); + PUT_WORD(&result[result_pos - 2], GOOD); + if (api_parse(&li_req_parms[1].info[1 + participant_parms_pos], + (word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong message format", + UnMapId(Id), (char *)(FILE_), __LINE__)); + PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT); + break; + } + if (api_parse(&li_participant_struct[0].info[1], + li_participant_struct[0].length, "dd", li_participant_parms)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong message format", + UnMapId(Id), (char *)(FILE_), __LINE__)); + PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT); + break; + } + plci_b_id = GET_DWORD(li_participant_parms[0].info) & 0xffff; + li_flags = GET_DWORD(li_participant_parms[1].info); + PUT_DWORD(&result[result_pos - 6], plci_b_id); + if (sizeof(result) - result_pos < 7) + { + dbug(1, dprintf("[%06lx] %s,%d: LI result overrun", + UnMapId(Id), (char *)(FILE_), __LINE__)); + PUT_WORD(&result[result_pos - 2], _WRONG_STATE); + break; + } + plci_b = li2_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]); + if (plci_b != NULL) + { + li2_update_connect(Id, a, plci, plci_b_id, true, li_flags); + plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | + ((li_flags & (LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A | + LI2_FLAG_PCCONNECT_A_B | LI2_FLAG_PCCONNECT_B_A)) ? 0 : LI_PLCI_B_DISC_FLAG); + plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1; + } + participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) - + (&li_req_parms[1].info[1])); + } + result[0] = (byte)(result_pos - 1); + result[3] = (byte)(result_pos - 4); + result[6] = (byte)(result_pos - 7); + i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1; + if ((plci_b_write_pos == plci->li_plci_b_read_pos) + || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG)) + { + plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG; + plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1; + } + else + plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG; + plci->li_plci_b_write_pos = plci_b_write_pos; + } + mixer_calculate_coefs(a); + plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel; + mixer_notify_update(plci, true); + sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number, + "wwS", Info, SELECTOR_LINE_INTERCONNECT, result); + plci->command = 0; + plci->li_cmd = GET_WORD(li_parms[0].info); + start_internal_command(Id, plci, mixer_command); + return (false); + + case LI_REQ_DISCONNECT: + if (li_parms[1].length == 4) + { + appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC; + if (api_parse(&li_parms[1].info[1], li_parms[1].length, "d", li_req_parms)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong message format", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + plci_b_id = GET_DWORD(li_req_parms[0].info) & 0xffff; + Info = li_check_main_plci(Id, plci); + result_buffer[0] = 9; + result_buffer[3] = 6; + PUT_DWORD(&result_buffer[4], GET_DWORD(li_req_parms[0].info)); + PUT_WORD(&result_buffer[8], GOOD); + if (Info != GOOD) + break; + result = plci->saved_msg.info; + for (i = 0; i <= result_buffer[0]; i++) + result[i] = result_buffer[i]; + plci_b_write_pos = plci->li_plci_b_write_pos; + plci_b = li_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[8]); + if (plci_b == NULL) + break; + li_update_connect(Id, a, plci, plci_b_id, false, 0); + plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG | LI_PLCI_B_LAST_FLAG; + plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1; + plci->li_plci_b_write_pos = plci_b_write_pos; + } + else + { + appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC; + if (api_parse(&li_parms[1].info[1], li_parms[1].length, "s", li_req_parms)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong message format", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_MESSAGE_FORMAT; + break; + } + Info = li_check_main_plci(Id, plci); + result_buffer[0] = 7; + result_buffer[3] = 4; + PUT_WORD(&result_buffer[4], Info); + result_buffer[6] = 0; + if (Info != GOOD) + break; + result = plci->saved_msg.info; + for (i = 0; i <= result_buffer[0]; i++) + result[i] = result_buffer[i]; + plci_b_write_pos = plci->li_plci_b_write_pos; + participant_parms_pos = 0; + result_pos = 7; + while (participant_parms_pos < li_req_parms[0].length) + { + result[result_pos] = 6; + result_pos += 7; + PUT_DWORD(&result[result_pos - 6], 0); + PUT_WORD(&result[result_pos - 2], GOOD); + if (api_parse(&li_req_parms[0].info[1 + participant_parms_pos], + (word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong message format", + UnMapId(Id), (char *)(FILE_), __LINE__)); + PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT); + break; + } + if (api_parse(&li_participant_struct[0].info[1], + li_participant_struct[0].length, "d", li_participant_parms)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong message format", + UnMapId(Id), (char *)(FILE_), __LINE__)); + PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT); + break; + } + plci_b_id = GET_DWORD(li_participant_parms[0].info) & 0xffff; + PUT_DWORD(&result[result_pos - 6], plci_b_id); + if (sizeof(result) - result_pos < 7) + { + dbug(1, dprintf("[%06lx] %s,%d: LI result overrun", + UnMapId(Id), (char *)(FILE_), __LINE__)); + PUT_WORD(&result[result_pos - 2], _WRONG_STATE); + break; + } + plci_b = li2_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]); + if (plci_b != NULL) + { + li2_update_connect(Id, a, plci, plci_b_id, false, 0); + plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG; + plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1; + } + participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) - + (&li_req_parms[0].info[1])); + } + result[0] = (byte)(result_pos - 1); + result[3] = (byte)(result_pos - 4); + result[6] = (byte)(result_pos - 7); + i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1; + if ((plci_b_write_pos == plci->li_plci_b_read_pos) + || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG)) + { + plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG; + plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1; + } + else + plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG; + plci->li_plci_b_write_pos = plci_b_write_pos; + } + mixer_calculate_coefs(a); + plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel; + mixer_notify_update(plci, true); + sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number, + "wwS", Info, SELECTOR_LINE_INTERCONNECT, result); + plci->command = 0; + plci->li_cmd = GET_WORD(li_parms[0].info); + start_internal_command(Id, plci, mixer_command); + return (false); + + case LI_REQ_SILENT_UPDATE: + if (!plci || !plci->State + || !plci->NL.Id || plci->nl_remove_id + || (plci->li_bchannel_id == 0) + || (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci != plci)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong state", + UnMapId(Id), (char *)(FILE_), __LINE__)); + return (false); + } + plci_b_write_pos = plci->li_plci_b_write_pos; + if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos : + LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2) + { + dbug(1, dprintf("[%06lx] %s,%d: LI request overrun", + UnMapId(Id), (char *)(FILE_), __LINE__)); + return (false); + } + i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1; + if ((plci_b_write_pos == plci->li_plci_b_read_pos) + || (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG)) + { + plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG; + plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1; + } + else + plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG; + plci->li_plci_b_write_pos = plci_b_write_pos; + plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel; + plci->command = 0; + plci->li_cmd = GET_WORD(li_parms[0].info); + start_internal_command(Id, plci, mixer_command); + return (false); + + default: + dbug(1, dprintf("[%06lx] %s,%d: LI unknown request %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(li_parms[0].info))); + Info = _FACILITY_NOT_SUPPORTED; + } + } + sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number, + "wwS", Info, SELECTOR_LINE_INTERCONNECT, result); + return (false); +} + + +static void mixer_indication_coefs_set(dword Id, PLCI *plci) +{ + dword d; + byte result[12]; + + dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_coefs_set", + UnMapId(Id), (char *)(FILE_), __LINE__)); + + if (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos) + { + do + { + d = plci->li_plci_b_queue[plci->li_plci_b_read_pos]; + if (!(d & LI_PLCI_B_SKIP_FLAG)) + { + if (plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC) + { + if (d & LI_PLCI_B_DISC_FLAG) + { + result[0] = 5; + PUT_WORD(&result[1], LI_IND_DISCONNECT); + result[3] = 2; + PUT_WORD(&result[4], _LI_USER_INITIATED); + } + else + { + result[0] = 7; + PUT_WORD(&result[1], LI_IND_CONNECT_ACTIVE); + result[3] = 4; + PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK); + } + } + else + { + if (d & LI_PLCI_B_DISC_FLAG) + { + result[0] = 9; + PUT_WORD(&result[1], LI_IND_DISCONNECT); + result[3] = 6; + PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK); + PUT_WORD(&result[8], _LI_USER_INITIATED); + } + else + { + result[0] = 7; + PUT_WORD(&result[1], LI_IND_CONNECT_ACTIVE); + result[3] = 4; + PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK); + } + } + sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, + "ws", SELECTOR_LINE_INTERCONNECT, result); + } + plci->li_plci_b_read_pos = (plci->li_plci_b_read_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? + 0 : plci->li_plci_b_read_pos + 1; + } while (!(d & LI_PLCI_B_LAST_FLAG) && (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos)); + } +} + + +static void mixer_indication_xconnect_from(dword Id, PLCI *plci, byte *msg, word length) +{ + word i, j, ch; + struct xconnect_transfer_address_s s, *p; + DIVA_CAPI_ADAPTER *a; + + dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_xconnect_from %d", + UnMapId(Id), (char *)(FILE_), __LINE__, (int)length)); + + a = plci->adapter; + i = 1; + for (i = 1; i < length; i += 16) + { + s.card_address.low = msg[i] | (msg[i + 1] << 8) | (((dword)(msg[i + 2])) << 16) | (((dword)(msg[i + 3])) << 24); + s.card_address.high = msg[i + 4] | (msg[i + 5] << 8) | (((dword)(msg[i + 6])) << 16) | (((dword)(msg[i + 7])) << 24); + s.offset = msg[i + 8] | (msg[i + 9] << 8) | (((dword)(msg[i + 10])) << 16) | (((dword)(msg[i + 11])) << 24); + ch = msg[i + 12] | (msg[i + 13] << 8); + j = ch & XCONNECT_CHANNEL_NUMBER_MASK; + if (!a->li_pri && (plci->li_bchannel_id == 2)) + j = 1 - j; + j += a->li_base; + if (ch & XCONNECT_CHANNEL_PORT_PC) + p = &(li_config_table[j].send_pc); + else + p = &(li_config_table[j].send_b); + p->card_address.low = s.card_address.low; + p->card_address.high = s.card_address.high; + p->offset = s.offset; + li_config_table[j].channel |= LI_CHANNEL_ADDRESSES_SET; + } + if (plci->internal_command_queue[0] + && ((plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2) + || (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3) + || (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4))) + { + (*(plci->internal_command_queue[0]))(Id, plci, 0); + if (!plci->internal_command) + next_internal_command(Id, plci); + } + mixer_notify_update(plci, true); +} + + +static void mixer_indication_xconnect_to(dword Id, PLCI *plci, byte *msg, word length) +{ + + dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_xconnect_to %d", + UnMapId(Id), (char *)(FILE_), __LINE__, (int) length)); + +} + + +static byte mixer_notify_source_removed(PLCI *plci, dword plci_b_id) +{ + word plci_b_write_pos; + + plci_b_write_pos = plci->li_plci_b_write_pos; + if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos : + LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 1) + { + dbug(1, dprintf("[%06lx] %s,%d: LI request overrun", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + return (false); + } + plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG; + plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1; + plci->li_plci_b_write_pos = plci_b_write_pos; + return (true); +} + + +static void mixer_remove(PLCI *plci) +{ + DIVA_CAPI_ADAPTER *a; + PLCI *notify_plci; + dword plci_b_id; + word i, j; + + dbug(1, dprintf("[%06lx] %s,%d: mixer_remove", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + + a = plci->adapter; + plci_b_id = (plci->Id << 8) | UnMapController(plci->adapter->Id); + if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED) + { + if ((plci->li_bchannel_id != 0) + && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci)) + { + i = a->li_base + (plci->li_bchannel_id - 1); + if ((li_config_table[i].curchnl | li_config_table[i].channel) & LI_CHANNEL_INVOLVED) + { + for (j = 0; j < li_total_channels; j++) + { + if ((li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT) + || (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT)) + { + notify_plci = li_config_table[j].plci; + if ((notify_plci != NULL) + && (notify_plci != plci) + && (notify_plci->appl != NULL) + && !(notify_plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC) + && (notify_plci->State) + && notify_plci->NL.Id && !notify_plci->nl_remove_id) + { + mixer_notify_source_removed(notify_plci, plci_b_id); + } + } + } + mixer_clear_config(plci); + mixer_calculate_coefs(a); + mixer_notify_update(plci, true); + } + li_config_table[i].plci = NULL; + plci->li_bchannel_id = 0; + } + } +} + + +/*------------------------------------------------------------------*/ +/* Echo canceller facilities */ +/*------------------------------------------------------------------*/ + + +static void ec_write_parameters(PLCI *plci) +{ + word w; + byte parameter_buffer[6]; + + dbug(1, dprintf("[%06lx] %s,%d: ec_write_parameters", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + + parameter_buffer[0] = 5; + parameter_buffer[1] = DSP_CTRL_SET_LEC_PARAMETERS; + PUT_WORD(¶meter_buffer[2], plci->ec_idi_options); + plci->ec_idi_options &= ~LEC_RESET_COEFFICIENTS; + w = (plci->ec_tail_length == 0) ? 128 : plci->ec_tail_length; + PUT_WORD(¶meter_buffer[4], w); + add_p(plci, FTY, parameter_buffer); + sig_req(plci, TEL_CTRL, 0); + send_req(plci); +} + + +static void ec_clear_config(PLCI *plci) +{ + + dbug(1, dprintf("[%06lx] %s,%d: ec_clear_config", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + + plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER | + LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING; + plci->ec_tail_length = 0; +} + + +static void ec_prepare_switch(dword Id, PLCI *plci) +{ + + dbug(1, dprintf("[%06lx] %s,%d: ec_prepare_switch", + UnMapId(Id), (char *)(FILE_), __LINE__)); + +} + + +static word ec_save_config(dword Id, PLCI *plci, byte Rc) +{ + + dbug(1, dprintf("[%06lx] %s,%d: ec_save_config %02x %d", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state)); + + return (GOOD); +} + + +static word ec_restore_config(dword Id, PLCI *plci, byte Rc) +{ + word Info; + + dbug(1, dprintf("[%06lx] %s,%d: ec_restore_config %02x %d", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state)); + + Info = GOOD; + if (plci->B1_facilities & B1_FACILITY_EC) + { + switch (plci->adjust_b_state) + { + case ADJUST_B_RESTORE_EC_1: + plci->internal_command = plci->adjust_b_command; + if (plci->sig_req) + { + plci->adjust_b_state = ADJUST_B_RESTORE_EC_1; + break; + } + ec_write_parameters(plci); + plci->adjust_b_state = ADJUST_B_RESTORE_EC_2; + break; + case ADJUST_B_RESTORE_EC_2: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: Restore EC failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + Info = _WRONG_STATE; + break; + } + break; + } + } + return (Info); +} + + +static void ec_command(dword Id, PLCI *plci, byte Rc) +{ + word internal_command, Info; + byte result[8]; + + dbug(1, dprintf("[%06lx] %s,%d: ec_command %02x %04x %04x %04x %d", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command, + plci->ec_cmd, plci->ec_idi_options, plci->ec_tail_length)); + + Info = GOOD; + if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) + { + result[0] = 2; + PUT_WORD(&result[1], EC_SUCCESS); + } + else + { + result[0] = 5; + PUT_WORD(&result[1], plci->ec_cmd); + result[3] = 2; + PUT_WORD(&result[4], GOOD); + } + internal_command = plci->internal_command; + plci->internal_command = 0; + switch (plci->ec_cmd) + { + case EC_ENABLE_OPERATION: + case EC_FREEZE_COEFFICIENTS: + case EC_RESUME_COEFFICIENT_UPDATE: + case EC_RESET_COEFFICIENTS: + switch (internal_command) + { + default: + adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities | + B1_FACILITY_EC), EC_COMMAND_1); + case EC_COMMAND_1: + if (adjust_b_process(Id, plci, Rc) != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: Load EC failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _FACILITY_NOT_SUPPORTED; + break; + } + if (plci->internal_command) + return; + case EC_COMMAND_2: + if (plci->sig_req) + { + plci->internal_command = EC_COMMAND_2; + return; + } + plci->internal_command = EC_COMMAND_3; + ec_write_parameters(plci); + return; + case EC_COMMAND_3: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: Enable EC failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + Info = _FACILITY_NOT_SUPPORTED; + break; + } + break; + } + break; + + case EC_DISABLE_OPERATION: + switch (internal_command) + { + default: + case EC_COMMAND_1: + if (plci->B1_facilities & B1_FACILITY_EC) + { + if (plci->sig_req) + { + plci->internal_command = EC_COMMAND_1; + return; + } + plci->internal_command = EC_COMMAND_2; + ec_write_parameters(plci); + return; + } + Rc = OK; + case EC_COMMAND_2: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: Disable EC failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + Info = _FACILITY_NOT_SUPPORTED; + break; + } + adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities & + ~B1_FACILITY_EC), EC_COMMAND_3); + case EC_COMMAND_3: + if (adjust_b_process(Id, plci, Rc) != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: Unload EC failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _FACILITY_NOT_SUPPORTED; + break; + } + if (plci->internal_command) + return; + break; + } + break; + } + sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number, + "wws", Info, (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ? + PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result); +} + + +static byte ec_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg) +{ + word Info; + word opt; + API_PARSE ec_parms[3]; + byte result[16]; + + dbug(1, dprintf("[%06lx] %s,%d: ec_request", + UnMapId(Id), (char *)(FILE_), __LINE__)); + + Info = GOOD; + result[0] = 0; + if (!(a->man_profile.private_options & (1L << PRIVATE_ECHO_CANCELLER))) + { + dbug(1, dprintf("[%06lx] %s,%d: Facility not supported", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _FACILITY_NOT_SUPPORTED; + } + else + { + if (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) + { + if (api_parse(&msg[1].info[1], msg[1].length, "w", ec_parms)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong message format", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_MESSAGE_FORMAT; + } + else + { + if (plci == NULL) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_IDENTIFIER; + } + else if (!plci->State || !plci->NL.Id || plci->nl_remove_id) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong state", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_STATE; + } + else + { + plci->command = 0; + plci->ec_cmd = GET_WORD(ec_parms[0].info); + plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS); + result[0] = 2; + PUT_WORD(&result[1], EC_SUCCESS); + if (msg[1].length >= 4) + { + opt = GET_WORD(&ec_parms[0].info[2]); + plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING | + LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS); + if (!(opt & EC_DISABLE_NON_LINEAR_PROCESSING)) + plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING; + if (opt & EC_DETECT_DISABLE_TONE) + plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR; + if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS)) + plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS; + if (msg[1].length >= 6) + { + plci->ec_tail_length = GET_WORD(&ec_parms[0].info[4]); + } + } + switch (plci->ec_cmd) + { + case EC_ENABLE_OPERATION: + plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS; + start_internal_command(Id, plci, ec_command); + return (false); + + case EC_DISABLE_OPERATION: + plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER | + LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING | + LEC_RESET_COEFFICIENTS; + start_internal_command(Id, plci, ec_command); + return (false); + + case EC_FREEZE_COEFFICIENTS: + plci->ec_idi_options |= LEC_FREEZE_COEFFICIENTS; + start_internal_command(Id, plci, ec_command); + return (false); + + case EC_RESUME_COEFFICIENT_UPDATE: + plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS; + start_internal_command(Id, plci, ec_command); + return (false); + + case EC_RESET_COEFFICIENTS: + plci->ec_idi_options |= LEC_RESET_COEFFICIENTS; + start_internal_command(Id, plci, ec_command); + return (false); + + default: + dbug(1, dprintf("[%06lx] %s,%d: EC unknown request %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, plci->ec_cmd)); + PUT_WORD(&result[1], EC_UNSUPPORTED_OPERATION); + } + } + } + } + else + { + if (api_parse(&msg[1].info[1], msg[1].length, "ws", ec_parms)) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong message format", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_MESSAGE_FORMAT; + } + else + { + if (GET_WORD(ec_parms[0].info) == EC_GET_SUPPORTED_SERVICES) + { + result[0] = 11; + PUT_WORD(&result[1], EC_GET_SUPPORTED_SERVICES); + result[3] = 8; + PUT_WORD(&result[4], GOOD); + PUT_WORD(&result[6], 0x0007); + PUT_WORD(&result[8], LEC_MAX_SUPPORTED_TAIL_LENGTH); + PUT_WORD(&result[10], 0); + } + else if (plci == NULL) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_IDENTIFIER; + } + else if (!plci->State || !plci->NL.Id || plci->nl_remove_id) + { + dbug(1, dprintf("[%06lx] %s,%d: Wrong state", + UnMapId(Id), (char *)(FILE_), __LINE__)); + Info = _WRONG_STATE; + } + else + { + plci->command = 0; + plci->ec_cmd = GET_WORD(ec_parms[0].info); + plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS); + result[0] = 5; + PUT_WORD(&result[1], plci->ec_cmd); + result[3] = 2; + PUT_WORD(&result[4], GOOD); + plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING | + LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS); + plci->ec_tail_length = 0; + if (ec_parms[1].length >= 2) + { + opt = GET_WORD(&ec_parms[1].info[1]); + if (opt & EC_ENABLE_NON_LINEAR_PROCESSING) + plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING; + if (opt & EC_DETECT_DISABLE_TONE) + plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR; + if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS)) + plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS; + if (ec_parms[1].length >= 4) + { + plci->ec_tail_length = GET_WORD(&ec_parms[1].info[3]); + } + } + switch (plci->ec_cmd) + { + case EC_ENABLE_OPERATION: + plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS; + start_internal_command(Id, plci, ec_command); + return (false); + + case EC_DISABLE_OPERATION: + plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER | + LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING | + LEC_RESET_COEFFICIENTS; + start_internal_command(Id, plci, ec_command); + return (false); + + default: + dbug(1, dprintf("[%06lx] %s,%d: EC unknown request %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, plci->ec_cmd)); + PUT_WORD(&result[4], _FACILITY_SPECIFIC_FUNCTION_NOT_SUPP); + } + } + } + } + } + sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number, + "wws", Info, (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ? + PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result); + return (false); +} + + +static void ec_indication(dword Id, PLCI *plci, byte *msg, word length) +{ + byte result[8]; + + dbug(1, dprintf("[%06lx] %s,%d: ec_indication", + UnMapId(Id), (char *)(FILE_), __LINE__)); + + if (!(plci->ec_idi_options & LEC_MANUAL_DISABLE)) + { + if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) + { + result[0] = 2; + PUT_WORD(&result[1], 0); + switch (msg[1]) + { + case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ: + PUT_WORD(&result[1], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ); + break; + case LEC_DISABLE_TYPE_REVERSED_2100HZ: + PUT_WORD(&result[1], EC_BYPASS_DUE_TO_REVERSED_2100HZ); + break; + case LEC_DISABLE_RELEASED: + PUT_WORD(&result[1], EC_BYPASS_RELEASED); + break; + } + } + else + { + result[0] = 5; + PUT_WORD(&result[1], EC_BYPASS_INDICATION); + result[3] = 2; + PUT_WORD(&result[4], 0); + switch (msg[1]) + { + case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ: + PUT_WORD(&result[4], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ); + break; + case LEC_DISABLE_TYPE_REVERSED_2100HZ: + PUT_WORD(&result[4], EC_BYPASS_DUE_TO_REVERSED_2100HZ); + break; + case LEC_DISABLE_RELEASED: + PUT_WORD(&result[4], EC_BYPASS_RELEASED); + break; + } + } + sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ? + PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result); + } +} + + + +/*------------------------------------------------------------------*/ +/* Advanced voice */ +/*------------------------------------------------------------------*/ + +static void adv_voice_write_coefs(PLCI *plci, word write_command) +{ + DIVA_CAPI_ADAPTER *a; + word i; + byte *p; + + word w, n, j, k; + byte ch_map[MIXER_CHANNELS_BRI]; + + byte coef_buffer[ADV_VOICE_COEF_BUFFER_SIZE + 2]; + + dbug(1, dprintf("[%06lx] %s,%d: adv_voice_write_coefs %d", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__, write_command)); + + a = plci->adapter; + p = coef_buffer + 1; + *(p++) = DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS; + i = 0; + while (i + sizeof(word) <= a->adv_voice_coef_length) + { + PUT_WORD(p, GET_WORD(a->adv_voice_coef_buffer + i)); + p += 2; + i += 2; + } + while (i < ADV_VOICE_OLD_COEF_COUNT * sizeof(word)) + { + PUT_WORD(p, 0x8000); + p += 2; + i += 2; + } + + if (!a->li_pri && (plci->li_bchannel_id == 0)) + { + if ((li_config_table[a->li_base].plci == NULL) && (li_config_table[a->li_base + 1].plci != NULL)) + { + plci->li_bchannel_id = 1; + li_config_table[a->li_base].plci = plci; + dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__, plci->li_bchannel_id)); + } + else if ((li_config_table[a->li_base].plci != NULL) && (li_config_table[a->li_base + 1].plci == NULL)) + { + plci->li_bchannel_id = 2; + li_config_table[a->li_base + 1].plci = plci; + dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__, plci->li_bchannel_id)); + } + } + if (!a->li_pri && (plci->li_bchannel_id != 0) + && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci)) + { + i = a->li_base + (plci->li_bchannel_id - 1); + switch (write_command) + { + case ADV_VOICE_WRITE_ACTIVATION: + j = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1); + k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id); + if (!(plci->B1_facilities & B1_FACILITY_MIXER)) + { + li_config_table[j].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX; + li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR; + } + if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) + { + li_config_table[k].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX; + li_config_table[i].flag_table[k] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR; + li_config_table[k].flag_table[j] |= LI_FLAG_CONFERENCE; + li_config_table[j].flag_table[k] |= LI_FLAG_CONFERENCE; + } + mixer_calculate_coefs(a); + li_config_table[i].curchnl = li_config_table[i].channel; + li_config_table[j].curchnl = li_config_table[j].channel; + if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) + li_config_table[k].curchnl = li_config_table[k].channel; + break; + + case ADV_VOICE_WRITE_DEACTIVATION: + for (j = 0; j < li_total_channels; j++) + { + li_config_table[i].flag_table[j] = 0; + li_config_table[j].flag_table[i] = 0; + } + k = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1); + for (j = 0; j < li_total_channels; j++) + { + li_config_table[k].flag_table[j] = 0; + li_config_table[j].flag_table[k] = 0; + } + if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) + { + k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id); + for (j = 0; j < li_total_channels; j++) + { + li_config_table[k].flag_table[j] = 0; + li_config_table[j].flag_table[k] = 0; + } + } + mixer_calculate_coefs(a); + break; + } + if (plci->B1_facilities & B1_FACILITY_MIXER) + { + w = 0; + if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length) + w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE); + if (li_config_table[i].channel & LI_CHANNEL_TX_DATA) + w |= MIXER_FEATURE_ENABLE_TX_DATA; + if (li_config_table[i].channel & LI_CHANNEL_RX_DATA) + w |= MIXER_FEATURE_ENABLE_RX_DATA; + *(p++) = (byte) w; + *(p++) = (byte)(w >> 8); + for (j = 0; j < sizeof(ch_map); j += 2) + { + ch_map[j] = (byte)(j + (plci->li_bchannel_id - 1)); + ch_map[j + 1] = (byte)(j + (2 - plci->li_bchannel_id)); + } + for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++) + { + i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch]; + j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch]; + if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED) + { + *(p++) = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01); + w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4)); + li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4; + } + else + { + *(p++) = (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n < a->adv_voice_coef_length) ? + a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n] : 0x00; + } + } + } + else + { + for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++) + *(p++) = a->adv_voice_coef_buffer[i]; + } + } + else + + { + for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++) + *(p++) = a->adv_voice_coef_buffer[i]; + } + coef_buffer[0] = (p - coef_buffer) - 1; + add_p(plci, FTY, coef_buffer); + sig_req(plci, TEL_CTRL, 0); + send_req(plci); +} + + +static void adv_voice_clear_config(PLCI *plci) +{ + DIVA_CAPI_ADAPTER *a; + + word i, j; + + + dbug(1, dprintf("[%06lx] %s,%d: adv_voice_clear_config", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + + a = plci->adapter; + if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)) + { + a->adv_voice_coef_length = 0; + + if (!a->li_pri && (plci->li_bchannel_id != 0) + && (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci)) + { + i = a->li_base + (plci->li_bchannel_id - 1); + li_config_table[i].curchnl = 0; + li_config_table[i].channel = 0; + li_config_table[i].chflags = 0; + for (j = 0; j < li_total_channels; j++) + { + li_config_table[i].flag_table[j] = 0; + li_config_table[j].flag_table[i] = 0; + li_config_table[i].coef_table[j] = 0; + li_config_table[j].coef_table[i] = 0; + } + li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET; + i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1); + li_config_table[i].curchnl = 0; + li_config_table[i].channel = 0; + li_config_table[i].chflags = 0; + for (j = 0; j < li_total_channels; j++) + { + li_config_table[i].flag_table[j] = 0; + li_config_table[j].flag_table[i] = 0; + li_config_table[i].coef_table[j] = 0; + li_config_table[j].coef_table[i] = 0; + } + if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) + { + i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id); + li_config_table[i].curchnl = 0; + li_config_table[i].channel = 0; + li_config_table[i].chflags = 0; + for (j = 0; j < li_total_channels; j++) + { + li_config_table[i].flag_table[j] = 0; + li_config_table[j].flag_table[i] = 0; + li_config_table[i].coef_table[j] = 0; + li_config_table[j].coef_table[i] = 0; + } + } + } + + } +} + + +static void adv_voice_prepare_switch(dword Id, PLCI *plci) +{ + + dbug(1, dprintf("[%06lx] %s,%d: adv_voice_prepare_switch", + UnMapId(Id), (char *)(FILE_), __LINE__)); + +} + + +static word adv_voice_save_config(dword Id, PLCI *plci, byte Rc) +{ + + dbug(1, dprintf("[%06lx] %s,%d: adv_voice_save_config %02x %d", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state)); + + return (GOOD); +} + + +static word adv_voice_restore_config(dword Id, PLCI *plci, byte Rc) +{ + DIVA_CAPI_ADAPTER *a; + word Info; + + dbug(1, dprintf("[%06lx] %s,%d: adv_voice_restore_config %02x %d", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state)); + + Info = GOOD; + a = plci->adapter; + if ((plci->B1_facilities & B1_FACILITY_VOICE) + && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)) + { + switch (plci->adjust_b_state) + { + case ADJUST_B_RESTORE_VOICE_1: + plci->internal_command = plci->adjust_b_command; + if (plci->sig_req) + { + plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1; + break; + } + adv_voice_write_coefs(plci, ADV_VOICE_WRITE_UPDATE); + plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_2; + break; + case ADJUST_B_RESTORE_VOICE_2: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: Restore voice config failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + Info = _WRONG_STATE; + break; + } + break; + } + } + return (Info); +} + + + + +/*------------------------------------------------------------------*/ +/* B1 resource switching */ +/*------------------------------------------------------------------*/ + +static byte b1_facilities_table[] = +{ + 0x00, /* 0 No bchannel resources */ + 0x00, /* 1 Codec (automatic law) */ + 0x00, /* 2 Codec (A-law) */ + 0x00, /* 3 Codec (y-law) */ + 0x00, /* 4 HDLC for X.21 */ + 0x00, /* 5 HDLC */ + 0x00, /* 6 External Device 0 */ + 0x00, /* 7 External Device 1 */ + 0x00, /* 8 HDLC 56k */ + 0x00, /* 9 Transparent */ + 0x00, /* 10 Loopback to network */ + 0x00, /* 11 Test pattern to net */ + 0x00, /* 12 Rate adaptation sync */ + 0x00, /* 13 Rate adaptation async */ + 0x00, /* 14 R-Interface */ + 0x00, /* 15 HDLC 128k leased line */ + 0x00, /* 16 FAX */ + 0x00, /* 17 Modem async */ + 0x00, /* 18 Modem sync HDLC */ + 0x00, /* 19 V.110 async HDLC */ + 0x12, /* 20 Adv voice (Trans,mixer) */ + 0x00, /* 21 Codec connected to IC */ + 0x0c, /* 22 Trans,DTMF */ + 0x1e, /* 23 Trans,DTMF+mixer */ + 0x1f, /* 24 Trans,DTMF+mixer+local */ + 0x13, /* 25 Trans,mixer+local */ + 0x12, /* 26 HDLC,mixer */ + 0x12, /* 27 HDLC 56k,mixer */ + 0x2c, /* 28 Trans,LEC+DTMF */ + 0x3e, /* 29 Trans,LEC+DTMF+mixer */ + 0x3f, /* 30 Trans,LEC+DTMF+mixer+local */ + 0x2c, /* 31 RTP,LEC+DTMF */ + 0x3e, /* 32 RTP,LEC+DTMF+mixer */ + 0x3f, /* 33 RTP,LEC+DTMF+mixer+local */ + 0x00, /* 34 Signaling task */ + 0x00, /* 35 PIAFS */ + 0x0c, /* 36 Trans,DTMF+TONE */ + 0x1e, /* 37 Trans,DTMF+TONE+mixer */ + 0x1f /* 38 Trans,DTMF+TONE+mixer+local*/ +}; + + +static word get_b1_facilities(PLCI *plci, byte b1_resource) +{ + word b1_facilities; + + b1_facilities = b1_facilities_table[b1_resource]; + if ((b1_resource == 9) || (b1_resource == 20) || (b1_resource == 25)) + { + + if (!(((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE)) + || (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id - 1] & (1L << PRIVATE_DTMF_TONE))))) + + { + if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND) + b1_facilities |= B1_FACILITY_DTMFX; + if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE) + b1_facilities |= B1_FACILITY_DTMFR; + } + } + if ((b1_resource == 17) || (b1_resource == 18)) + { + if (plci->adapter->manufacturer_features & (MANUFACTURER_FEATURE_V18 | MANUFACTURER_FEATURE_VOWN)) + b1_facilities |= B1_FACILITY_DTMFX | B1_FACILITY_DTMFR; + } +/* + dbug (1, dprintf("[%06lx] %s,%d: get_b1_facilities %d %04x", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char far *)(FILE_), __LINE__, b1_resource, b1_facilites)); +*/ + return (b1_facilities); +} + + +static byte add_b1_facilities(PLCI *plci, byte b1_resource, word b1_facilities) +{ + byte b; + + switch (b1_resource) + { + case 5: + case 26: + if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE)) + b = 26; + else + b = 5; + break; + + case 8: + case 27: + if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE)) + b = 27; + else + b = 8; + break; + + case 9: + case 20: + case 22: + case 23: + case 24: + case 25: + case 28: + case 29: + case 30: + case 36: + case 37: + case 38: + if (b1_facilities & B1_FACILITY_EC) + { + if (b1_facilities & B1_FACILITY_LOCAL) + b = 30; + else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE)) + b = 29; + else + b = 28; + } + + else if ((b1_facilities & (B1_FACILITY_DTMFX | B1_FACILITY_DTMFR | B1_FACILITY_MIXER)) + && (((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE)) + || (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id - 1] & (1L << PRIVATE_DTMF_TONE))))) + { + if (b1_facilities & B1_FACILITY_LOCAL) + b = 38; + else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE)) + b = 37; + else + b = 36; + } + + else if (((plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF) + && !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)) + || ((b1_facilities & B1_FACILITY_DTMFR) + && ((b1_facilities & B1_FACILITY_MIXER) + || !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))) + || ((b1_facilities & B1_FACILITY_DTMFX) + && ((b1_facilities & B1_FACILITY_MIXER) + || !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND)))) + { + if (b1_facilities & B1_FACILITY_LOCAL) + b = 24; + else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE)) + b = 23; + else + b = 22; + } + else + { + if (b1_facilities & B1_FACILITY_LOCAL) + b = 25; + else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE)) + b = 20; + else + b = 9; + } + break; + + case 31: + case 32: + case 33: + if (b1_facilities & B1_FACILITY_LOCAL) + b = 33; + else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE)) + b = 32; + else + b = 31; + break; + + default: + b = b1_resource; + } + dbug(1, dprintf("[%06lx] %s,%d: add_b1_facilities %d %04x %d %04x", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__, + b1_resource, b1_facilities, b, get_b1_facilities(plci, b))); + return (b); +} + + +static void adjust_b1_facilities(PLCI *plci, byte new_b1_resource, word new_b1_facilities) +{ + word removed_facilities; + + dbug(1, dprintf("[%06lx] %s,%d: adjust_b1_facilities %d %04x %04x", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__, new_b1_resource, new_b1_facilities, + new_b1_facilities & get_b1_facilities(plci, new_b1_resource))); + + new_b1_facilities &= get_b1_facilities(plci, new_b1_resource); + removed_facilities = plci->B1_facilities & ~new_b1_facilities; + + if (removed_facilities & B1_FACILITY_EC) + ec_clear_config(plci); + + + if (removed_facilities & B1_FACILITY_DTMFR) + { + dtmf_rec_clear_config(plci); + dtmf_parameter_clear_config(plci); + } + if (removed_facilities & B1_FACILITY_DTMFX) + dtmf_send_clear_config(plci); + + + if (removed_facilities & B1_FACILITY_MIXER) + mixer_clear_config(plci); + + if (removed_facilities & B1_FACILITY_VOICE) + adv_voice_clear_config(plci); + plci->B1_facilities = new_b1_facilities; +} + + +static void adjust_b_clear(PLCI *plci) +{ + + dbug(1, dprintf("[%06lx] %s,%d: adjust_b_clear", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + + plci->adjust_b_restore = false; +} + + +static word adjust_b_process(dword Id, PLCI *plci, byte Rc) +{ + word Info; + byte b1_resource; + NCCI *ncci_ptr; + API_PARSE bp[2]; + + dbug(1, dprintf("[%06lx] %s,%d: adjust_b_process %02x %d", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state)); + + Info = GOOD; + switch (plci->adjust_b_state) + { + case ADJUST_B_START: + if ((plci->adjust_b_parms_msg == NULL) + && (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1) + && ((plci->adjust_b_mode & ~(ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 | + ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_RESTORE)) == 0)) + { + b1_resource = (plci->adjust_b_mode == ADJUST_B_MODE_NO_RESOURCE) ? + 0 : add_b1_facilities(plci, plci->B1_resource, plci->adjust_b_facilities); + if (b1_resource == plci->B1_resource) + { + adjust_b1_facilities(plci, b1_resource, plci->adjust_b_facilities); + break; + } + if (plci->adjust_b_facilities & ~get_b1_facilities(plci, b1_resource)) + { + dbug(1, dprintf("[%06lx] %s,%d: Adjust B nonsupported facilities %d %d %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, + plci->B1_resource, b1_resource, plci->adjust_b_facilities)); + Info = _WRONG_STATE; + break; + } + } + if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE) + { + + mixer_prepare_switch(Id, plci); + + + dtmf_prepare_switch(Id, plci); + dtmf_parameter_prepare_switch(Id, plci); + + + ec_prepare_switch(Id, plci); + + adv_voice_prepare_switch(Id, plci); + } + plci->adjust_b_state = ADJUST_B_SAVE_MIXER_1; + Rc = OK; + case ADJUST_B_SAVE_MIXER_1: + if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE) + { + + Info = mixer_save_config(Id, plci, Rc); + if ((Info != GOOD) || plci->internal_command) + break; + + } + plci->adjust_b_state = ADJUST_B_SAVE_DTMF_1; + Rc = OK; + case ADJUST_B_SAVE_DTMF_1: + if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE) + { + + Info = dtmf_save_config(Id, plci, Rc); + if ((Info != GOOD) || plci->internal_command) + break; + + } + plci->adjust_b_state = ADJUST_B_REMOVE_L23_1; + case ADJUST_B_REMOVE_L23_1: + if ((plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23) + && plci->NL.Id && !plci->nl_remove_id) + { + plci->internal_command = plci->adjust_b_command; + if (plci->adjust_b_ncci != 0) + { + ncci_ptr = &(plci->adapter->ncci[plci->adjust_b_ncci]); + while (ncci_ptr->data_pending) + { + plci->data_sent_ptr = ncci_ptr->DBuffer[ncci_ptr->data_out].P; + data_rc(plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]); + } + while (ncci_ptr->data_ack_pending) + data_ack(plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]); + } + nl_req_ncci(plci, REMOVE, + (byte)((plci->adjust_b_mode & ADJUST_B_MODE_CONNECT) ? plci->adjust_b_ncci : 0)); + send_req(plci); + plci->adjust_b_state = ADJUST_B_REMOVE_L23_2; + break; + } + plci->adjust_b_state = ADJUST_B_REMOVE_L23_2; + Rc = OK; + case ADJUST_B_REMOVE_L23_2: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: Adjust B remove failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + Info = _WRONG_STATE; + break; + } + if (plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23) + { + if (plci_nl_busy(plci)) + { + plci->internal_command = plci->adjust_b_command; + break; + } + } + plci->adjust_b_state = ADJUST_B_SAVE_EC_1; + Rc = OK; + case ADJUST_B_SAVE_EC_1: + if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE) + { + + Info = ec_save_config(Id, plci, Rc); + if ((Info != GOOD) || plci->internal_command) + break; + + } + plci->adjust_b_state = ADJUST_B_SAVE_DTMF_PARAMETER_1; + Rc = OK; + case ADJUST_B_SAVE_DTMF_PARAMETER_1: + if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE) + { + + Info = dtmf_parameter_save_config(Id, plci, Rc); + if ((Info != GOOD) || plci->internal_command) + break; + + } + plci->adjust_b_state = ADJUST_B_SAVE_VOICE_1; + Rc = OK; + case ADJUST_B_SAVE_VOICE_1: + if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE) + { + Info = adv_voice_save_config(Id, plci, Rc); + if ((Info != GOOD) || plci->internal_command) + break; + } + plci->adjust_b_state = ADJUST_B_SWITCH_L1_1; + case ADJUST_B_SWITCH_L1_1: + if (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1) + { + if (plci->sig_req) + { + plci->internal_command = plci->adjust_b_command; + break; + } + if (plci->adjust_b_parms_msg != NULL) + api_load_msg(plci->adjust_b_parms_msg, bp); + else + api_load_msg(&plci->B_protocol, bp); + Info = add_b1(plci, bp, + (word)((plci->adjust_b_mode & ADJUST_B_MODE_NO_RESOURCE) ? 2 : 0), + plci->adjust_b_facilities); + if (Info != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: Adjust B invalid L1 parameters %d %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, + plci->B1_resource, plci->adjust_b_facilities)); + break; + } + plci->internal_command = plci->adjust_b_command; + sig_req(plci, RESOURCES, 0); + send_req(plci); + plci->adjust_b_state = ADJUST_B_SWITCH_L1_2; + break; + } + plci->adjust_b_state = ADJUST_B_SWITCH_L1_2; + Rc = OK; + case ADJUST_B_SWITCH_L1_2: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: Adjust B switch failed %02x %d %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, + Rc, plci->B1_resource, plci->adjust_b_facilities)); + Info = _WRONG_STATE; + break; + } + plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1; + Rc = OK; + case ADJUST_B_RESTORE_VOICE_1: + case ADJUST_B_RESTORE_VOICE_2: + if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE) + { + Info = adv_voice_restore_config(Id, plci, Rc); + if ((Info != GOOD) || plci->internal_command) + break; + } + plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1; + Rc = OK; + case ADJUST_B_RESTORE_DTMF_PARAMETER_1: + case ADJUST_B_RESTORE_DTMF_PARAMETER_2: + if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE) + { + + Info = dtmf_parameter_restore_config(Id, plci, Rc); + if ((Info != GOOD) || plci->internal_command) + break; + + } + plci->adjust_b_state = ADJUST_B_RESTORE_EC_1; + Rc = OK; + case ADJUST_B_RESTORE_EC_1: + case ADJUST_B_RESTORE_EC_2: + if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE) + { + + Info = ec_restore_config(Id, plci, Rc); + if ((Info != GOOD) || plci->internal_command) + break; + + } + plci->adjust_b_state = ADJUST_B_ASSIGN_L23_1; + case ADJUST_B_ASSIGN_L23_1: + if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23) + { + if (plci_nl_busy(plci)) + { + plci->internal_command = plci->adjust_b_command; + break; + } + if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT) + plci->call_dir |= CALL_DIR_FORCE_OUTG_NL; + if (plci->adjust_b_parms_msg != NULL) + api_load_msg(plci->adjust_b_parms_msg, bp); + else + api_load_msg(&plci->B_protocol, bp); + Info = add_b23(plci, bp); + if (Info != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: Adjust B invalid L23 parameters %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, Info)); + break; + } + plci->internal_command = plci->adjust_b_command; + nl_req_ncci(plci, ASSIGN, 0); + send_req(plci); + plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2; + break; + } + plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2; + Rc = ASSIGN_OK; + case ADJUST_B_ASSIGN_L23_2: + if ((Rc != OK) && (Rc != OK_FC) && (Rc != ASSIGN_OK)) + { + dbug(1, dprintf("[%06lx] %s,%d: Adjust B assign failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + Info = _WRONG_STATE; + break; + } + if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23) + { + if (Rc != ASSIGN_OK) + { + plci->internal_command = plci->adjust_b_command; + break; + } + } + if (plci->adjust_b_mode & ADJUST_B_MODE_USER_CONNECT) + { + plci->adjust_b_restore = true; + break; + } + plci->adjust_b_state = ADJUST_B_CONNECT_1; + case ADJUST_B_CONNECT_1: + if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT) + { + plci->internal_command = plci->adjust_b_command; + if (plci_nl_busy(plci)) + break; + nl_req_ncci(plci, N_CONNECT, 0); + send_req(plci); + plci->adjust_b_state = ADJUST_B_CONNECT_2; + break; + } + plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1; + Rc = OK; + case ADJUST_B_CONNECT_2: + case ADJUST_B_CONNECT_3: + case ADJUST_B_CONNECT_4: + if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0)) + { + dbug(1, dprintf("[%06lx] %s,%d: Adjust B connect failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + Info = _WRONG_STATE; + break; + } + if (Rc == OK) + { + if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT) + { + get_ncci(plci, (byte)(Id >> 16), plci->adjust_b_ncci); + Id = (Id & 0xffff) | (((dword)(plci->adjust_b_ncci)) << 16); + } + if (plci->adjust_b_state == ADJUST_B_CONNECT_2) + plci->adjust_b_state = ADJUST_B_CONNECT_3; + else if (plci->adjust_b_state == ADJUST_B_CONNECT_4) + plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1; + } + else if (Rc == 0) + { + if (plci->adjust_b_state == ADJUST_B_CONNECT_2) + plci->adjust_b_state = ADJUST_B_CONNECT_4; + else if (plci->adjust_b_state == ADJUST_B_CONNECT_3) + plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1; + } + if (plci->adjust_b_state != ADJUST_B_RESTORE_DTMF_1) + { + plci->internal_command = plci->adjust_b_command; + break; + } + Rc = OK; + case ADJUST_B_RESTORE_DTMF_1: + case ADJUST_B_RESTORE_DTMF_2: + if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE) + { + + Info = dtmf_restore_config(Id, plci, Rc); + if ((Info != GOOD) || plci->internal_command) + break; + + } + plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1; + Rc = OK; + case ADJUST_B_RESTORE_MIXER_1: + case ADJUST_B_RESTORE_MIXER_2: + case ADJUST_B_RESTORE_MIXER_3: + case ADJUST_B_RESTORE_MIXER_4: + case ADJUST_B_RESTORE_MIXER_5: + case ADJUST_B_RESTORE_MIXER_6: + case ADJUST_B_RESTORE_MIXER_7: + if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE) + { + + Info = mixer_restore_config(Id, plci, Rc); + if ((Info != GOOD) || plci->internal_command) + break; + + } + plci->adjust_b_state = ADJUST_B_END; + case ADJUST_B_END: + break; + } + return (Info); +} + + +static void adjust_b1_resource(dword Id, PLCI *plci, API_SAVE *bp_msg, word b1_facilities, word internal_command) +{ + + dbug(1, dprintf("[%06lx] %s,%d: adjust_b1_resource %d %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, + plci->B1_resource, b1_facilities)); + + plci->adjust_b_parms_msg = bp_msg; + plci->adjust_b_facilities = b1_facilities; + plci->adjust_b_command = internal_command; + plci->adjust_b_ncci = (word)(Id >> 16); + if ((bp_msg == NULL) && (plci->B1_resource == 0)) + plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_SWITCH_L1; + else + plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 | ADJUST_B_MODE_RESTORE; + plci->adjust_b_state = ADJUST_B_START; + dbug(1, dprintf("[%06lx] %s,%d: Adjust B1 resource %d %04x...", + UnMapId(Id), (char *)(FILE_), __LINE__, + plci->B1_resource, b1_facilities)); +} + + +static void adjust_b_restore(dword Id, PLCI *plci, byte Rc) +{ + word internal_command; + + dbug(1, dprintf("[%06lx] %s,%d: adjust_b_restore %02x %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command)); + + internal_command = plci->internal_command; + plci->internal_command = 0; + switch (internal_command) + { + default: + plci->command = 0; + if (plci->req_in != 0) + { + plci->internal_command = ADJUST_B_RESTORE_1; + break; + } + Rc = OK; + case ADJUST_B_RESTORE_1: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: Adjust B enqueued failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + } + plci->adjust_b_parms_msg = NULL; + plci->adjust_b_facilities = plci->B1_facilities; + plci->adjust_b_command = ADJUST_B_RESTORE_2; + plci->adjust_b_ncci = (word)(Id >> 16); + plci->adjust_b_mode = ADJUST_B_MODE_RESTORE; + plci->adjust_b_state = ADJUST_B_START; + dbug(1, dprintf("[%06lx] %s,%d: Adjust B restore...", + UnMapId(Id), (char *)(FILE_), __LINE__)); + case ADJUST_B_RESTORE_2: + if (adjust_b_process(Id, plci, Rc) != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: Adjust B restore failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + } + if (plci->internal_command) + break; + break; + } +} + + +static void reset_b3_command(dword Id, PLCI *plci, byte Rc) +{ + word Info; + word internal_command; + + dbug(1, dprintf("[%06lx] %s,%d: reset_b3_command %02x %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command)); + + Info = GOOD; + internal_command = plci->internal_command; + plci->internal_command = 0; + switch (internal_command) + { + default: + plci->command = 0; + plci->adjust_b_parms_msg = NULL; + plci->adjust_b_facilities = plci->B1_facilities; + plci->adjust_b_command = RESET_B3_COMMAND_1; + plci->adjust_b_ncci = (word)(Id >> 16); + plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_CONNECT; + plci->adjust_b_state = ADJUST_B_START; + dbug(1, dprintf("[%06lx] %s,%d: Reset B3...", + UnMapId(Id), (char *)(FILE_), __LINE__)); + case RESET_B3_COMMAND_1: + Info = adjust_b_process(Id, plci, Rc); + if (Info != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: Reset failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + break; + } + if (plci->internal_command) + return; + break; + } +/* sendf (plci->appl, _RESET_B3_R | CONFIRM, Id, plci->number, "w", Info);*/ + sendf(plci->appl, _RESET_B3_I, Id, 0, "s", ""); +} + + +static void select_b_command(dword Id, PLCI *plci, byte Rc) +{ + word Info; + word internal_command; + byte esc_chi[3]; + + dbug(1, dprintf("[%06lx] %s,%d: select_b_command %02x %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command)); + + Info = GOOD; + internal_command = plci->internal_command; + plci->internal_command = 0; + switch (internal_command) + { + default: + plci->command = 0; + plci->adjust_b_parms_msg = &plci->saved_msg; + if ((plci->tel == ADV_VOICE) && (plci == plci->adapter->AdvSignalPLCI)) + plci->adjust_b_facilities = plci->B1_facilities | B1_FACILITY_VOICE; + else + plci->adjust_b_facilities = plci->B1_facilities & ~B1_FACILITY_VOICE; + plci->adjust_b_command = SELECT_B_COMMAND_1; + plci->adjust_b_ncci = (word)(Id >> 16); + if (plci->saved_msg.parms[0].length == 0) + { + plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 | + ADJUST_B_MODE_NO_RESOURCE; + } + else + { + plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 | + ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE; + } + plci->adjust_b_state = ADJUST_B_START; + dbug(1, dprintf("[%06lx] %s,%d: Select B protocol...", + UnMapId(Id), (char *)(FILE_), __LINE__)); + case SELECT_B_COMMAND_1: + Info = adjust_b_process(Id, plci, Rc); + if (Info != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: Select B protocol failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + break; + } + if (plci->internal_command) + return; + if (plci->tel == ADV_VOICE) + { + esc_chi[0] = 0x02; + esc_chi[1] = 0x18; + esc_chi[2] = plci->b_channel; + SetVoiceChannel(plci->adapter->AdvCodecPLCI, esc_chi, plci->adapter); + } + break; + } + sendf(plci->appl, _SELECT_B_REQ | CONFIRM, Id, plci->number, "w", Info); +} + + +static void fax_connect_ack_command(dword Id, PLCI *plci, byte Rc) +{ + word internal_command; + + dbug(1, dprintf("[%06lx] %s,%d: fax_connect_ack_command %02x %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command)); + + internal_command = plci->internal_command; + plci->internal_command = 0; + switch (internal_command) + { + default: + plci->command = 0; + case FAX_CONNECT_ACK_COMMAND_1: + if (plci_nl_busy(plci)) + { + plci->internal_command = FAX_CONNECT_ACK_COMMAND_1; + return; + } + plci->internal_command = FAX_CONNECT_ACK_COMMAND_2; + plci->NData[0].P = plci->fax_connect_info_buffer; + plci->NData[0].PLength = plci->fax_connect_info_length; + plci->NL.X = plci->NData; + plci->NL.ReqCh = 0; + plci->NL.Req = plci->nl_req = (byte) N_CONNECT_ACK; + plci->adapter->request(&plci->NL); + return; + case FAX_CONNECT_ACK_COMMAND_2: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: FAX issue CONNECT ACK failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + break; + } + } + if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT) + && !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT)) + { + if (plci->B3_prot == 4) + sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", ""); + else + sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer); + plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT; + } +} + + +static void fax_edata_ack_command(dword Id, PLCI *plci, byte Rc) +{ + word internal_command; + + dbug(1, dprintf("[%06lx] %s,%d: fax_edata_ack_command %02x %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command)); + + internal_command = plci->internal_command; + plci->internal_command = 0; + switch (internal_command) + { + default: + plci->command = 0; + case FAX_EDATA_ACK_COMMAND_1: + if (plci_nl_busy(plci)) + { + plci->internal_command = FAX_EDATA_ACK_COMMAND_1; + return; + } + plci->internal_command = FAX_EDATA_ACK_COMMAND_2; + plci->NData[0].P = plci->fax_connect_info_buffer; + plci->NData[0].PLength = plci->fax_edata_ack_length; + plci->NL.X = plci->NData; + plci->NL.ReqCh = 0; + plci->NL.Req = plci->nl_req = (byte) N_EDATA; + plci->adapter->request(&plci->NL); + return; + case FAX_EDATA_ACK_COMMAND_2: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: FAX issue EDATA ACK failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + break; + } + } +} + + +static void fax_connect_info_command(dword Id, PLCI *plci, byte Rc) +{ + word Info; + word internal_command; + + dbug(1, dprintf("[%06lx] %s,%d: fax_connect_info_command %02x %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command)); + + Info = GOOD; + internal_command = plci->internal_command; + plci->internal_command = 0; + switch (internal_command) + { + default: + plci->command = 0; + case FAX_CONNECT_INFO_COMMAND_1: + if (plci_nl_busy(plci)) + { + plci->internal_command = FAX_CONNECT_INFO_COMMAND_1; + return; + } + plci->internal_command = FAX_CONNECT_INFO_COMMAND_2; + plci->NData[0].P = plci->fax_connect_info_buffer; + plci->NData[0].PLength = plci->fax_connect_info_length; + plci->NL.X = plci->NData; + plci->NL.ReqCh = 0; + plci->NL.Req = plci->nl_req = (byte) N_EDATA; + plci->adapter->request(&plci->NL); + return; + case FAX_CONNECT_INFO_COMMAND_2: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: FAX setting connect info failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + Info = _WRONG_STATE; + break; + } + if (plci_nl_busy(plci)) + { + plci->internal_command = FAX_CONNECT_INFO_COMMAND_2; + return; + } + plci->command = _CONNECT_B3_R; + nl_req_ncci(plci, N_CONNECT, 0); + send_req(plci); + return; + } + sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info); +} + + +static void fax_adjust_b23_command(dword Id, PLCI *plci, byte Rc) +{ + word Info; + word internal_command; + + dbug(1, dprintf("[%06lx] %s,%d: fax_adjust_b23_command %02x %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command)); + + Info = GOOD; + internal_command = plci->internal_command; + plci->internal_command = 0; + switch (internal_command) + { + default: + plci->command = 0; + plci->adjust_b_parms_msg = NULL; + plci->adjust_b_facilities = plci->B1_facilities; + plci->adjust_b_command = FAX_ADJUST_B23_COMMAND_1; + plci->adjust_b_ncci = (word)(Id >> 16); + plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23; + plci->adjust_b_state = ADJUST_B_START; + dbug(1, dprintf("[%06lx] %s,%d: FAX adjust B23...", + UnMapId(Id), (char *)(FILE_), __LINE__)); + case FAX_ADJUST_B23_COMMAND_1: + Info = adjust_b_process(Id, plci, Rc); + if (Info != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: FAX adjust failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + break; + } + if (plci->internal_command) + return; + case FAX_ADJUST_B23_COMMAND_2: + if (plci_nl_busy(plci)) + { + plci->internal_command = FAX_ADJUST_B23_COMMAND_2; + return; + } + plci->command = _CONNECT_B3_R; + nl_req_ncci(plci, N_CONNECT, 0); + send_req(plci); + return; + } + sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info); +} + + +static void fax_disconnect_command(dword Id, PLCI *plci, byte Rc) +{ + word internal_command; + + dbug(1, dprintf("[%06lx] %s,%d: fax_disconnect_command %02x %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command)); + + internal_command = plci->internal_command; + plci->internal_command = 0; + switch (internal_command) + { + default: + plci->command = 0; + plci->internal_command = FAX_DISCONNECT_COMMAND_1; + return; + case FAX_DISCONNECT_COMMAND_1: + case FAX_DISCONNECT_COMMAND_2: + case FAX_DISCONNECT_COMMAND_3: + if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0)) + { + dbug(1, dprintf("[%06lx] %s,%d: FAX disconnect EDATA failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + break; + } + if (Rc == OK) + { + if ((internal_command == FAX_DISCONNECT_COMMAND_1) + || (internal_command == FAX_DISCONNECT_COMMAND_2)) + { + plci->internal_command = FAX_DISCONNECT_COMMAND_2; + } + } + else if (Rc == 0) + { + if (internal_command == FAX_DISCONNECT_COMMAND_1) + plci->internal_command = FAX_DISCONNECT_COMMAND_3; + } + return; + } +} + + + +static void rtp_connect_b3_req_command(dword Id, PLCI *plci, byte Rc) +{ + word Info; + word internal_command; + + dbug(1, dprintf("[%06lx] %s,%d: rtp_connect_b3_req_command %02x %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command)); + + Info = GOOD; + internal_command = plci->internal_command; + plci->internal_command = 0; + switch (internal_command) + { + default: + plci->command = 0; + case RTP_CONNECT_B3_REQ_COMMAND_1: + if (plci_nl_busy(plci)) + { + plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_1; + return; + } + plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2; + nl_req_ncci(plci, N_CONNECT, 0); + send_req(plci); + return; + case RTP_CONNECT_B3_REQ_COMMAND_2: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: RTP setting connect info failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + Info = _WRONG_STATE; + break; + } + if (plci_nl_busy(plci)) + { + plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2; + return; + } + plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_3; + plci->NData[0].PLength = plci->internal_req_buffer[0]; + plci->NData[0].P = plci->internal_req_buffer + 1; + plci->NL.X = plci->NData; + plci->NL.ReqCh = 0; + plci->NL.Req = plci->nl_req = (byte) N_UDATA; + plci->adapter->request(&plci->NL); + break; + case RTP_CONNECT_B3_REQ_COMMAND_3: + return; + } + sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info); +} + + +static void rtp_connect_b3_res_command(dword Id, PLCI *plci, byte Rc) +{ + word internal_command; + + dbug(1, dprintf("[%06lx] %s,%d: rtp_connect_b3_res_command %02x %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command)); + + internal_command = plci->internal_command; + plci->internal_command = 0; + switch (internal_command) + { + default: + plci->command = 0; + case RTP_CONNECT_B3_RES_COMMAND_1: + if (plci_nl_busy(plci)) + { + plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_1; + return; + } + plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2; + nl_req_ncci(plci, N_CONNECT_ACK, (byte)(Id >> 16)); + send_req(plci); + return; + case RTP_CONNECT_B3_RES_COMMAND_2: + if ((Rc != OK) && (Rc != OK_FC)) + { + dbug(1, dprintf("[%06lx] %s,%d: RTP setting connect resp info failed %02x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc)); + break; + } + if (plci_nl_busy(plci)) + { + plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2; + return; + } + sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", ""); + plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_3; + plci->NData[0].PLength = plci->internal_req_buffer[0]; + plci->NData[0].P = plci->internal_req_buffer + 1; + plci->NL.X = plci->NData; + plci->NL.ReqCh = 0; + plci->NL.Req = plci->nl_req = (byte) N_UDATA; + plci->adapter->request(&plci->NL); + return; + case RTP_CONNECT_B3_RES_COMMAND_3: + return; + } +} + + + +static void hold_save_command(dword Id, PLCI *plci, byte Rc) +{ + byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/ + word Info; + word internal_command; + + dbug(1, dprintf("[%06lx] %s,%d: hold_save_command %02x %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command)); + + Info = GOOD; + internal_command = plci->internal_command; + plci->internal_command = 0; + switch (internal_command) + { + default: + if (!plci->NL.Id) + break; + plci->command = 0; + plci->adjust_b_parms_msg = NULL; + plci->adjust_b_facilities = plci->B1_facilities; + plci->adjust_b_command = HOLD_SAVE_COMMAND_1; + plci->adjust_b_ncci = (word)(Id >> 16); + plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23; + plci->adjust_b_state = ADJUST_B_START; + dbug(1, dprintf("[%06lx] %s,%d: HOLD save...", + UnMapId(Id), (char *)(FILE_), __LINE__)); + case HOLD_SAVE_COMMAND_1: + Info = adjust_b_process(Id, plci, Rc); + if (Info != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: HOLD save failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + break; + } + if (plci->internal_command) + return; + } + sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind); +} + + +static void retrieve_restore_command(dword Id, PLCI *plci, byte Rc) +{ + byte SS_Ind[] = "\x05\x03\x00\x02\x00\x00"; /* Retrieve_Ind struct*/ + word Info; + word internal_command; + + dbug(1, dprintf("[%06lx] %s,%d: retrieve_restore_command %02x %04x", + UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command)); + + Info = GOOD; + internal_command = plci->internal_command; + plci->internal_command = 0; + switch (internal_command) + { + default: + plci->command = 0; + plci->adjust_b_parms_msg = NULL; + plci->adjust_b_facilities = plci->B1_facilities; + plci->adjust_b_command = RETRIEVE_RESTORE_COMMAND_1; + plci->adjust_b_ncci = (word)(Id >> 16); + plci->adjust_b_mode = ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE; + plci->adjust_b_state = ADJUST_B_START; + dbug(1, dprintf("[%06lx] %s,%d: RETRIEVE restore...", + UnMapId(Id), (char *)(FILE_), __LINE__)); + case RETRIEVE_RESTORE_COMMAND_1: + Info = adjust_b_process(Id, plci, Rc); + if (Info != GOOD) + { + dbug(1, dprintf("[%06lx] %s,%d: RETRIEVE restore failed", + UnMapId(Id), (char *)(FILE_), __LINE__)); + break; + } + if (plci->internal_command) + return; + } + sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind); +} + + +static void init_b1_config(PLCI *plci) +{ + + dbug(1, dprintf("[%06lx] %s,%d: init_b1_config", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + + plci->B1_resource = 0; + plci->B1_facilities = 0; + + plci->li_bchannel_id = 0; + mixer_clear_config(plci); + + + ec_clear_config(plci); + + + dtmf_rec_clear_config(plci); + dtmf_send_clear_config(plci); + dtmf_parameter_clear_config(plci); + + adv_voice_clear_config(plci); + adjust_b_clear(plci); +} + + +static void clear_b1_config(PLCI *plci) +{ + + dbug(1, dprintf("[%06lx] %s,%d: clear_b1_config", + (dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)), + (char *)(FILE_), __LINE__)); + + adv_voice_clear_config(plci); + adjust_b_clear(plci); + + ec_clear_config(plci); + + + dtmf_rec_clear_config(plci); + dtmf_send_clear_config(plci); + dtmf_parameter_clear_config(plci); + + + if ((plci->li_bchannel_id != 0) + && (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci == plci)) + { + mixer_clear_config(plci); + li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = NULL; + plci->li_bchannel_id = 0; + } + + plci->B1_resource = 0; + plci->B1_facilities = 0; +} + + +/* ----------------------------------------------------------------- + XON protocol local helpers + ----------------------------------------------------------------- */ +static void channel_flow_control_remove(PLCI *plci) { + DIVA_CAPI_ADAPTER *a = plci->adapter; + word i; + for (i = 1; i < MAX_NL_CHANNEL + 1; i++) { + if (a->ch_flow_plci[i] == plci->Id) { + a->ch_flow_plci[i] = 0; + a->ch_flow_control[i] = 0; + } + } +} + +static void channel_x_on(PLCI *plci, byte ch) { + DIVA_CAPI_ADAPTER *a = plci->adapter; + if (a->ch_flow_control[ch] & N_XON_SENT) { + a->ch_flow_control[ch] &= ~N_XON_SENT; + } +} + +static void channel_x_off(PLCI *plci, byte ch, byte flag) { + DIVA_CAPI_ADAPTER *a = plci->adapter; + if ((a->ch_flow_control[ch] & N_RX_FLOW_CONTROL_MASK) == 0) { + a->ch_flow_control[ch] |= (N_CH_XOFF | flag); + a->ch_flow_plci[ch] = plci->Id; + a->ch_flow_control_pending++; + } +} + +static void channel_request_xon(PLCI *plci, byte ch) { + DIVA_CAPI_ADAPTER *a = plci->adapter; + + if (a->ch_flow_control[ch] & N_CH_XOFF) { + a->ch_flow_control[ch] |= N_XON_REQ; + a->ch_flow_control[ch] &= ~N_CH_XOFF; + a->ch_flow_control[ch] &= ~N_XON_CONNECT_IND; + } +} + +static void channel_xmit_extended_xon(PLCI *plci) { + DIVA_CAPI_ADAPTER *a; + int max_ch = ARRAY_SIZE(a->ch_flow_control); + int i, one_requested = 0; + + if ((!plci) || (!plci->Id) || ((a = plci->adapter) == NULL)) { + return; + } + + for (i = 0; i < max_ch; i++) { + if ((a->ch_flow_control[i] & N_CH_XOFF) && + (a->ch_flow_control[i] & N_XON_CONNECT_IND) && + (plci->Id == a->ch_flow_plci[i])) { + channel_request_xon(plci, (byte)i); + one_requested = 1; + } + } + + if (one_requested) { + channel_xmit_xon(plci); + } +} + +/* + Try to xmit next X_ON +*/ +static int find_channel_with_pending_x_on(DIVA_CAPI_ADAPTER *a, PLCI *plci) { + int max_ch = ARRAY_SIZE(a->ch_flow_control); + int i; + + if (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)) { + return (0); + } + + if (a->last_flow_control_ch >= max_ch) { + a->last_flow_control_ch = 1; + } + for (i = a->last_flow_control_ch; i < max_ch; i++) { + if ((a->ch_flow_control[i] & N_XON_REQ) && + (plci->Id == a->ch_flow_plci[i])) { + a->last_flow_control_ch = i + 1; + return (i); + } + } + + for (i = 1; i < a->last_flow_control_ch; i++) { + if ((a->ch_flow_control[i] & N_XON_REQ) && + (plci->Id == a->ch_flow_plci[i])) { + a->last_flow_control_ch = i + 1; + return (i); + } + } + + return (0); +} + +static void channel_xmit_xon(PLCI *plci) { + DIVA_CAPI_ADAPTER *a = plci->adapter; + byte ch; + + if (plci->nl_req || !plci->NL.Id || plci->nl_remove_id) { + return; + } + if ((ch = (byte)find_channel_with_pending_x_on(a, plci)) == 0) { + return; + } + a->ch_flow_control[ch] &= ~N_XON_REQ; + a->ch_flow_control[ch] |= N_XON_SENT; + + plci->NL.Req = plci->nl_req = (byte)N_XON; + plci->NL.ReqCh = ch; + plci->NL.X = plci->NData; + plci->NL.XNum = 1; + plci->NData[0].P = &plci->RBuffer[0]; + plci->NData[0].PLength = 0; + + plci->adapter->request(&plci->NL); +} + +static int channel_can_xon(PLCI *plci, byte ch) { + APPL *APPLptr; + DIVA_CAPI_ADAPTER *a; + word NCCIcode; + dword count; + word Num; + word i; + + APPLptr = plci->appl; + a = plci->adapter; + + if (!APPLptr) + return (0); + + NCCIcode = a->ch_ncci[ch] | (((word) a->Id) << 8); + + /* count all buffers within the Application pool */ + /* belonging to the same NCCI. XON if a first is */ + /* used. */ + count = 0; + Num = 0xffff; + for (i = 0; i < APPLptr->MaxBuffer; i++) { + if (NCCIcode == APPLptr->DataNCCI[i]) count++; + if (!APPLptr->DataNCCI[i] && Num == 0xffff) Num = i; + } + if ((count > 2) || (Num == 0xffff)) { + return (0); + } + return (1); +} + + +/*------------------------------------------------------------------*/ + +static word CPN_filter_ok(byte *cpn, DIVA_CAPI_ADAPTER *a, word offset) +{ + return 1; +} + + + +/**********************************************************************************/ +/* function groups the listening applications according to the CIP mask and the */ +/* Info_Mask. Each group gets just one Connect_Ind. Some application manufacturer */ +/* are not multi-instance capable, so they start e.g. 30 applications what causes */ +/* big problems on application level (one call, 30 Connect_Ind, ect). The */ +/* function must be enabled by setting "a->group_optimization_enabled" from the */ +/* OS specific part (per adapter). */ +/**********************************************************************************/ +static void group_optimization(DIVA_CAPI_ADAPTER *a, PLCI *plci) +{ + word i, j, k, busy, group_found; + dword info_mask_group[MAX_CIP_TYPES]; + dword cip_mask_group[MAX_CIP_TYPES]; + word appl_number_group_type[MAX_APPL]; + PLCI *auxplci; + + set_group_ind_mask(plci); /* all APPLs within this inc. call are allowed to dial in */ + + if (!a->group_optimization_enabled) + { + dbug(1, dprintf("No group optimization")); + return; + } + + dbug(1, dprintf("Group optimization = 0x%x...", a->group_optimization_enabled)); + + for (i = 0; i < MAX_CIP_TYPES; i++) + { + info_mask_group[i] = 0; + cip_mask_group[i] = 0; + } + for (i = 0; i < MAX_APPL; i++) + { + appl_number_group_type[i] = 0; + } + for (i = 0; i < max_appl; i++) /* check if any multi instance capable application is present */ + { /* group_optimization set to 1 means not to optimize multi-instance capable applications (default) */ + if (application[i].Id && (application[i].MaxNCCI) > 1 && (a->CIP_Mask[i]) && (a->group_optimization_enabled == 1)) + { + dbug(1, dprintf("Multi-Instance capable, no optimization required")); + return; /* allow good application unfiltered access */ + } + } + for (i = 0; i < max_appl; i++) /* Build CIP Groups */ + { + if (application[i].Id && a->CIP_Mask[i]) + { + for (k = 0, busy = false; k < a->max_plci; k++) + { + if (a->plci[k].Id) + { + auxplci = &a->plci[k]; + if (auxplci->appl == &application[i]) /* application has a busy PLCI */ + { + busy = true; + dbug(1, dprintf("Appl 0x%x is busy", i + 1)); + } + else if (test_c_ind_mask_bit(auxplci, i)) /* application has an incoming call pending */ + { + busy = true; + dbug(1, dprintf("Appl 0x%x has inc. call pending", i + 1)); + } + } + } + + for (j = 0, group_found = 0; j <= (MAX_CIP_TYPES) && !busy && !group_found; j++) /* build groups with free applications only */ + { + if (j == MAX_CIP_TYPES) /* all groups are in use but group still not found */ + { /* the MAX_CIP_TYPES group enables all calls because of field overflow */ + appl_number_group_type[i] = MAX_CIP_TYPES; + group_found = true; + dbug(1, dprintf("Field overflow appl 0x%x", i + 1)); + } + else if ((info_mask_group[j] == a->CIP_Mask[i]) && (cip_mask_group[j] == a->Info_Mask[i])) + { /* is group already present ? */ + appl_number_group_type[i] = j | 0x80; /* store the group number for each application */ + group_found = true; + dbug(1, dprintf("Group 0x%x found with appl 0x%x, CIP=0x%lx", appl_number_group_type[i], i + 1, info_mask_group[j])); + } + else if (!info_mask_group[j]) + { /* establish a new group */ + appl_number_group_type[i] = j | 0x80; /* store the group number for each application */ + info_mask_group[j] = a->CIP_Mask[i]; /* store the new CIP mask for the new group */ + cip_mask_group[j] = a->Info_Mask[i]; /* store the new Info_Mask for this new group */ + group_found = true; + dbug(1, dprintf("New Group 0x%x established with appl 0x%x, CIP=0x%lx", appl_number_group_type[i], i + 1, info_mask_group[j])); + } + } + } + } + + for (i = 0; i < max_appl; i++) /* Build group_optimization_mask_table */ + { + if (appl_number_group_type[i]) /* application is free, has listens and is member of a group */ + { + if (appl_number_group_type[i] == MAX_CIP_TYPES) + { + dbug(1, dprintf("OverflowGroup 0x%x, valid appl = 0x%x, call enabled", appl_number_group_type[i], i + 1)); + } + else + { + dbug(1, dprintf("Group 0x%x, valid appl = 0x%x", appl_number_group_type[i], i + 1)); + for (j = i + 1; j < max_appl; j++) /* search other group members and mark them as busy */ + { + if (appl_number_group_type[i] == appl_number_group_type[j]) + { + dbug(1, dprintf("Appl 0x%x is member of group 0x%x, no call", j + 1, appl_number_group_type[j])); + clear_group_ind_mask_bit(plci, j); /* disable call on other group members */ + appl_number_group_type[j] = 0; /* remove disabled group member from group list */ + } + } + } + } + else /* application should not get a call */ + { + clear_group_ind_mask_bit(plci, i); + } + } + +} + + + +/* OS notifies the driver about a application Capi_Register */ +word CapiRegister(word id) +{ + word i, j, appls_found; + + PLCI *plci; + DIVA_CAPI_ADAPTER *a; + + for (i = 0, appls_found = 0; i < max_appl; i++) + { + if (application[i].Id && (application[i].Id != id)) + { + appls_found++; /* an application has been found */ + } + } + + if (appls_found) return true; + for (i = 0; i < max_adapter; i++) /* scan all adapters... */ + { + a = &adapter[i]; + if (a->request) + { + if (a->flag_dynamic_l1_down) /* remove adapter from L1 tristate (Huntgroup) */ + { + if (!appls_found) /* first application does a capi register */ + { + if ((j = get_plci(a))) /* activate L1 of all adapters */ + { + plci = &a->plci[j - 1]; + plci->command = 0; + add_p(plci, OAD, "\x01\xfd"); + add_p(plci, CAI, "\x01\x80"); + add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30"); + add_p(plci, SHIFT | 6, NULL); + add_p(plci, SIN, "\x02\x00\x00"); + plci->internal_command = START_L1_SIG_ASSIGN_PEND; + sig_req(plci, ASSIGN, DSIG_ID); + add_p(plci, FTY, "\x02\xff\x07"); /* l1 start */ + sig_req(plci, SIG_CTRL, 0); + send_req(plci); + } + } + } + } + } + return false; +} + +/*------------------------------------------------------------------*/ + +/* Functions for virtual Switching e.g. Transfer by join, Conference */ + +static void VSwitchReqInd(PLCI *plci, dword Id, byte **parms) +{ + word i; + /* Format of vswitch_t: + 0 byte length + 1 byte VSWITCHIE + 2 byte VSWITCH_REQ/VSWITCH_IND + 3 byte reserved + 4 word VSwitchcommand + 6 word returnerror + 8... Params + */ + if (!plci || + !plci->appl || + !plci->State || + plci->Sig.Ind == NCR_FACILITY + ) + return; + + for (i = 0; i < MAX_MULTI_IE; i++) + { + if (!parms[i][0]) continue; + if (parms[i][0] < 7) + { + parms[i][0] = 0; /* kill it */ + continue; + } + dbug(1, dprintf("VSwitchReqInd(%d)", parms[i][4])); + switch (parms[i][4]) + { + case VSJOIN: + if (!plci->relatedPTYPLCI || + (plci->ptyState != S_ECT && plci->relatedPTYPLCI->ptyState != S_ECT)) + { /* Error */ + break; + } + /* remember all necessary informations */ + if (parms[i][0] != 11 || parms[i][8] != 3) /* Length Test */ + { + break; + } + if (parms[i][2] == VSWITCH_IND && parms[i][9] == 1) + { /* first indication after ECT-Request on Consultation Call */ + plci->vswitchstate = parms[i][9]; + parms[i][9] = 2; /* State */ + /* now ask first Call to join */ + } + else if (parms[i][2] == VSWITCH_REQ && parms[i][9] == 3) + { /* Answer of VSWITCH_REQ from first Call */ + plci->vswitchstate = parms[i][9]; + /* tell consultation call to join + and the protocol capabilities of the first call */ + } + else + { /* Error */ + break; + } + plci->vsprot = parms[i][10]; /* protocol */ + plci->vsprotdialect = parms[i][11]; /* protocoldialect */ + /* send join request to related PLCI */ + parms[i][1] = VSWITCHIE; + parms[i][2] = VSWITCH_REQ; + + plci->relatedPTYPLCI->command = 0; + plci->relatedPTYPLCI->internal_command = VSWITCH_REQ_PEND; + add_p(plci->relatedPTYPLCI, ESC, &parms[i][0]); + sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0); + send_req(plci->relatedPTYPLCI); + break; + case VSTRANSPORT: + default: + if (plci->relatedPTYPLCI && + plci->vswitchstate == 3 && + plci->relatedPTYPLCI->vswitchstate == 3) + { + add_p(plci->relatedPTYPLCI, ESC, &parms[i][0]); + sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0); + send_req(plci->relatedPTYPLCI); + } + break; + } + parms[i][0] = 0; /* kill it */ + } +} + + +/*------------------------------------------------------------------*/ + +static int diva_get_dma_descriptor(PLCI *plci, dword *dma_magic) { + ENTITY e; + IDI_SYNC_REQ *pReq = (IDI_SYNC_REQ *)&e; + + if (!(diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_RX_DMA)) { + return (-1); + } + + pReq->xdi_dma_descriptor_operation.Req = 0; + pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION; + + pReq->xdi_dma_descriptor_operation.info.operation = IDI_SYNC_REQ_DMA_DESCRIPTOR_ALLOC; + pReq->xdi_dma_descriptor_operation.info.descriptor_number = -1; + pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL; + pReq->xdi_dma_descriptor_operation.info.descriptor_magic = 0; + + e.user[0] = plci->adapter->Id - 1; + plci->adapter->request((ENTITY *)pReq); + + if (!pReq->xdi_dma_descriptor_operation.info.operation && + (pReq->xdi_dma_descriptor_operation.info.descriptor_number >= 0) && + pReq->xdi_dma_descriptor_operation.info.descriptor_magic) { + *dma_magic = pReq->xdi_dma_descriptor_operation.info.descriptor_magic; + dbug(3, dprintf("dma_alloc, a:%d (%d-%08x)", + plci->adapter->Id, + pReq->xdi_dma_descriptor_operation.info.descriptor_number, + *dma_magic)); + return (pReq->xdi_dma_descriptor_operation.info.descriptor_number); + } else { + dbug(1, dprintf("dma_alloc failed")); + return (-1); + } +} + +static void diva_free_dma_descriptor(PLCI *plci, int nr) { + ENTITY e; + IDI_SYNC_REQ *pReq = (IDI_SYNC_REQ *)&e; + + if (nr < 0) { + return; + } + + pReq->xdi_dma_descriptor_operation.Req = 0; + pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION; + + pReq->xdi_dma_descriptor_operation.info.operation = IDI_SYNC_REQ_DMA_DESCRIPTOR_FREE; + pReq->xdi_dma_descriptor_operation.info.descriptor_number = nr; + pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL; + pReq->xdi_dma_descriptor_operation.info.descriptor_magic = 0; + + e.user[0] = plci->adapter->Id - 1; + plci->adapter->request((ENTITY *)pReq); + + if (!pReq->xdi_dma_descriptor_operation.info.operation) { + dbug(1, dprintf("dma_free(%d)", nr)); + } else { + dbug(1, dprintf("dma_free failed (%d)", nr)); + } +} + +/*------------------------------------------------------------------*/ |