FreeCalypso > hg > fc-tourmaline
diff src/g23m-gprs/llc/llc_uf.c @ 1:fa8dc04885d8
src/g23m-*: import from Magnetite
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Fri, 16 Oct 2020 06:25:50 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/g23m-gprs/llc/llc_uf.c Fri Oct 16 06:25:50 2020 +0000 @@ -0,0 +1,4152 @@ + /* ++----------------------------------------------------------------------------- +| Project : +| Modul : ++----------------------------------------------------------------------------- +| Copyright 2002 Texas Instruments Berlin, AG +| All rights reserved. +| +| This file is confidential and a trade secret of Texas +| Instruments Berlin, AG +| The receipt of or possession of this file does not convey +| any rights to reproduce or disclose its contents or to +| manufacture, use, or sell anything it may describe, in +| whole, or in part, without the specific written consent of +| Texas Instruments Berlin, AG. ++----------------------------------------------------------------------------- +| Purpose : This modul is part of the entity LLC and implements all +| procedures and functions as described in the +| SDL-documentation (U-statemachine) ++----------------------------------------------------------------------------- +*/ + + +#ifndef LLC_UF_C +#define LLC_UF_C +#endif + +#define ENTITY_LLC + +/*==== INCLUDES =============================================================*/ + +#include <string.h> /* to get memcpy() */ + +#include "typedefs.h" /* to get Condat data types */ +#include "vsi.h" /* to get a lot of macros */ +#include "macdef.h" +#include "gprs.h" +#include "gsm.h" /* to get a lot of macros */ +#include "cnf_llc.h" /* to get cnf-definitions */ +#include "mon_llc.h" /* to get mon-definitions */ +#include "prim.h" /* to get the definitions of used SAP and directions */ +#include "llc.h" /* to get the global entity definitions */ + +#include "llc_f.h" /* to get global functions, e.g. llc_init_parameters */ +#include "llc_uf.h" /* to get local XID definitions */ +#include "llc_t200s.h" /* to get signal interface to T200 */ +#include "llc_txs.h" /* to get signal interface to TX */ + +/*==== CONST ================================================================*/ + +/*==== LOCAL VARS ===========================================================*/ + +/*==== PRIVATE FUNCTIONS ====================================================*/ + +/*==== PUBLIC FUNCTIONS =====================================================*/ + + +/* + * CHECK_INSTANCE: + * v(ariable) - variable name of parameter + */ +#define CHECK_INSTANCE(v) \ + if (llc_data->decoded_xid.##v##.valid) \ + { \ + /* \ + * More than one instance of the same XID parameter type is included. \ + */ \ + if (cr_bit EQ SGSN_COMMAND) \ + { \ + /* \ + * XID command: Ignore all instances except the first. \ + * <R.LLC.XIDNEG_R.A.014> \ + */ \ + continue; \ + } \ + else /* SGSN_RESPONSE */ \ + { \ + /* \ + * XID response: The XID information field is regarded as invalid. \ + * <R.LLC.XID_INVA.A.012> \ + */ \ + TRACE_0_INFO ("More than one instance of an XID-IE in RSP"); \ + return FALSE; \ + } \ + } + + +/* + * CHECK_LENGTH_VALUE: + * l(ength) - default length of parameter + * c(ondition) - out-of-range value condition + * v(ariable) - variable name of parameter + * d(default) - default value of parameter + */ +#define CHECK_LENGTH_VALUE(l,c,v,d) \ + if ((length NEQ l) OR (c)) \ + { \ + /* \ + * Unsupported length or out-of-range values. \ + */ \ + if (cr_bit EQ SGSN_COMMAND) \ + { \ + /* \ + * XID command: Set the value for this type according to our \ + * preferences. \ + * <R.LLC.XIDNEG_R.A.003> \ + */ \ + llc_data->decoded_xid.##v##.valid = TRUE; \ + llc_data->decoded_xid.##v##.value = d; \ + break; \ + } \ + else /* SGSN_RESPONSE */ \ + { \ + /* \ + * XID response: The XID information field is regarded as invalid. \ + * <R.LLC.XID_INVA.A.007>, <R.LLC.XID_INVA.A.009> \ + */ \ + TRACE_0_INFO ("Unsupported length or out-of-range values in RSP"); \ + return FALSE; \ + } \ + } + + +/* + * CHECK_SENSE_OF_NEGOTIATION: + * d(ata) - received data value to check + * v(ariable) - variable name of parameter + * s(ense) - sense of negotiation (XID_SENSE_UP / XID_SENSE_DOWN) + */ +#define CHECK_SENSE_OF_NEGOTIATION(d,v,s) \ + { \ + /* \ + * XID response must not contain an XID parameter with a value that \ + * violates the sense of negotiation. \ + * <R.LLC.XID_INVA.A.008> \ + */ \ + if (cr_bit EQ SGSN_RESPONSE) \ + { \ + /* \ + * First compare the value with the requested value, if there is any \ + */ \ + if ( (llc_data->u->requested_xid.##v##.valid) AND \ + (llc_data->u->requested_xid.##v##.value s d) ) \ + { \ + TRACE_0_INFO ("Sense of negotiation error"); \ + return FALSE; \ + } \ + else if( !(llc_data->u->requested_xid.##v##.valid) AND \ + (*(llc_data->##v) s d) ) \ + { \ + /* \ + * If the value was not requested but included in response, compare \ + * it with the current value \ + */ \ + TRACE_0_INFO ("Value not requested, but sense of negotiation error"); \ + return FALSE; \ + } \ + } \ + } + + +/* ++------------------------------------------------------------------------------ +| Function : u_init ++------------------------------------------------------------------------------ +| Description : This procedure initialises all necessary variables of u_frames +| for all SAPIs. +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_init (void) +{ + TRACE_FUNCTION( "u_init" ); + + /* + * Initialise every incarnation of U with state TLLI_UNASSIGNED. + */ + SWITCH_SERVICE (llc, u, 0); + INIT_STATE (U_0, U_TLLI_UNASSIGNED); + + SWITCH_SERVICE (llc, u, 1); + INIT_STATE (U_1, U_TLLI_UNASSIGNED); + + SWITCH_SERVICE (llc, u, 2); + INIT_STATE (U_2, U_TLLI_UNASSIGNED); + + SWITCH_SERVICE (llc, u, 3); + INIT_STATE (U_3, U_TLLI_UNASSIGNED); + + SWITCH_SERVICE (llc, u, 4); + INIT_STATE (U_4, U_TLLI_UNASSIGNED); + + SWITCH_SERVICE (llc, u, 5); + INIT_STATE (U_5, U_TLLI_UNASSIGNED); + + return; +} /* u_init() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : u_init_sapi ++------------------------------------------------------------------------------ +| Description : This procedure initialises all necessary variables of u_frames +| for the given SAPI after a TLLI assignment of LLC was occurred. +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_init_sapi (void) +{ + TRACE_FUNCTION( "u_init_sapi" ); + + /* + * Initial, no XID command is currently being sent. + */ + llc_data->u->xid_pending = FALSE; + + llc_data->u->xid_tag = 0L; + llc_data->u->xid_tag_negotiate = 0L; + llc_data->u->xid_tag_sent = 0L; + + llc_data->u->release_requested = FALSE; + llc_data->u->ll_xid_resp_pending = FALSE; + + return; +} /* u_init_sapi() */ + +/* ++------------------------------------------------------------------------------ +| Function : u_build_u_frame ++------------------------------------------------------------------------------ +| Description : This procedure fills the given sdu with a correct LLC frame, +| containing the address field and the control field (U format). +| The information field is not filled in by this procedure. +| The checksum field (FCS) is also not filled in by this +| procedure, it is filled in by the send_pdu service before +| sending. +| +| Parameters : sdu - a valid pointer to an SDU, containing enough octets for +| the requested command/response +| cr_bit - C/R bit for the frame +| sapi - a valid SAPI for unacknowledged operation +| pf_bit - P/F bit for the U frame +| command - a valid command/response for the U frame +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_build_u_frame +( +#ifdef LL_DESC + T_desc_list3 *desc_list3, +#else + T_sdu *sdu, +#endif + T_BIT cr_bit, + UBYTE sapi, + T_BIT pf_bit, + T_COMMAND command +) +{ +#ifdef LL_DESC + T_desc3 *desc3; + UBYTE *desc_buf; +#endif + + TRACE_FUNCTION( "u_build_u_frame" ); + +#ifdef LL_DESC + /* + * Let every frame begin at the beginning. + */ + desc3 = (T_desc3*)desc_list3->first; + desc3->offset = 0; + desc_buf = (UBYTE*)desc3->buffer; + + /* + * Fill in address and control fields. + * NOTE: The values of the commands are chosen to correspond with the + * defined values of the Mx bits in the control field. Therefore the given + * command can be used to build the header, regardless of its actual value. + */ + desc_buf[0] = ((UBYTE)cr_bit << 6) | sapi; + desc_buf[1] = 0xE0 | ((UBYTE)pf_bit << 4) | (UBYTE)command; + + + /* + * Determine the length of the frame, depending on the command/ + * response. + */ + switch (command) + { +#ifdef REL99 + case U_NULL: + /* + * The NULL command contains no information field. The size + * of the frame is fixed. (FCS ist not yet considered in l_buf, will + * be included when FCS is appended to the frame.) + */ + desc3->len = U_NULL_SIZE_BITS/8; + break; +#endif /* REL99 */ + case U_DM: + /* + * The DM response contains no information field. The size + * of the frame is fixed. (FCS ist not yet considered in l_buf, will + * be included when FCS is appended to the frame.) + */ + desc3->len = U_DM_SIZE_BITS/8; + break; + case U_DISC: + /* + * The DISC response contains no information field. The size + * of the frame is fixed. (FCS ist not yet considered in l_buf, will + * be included when FCS is appended to the frame.) + */ + desc3->len = U_DISC_SIZE_BITS/8; + break; + case U_UA: + /* + * The UA response may contain an information field. Set only the + * size of the header (address + control fields). + */ + desc3->len = 2; + break; + case U_SABM: + /* + * The SABM command may contain an information field. Set only the + * size of the header (address + control fields). + */ + desc3->len = 2; + break; + case U_FRMR: + /* + * The FRMR response contains an information field of fixed size. + * u_insert_frmr_information() relies on a sane value in l_buf, + * therefore set only the size of the header (address + control field). + */ + desc3->len = 2; + break; + case U_XID: + /* + * The XID command/response contains an information field. Set only the + * size of the header (address + control fields). + */ + desc3->len = 2; + break; + default: + desc3->len = 0; + TRACE_ERROR ("Undefined Command specified"); + break; + } + + desc_list3->list_len = desc3->len; + + return; + +#else + /* + * Let every frame begin at the beginning. + */ + sdu->o_buf = 0; + + /* + * Fill in address and control fields. + * NOTE: The values of the commands are chosen to correspond with the + * defined values of the Mx bits in the control field. Therefore the given + * command can be used to build the header, regardless of its actual value. + */ + sdu->buf[0] = ((UBYTE)cr_bit << 6) | sapi; + sdu->buf[1] = 0xE0 | ((UBYTE)pf_bit << 4) | (UBYTE)command; + + + /* + * Determine the length of the frame, depending on the command/ + * response. + */ + switch (command) + { +#ifdef REL99 + case U_NULL: + /* + * The NULL command contains no information field. The size + * of the frame is fixed. (FCS ist not yet considered in l_buf, will + * be included when FCS is appended to the frame.) + */ + sdu->l_buf = U_NULL_SIZE_BITS; + break; +#endif /* REL99 */ + + case U_DM: + /* + * The DM response contains no information field. The size + * of the frame is fixed. (FCS ist not yet considered in l_buf, will + * be included when FCS is appended to the frame.) + */ + sdu->l_buf = U_DM_SIZE_BITS; + break; + case U_DISC: + /* + * The DISC response contains no information field. The size + * of the frame is fixed. (FCS ist not yet considered in l_buf, will + * be included when FCS is appended to the frame.) + */ + sdu->l_buf = U_DISC_SIZE_BITS; + break; + case U_UA: + /* + * The UA response may contain an information field. Set only the + * size of the header (address + control fields). + */ + sdu->l_buf = 2*8; + break; + case U_SABM: + /* + * The SABM command may contain an information field. Set only the + * size of the header (address + control fields). + */ + sdu->l_buf = 2*8; + break; + case U_FRMR: + /* + * The FRMR response contains an information field of fixed size. + * u_insert_frmr_information() relies on a sane value in l_buf, + * therefore set only the size of the header (address + control field). + */ + sdu->l_buf = 2*8; + break; + case U_XID: + /* + * The XID command/response contains an information field. Set only the + * size of the header (address + control fields). + */ + sdu->l_buf = 2*8; + break; + default: + sdu->l_buf = 0; + TRACE_ERROR ("Undefined Command specified"); + break; + } + + return; +#endif /* LL_DESC */ +} /* u_build_u_frame() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : u_check_xid ++------------------------------------------------------------------------------ +| Description : This procedure checks the XID information field that is given +| in SDU. If it is invalid, rc_xid_valid is set to FALSE, +| otherwise to TRUE. All XID parameters are decoded and stored +| in llc_decoded_xid (global variable) if they are valid. The +| parameters cr_bit and command are necessary to distinguish +| between the different commands and responses. Each parameter +| is checked for multiple instances, correct sense of +| negotiation, and valid field length and value. +| +| Parameters : sdu - a valid pointer to an SDU +| cr_bit - C/R bit of the frame +| command - command/response of the U frame +| ++------------------------------------------------------------------------------ +*/ +GLOBAL BOOL u_check_xid (T_sdu *sdu, + T_BIT cr_bit, + T_COMMAND command) +{ + UBYTE *par; + BOOL xl; + UBYTE type; + UBYTE length = 0; + UBYTE *data; + ULONG value; + + + TRACE_FUNCTION( "u_check_xid" ); + + /* + * Initialise each valid flag to FALSE. + */ + llc_data->decoded_xid.version.valid = FALSE; + llc_data->decoded_xid.iov_ui.valid = FALSE; + llc_data->decoded_xid.iov_i.valid = FALSE; + llc_data->decoded_xid.t200.valid = FALSE; + llc_data->decoded_xid.n200.valid = FALSE; + llc_data->decoded_xid.n201_u.valid = FALSE; + llc_data->decoded_xid.n201_i.valid = FALSE; + llc_data->decoded_xid.md.valid = FALSE; + llc_data->decoded_xid.mu.valid = FALSE; + llc_data->decoded_xid.kd.valid = FALSE; + llc_data->decoded_xid.ku.valid = FALSE; + llc_data->decoded_xid.reset.valid = FALSE; + + llc_data->decoded_l3_xid.valid = FALSE; + + /* + * Initialise par with the first XID parameter. + * Process each XID parameter until the end of the list is reached: + * - Check if end of list is reached (max. SDU length). + * ...process XID parameter (set xl and length)... + * - Increment par to point to the next XID parameter (is incremented by + * (data) length plus header length). + */ +#ifdef TRACE_EVE + { + int i; + int l = sdu->l_buf/8; + int o = sdu->o_buf/8; + + vsi_o_ttrace(VSI_CALLER TC_EVENT, "XID sdu dump len:%d bytes", l); + + for (i=0; i<l; i+=10) + { + vsi_o_ttrace(VSI_CALLER TC_EVENT, "%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x", + sdu->buf[o+i+0], sdu->buf[o+i+1], + sdu->buf[o+i+2], sdu->buf[o+i+3], sdu->buf[o+i+4], + + sdu->buf[o+i+5], sdu->buf[o+i+6], + sdu->buf[o+i+7], sdu->buf[o+i+8], sdu->buf[o+i+9]); + } + } +#endif + + for (par = &(sdu->buf[sdu->o_buf/8]); + par < (&(sdu->buf[sdu->o_buf/8]) + sdu->l_buf/8); + par += length + (xl ? 2 : 1)) + { + /* + * Store XL bit in boolean xl. + */ + xl = (*par & 0x80) > 0; + + /* + * Store (data) length, and set data to point to the beginning + * of the XID parameter data. + */ + if (xl) + { + /* + * XL == 1: length is given in 8 bits. + */ + length = (*par & 0x03) << 6; + length += (*(par+1) & 0xFC) >> 2; + + data = par + 2; + } + else + { + /* + * XL == 0: length is given in 2 bits. + */ + length = *par & 0x03; + + data = par + 1; + } + + + if (data + length > &(sdu->buf[sdu->o_buf/8]) + sdu->l_buf/8) + { + /* + * The XID parameter field violates the LLC frame format (exceeds given + * SDU size). + * <R.LLC.XID_INVA.A.001> + */ + return FALSE; + } + + + /* + * Store type field. + */ + type = (*par & 0x7C) >> 2; + + + /* + * Check type and store parameter data, if any. + */ + switch (type) + { + case XID_VERSION: + CHECK_INSTANCE (version); + + /* + * XID response must not contain an XID parameter with a value that + * violates the sense of negotiation. + * <R.LLC.XID_INVA.A.008> + */ + if (cr_bit EQ SGSN_RESPONSE) + { + /* + * First compare the value with the requested value, if there is any + */ + if ( (llc_data->u->requested_xid.version.valid) AND + (llc_data->u->requested_xid.version.value XID_SENSE_DOWN (*data & 0x0F)) ) + { + return FALSE; + } + else if( !(llc_data->u->requested_xid.version.valid) AND + llc_data->version XID_SENSE_DOWN (*data & 0x0F) ) + { + /* + * If the value was not requested but included in response, compare + * it with the current value + */ + return FALSE; + } + } + /*lint -e685 Relational operator always evaluates to false*/ + CHECK_LENGTH_VALUE (XID_VERSION_LEN, + ((*data & 0x0F) > XID_VERSION_MAX), + version, llc_data->version); + /*lint +e685 Relational operator always evaluates to false*/ + /* + * Set version as valid and store value. + */ + llc_data->decoded_xid.version.valid = TRUE; + llc_data->decoded_xid.version.value = *data & 0x0F; + TRACE_1_INFO("XID Version:%d", llc_data->decoded_xid.version.value); + break; + case XID_IOV_UI: + CHECK_INSTANCE (iov_ui); + + value = ((ULONG)*data) << 24; + value += ((ULONG)*(data+1)) << 16; + value += ((ULONG)*(data+2)) << 8; + value += *(data+3); + /*lint -e685 Relational operator always evaluates to false*/ + CHECK_LENGTH_VALUE (XID_IOV_UI_LEN, + (value > XID_IOV_UI_MAX), + iov_ui, llc_data->iov_ui); + /*lint +e685 Relational operator always evaluates to false*/ + /* + * Set iov_ui as valid and store value. + */ + llc_data->decoded_xid.iov_ui.valid = TRUE; + llc_data->decoded_xid.iov_ui.value = value; + TRACE_1_INFO("XID IOV-UI:0x%.8X", value); + break; + case XID_IOV_I: + if (command EQ U_XID) + { + /* + * IOV-I must not be contained in an XID command/response. + * <R.LLC.XID_INVA.A.010>, <R.LLC.XID_PAR.A.003> + */ + TRACE_0_INFO("IOV-I must not be contained in an XID command/response"); + return FALSE; + } + + CHECK_INSTANCE (iov_i); + + value = ((ULONG)*data) << 24; + value += ((ULONG)*(data+1)) << 16; + value += ((ULONG)*(data+2)) << 8; + value += *(data+3); + /*lint -e685 Relational operator always evaluates to false*/ + CHECK_LENGTH_VALUE (XID_IOV_I_LEN, + (value > XID_IOV_I_MAX), + iov_i, *(llc_data->iov_i)); + /*lint +e685 Relational operator always evaluates to false*/ + /* + * Set iov_i as valid and store value. + */ + llc_data->decoded_xid.iov_i.valid = TRUE; + llc_data->decoded_xid.iov_i.value = value; + TRACE_1_INFO("XID IOV-I:0x%.8X", value); + break; + case XID_T200: + CHECK_INSTANCE (t200); + + value = ((ULONG)*data) << 8; + value += *(data+1); + value &= 0x00000FFFL; + + /* + * XID response must not contain an XID parameter with a value that + * violates the sense of negotiation. + * <R.LLC.XID_INVA.A.008> + */ + if (cr_bit EQ SGSN_RESPONSE) + { + /* + * First compare the value with the requested value, if there is any + */ + if ( (llc_data->u->requested_xid.t200.valid) AND + (llc_data->u->requested_xid.t200.value XID_SENSE_UP value) ) + { + TRACE_1_INFO("Value of T200:%d illegal", value); + return FALSE; + } + else if( !(llc_data->u->requested_xid.t200.valid) AND + (USHORT)INT2XID(llc_data->t200->length) XID_SENSE_UP value ) + { + /* + * If the value was not requested but included in response, compare + * it with the current value + */ + TRACE_1_INFO("Requested value of T200:%d illegal", value); + return FALSE; + } + } + + CHECK_LENGTH_VALUE (XID_T200_LEN, + ((value < XID_T200_MIN) OR (value > XID_T200_MAX)), + t200, (USHORT)INT2XID(llc_data->t200->length)); + + /* + * Set t200 as valid and store value. + */ + llc_data->decoded_xid.t200.valid = TRUE; + llc_data->decoded_xid.t200.value = (USHORT)value; + TRACE_1_INFO("XID T200:%d", llc_data->decoded_xid.t200.value); + break; + case XID_N200: + CHECK_INSTANCE (n200); + + CHECK_SENSE_OF_NEGOTIATION ((*data & 0x0F), n200, XID_SENSE_UP); + /*lint -e685 Relational operator always evaluates to false*/ + CHECK_LENGTH_VALUE (XID_N200_LEN, + (((*data & 0x0F) < XID_N200_MIN) OR ((*data & 0x0F) > XID_N200_MAX)), + n200, *(llc_data->n200)); + /*lint +e685 Relational operator always evaluates to false*/ + /* + * Set n200 as valid and store value. + */ + llc_data->decoded_xid.n200.valid = TRUE; + llc_data->decoded_xid.n200.value = *data & 0x0F; + TRACE_1_INFO("XID N200:%d", llc_data->decoded_xid.n200.value); + break; + case XID_N201_U: + CHECK_INSTANCE (n201_u); + + value = ((ULONG)*data) << 8; + value += *(data+1); + value &= 0x000007FFL; + + CHECK_SENSE_OF_NEGOTIATION ((USHORT)value, n201_u, XID_SENSE_DOWN); + + CHECK_LENGTH_VALUE (XID_N201_U_LEN, + (((USHORT)value < XID_N201_U_MIN) OR (value > XID_N201_U_MAX)), + n201_u, *(llc_data->n201_u)); + + /* + * Set n201_u as valid and store value. + */ + llc_data->decoded_xid.n201_u.valid = TRUE; + llc_data->decoded_xid.n201_u.value = (USHORT)value; + TRACE_1_INFO("XID N201-U:%d", llc_data->decoded_xid.n201_u.value); + break; + case XID_N201_I: + CHECK_INSTANCE (n201_i); + + value = ((ULONG)*data) << 8; + value += *(data+1); + value &= 0x000007FFL; + + CHECK_SENSE_OF_NEGOTIATION ((USHORT)value, n201_i, XID_SENSE_DOWN); + + CHECK_LENGTH_VALUE (XID_N201_I_LEN, + ((value < XID_N201_I_MIN) OR (value > XID_N201_I_MAX)), + n201_i, *(llc_data->n201_i)); + + /* + * Set n201_i as valid and store value. + */ + llc_data->decoded_xid.n201_i.valid = TRUE; + llc_data->decoded_xid.n201_i.value = (USHORT)value; + TRACE_1_INFO("XID N201-I:%d", llc_data->decoded_xid.n201_i.value); + break; + case XID_MD: + CHECK_INSTANCE (md); + + value = ((ULONG)*data) << 8; + value += *(data+1); + value &= 0x00007FFFL; + + CHECK_SENSE_OF_NEGOTIATION ((USHORT)value, md, XID_SENSE_DOWN); + + CHECK_LENGTH_VALUE (XID_MD_LEN, + ((value != XID_MD_OFF) AND ((value < XID_MD_MIN) OR (value > XID_MD_MAX))), + md, *(llc_data->md)); + + /* + * Set md as valid and store value. + */ + llc_data->decoded_xid.md.valid = TRUE; + llc_data->decoded_xid.md.value = (USHORT)value; + TRACE_1_INFO("XID MD:%d", llc_data->decoded_xid.md.value); + break; + case XID_MU: + CHECK_INSTANCE (mu); + + value = ((ULONG)*data) << 8; + value += *(data+1); + value &= 0x00007FFFL; + + CHECK_SENSE_OF_NEGOTIATION ((USHORT)value, mu, XID_SENSE_DOWN); + + CHECK_LENGTH_VALUE (XID_MU_LEN, + ((value != XID_MU_OFF) AND ((value < XID_MU_MIN) OR (value > XID_MU_MAX))), + mu, *(llc_data->mu)); + + /* + * Set mu as valid and store value. + */ + llc_data->decoded_xid.mu.valid = TRUE; + llc_data->decoded_xid.mu.value = (USHORT)value; + TRACE_1_INFO("XID MU:%d", llc_data->decoded_xid.mu.value); + break; + case XID_KD: + CHECK_INSTANCE (kd); + + CHECK_SENSE_OF_NEGOTIATION (*data, kd, XID_SENSE_DOWN); + /*lint -e685 Relational operator always evaluates to false*/ + CHECK_LENGTH_VALUE (XID_KD_LEN, + ((*data < XID_KD_MIN) OR (*data > XID_KD_MAX)), + kd, *(llc_data->kd)); + /*lint +e685 Relational operator always evaluates to false*/ + /* + * Set kd as valid and store value. + */ + llc_data->decoded_xid.kd.valid = TRUE; + llc_data->decoded_xid.kd.value = *data; + TRACE_1_INFO("XID KD:%d", llc_data->decoded_xid.kd.value); + break; + case XID_KU: + CHECK_INSTANCE (ku); + + CHECK_SENSE_OF_NEGOTIATION (*data, ku, XID_SENSE_DOWN); + /*lint -e685 Relational operator always evaluates to false*/ + CHECK_LENGTH_VALUE (XID_KU_LEN, + ((*data < XID_KU_MIN) OR (*data > XID_KU_MAX)), + ku, *(llc_data->ku)); + /*lint +e685 Relational operator always evaluates to false*/ + /* + * Set ku as valid and store value. + */ + llc_data->decoded_xid.ku.valid = TRUE; + llc_data->decoded_xid.ku.value = *data; + TRACE_1_INFO("XID KU:%d", llc_data->decoded_xid.ku.value); + break; + case XID_LAYER_3: + if (llc_data->decoded_l3_xid.valid) + { + /* + * More than one instance of the same XID parameter type is included. + */ + if (cr_bit EQ SGSN_COMMAND) + { + /* + * XID command: Ignore all instances except the first. + * <R.LLC.XIDNEG_R.A.014> + */ + continue; + } + else /* SGSN_RESPONSE */ + { + /* + * XID response: The XID information field is regarded as invalid. + * <R.LLC.XID_INVA.A.012> + */ + TRACE_0_INFO("More than one L3 parameters are included in XID response."); + return FALSE; + } + } + + if ((llc_data->current_sapi NEQ LL_SAPI_3) AND + (llc_data->current_sapi NEQ LL_SAPI_5) AND + (llc_data->current_sapi NEQ LL_SAPI_9) AND + (llc_data->current_sapi NEQ LL_SAPI_11)) + { + /* + * Layer-3 parameters on a SAPI different from 3, 5, 9, and 11. + * <R.LLC.XID_INVA.A.011> + */ + TRACE_0_INFO("L3 parameters on a SAPI different from 3, 5, 9, and 11."); + return FALSE; + } + + /* + * Set layer_3 as valid and store Layer-3 XID parameters. + */ + llc_data->decoded_l3_xid.valid = TRUE; + llc_data->decoded_l3_xid.length = length; + memcpy (llc_data->decoded_l3_xid.value, data, length); + TRACE_1_INFO("XID L3:%d bytes", length); + break; + case XID_RESET: + if (par NEQ &(sdu->buf[sdu->o_buf/8])) + { + /* + * Reset must be the first parameter in the XID information field. + * <R.LLC.XID_INVA.A.004> + */ + TRACE_0_INFO("Reset must be the first XID parameter."); + return FALSE; + } + + if (cr_bit EQ SGSN_COMMAND) + { + if (command EQ U_SABM) + { + /* + * SABM command: Reset is not allowed. + * <R.LLC.XID_INVA.A.003> + */ + TRACE_0_INFO("Reset is not allowed in SABM command"); + return FALSE; + } + } + else /* SGSN_RESPONSE */ + { + /* + * UA/XID response: Reset is not allowed. + * <R.LLC.XID_INVA.A.005> + */ + TRACE_0_INFO("Reset is not allowed in UA/XID response"); + return FALSE; + } + + /* + * Set reset as valid. + */ + llc_data->decoded_xid.reset.valid = TRUE; + TRACE_0_INFO("XID Reset"); + break; + default: + /* + * Unrecognised type field. + */ + if (cr_bit EQ SGSN_COMMAND) + { + /* + * XID command: Skip XID parameter. + * <R.LLC.XIDNEG_R.A.002> + */ + continue; + } + else /* SGSN_RESPONSE */ + { + /* + * XID response: The XID information field is regarded as invalid. + * <R.LLC.XID_INVA.A.006> + */ + TRACE_0_INFO("Unrecognised type field in XID response."); + return FALSE; + } + } + } + + /* + * All XID parameters have been processed, XID information field seems + * to be correct. + */ + return TRUE; +} /* u_check_xid() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : u_eval_xid ++------------------------------------------------------------------------------ +| Description : This procedure evaluates the decoded XID information field in +| llc_decoded_xid (global variable). If Reset is present, the +| state of every incarnation in ABM is set to ADM (including +| the current incarnation!), all LLC layer parameters are set +| to their default values, the OCs for unack. transfer are set +| to 0, and the parameter reset_received is set to TRUE. If a +| command has been received (cr_bit is set to SGSN_COMMAND), +| all XID parameters are evaluated and stored as global values, +| if acceptable. Each XID parameter is tagged in llc_xid_tag +| for the next response. Otherwise (a response has been +| received), store the received parameters as global values +| and reset their valid flags in llc_requested_xid. In each +| case, if N201-I or N201-U have been changed, or if Layer-3 +| XID parameters have been received, set xid_ind to TRUE, +| otherwise to FALSE. Additionally remove any received parameter +| in llc_xid_negotiate, because it has been explicitly +| negotiated by the peer. +| +| Parameters : cr_bit - SGSN_COMMAND/_RESPONSE has been received +| reset_received - TRUE indicates received Reset parameter, +| else FALSE +| xid_ind - TRUE indicates changed N201-U and/or N201-I, +| so that LL_XID_IND must be sent to layer 3 +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_eval_xid (T_BIT cr_bit, + BOOL *reset_received, + BOOL *xid_ind) +{ + UBYTE incarnation; + + + TRACE_FUNCTION ("u_eval_xid"); + + /* + * Preset both indicators with default values. + */ + *reset_received = FALSE; + *xid_ind = FALSE; + + /* + * Preset global XID indicator for next response. + */ + llc_data->u->xid_tag = 0L; + + + /************************************************************************** + * Reset: + * Has to be processed first in order to take effect! + */ + if (llc_data->decoded_xid.reset.valid) + { + /* + * Initialise all LLC layer parameters for all SAPIs. + */ + llc_init_parameters(); + llc_init_requested_xid(); + + /* + * Reset all incarnations of service U that are in state 'ABM' to 'ADM'. + */ + for (incarnation = 0; incarnation < U_NUM_INC; incarnation++) + { + llc_data->u_base[incarnation].state = U_ADM; + } + + /* + * LLC has to be reset. Send SIG_U_LLME_RESET_IND. + */ + *reset_received = TRUE; + } + + + /************************************************************************** + * Version: + * Shall not be negotiated while in state 'ABM'. + * <R.LLC.XID_PAR.A.001> + */ + if ((llc_data->decoded_xid.version.valid) AND (GET_STATE(U) NEQ U_ABM)) + { + if (cr_bit EQ SGSN_COMMAND) + { + if (llc_xid_value_acceptable (llc_data->current_sapi, XID_VERSION, + llc_data->decoded_xid.version.value)) + { + llc_data->version = llc_data->decoded_xid.version.value; + } + else /* value is not acceptable */ + { + /* + * Sense of negotiation down: offer lower value; sense of + * negotiation up: offer higher value. + * This happens automatically by just responding with our current + * global value. + */ + } + + /* + * Tag parameter for next response. + */ + llc_data->u->xid_tag |= 0x00000001L << XID_VERSION; + } + else /* SGSN_RESPONSE */ + { + /* + * Sense of negotiation-correctness of response has already been checked + * in u_check_xid(). + */ + llc_data->version = llc_data->decoded_xid.version.value; + } + + /* + * Remove tag in xid_tag_negotiate, because this parameter has been + * explicitly negotiated by the peer. + * <R.LLC.XIDNEG_R.A.015> + */ + llc_data->u->xid_tag_negotiate &= ~(0x00000001L << XID_VERSION); + } + + + /************************************************************************** + * IOV-UI: + * Shall only be negotiated in state 'ADM'. <R.LLC.XID_PAR.A.002> + */ + if ((llc_data->decoded_xid.iov_ui.valid) AND (GET_STATE(U) NEQ U_ABM) ) + { + /* + * Do not tag iov_ui for the XID response, because it shall only be + * transmitted in downlink direction. + * <R.LLC.XID_PAR.A.004> + */ + + /* + * Copy value to global variable (no sense of negotiation). + */ + llc_data->iov_ui = llc_data->decoded_xid.iov_ui.value; + } + + + /************************************************************************** + * IOV-I: + * Shall only be negotiated with SABM and UA frames. This is already + * checked in u_check_xid(). + * <R.LLC.XID_PAR.A.003>, <R.LLC.XID_INVA.A.010> + */ + if (llc_data->decoded_xid.iov_i.valid) + { + /* + * Do not tag iov_i for the XID response, because it shall only be + * transmitted in downlink direction. + * <R.LLC.XID_PAR.A.004> + */ + + /* + * Copy value to global variable (no sense of negotiation). + */ + *(llc_data->iov_i) = llc_data->decoded_xid.iov_i.value; + } + + + /************************************************************************** + * T200 (and T201): + * Can be negotiated in state 'ADM' and 'ABM'. New values shall only apply + * to timers set after the negotiation has been completed (which is + * accomplished automatically). + * <R.LLC.XID_PAR.A.006>, <R.LLC.XID_PAR.A.007> + */ + if (llc_data->decoded_xid.t200.valid) + { + if (cr_bit EQ SGSN_COMMAND) + { + if (llc_xid_value_acceptable (llc_data->current_sapi, XID_T200, + llc_data->decoded_xid.t200.value)) + { + llc_data->t200->length = XID2INT (llc_data->decoded_xid.t200.value); + } + else /* value is not acceptable */ + { + /* + * Sense of negotiation down: offer lower value; sense of + * negotiation up: offer higher value. + * This happens automatically by just responding with our current + * global value. + */ + } + + /* + * In case we also want to negotiate this value, but to a lower! + * value, delete this parameter from the requested XID structure + */ + if (llc_data->u->requested_xid.t200.valid AND + llc_data->u->requested_xid.t200.value <= llc_data->decoded_xid.t200.value) + { + llc_data->u->requested_xid.t200.valid = FALSE; + } + + /* + * Tag parameter for next response. + */ + llc_data->u->xid_tag |= 0x00000001L << XID_T200; + } + else /* SGSN_RESPONSE */ + { + /* + * Sense of negotiation-correctness of response has already been checked + * in u_check_xid(). + */ + llc_data->t200->length = XID2INT (llc_data->decoded_xid.t200.value); + } + + /* + * Remove tag in xid_tag_negotiate, because this parameter has been + * explicitly negotiated by the peer. + * <R.LLC.XIDNEG_R.A.015> + */ + llc_data->u->xid_tag_negotiate &= ~(0x00000001L << XID_T200); + } + + + /************************************************************************** + * N200: + * Can be negotiated in state 'ADM' and 'ABM'. + * <R.LLC.XID_PAR.A.006> + */ + if (llc_data->decoded_xid.n200.valid) + { + if (cr_bit EQ SGSN_COMMAND) + { + if (llc_xid_value_acceptable (llc_data->current_sapi, XID_N200, + llc_data->decoded_xid.n200.value)) + { + *(llc_data->n200) = llc_data->decoded_xid.n200.value; + } + else /* value is not acceptable */ + { + /* + * Sense of negotiation down: offer lower value; sense of + * negotiation up: offer higher value. + * This happens automatically by just responding with our current + * global value. + */ + } + + /* + * In case we also want to negotiate this value, but to a lower! + * value, delete this parameter from the requested XID structure + */ + if (llc_data->u->requested_xid.n200.valid AND + llc_data->u->requested_xid.n200.value <= llc_data->decoded_xid.n200.value) + { + llc_data->u->requested_xid.n200.valid = FALSE; + } + + /* + * Tag parameter for next response. + */ + llc_data->u->xid_tag |= 0x00000001L << XID_N200; + } + else /* SGSN_RESPONSE */ + { + /* + * Sense of negotiation-correctness of response has already been checked + * in u_check_xid(). + */ + *(llc_data->n200) = llc_data->decoded_xid.n200.value; + } + + /* + * Remove tag in xid_tag_negotiate, because this parameter has been + * explicitly negotiated by the peer. + * <R.LLC.XIDNEG_R.A.015> + */ + llc_data->u->xid_tag_negotiate &= ~(0x00000001L << XID_N200); + } + + + /************************************************************************** + * N201-U: + * Can be negotiated in state 'ADM' and 'ABM'. If N201-U is negotiated to a + * lower value than previously used, then any queued or new U and UI frames + * that violate the new value of N201-U should be discarded and not + * transmitted. + * <R.LLC.XID_PAR.A.006>, <R.LLC.XID_PAR.A.010> + */ + if (llc_data->decoded_xid.n201_u.valid) + { + if (cr_bit EQ SGSN_COMMAND) + { + if (llc_xid_value_acceptable (llc_data->current_sapi, XID_N201_U, + llc_data->decoded_xid.n201_u.value)) + { + if (llc_data->decoded_xid.n201_u.value NEQ *(llc_data->n201_u)) + { + *(llc_data->n201_u) = llc_data->decoded_xid.n201_u.value; + + /* + * LL_XID_IND has to be sent to layer 3. + */ + *xid_ind = TRUE; + } + } + else /* value is not acceptable */ + { + /* + * Sense of negotiation down: offer lower value; sense of + * negotiation up: offer higher value. + * This happens automatically by just responding with our current + * global value. + */ + } + + /* + * In case we also want to negotiate this value, but to a higher + * value, delete this parameter from the requested XID structure + */ + if (llc_data->u->requested_xid.n201_u.valid AND + llc_data->u->requested_xid.n201_u.value >= llc_data->decoded_xid.n201_u.value) + { + llc_data->u->requested_xid.n201_u.valid = FALSE; + } + + /* + * Tag parameter for next response. + */ + llc_data->u->xid_tag |= 0x00000001L << XID_N201_U; + } + else /* SGSN_RESPONSE */ + { + if (llc_data->decoded_xid.n201_u.value NEQ *(llc_data->n201_u)) + { + /* + * Sense of negotiation-correctness of response has already been checked + * in u_check_xid(). + */ + *(llc_data->n201_u) = llc_data->decoded_xid.n201_u.value; + + /* + * LL_XID_IND has to be sent to layer 3. + */ + *xid_ind = TRUE; + } + } + + /* + * Remove tag in xid_tag_negotiate, because this parameter has been + * explicitly negotiated by the peer. + * <R.LLC.XIDNEG_R.A.015> + */ + llc_data->u->xid_tag_negotiate &= ~(0x00000001L << XID_N201_U); + } + + + /************************************************************************** + * N201-I: + * N201-I can be negotiated to any value in state 'ADM'. It can only be + * negotiated to the same or higher value as previously used in state 'ABM'. + * <R.LLC.XID_PAR.A.008>, <R.LLC.XID_PAR.A.009> + */ + if (llc_data->decoded_xid.n201_i.valid) + { + if (cr_bit EQ SGSN_COMMAND) + { + if (llc_xid_value_acceptable (llc_data->current_sapi, XID_N201_I, + llc_data->decoded_xid.n201_i.value)) + { + if (((GET_STATE (U) EQ U_ABM) AND + (llc_data->decoded_xid.n201_i.value > *(llc_data->n201_i))) + OR /* state 'ADM' */ + (llc_data->decoded_xid.n201_i.value NEQ *(llc_data->n201_i))) + { + *(llc_data->n201_i) = llc_data->decoded_xid.n201_i.value; + + /* + * LL_XID_IND has to be sent to layer 3. + */ + *xid_ind = TRUE; + } + } + else /* value is not acceptable */ + { + /* + * Sense of negotiation down: offer lower value; sense of + * negotiation up: offer higher value. + * This happens automatically by just responding with our current + * global value. + */ + } + + /* + * In case we also want to negotiate this value, but to a higher + * value, delete this parameter from the requested XID structure + */ + + if (llc_data->u->requested_xid.n201_i.valid AND + llc_data->u->requested_xid.n201_i.value >= llc_data->decoded_xid.n201_i.value) + { + llc_data->u->requested_xid.n201_i.valid = FALSE; + } + + /* + * Tag parameter for next response. + */ + llc_data->u->xid_tag |= 0x00000001L << XID_N201_I; + } + else /* SGSN_RESPONSE */ + { + /* + * Sense of negotiation-correctness of response has already been checked + * in u_check_xid(). + */ + if (((GET_STATE (U) EQ U_ABM) AND + (llc_data->decoded_xid.n201_i.value > *(llc_data->n201_i))) + OR /* state 'ADM' */ + (llc_data->decoded_xid.n201_i.value NEQ *(llc_data->n201_i))) + { + *(llc_data->n201_i) = llc_data->decoded_xid.n201_i.value; + + /* + * LL_XID_IND has to be sent to layer 3. + */ + *xid_ind = TRUE; + } + } + + /* + * Remove tag in xid_tag_negotiate, because this parameter has been + * explicitly negotiated by the peer. + * <R.LLC.XIDNEG_R.A.015> + */ + llc_data->u->xid_tag_negotiate &= ~(0x00000001L << XID_N201_I); + } + + + /************************************************************************** + * mD: + * mD can be negotiated to any value in state 'ADM'. It can only be + * negotiated to the same or higher value as previously used in state 'ABM'. + * <R.LLC.XID_PAR.A.008>, <R.LLC.XID_PAR.A.009> + */ + if (llc_data->decoded_xid.md.valid) + { + if (cr_bit EQ SGSN_COMMAND) + { + if (llc_xid_value_acceptable (llc_data->current_sapi, XID_MD, + llc_data->decoded_xid.md.value)) + { + if (((GET_STATE (U) EQ U_ABM) AND + (llc_data->decoded_xid.md.value > *(llc_data->md))) + OR /* state 'ADM' */ + (llc_data->decoded_xid.md.value NEQ *(llc_data->md))) + { + *(llc_data->md) = llc_data->decoded_xid.md.value; + } + } + else /* value is not acceptable */ + { + /* + * Sense of negotiation down: offer lower value; sense of + * negotiation up: offer higher value. + * This happens automatically by just responding with our current + * global value. + */ + } + + /* + * In case we also want to negotiate this value, but to a higher + * value, delete this parameter from the requested XID structure + */ + if (llc_data->u->requested_xid.md.valid AND + llc_data->u->requested_xid.md.value >= llc_data->decoded_xid.md.value) + { + llc_data->u->requested_xid.md.valid = FALSE; + } + + /* + * Tag parameter for next response. + */ + llc_data->u->xid_tag |= 0x00000001L << XID_MD; + } + else /* SGSN_RESPONSE */ + { + /* + * Sense of negotiation-correctness of response has already been checked + * in u_check_xid(). + */ + if (((GET_STATE (U) EQ U_ABM) AND + (llc_data->decoded_xid.md.value > *(llc_data->md))) + OR /* state 'ADM' */ + (llc_data->decoded_xid.md.value NEQ *(llc_data->md))) + { + *(llc_data->md) = llc_data->decoded_xid.md.value; + } + } + + /* + * Remove tag in xid_tag_negotiate, because this parameter has been + * explicitly negotiated by the peer. + * <R.LLC.XIDNEG_R.A.015> + */ + llc_data->u->xid_tag_negotiate &= ~(0x00000001L << XID_MD); + } + + + /************************************************************************** + * mU: + * mU can be negotiated to any value in state 'ADM'. It can only be + * negotiated to the same or higher value as previously used in state 'ABM'. + * <R.LLC.XID_PAR.A.008>, <R.LLC.XID_PAR.A.009> + */ + if (llc_data->decoded_xid.mu.valid) + { + if (cr_bit EQ SGSN_COMMAND) + { + if (llc_xid_value_acceptable (llc_data->current_sapi, XID_MU, + llc_data->decoded_xid.mu.value)) + { + if (((GET_STATE (U) EQ U_ABM) AND + (llc_data->decoded_xid.mu.value > *(llc_data->mu))) + OR /* state 'ADM' */ + (llc_data->decoded_xid.mu.value NEQ *(llc_data->mu))) + { + *(llc_data->mu) = llc_data->decoded_xid.mu.value; + } + } + else /* value is not acceptable */ + { + /* + * Sense of negotiation down: offer lower value; sense of + * negotiation up: offer higher value. + * This happens automatically by just responding with our current + * global value. + */ + } + + /* + * In case we also want to negotiate this value, but to a higher + * value, delete this parameter from the requested XID structure + */ + if (llc_data->u->requested_xid.mu.valid AND + llc_data->u->requested_xid.mu.value >= llc_data->decoded_xid.mu.value) + { + llc_data->u->requested_xid.mu.valid = FALSE; + } + + /* + * Tag parameter for next response. + */ + llc_data->u->xid_tag |= 0x00000001L << XID_MU; + } + else /* SGSN_RESPONSE */ + { + /* + * Sense of negotiation-correctness of response has already been checked + * in u_check_xid(). + */ + if (((GET_STATE (U) EQ U_ABM) AND + (llc_data->decoded_xid.mu.value > *(llc_data->mu))) + OR /* state 'ADM' */ + (llc_data->decoded_xid.mu.value NEQ *(llc_data->mu))) + { + *(llc_data->mu) = llc_data->decoded_xid.mu.value; + } + } + + /* + * Remove tag in xid_tag_negotiate, because this parameter has been + * explicitly negotiated by the peer. + * <R.LLC.XIDNEG_R.A.015> + */ + llc_data->u->xid_tag_negotiate &= ~(0x00000001L << XID_MU); + } + + + /************************************************************************** + * kD: + * kD can be negotiated to any value in state 'ADM'. It can only be + * negotiated to the same or higher value as previously used in state 'ABM'. + * <R.LLC.XID_PAR.A.008>, <R.LLC.XID_PAR.A.009> + */ + if (llc_data->decoded_xid.kd.valid) + { + if (cr_bit EQ SGSN_COMMAND) + { + if (llc_xid_value_acceptable (llc_data->current_sapi, XID_KD, + llc_data->decoded_xid.kd.value)) + { + if (((GET_STATE (U) EQ U_ABM) AND + (llc_data->decoded_xid.kd.value > *(llc_data->kd))) + OR /* state 'ADM' */ + (llc_data->decoded_xid.kd.value NEQ *(llc_data->kd))) + { + *(llc_data->kd) = llc_data->decoded_xid.kd.value; + } + } + else /* value is not acceptable */ + { + /* + * Sense of negotiation down: offer lower value; sense of + * negotiation up: offer higher value. + * This happens automatically by just responding with our current + * global value. + */ + } + + /* + * In case we also want to negotiate this value, but to a higher + * value, delete this parameter from the requested XID structure + */ + if (llc_data->u->requested_xid.kd.valid AND + llc_data->u->requested_xid.kd.value >= llc_data->decoded_xid.kd.value) + { + llc_data->u->requested_xid.kd.valid = FALSE; + } + + /* + * Tag parameter for next response. + */ + llc_data->u->xid_tag |= 0x00000001L << XID_KD; + } + else /* SGSN_RESPONSE */ + { + /* + * Sense of negotiation-correctness of response has already been checked + * in u_check_xid(). + */ + if (((GET_STATE (U) EQ U_ABM) AND + (llc_data->decoded_xid.kd.value > *(llc_data->kd))) + OR /* state 'ADM' */ + (llc_data->decoded_xid.kd.value NEQ *(llc_data->kd))) + { + *(llc_data->kd) = llc_data->decoded_xid.kd.value; + } + } + + /* + * Remove tag in xid_tag_negotiate, because this parameter has been + * explicitly negotiated by the peer. + * <R.LLC.XIDNEG_R.A.015> + */ + llc_data->u->xid_tag_negotiate &= ~(0x00000001L << XID_KD); + } + + + /************************************************************************** + * kU: + * kU can be negotiated to any value in state 'ADM'. It can only be + * negotiated to the same or higher value as previously used in state 'ABM'. + * <R.LLC.XID_PAR.A.008>, <R.LLC.XID_PAR.A.009> + */ + if (llc_data->decoded_xid.ku.valid) + { + if (cr_bit EQ SGSN_COMMAND) + { + if (llc_xid_value_acceptable (llc_data->current_sapi, XID_KU, + llc_data->decoded_xid.ku.value)) + { + if (((GET_STATE (U) EQ U_ABM) AND + (llc_data->decoded_xid.ku.value > *(llc_data->ku))) + OR /* state 'ADM' */ + (llc_data->decoded_xid.ku.value NEQ *(llc_data->ku))) + { + *(llc_data->ku) = llc_data->decoded_xid.ku.value; + } + } + else /* value is not acceptable */ + { + /* + * Sense of negotiation down: offer lower value; sense of + * negotiation up: offer higher value. + * This happens automatically by just responding with our current + * global value. + */ + } + + /* + * In case we also want to negotiate this value, but to a higher + * value, delete this parameter from the requested XID structure + */ + if (llc_data->u->requested_xid.ku.valid AND + llc_data->u->requested_xid.ku.value >= llc_data->decoded_xid.ku.value) + { + llc_data->u->requested_xid.ku.valid = FALSE; + } + + /* + * Tag parameter for next response. + */ + llc_data->u->xid_tag |= 0x00000001L << XID_KU; + } + else /* SGSN_RESPONSE */ + { + /* + * Sense of negotiation-correctness of response has already been checked + * in u_check_xid(). + */ + if (((GET_STATE (U) EQ U_ABM) AND + (llc_data->decoded_xid.ku.value > *(llc_data->ku))) + OR /* state 'ADM' */ + (llc_data->decoded_xid.ku.value NEQ *(llc_data->ku))) + { + *(llc_data->ku) = llc_data->decoded_xid.ku.value; + } + } + + /* + * Remove tag in xid_tag_negotiate, because this parameter has been + * explicitly negotiated by the peer. + * <R.LLC.XIDNEG_R.A.015> + */ + llc_data->u->xid_tag_negotiate &= ~(0x00000001L << XID_KU); + } + + + /************************************************************************** + * Layer 3 stuff + */ + if (llc_data->decoded_l3_xid.valid) + { + /* + * LL_XID_IND has to be sent to layer 3. + */ + *xid_ind = TRUE; + + if (cr_bit EQ SGSN_COMMAND) + { + /* + * Tag parameter for next response. + */ + llc_data->u->xid_tag |= 0x00000001L << XID_LAYER_3; + } + else /* SGSN_RESPONSE */ + { + /* + * Reset valid flag of parameter in requested_xid because it has been + * included in the response. + */ + llc_data->requested_l3_xid->valid = FALSE; + } + + /* + * Remove tag in xid_tag_negotiate, because this parameter has been + * explicitly negotiated by the peer. + * <R.LLC.XIDNEG_R.A.015> + */ + llc_data->u->xid_tag_negotiate &= ~(0x00000001L << XID_LAYER_3); + } + + return; /* u_eval_xid */ +} + + +/* ++------------------------------------------------------------------------------ +| Function : u_insert_xid ++------------------------------------------------------------------------------ +| Description : This procedure inserts (i.e. appends) the XID parameters that +| are tagged in llc_xid_tag. This variable is normally set in +| u_eval_xid(). The parameter cr_bit indicates if the XID +| information field is written in a command or a response frame. +| The values of the parameters are taken from llc_requested_xid +| if marked as valid (normally the cause when a command frame is +| to be sent), otherwise from global variables (the normal cause +| for a response frame). If a response frame is to be sent, and +| the parameter is tagged in llc_xid_tag, but has not been +| received in the command frame (as indicated by +| llc_decoded_xid), the parameter is tagged in llc_xid_negotiate. +| Each parameter is tagged in llc_xid_tag_sent for collision +| checks and the like +| +| Parameters : sdu - a valid pointer to an SDU, containing enough octets +| for the tagged number of XID parameters +| cr_bit - MS_COMMAND/_RESPONSE is to be sent +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_insert_xid +( +#ifdef LL_DESC + T_desc_list3 *desc_list3, +#else + T_sdu *sdu, +#endif + T_BIT cr_bit +) +{ + UBYTE *data; + ULONG value; +#ifdef LL_DESC + UBYTE *desc_buf; + T_desc3 *desc3; +#endif + TRACE_FUNCTION( "u_insert_xid" ); + + /* + * Set data to point to the first free data octet in sdu. data has to + * be incremented with each octet that is written in sdu to ensure that + * it always points to the first free data octet. + */ +#ifdef LL_DESC + desc3 = (T_desc3*) desc_list3->first; + desc_buf = (UBYTE*)desc3->buffer; + data = &desc_buf[(desc3->offset)+(desc3->len)]; +#else + data = &sdu->buf[(sdu->o_buf/8)+(sdu->l_buf/8)]; +#endif + /* + * Preset global XID sent indicator for next response. + */ + llc_data->u->xid_tag_sent = 0L; + + + /************************************************************************* + * Version: + * Shall not be negotiated while in state 'ABM'. + * <R.LLC.XID_PAR.A.001> + */ + if (llc_data->u->xid_tag & (0x00000001L << XID_VERSION) AND + (GET_STATE (U) NEQ U_ABM)) + { + if (cr_bit EQ MS_COMMAND) + { + value = llc_data->u->requested_xid.version.value; + } + else + { + if (llc_data->u->requested_xid.version.valid) + { + llc_data->version = llc_data->u->requested_xid.version.value; + } + + value = llc_data->version; + + /* + * Tag a parameter for further negotiation that was not included in + * the XID command in every XID response until the parameter has been + * explicitly negotiated, either by responding to an XID command that + * included the parameter, or by explicitly including the parameter + * the next time an XID command is transmitted. + * <R.LLC.XIDNEG_R.A.015> + */ + if (!llc_data->decoded_xid.version.valid) + { + llc_data->u->xid_tag_negotiate |= 0x00000001L << XID_VERSION; + } + } + + /* + * Append determined value to SDU data, increment SDU data pointer to + * point to the first free data octet again. + */ + *data++ = (UBYTE)0x00 | ((UBYTE)XID_VERSION << 2) | (UBYTE)XID_VERSION_LEN; + *data++ = (UBYTE)value; + +#ifdef LL_DESC + desc3->len += (XID_VERSION_LEN + 1); +#else + sdu->l_buf += (XID_VERSION_LEN + 1) * 8; +#endif + /* + * Tag parameter for collision checks and the like. + */ + llc_data->u->xid_tag_sent |= 0x00000001L << XID_VERSION; + } + + /************************************************************************* + * T200: + * Can be negotiated in state 'ADM' and 'ABM'. + * <R.LLC.XID_PAR.A.006> + */ + if (llc_data->u->xid_tag & (0x00000001L << XID_T200)) + { + if (cr_bit EQ MS_COMMAND) + { + value = llc_data->u->requested_xid.t200.value; + } + else + { + if (llc_data->u->requested_xid.t200.valid) + { + llc_data->t200->length = XID2INT(llc_data->u->requested_xid.t200.value); + } + + value = INT2XID(llc_data->t200->length); + + /* + * Tag a parameter for further negotiation that was not included in + * the XID command in every XID response until the parameter has been + * explicitly negotiated, either by responding to an XID command that + * included the parameter, or by explicitly including the parameter + * the next time an XID command is transmitted. + * <R.LLC.XIDNEG_R.A.015> + */ + if (!llc_data->decoded_xid.t200.valid) + { + llc_data->u->xid_tag_negotiate |= 0x00000001L << XID_T200; + } + } + + /* + * Append determined value to SDU data, increment SDU data pointer to + * point to the first free data octet again. + */ + *data++ = (UBYTE)0x00 | ((UBYTE)XID_T200 << 2) | (UBYTE)XID_T200_LEN; + *data++ = (UBYTE)(value >> 8); + *data++ = (UBYTE)value; + +#ifdef LL_DESC + desc3->len += (XID_T200_LEN + 1); +#else + sdu->l_buf += (XID_T200_LEN + 1) * 8; +#endif + + /* + * Tag parameter for collision checks and the like. + */ + llc_data->u->xid_tag_sent |= 0x00000001L << XID_T200; + } + + /************************************************************************* + * N200: + * Can be negotiated in state 'ADM' and 'ABM'. + * <R.LLC.XID_PAR.A.006> + */ + if (llc_data->u->xid_tag & (0x00000001L << XID_N200)) + { + if (cr_bit EQ MS_COMMAND) + { + value = llc_data->u->requested_xid.n200.value; + } + else + { + if (llc_data->u->requested_xid.n200.valid) + { + *(llc_data->n200) = llc_data->u->requested_xid.n200.value; + } + + value = *(llc_data->n200); + + /* + * Tag a parameter for further negotiation that was not included in + * the XID command in every XID response until the parameter has been + * explicitly negotiated, either by responding to an XID command that + * included the parameter, or by explicitly including the parameter + * the next time an XID command is transmitted. + * <R.LLC.XIDNEG_R.A.015> + */ + if (!llc_data->decoded_xid.n200.valid) + { + llc_data->u->xid_tag_negotiate |= 0x00000001L << XID_N200; + } + } + + /* + * Append determined value to SDU data, increment SDU data pointer to + * point to the first free data octet again. + */ + *data++ = (UBYTE)0x00 | ((UBYTE)XID_N200 << 2) | (UBYTE)XID_N200_LEN; + *data++ = (UBYTE)value; + +#ifdef LL_DESC + desc3->len += (XID_N200_LEN + 1); +#else + sdu->l_buf += (XID_N200_LEN + 1) * 8; +#endif + + /* + * Tag parameter for collision checks and the like. + */ + llc_data->u->xid_tag_sent |= 0x00000001L << XID_N200; + } + + /************************************************************************* + * N201-U: + * Can be negotiated in state 'ADM' and 'ABM'. + * <R.LLC.XID_PAR.A.006> + */ + if (llc_data->u->xid_tag & (0x00000001L << XID_N201_U)) + { + if (cr_bit EQ MS_COMMAND) + { + value = llc_data->u->requested_xid.n201_u.value; + } + else + { + if (llc_data->u->requested_xid.n201_u.valid) + { + *(llc_data->n201_u) = llc_data->u->requested_xid.n201_u.value; + } + + value = *(llc_data->n201_u); + + /* + * Tag a parameter for further negotiation that was not included in + * the XID command in every XID response until the parameter has been + * explicitly negotiated, either by responding to an XID command that + * included the parameter, or by explicitly including the parameter + * the next time an XID command is transmitted. + * <R.LLC.XIDNEG_R.A.015> + */ + if (!llc_data->decoded_xid.n201_u.valid) + { + llc_data->u->xid_tag_negotiate |= 0x00000001L << XID_N201_U; + } + } + + /* + * Append determined value to SDU data, increment SDU data pointer to + * point to the first free data octet again. + */ + *data++ = (UBYTE)0x00 | ((UBYTE)XID_N201_U << 2) | (UBYTE)XID_N201_U_LEN; + *data++ = (UBYTE)(value >> 8); + *data++ = (UBYTE)value; + +#ifdef LL_DESC + desc3->len += (XID_N201_U_LEN + 1); +#else + sdu->l_buf += (XID_N201_U_LEN + 1) * 8; +#endif + + /* + * Tag parameter for collision checks and the like. + */ + llc_data->u->xid_tag_sent |= 0x00000001L << XID_N201_U; + } + + /************************************************************************* + * N201-I: + * Can be negotiated in state 'ADM' and 'ABM'. + * <R.LLC.XID_PAR.A.006> + */ + if (llc_data->u->xid_tag & (0x00000001L << XID_N201_I)) + { + if (cr_bit EQ MS_COMMAND) + { + value = llc_data->u->requested_xid.n201_i.value; + } + else + { + if (llc_data->u->requested_xid.n201_i.valid) + { + *(llc_data->n201_i) = llc_data->u->requested_xid.n201_i.value; + } + + value = *(llc_data->n201_i); + + /* + * Tag a parameter for further negotiation that was not included in + * the XID command in every XID response until the parameter has been + * explicitly negotiated, either by responding to an XID command that + * included the parameter, or by explicitly including the parameter + * the next time an XID command is transmitted. + * <R.LLC.XIDNEG_R.A.015> + */ + if (!llc_data->decoded_xid.n201_i.valid) + { + llc_data->u->xid_tag_negotiate |= 0x00000001L << XID_N201_I; + } + } + + /* + * Append determined value to SDU data, increment SDU data pointer to + * point to the first free data octet again. + */ + *data++ = (UBYTE)0x00 | ((UBYTE)XID_N201_I << 2) | (UBYTE)XID_N201_I_LEN; + *data++ = (UBYTE)(value >> 8); + *data++ = (UBYTE)value; + +#ifdef LL_DESC + desc3->len += (XID_N201_I_LEN + 1); +#else + sdu->l_buf += (XID_N201_I_LEN + 1) * 8; +#endif + + /* + * Tag parameter for collision checks and the like. + */ + llc_data->u->xid_tag_sent |= 0x00000001L << XID_N201_I; + } + + /************************************************************************* + * md: + * Can be negotiated in state 'ADM' and 'ABM'. + * <R.LLC.XID_PAR.A.006> + */ + if (llc_data->u->xid_tag & (0x00000001L << XID_MD)) + { + if (cr_bit EQ MS_COMMAND) + { + value = llc_data->u->requested_xid.md.value; + } + else + { + if (llc_data->u->requested_xid.md.valid) + { + *(llc_data->md) = llc_data->u->requested_xid.md.value; + } + + value = *(llc_data->md); + + /* + * Tag a parameter for further negotiation that was not included in + * the XID command in every XID response until the parameter has been + * explicitly negotiated, either by responding to an XID command that + * included the parameter, or by explicitly including the parameter + * the next time an XID command is transmitted. + * <R.LLC.XIDNEG_R.A.015> + */ + if (!llc_data->decoded_xid.md.valid) + { + llc_data->u->xid_tag_negotiate |= 0x00000001L << XID_MD; + } + } + + /* + * Append determined value to SDU data, increment SDU data pointer to + * point to the first free data octet again. + */ + *data++ = (UBYTE)0x00 | ((UBYTE)XID_MD << 2) | (UBYTE)XID_MD_LEN; + *data++ = (UBYTE)(value >> 8); + *data++ = (UBYTE)value; + +#ifdef LL_DESC + desc3->len += (XID_MD_LEN + 1); +#else + sdu->l_buf += (XID_MD_LEN + 1) * 8; +#endif + + /* + * Tag parameter for collision checks and the like. + */ + llc_data->u->xid_tag_sent |= 0x00000001L << XID_MD; + } + + /************************************************************************* + * mu: + * Can be negotiated in state 'ADM' and 'ABM'. + * <R.LLC.XID_PAR.A.006> + */ + if (llc_data->u->xid_tag & (0x00000001L << XID_MU)) + { + if (cr_bit EQ MS_COMMAND) + { + value = llc_data->u->requested_xid.mu.value; + } + else + { + if (llc_data->u->requested_xid.mu.valid) + { + *(llc_data->mu) = llc_data->u->requested_xid.mu.value; + } + + value = *(llc_data->mu); + + /* + * Tag a parameter for further negotiation that was not included in + * the XID command in every XID response until the parameter has been + * explicitly negotiated, either by responding to an XID command that + * included the parameter, or by explicitly including the parameter + * the next time an XID command is transmitted. + * <R.LLC.XIDNEG_R.A.015> + */ + if (!llc_data->decoded_xid.mu.valid) + { + llc_data->u->xid_tag_negotiate |= 0x00000001L << XID_MU; + } + } + + /* + * Append determined value to SDU data, increment SDU data pointer to + * point to the first free data octet again. + */ + *data++ = (UBYTE)0x00 | ((UBYTE)XID_MU << 2) | (UBYTE)XID_MU_LEN; + *data++ = (UBYTE)(value >> 8); + *data++ = (UBYTE)value; + +#ifdef LL_DESC + desc3->len += (XID_MU_LEN + 1); +#else + sdu->l_buf += (XID_MU_LEN + 1) * 8; +#endif + + /* + * Tag parameter for collision checks and the like. + */ + llc_data->u->xid_tag_sent |= 0x00000001L << XID_MU; + } + + /************************************************************************* + * kd: + * Can be negotiated in state 'ADM' and 'ABM'. + * <R.LLC.XID_PAR.A.006> + */ + if (llc_data->u->xid_tag & (0x00000001L << XID_KD)) + { + if (cr_bit EQ MS_COMMAND) + { + value = llc_data->u->requested_xid.kd.value; + } + else + { + if (llc_data->u->requested_xid.kd.valid) + { + *(llc_data->kd) = llc_data->u->requested_xid.kd.value; + } + + value = *(llc_data->kd); + + /* + * Tag a parameter for further negotiation that was not included in + * the XID command in every XID response until the parameter has been + * explicitly negotiated, either by responding to an XID command that + * included the parameter, or by explicitly including the parameter + * the next time an XID command is transmitted. + * <R.LLC.XIDNEG_R.A.015> + */ + if (!llc_data->decoded_xid.kd.valid) + { + llc_data->u->xid_tag_negotiate |= 0x00000001L << XID_KD; + } + } + + /* + * Append determined value to SDU data, increment SDU data pointer to + * point to the first free data octet again. + */ + *data++ = (UBYTE)0x00 | ((UBYTE)XID_KD << 2) | (UBYTE)XID_KD_LEN; + *data++ = (UBYTE)value; + +#ifdef LL_DESC + desc3->len += (XID_KD_LEN + 1); +#else + sdu->l_buf += (XID_KD_LEN + 1) * 8; +#endif + + /* + * Tag parameter for collision checks and the like. + */ + llc_data->u->xid_tag_sent |= 0x00000001L << XID_KD; + } + + /************************************************************************* + * ku: + * Can be negotiated in state 'ADM' and 'ABM'. + * <R.LLC.XID_PAR.A.006> + */ + if (llc_data->u->xid_tag & (0x00000001L << XID_KU)) + { + if (cr_bit EQ MS_COMMAND) + { + value = llc_data->u->requested_xid.ku.value; + } + else + { + if (llc_data->u->requested_xid.ku.valid) + { + *(llc_data->ku) = llc_data->u->requested_xid.ku.value; + } + + value = *(llc_data->ku); + + /* + * Tag a parameter for further negotiation that was not included in + * the XID command in every XID response until the parameter has been + * explicitly negotiated, either by responding to an XID command that + * included the parameter, or by explicitly including the parameter + * the next time an XID command is transmitted. + * <R.LLC.XIDNEG_R.A.015> + */ + if (!llc_data->decoded_xid.ku.valid) + { + llc_data->u->xid_tag_negotiate |= 0x00000001L << XID_KU; + } + } + + /* + * Append determined value to SDU data, increment SDU data pointer to + * point to the first free data octet again. + */ + *data++ = (UBYTE)0x00 | ((UBYTE)XID_KU << 2) | (UBYTE)XID_KU_LEN; + *data++ = (UBYTE)value; + +#ifdef LL_DESC + desc3->len += (XID_KU_LEN + 1); +#else + sdu->l_buf += (XID_KU_LEN + 1) * 8; +#endif + + /* + * Tag parameter for collision checks and the like. + */ + llc_data->u->xid_tag_sent |= 0x00000001L << XID_KU; + } + + /************************************************************************* + * Insert Layer 3 (sense of negotiation: both) + */ + if (llc_data->u->xid_tag & (0x00000001L << XID_LAYER_3)) + { + if (llc_data->requested_l3_xid->valid) + { + /* + * Write two bytes header + */ + *data++ = (UBYTE)0x80 /* = set length to 8 bit */ | ((UBYTE)XID_LAYER_3 << 2) + | ((UBYTE)((llc_data->requested_l3_xid->length >> 6) & 0x03)); + *data++ = (UBYTE)(llc_data->requested_l3_xid->length << 2); + + /* + * Copy data + */ + memcpy (data, llc_data->requested_l3_xid->value, + llc_data->requested_l3_xid->length); + + /* + * Increase DESC/SDU size + */ +#ifdef LL_DESC + desc3->len += (llc_data->requested_l3_xid->length + 2); +#else + sdu->l_buf += (llc_data->requested_l3_xid->length + 2) * 8; +#endif + /* + * Tag parameter for collision checks and the like. + */ + llc_data->u->xid_tag_sent |= 0x00000001L << XID_LAYER_3; + } + } + +#ifdef LL_DESC + desc_list3->list_len = desc3->len; +#endif /* LL_DESC */ + +#ifdef TRACE_EVE +#ifdef LL_DESC + { + int i; + int l = desc3->len; + int o = desc3->offset; + + vsi_o_ttrace(VSI_CALLER TC_EVENT, "ul XID sdu dump len:%d bytes", l); + + for (i=0; i<l; i+=10) + { + vsi_o_ttrace(VSI_CALLER TC_EVENT, "%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x", + desc_buf[o+i+0], desc_buf[o+i+1], + desc_buf[o+i+2], desc_buf[o+i+3], desc_buf[o+i+4], + + desc_buf[o+i+5], desc_buf[o+i+6], + desc_buf[o+i+7], desc_buf[o+i+8], desc_buf[o+i+9]); + } + } + +#else + { + int i; + int l = sdu->l_buf/8; + int o = sdu->o_buf/8; + + vsi_o_ttrace(VSI_CALLER TC_EVENT, "ul XID sdu dump len:%d bytes", l); + + for (i=0; i<l; i+=10) + { + vsi_o_ttrace(VSI_CALLER TC_EVENT, "%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x", + sdu->buf[o+i+0], sdu->buf[o+i+1], + sdu->buf[o+i+2], sdu->buf[o+i+3], sdu->buf[o+i+4], + + sdu->buf[o+i+5], sdu->buf[o+i+6], + sdu->buf[o+i+7], sdu->buf[o+i+8], sdu->buf[o+i+9]); + } + } + +#endif /* LL_DESC */ +#endif /* TRACE_EVE */ + /* + * If we have build an response including all XID parameters, + * we can clean all the xid_tags and layer 3 parameters. + */ + if (cr_bit EQ MS_RESPONSE) + { + llc_data->u->xid_tag = 0; + llc_data->requested_l3_xid->valid = FALSE; + } + + return; +} /* u_insert_xid() */ + + +/* ++------------------------------------------------------------------------------ +| Function : u_insert_frmr_information ++------------------------------------------------------------------------------ +| Description : This procedure inserts (i.e. appends) an FRMR information +| field into the given sdu. frame is the rejected frame of which +| the control field is included (ctrl_length is truncated to a +| maximum of six octets; if it is not known, length is +| determinated from pdu_type), v_s and v_r are the current +| send and receive state numbers of ITX/IRX, cr_bit indicates +| if the frame was a command or response (SGSN_COMMAND/RESPONSE), +| and reason indicates the reason of the frame rejection +| condition (the lower nibble of reason is equivalent to W4-W1). +| +| Parameters : sdu - a valid pointer to an SDU, containing enough +| octets for the FRMR information field +| (U_FRMR_INFO_SIZE) +| frame - frame that caused the frame rejection condition +| pdu_type - frame type +| ctrl_length - control field length, if known +| v_s - current V(S) +| v_r - current V(R) +| cr_bit - setting of C/R bit in frame +| reason - reason of the frame rejection condition (lower +| nibble conforms to W4-W1 in FRMR response) +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_insert_frmr_information +( +#ifndef LL_DESC + T_sdu *sdu, +#else + T_desc_list3 *desc_list3, +#endif + T_LL_UNITDATA_IND *frame, + T_PDU_TYPE pdu_type, + USHORT ctrl_length, + T_FRAME_NUM v_s, + T_FRAME_NUM v_r, + T_BIT cr_bit, + UBYTE reason +) +{ + +#ifndef LL_DESC + UBYTE *sdu_data; +#else + UBYTE *help, *desc_data; + T_desc3 *desc3; +#endif + UBYTE *ctrl; + USHORT octet; + + + TRACE_FUNCTION( "u_insert_frmr_information" ); + +#ifndef LL_DESC + /* + * Set sdu_data to point to the first free data octet in sdu. sdu_data + * has to be incremented with each octet that is written in sdu to ensure + * that it always points to the first free data octet. + */ + sdu_data = &sdu->buf[(sdu->o_buf/8)+(sdu->l_buf/8)]; + + /* + * Adjust length of SDU to include fixed sized FRMR information field. + */ + sdu->l_buf += U_FRMR_INFO_SIZE * 8; + + /* + * Set ctrl to point to the first octet of the faulty frame control field. + */ + ctrl = &frame->sdu.buf[(frame->sdu.o_buf/8)+1]; + + /* + * If ctrl_length is unknown, the frame type is known, therefore the length + * of the control field can be easily determined. + */ + if (ctrl_length EQ FRMR_CTRL_LENGTH_UNKNOWN) + { + if (pdu_type EQ I_FRAME) + { + ctrl_length = I_CTRL_OCTETS; + } + else if (pdu_type EQ S_FRAME) + { + ctrl_length = S_CTRL_OCTETS; + } + else if (pdu_type EQ UI_FRAME) + { + ctrl_length = UI_CTRL_OCTETS; + } + else if (pdu_type EQ U_FRAME) + { + ctrl_length = U_CTRL_OCTETS; + } + else + { + /* + * Undefined control field type, set control field length to SDU length + * minus address field, limited to six octets. + */ + TRACE_ERROR ("undefined control field type"); + ctrl_length = (sdu->l_buf/8 - 1) < 6 ? (sdu->l_buf/8 - 1) : 6; + } + } + else /* ctrl_length is already known */ + { + /* + * Limit control field length to six octets, according to 04.64. + */ + ctrl_length = ctrl_length < 6 ? ctrl_length : 6; + } + + + /* + * Copy the first six octets of faulty control field. If the control field + * is smaller that six octets, the unused octets are set to 0. + */ + for (octet = 0; octet < 6; octet++) + { + if (octet < ctrl_length) + { + sdu_data[octet] = ctrl[octet]; + } + else + { + sdu_data[octet] = 0x00; + } + } + + + /* + * Insert remaining four octets of FRMR information field: + * +---+---+---+---+---+---+---+---+ + * | X | X | X | X | V(S) | + * +---+---+---+---+---+---+---+---+ + * | V(S) | X | V(R) | + * +---+---+---+---+---+---+---+---+ + * | V(R) |C/R| + * +---+---+---+---+---+---+---+---+ + * | X | X | X | X | W4| W3| W2| W1| + * +---+---+---+---+---+---+---+---+ + */ + sdu_data[octet++] = (UBYTE)(v_s >> 5) & 0x0F; + sdu_data[octet++] = (UBYTE)(v_s << 3) | ((UBYTE)(v_r >> 7) & 0x0003); + sdu_data[octet++] = (UBYTE)(v_r << 1) | (cr_bit EQ SGSN_COMMAND ? + 0x00 : 0x01); + sdu_data[octet++] = reason & 0x0F; + + return; +#else + /* + * Set sdu_data to point to the first free data octet in sdu. sdu_data + * has to be incremented with each octet that is written in sdu to ensure + * that it always points to the first free data octet. + */ + desc3 = (T_desc3*)desc_list3->first; + + help = (U8*)desc3->buffer; + desc_data = &help[desc3->offset + desc3->len]; + + /* + * Adjust length of SDU to include fixed sized FRMR information field. + */ + desc3->len += U_FRMR_INFO_SIZE; + desc_list3->list_len += U_FRMR_INFO_SIZE; + + /* + * Set ctrl to point to the first octet of the faulty frame control field. + */ + ctrl = &frame->sdu.buf[(frame->sdu.o_buf/8)+1]; + + /* + * If ctrl_length is unknown, the frame type is known, therefore the length + * of the control field can be easily determined. + */ + if (ctrl_length EQ FRMR_CTRL_LENGTH_UNKNOWN) + { + if (pdu_type EQ I_FRAME) + { + ctrl_length = I_CTRL_OCTETS; + } + else if (pdu_type EQ S_FRAME) + { + ctrl_length = S_CTRL_OCTETS; + } + else if (pdu_type EQ UI_FRAME) + { + ctrl_length = UI_CTRL_OCTETS; + } + else if (pdu_type EQ U_FRAME) + { + ctrl_length = U_CTRL_OCTETS; + } + else + { + /* + * Undefined control field type, set control field length to SDU length + * minus address field, limited to six octets. + */ + TRACE_ERROR ("undefined control field type"); + ctrl_length = desc3->len - 1 < 6 ? (desc3->len - 1) : 6; + } + } + else /* ctrl_length is already known */ + { + /* + * Limit control field length to six octets, according to 04.64. + */ + ctrl_length = ctrl_length < 6 ? ctrl_length : 6; + } + + + /* + * Copy the first six octets of faulty control field. If the control field + * is smaller that six octets, the unused octets are set to 0. + */ + for (octet = 0; octet < 6; octet++) + { + if (octet < ctrl_length) + { + desc_data[octet] = ctrl[octet]; + } + else + { + desc_data[octet] = 0x00; + } + } + + + /* + * Insert remaining four octets of FRMR information field: + * +---+---+---+---+---+---+---+---+ + * | X | X | X | X | V(S) | + * +---+---+---+---+---+---+---+---+ + * | V(S) | X | V(R) | + * +---+---+---+---+---+---+---+---+ + * | V(R) |C/R| + * +---+---+---+---+---+---+---+---+ + * | X | X | X | X | W4| W3| W2| W1| + * +---+---+---+---+---+---+---+---+ + */ + desc_data[octet++] = (UBYTE)(v_s >> 5) & 0x0F; + desc_data[octet++] = (UBYTE)(v_s << 3) | ((UBYTE)(v_r >> 7) & 0x0003); + desc_data[octet++] = (UBYTE)(v_r << 1) | (cr_bit EQ SGSN_COMMAND ? + 0x00 : 0x01); + desc_data[octet++] = reason & 0x0F; + + return; +#endif +} /* u_insert_frmr_information() */ + + +/* ++------------------------------------------------------------------------------ +| Function : u_send_sabm ++------------------------------------------------------------------------------ +| Description : This procedure allocates a LL_UNITDATA_REQ primitive, fills in +| the required parameters, builds an U frame header containing +| an SABM command, and sends this primitive to TX. _Before_ it is +| sent to TX, T200 has to be started, because otherwise the +| primitive may not be valid anymore. +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_send_sabm (void) +{ + USHORT sdu_byte_len = 0; +#ifdef LL_DESC + T_desc3 *desc3; +#endif + + TRACE_FUNCTION( "u_send_sabm" ); + + u_tag_xid_parameters(0, TRUE); + + /* + * Calculate bit length of tagged XID parameters. First, add + * the size of each tagged parameter. The size of layer-3 + * parameters is variable, so add the given length in octets. + */ + ADD_IF_TAGGED (sdu_byte_len, XID_VERSION); + ADD_IF_TAGGED (sdu_byte_len, XID_T200); + ADD_IF_TAGGED (sdu_byte_len, XID_N200); + ADD_IF_TAGGED (sdu_byte_len, XID_N201_U); + ADD_IF_TAGGED (sdu_byte_len, XID_N201_I); + ADD_IF_TAGGED (sdu_byte_len, XID_MD); + ADD_IF_TAGGED (sdu_byte_len, XID_MU); + ADD_IF_TAGGED (sdu_byte_len, XID_KD); + ADD_IF_TAGGED (sdu_byte_len, XID_KU); + if (llc_data->u->xid_tag & (0x00000001L << XID_LAYER_3)) + { + sdu_byte_len += llc_data->requested_l3_xid->length + 2; + } + + /* + * Add SDU header and FCS field to the XID response size to get + * the overall SDU size. + */ + sdu_byte_len += U_HDR_SIZE + FCS_SIZE; + +#ifdef LL_DESC + { + PALLOC(ll_unitdesc_req, LL_UNITDESC_REQ); + + desc3 = llc_palloc_desc((USHORT)sdu_byte_len, 0); /* One desc3 descriptor and buffer allocated */ + + ll_unitdesc_req->sapi = llc_data->current_sapi; + ll_unitdesc_req->tlli = llc_data->u->current_tlli; + /* + * No attach to primitive necessary. For retransmission prim + * data is copied in T200. + */ + ll_unitdesc_req->attached_counter = CCI_NO_ATTACHE; + /* + * LLC does not know the QoS profile. + */ + ll_unitdesc_req->ll_qos = llc_data->cur_qos; + + TRACE_EVENT_P1("peak throughput = %d",llc_data->cur_qos.peak); + + /* + * LLC signalling frames are always sent with highest priority. + */ + ll_unitdesc_req->radio_prio = llc_data->cur_radio_prio; + TRACE_EVENT_P1("radio priority = %d",llc_data->cur_radio_prio); +#ifdef REL99 + /* + * From 24.008 & 23.060 it is interpreted that for all signalling data, a + * predefined PFI LL_PFI_SIGNALING shall be used. + */ + ll_unitdesc_req->pkt_flow_id = llc_data->cur_pfi; + TRACE_EVENT_P1("packet flow id = %d",llc_data->cur_pfi); +#endif /* REL99 */ + /* + * Set parameter of descriptor list3 + */ + ll_unitdesc_req->desc_list3.first = (ULONG)desc3; + ll_unitdesc_req->desc_list3.list_len = desc3->len; + + u_build_u_frame (&ll_unitdesc_req->desc_list3, MS_COMMAND, + llc_data->current_sapi, 1, U_SABM); + + u_insert_xid (&ll_unitdesc_req->desc_list3, MS_COMMAND); + + /* + * T200 has to be started _before_ the primitive is sent to TX, because + * the primitive is copied by t200_start() and it may not be valid + * anymore after sending to TX. + */ + sig_u_t200_start_req (ll_unitdesc_req, GRLC_DTACS_DEF); + + sig_u_tx_data_req (ll_unitdesc_req, GRLC_DTACS_DEF); + } + +#else + { + PALLOC_SDU (ll_unitdata_req, LL_UNITDATA_REQ, (USHORT)(sdu_byte_len*8)); + + ll_unitdata_req->sapi = llc_data->current_sapi; + ll_unitdata_req->tlli = llc_data->u->current_tlli; + /* + * No attach to primitive necessary. For retransmission prim + * data is copied in T200. + */ + ll_unitdata_req->attached_counter = CCI_NO_ATTACHE; + /* + * LLC does not know the QoS profile. + */ + ll_unitdata_req->ll_qos.peak = LL_PEAK_SUB; + /* + * LLC signalling frames are always sent with highest priority. + */ + ll_unitdata_req->radio_prio = LL_RADIO_PRIO_1; +#ifdef REL99 + /* + * From 24.008 & 23.060 it is interpreted that for all signalling data, a + * predefined PFI LL_PFI_SIGNALING shall be used. + */ + ll_unitdata_req->pkt_flow_id = LL_PFI_SIGNALING; +#endif /* REL99 */ + + u_build_u_frame (&ll_unitdata_req->sdu, MS_COMMAND, + llc_data->current_sapi, 1, U_SABM); + + u_insert_xid (&ll_unitdata_req->sdu, MS_COMMAND); + + /* + * T200 has to be started _before_ the primitive is sent to TX, because + * the primitive is copied by t200_start() and it may not be valid + * anymore after sending to TX. + */ + sig_u_t200_start_req (ll_unitdata_req, GRLC_DTACS_DEF); + + sig_u_tx_data_req (ll_unitdata_req, GRLC_DTACS_DEF); + } +#endif + return; +} /* u_send_sabm() */ + + +/* ++------------------------------------------------------------------------------ +| Function : u_send_disc ++------------------------------------------------------------------------------ +| Description : This procedure allocates a LL_UNITDATA_REQ primitive, fills in +| the required parameters, builds an U frame header containing +| an DISC command, and sends this primitive to TX. _Before_ it is +| sent to TX, T200 has to be started, because otherwise the +| primitive may not be valid anymore. +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_send_disc (void) +{ +#ifdef LL_DESC + T_desc3* desc3; +#endif + TRACE_FUNCTION( "u_send_disc" ); + + { +#ifndef LL_DESC + PALLOC_SDU (ll_unitdesc_req, LL_UNITDATA_REQ, + U_HDR_SIZE_BITS + FCS_SIZE_BITS); +#else + PALLOC (ll_unitdesc_req, LL_UNITDESC_REQ); + + desc3 = llc_palloc_desc((U_HDR_SIZE_BITS + FCS_SIZE_BITS)/8, 0); + ll_unitdesc_req->desc_list3.first = (ULONG)desc3; + ll_unitdesc_req->desc_list3.list_len = desc3->len; +#endif + + ll_unitdesc_req->sapi = llc_data->current_sapi; + ll_unitdesc_req->tlli = llc_data->u->current_tlli; + /* + * No attach to primitive necessary. For retransmission prim + * data is copied in T200. + */ + ll_unitdesc_req->attached_counter = CCI_NO_ATTACHE; + /* + * LLC does not know the QoS profile. + */ + ll_unitdesc_req->ll_qos = llc_data->cur_qos; + + TRACE_EVENT_P1("peak throughput = %d",llc_data->cur_qos.peak); + + /* + * LLC signalling frames are always sent with highest priority. + */ + ll_unitdesc_req->radio_prio = llc_data->cur_radio_prio; + TRACE_EVENT_P1("radio priority = %d",llc_data->cur_radio_prio); + +#ifdef REL99 + /* + * From 24.008 & 23.060 it is interpreted that for all signalling data, a + * predefined PFI LL_PFI_SIGNALING shall be used. + */ + ll_unitdesc_req->pkt_flow_id = llc_data->cur_pfi; + TRACE_EVENT_P1("packet flow id = %d",llc_data->cur_pfi); + +#endif /* REL99 */ + + + u_build_u_frame + ( +#ifndef LL_DESC + &ll_unitdesc_req->sdu, +#else + &ll_unitdesc_req->desc_list3, +#endif + MS_COMMAND, + llc_data->current_sapi, 1, U_DISC + ); + + /* + * T200 has to be started _before_ the primitive is sent to TX, because + * the primitive is copied by t200_start() and it may not be valid + * anymore after sending to TX. + */ + sig_u_t200_start_req (ll_unitdesc_req, GRLC_DTACS_DEF); + + sig_u_tx_data_req (ll_unitdesc_req, GRLC_DTACS_DEF); + } + + return; +} /* u_send_disc() */ + +#ifdef REL99 +/* ++------------------------------------------------------------------------------ +| Function : sig_tx_u_send_null ++------------------------------------------------------------------------------ +| Description : This procedure allocates a LL_UNITDATA_REQ primitive, fills in +| the required parameters, builds an U frame header containing +| an NULL command, and sends this primitive to TX. +| +| Parameters : cause - frame cause indicates grr about cell notification +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void sig_tx_u_send_null (UBYTE cause) +{ +#ifdef LL_DESC + T_desc3* desc3; +#endif + TRACE_FUNCTION( "sig_tx_u_send_null" ); + + { +#ifndef LL_DESC + PALLOC_SDU (ll_unitdesc_req, LL_UNITDATA_REQ, + U_HDR_SIZE_BITS + FCS_SIZE_BITS); +#else + PALLOC (ll_unitdesc_req, LL_UNITDESC_REQ); + desc3 = llc_palloc_desc((U_HDR_SIZE_BITS + FCS_SIZE_BITS)/8, 0); + ll_unitdesc_req->desc_list3.first = (ULONG)desc3; + ll_unitdesc_req->desc_list3.list_len = desc3->len; +#endif + /* + * Set TLLI for current transaction. + */ + llc_data->u->current_tlli = llc_data->tlli_new; + + ll_unitdesc_req->sapi = llc_data->current_sapi; + ll_unitdesc_req->tlli = llc_data->u->current_tlli; + /* + * No attach to primitive necessary. For retransmission prim + * data is copied in T200. + */ + ll_unitdesc_req->attached_counter = CCI_NO_ATTACHE; + /* + * LLC does not know the QoS profile. + */ + ll_unitdesc_req->ll_qos.peak = GRLC_PEAK_SUB; + /* + * LLC signalling frames are always sent with highest priority. + */ + ll_unitdesc_req->radio_prio = GRLC_RADIO_PRIO_1; + + u_build_u_frame + ( +#ifndef LL_DESC + &ll_unitdesc_req->sdu, +#else + &ll_unitdesc_req->desc_list3, +#endif + MS_COMMAND, + llc_data->current_sapi, 0, U_NULL + ); + + sig_u_tx_data_req (ll_unitdesc_req, cause); + } + return; +} /* sig_tx_u_send_null() */ + +#endif /* REL99 */ +/* ++------------------------------------------------------------------------------ +| Function : u_send_ua ++------------------------------------------------------------------------------ +| Description : This procedure allocates a LL_UNITDATA_REQ primitive, fills in +| the required parameters, builds an U frame header containing +| an UA response with the given pf_bit setting, and sends this +| primitive to TX. The parameter include_xid indicates if an +| XID information field (according to llc_xid_tag) shall be +| included (=TRUE) or not. +| +| Parameters : pf_bit - setting of the P/F bit in the received command +| include_xid - include XID information field in frame, or not +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_send_ua (T_BIT pf_bit, + BOOL include_xid) +{ +#ifdef LL_DESC +T_desc3* desc3; +#endif + USHORT byte_len = 0; + + + TRACE_FUNCTION( "u_send_ua" ); + + if (include_xid EQ TRUE) + { + + u_tag_xid_parameters(1, TRUE); + + /* + * Calculate bit length of tagged XID parameters. First, add + * the size of each tagged parameter. The size of layer-3 + * parameters is variable, so add the given length in octets. + */ + ADD_IF_TAGGED (byte_len, XID_VERSION); + ADD_IF_TAGGED (byte_len, XID_T200); + ADD_IF_TAGGED (byte_len, XID_N200); + ADD_IF_TAGGED (byte_len, XID_N201_U); + ADD_IF_TAGGED (byte_len, XID_N201_I); + ADD_IF_TAGGED (byte_len, XID_MD); + ADD_IF_TAGGED (byte_len, XID_MU); + ADD_IF_TAGGED (byte_len, XID_KD); + ADD_IF_TAGGED (byte_len, XID_KU); + if (llc_data->u->xid_tag & (0x00000001L << XID_LAYER_3)) + { + byte_len += llc_data->requested_l3_xid->length + 2; + } + } + + /* + * Add data header and FCS field to the XID response size to get + * the overall data size. + */ + byte_len += U_HDR_SIZE + FCS_SIZE; + + { +#ifndef LL_DESC + PALLOC_SDU (ll_unitdesc_req, LL_UNITDATA_REQ, (USHORT)(byte_len*8)); +#else + PALLOC (ll_unitdesc_req, LL_UNITDESC_REQ); + + desc3 = llc_palloc_desc((USHORT)(byte_len), 0); + ll_unitdesc_req->desc_list3.first = (ULONG)desc3; + ll_unitdesc_req->desc_list3.list_len = desc3->len; + +#endif + + ll_unitdesc_req->sapi = llc_data->current_sapi; + ll_unitdesc_req->tlli = llc_data->u->current_tlli; + /* + * No attach to primitive necessary. There is no retransmission. + */ + ll_unitdesc_req->attached_counter = CCI_NO_ATTACHE; + /* + * LLC does not know the QoS profile. + */ + ll_unitdesc_req->ll_qos = llc_data->cur_qos; + TRACE_EVENT_P1("peak throughput = %d",llc_data->cur_qos.peak); + + /* + * LLC signalling frames are always sent with highest priority. + */ + ll_unitdesc_req->radio_prio = llc_data->cur_radio_prio; + TRACE_EVENT_P1("radio priority = %d",llc_data->cur_radio_prio); + +#ifdef REL99 + /* + * From 24.008 & 23.060 it is interpreted that for all signalling data, a + * predefined PFI LL_PFI_SIGNALING shall be used. + */ + ll_unitdesc_req->pkt_flow_id = llc_data->cur_pfi; + TRACE_EVENT_P1("packet flow id = %d",llc_data->cur_pfi); +#endif /* REL99 */ + + u_build_u_frame + ( +#ifndef LL_DESC + &ll_unitdesc_req->sdu, +#else + &ll_unitdesc_req->desc_list3, +#endif + MS_RESPONSE, llc_data->current_sapi, pf_bit, U_UA + ); + + if (include_xid EQ TRUE) + { + u_insert_xid + ( +#ifndef LL_DESC + &ll_unitdesc_req->sdu, +#else + &ll_unitdesc_req->desc_list3, +#endif + MS_RESPONSE + ); + } + + sig_u_tx_data_req (ll_unitdesc_req, GRLC_DTACS_DEF); + } + + llc_init_requested_xid_sapi(llc_data->current_sapi); + return; +} /* u_send_ua() */ + + +/* ++------------------------------------------------------------------------------ +| Function : u_send_dm ++------------------------------------------------------------------------------ +| Description : This procedure allocates a LL_UNITDATA_REQ primitive, fills in +| all required parameters, builds an U frame header containing a +| DM response with the given pf_bit setting, and sends this +| primitive to TX. +| +| Parameters : pf_bit - setting of the P/F bit in the received command +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_send_dm (T_BIT pf_bit) +{ +#ifdef LL_DESC + T_desc3* desc3; +#endif + + TRACE_FUNCTION( "u_send_dm" ); + + { +#ifndef LL_DESC + PALLOC_SDU (ll_unitdesc_req, LL_UNITDATA_REQ, + U_DM_SIZE_BITS + FCS_SIZE_BITS); +#else + PALLOC (ll_unitdesc_req, LL_UNITDESC_REQ); + + desc3 = llc_palloc_desc((U_DM_SIZE_BITS + FCS_SIZE_BITS)/8, 0); + ll_unitdesc_req->desc_list3.first = (ULONG)desc3; + ll_unitdesc_req->desc_list3.list_len = desc3->len; +#endif + + ll_unitdesc_req->sapi = llc_data->current_sapi; + ll_unitdesc_req->tlli = llc_data->u->current_tlli; + /* + * No attach to primitive necessary. There is no retransmission. + */ + ll_unitdesc_req->attached_counter = CCI_NO_ATTACHE; + /* + * LLC does not know the QoS profile. + */ + ll_unitdesc_req->ll_qos = llc_data->cur_qos; + + TRACE_EVENT_P1("peak throughput = %d",llc_data->cur_qos.peak); + + + /* + * LLC signalling frames are always sent with highest priority. + */ + ll_unitdesc_req->radio_prio = llc_data->cur_radio_prio; + TRACE_EVENT_P1("radio priority = %d",llc_data->cur_radio_prio); + +#ifdef REL99 + /* + * From 24.008 & 23.060 it is interpreted that for all signalling data, a + * predefined PFI LL_PFI_SIGNALING shall be used. + */ + ll_unitdesc_req->pkt_flow_id = llc_data->cur_pfi; + TRACE_EVENT_P1("packet flow id = %d",llc_data->cur_pfi); + +#endif /* REL99 */ + + u_build_u_frame + ( +#ifndef LL_DESC + &ll_unitdesc_req->sdu, +#else + &ll_unitdesc_req->desc_list3, +#endif + MS_RESPONSE, + llc_data->current_sapi, pf_bit, U_DM + ); + + sig_u_tx_data_req (ll_unitdesc_req, GRLC_DTACS_DEF); + } + + return; +} /* u_send_dm() */ + + +/* ++------------------------------------------------------------------------------ +| Function : u_send_frmr ++------------------------------------------------------------------------------ +| Description : This procedure allocates a LL_UNITDATA_REQ primitive, fills in +| the required parameters, builds an U frame header containing +| an FRMR response, fills in the FRMR information field based on +| the given frame, vs, vr, the cr_bit setting of frame +| (SGSN_COMMAND/REPONSE), and the reason of the frame rejection +| condition (lower nibble conforms to W4-W1 in FRMR response). +| This primitive is then sent to TX. +| +| Parameters : frame - frame that caused the frame rejection condition +| pdu_type - frame type +| ctrl_length - control field length, if known +| vs - current V(S) +| vr - current V(R) +| cr_bit - setting of C/R bit in frame +| reason - reason of the frame rejection condition (lower +| nibble conforms to W4-W1 in FRMR response) +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_send_frmr (T_LL_UNITDATA_IND *frame, + T_PDU_TYPE pdu_type, + USHORT ctrl_length, + T_FRAME_NUM vs, + T_FRAME_NUM vr, + T_BIT cr_bit, + UBYTE reason) +{ +#ifdef LL_DESC + T_desc3* desc3; +#endif + + TRACE_FUNCTION( "u_send_frmr" ); + + { +#ifndef LL_DESC + PALLOC_SDU (ll_unitdesc_req, LL_UNITDATA_REQ, + U_FRMR_SIZE_BITS + FCS_SIZE_BITS); +#else + PALLOC (ll_unitdesc_req, LL_UNITDESC_REQ); + + desc3 = llc_palloc_desc((U_FRMR_SIZE_BITS + FCS_SIZE_BITS)/8, 0); + ll_unitdesc_req->desc_list3.first = (ULONG)desc3; + ll_unitdesc_req->desc_list3.list_len = desc3->len; +#endif + + ll_unitdesc_req->sapi = llc_data->current_sapi; + ll_unitdesc_req->tlli = llc_data->u->current_tlli; + /* + * No attach to primitive necessary. There is no retransmission. + */ + ll_unitdesc_req->attached_counter = CCI_NO_ATTACHE; + /* + * LLC does not know the QoS profile. + */ + ll_unitdesc_req->ll_qos = llc_data->cur_qos; + + TRACE_EVENT_P1("peak throughput = %d",llc_data->cur_qos.peak); + + + /* + * LLC signalling frames are always sent with highest priority. + */ + ll_unitdesc_req->radio_prio = llc_data->cur_radio_prio; + TRACE_EVENT_P1("radio priority = %d",llc_data->cur_radio_prio); + +#ifdef REL99 + /* + * From 24.008 & 23.060 it is interpreted that for all signalling data, a + * predefined PFI LL_PFI_SIGNALING shall be used. + */ + ll_unitdesc_req->pkt_flow_id = llc_data->cur_pfi; + TRACE_EVENT_P1("packet flow id = %d",llc_data->cur_pfi); + +#endif /* REL99 */ + + u_build_u_frame + ( +#ifndef LL_DESC + &ll_unitdesc_req->sdu, +#else + &ll_unitdesc_req->desc_list3, +#endif + MS_RESPONSE, + llc_data->current_sapi, 1, U_FRMR + ); + + u_insert_frmr_information + ( +#ifndef LL_DESC + &ll_unitdesc_req->sdu, +#else + &ll_unitdesc_req->desc_list3, +#endif + frame, pdu_type, + ctrl_length, vs, vr, cr_bit, reason + ); + + sig_u_tx_data_req (ll_unitdesc_req, GRLC_DTACS_DEF); + } + + return; +} /* u_send_frmr() */ + + +/* ++------------------------------------------------------------------------------ +| Function : u_send_llgmm_status_ind ++------------------------------------------------------------------------------ +| Description : This procedure allocates an LLGMM_STATUS_IND primitive, fills +| in the error_cause parameter, and sends this primitive to GMM. +| +| Parameters : error_cause - LLGMM error cause +| ++------------------------------------------------------------------------------ +*/ +#ifdef CC_CONCEPT +GLOBAL void u_send_llgmm_status_ind (USHORT error_cause) +#else +GLOBAL void u_send_llgmm_status_ind (UBYTE error_cause) +#endif +{ + TRACE_FUNCTION( "u_send_llgmm_status_ind" ); + + { + PALLOC (llgmm_status_ind, LLGMM_STATUS_IND); /* T_LLGMM_STATUS_IND */ + +#ifdef LL_2to1 + llgmm_status_ind->ps_cause.ctrl_value = CAUSE_is_from_llc; + llgmm_status_ind->ps_cause.value.llc_cause = error_cause; +#else + llgmm_status_ind->error_cause = error_cause; +#endif + + PSEND (hCommGMM, llgmm_status_ind); + } + + return; +} /* u_send_llgmm_status_ind() */ + + +/* ++------------------------------------------------------------------------------ +| Function : u_send_ll_release_cnf ++------------------------------------------------------------------------------ +| Description : This procedure allocates an LL_RELEASE_CNF primitive, fills in +| tlli and sapi parameters, and sends this primitive to SNDCP. +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_send_ll_release_cnf (void) +{ + TRACE_FUNCTION( "u_send_ll_release_cnf" ); + + { + PALLOC (ll_release_cnf, LL_RELEASE_CNF); + + ll_release_cnf->sapi = llc_data->current_sapi; + TRACE_1_OUT_PARA("s:%d", llc_data->current_sapi ); + PSEND (hCommSNDCP, ll_release_cnf); + } + + llc_data->u->release_requested = FALSE; + + return; +} /* u_send_ll_release_cnf() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : u_send_ll_status_ind ++------------------------------------------------------------------------------ +| Description : This procedure allocates an LL_STATUS_IND primitive, fills in +| tlli, sapi and cause parameters and sends this proimitive to L3 +| +| Parameters : cause - LL error cause +| ++------------------------------------------------------------------------------ +*/ +#ifdef CC_CONCEPT +GLOBAL void u_send_ll_status_ind (USHORT cause) +#else +GLOBAL void u_send_ll_status_ind (UBYTE cause) +#endif +{ + TRACE_FUNCTION( "u_send_ll_status_ind" ); + + { + PALLOC (ll_status_ind, LL_STATUS_IND); + + ll_status_ind->sapi = llc_data->current_sapi; +#ifdef LL_2to1 + ll_status_ind->ps_cause.ctrl_value = CAUSE_is_from_llc; + ll_status_ind->ps_cause.value.llc_cause = cause; +#else + ll_status_ind->error_cause = cause; +#endif + + TRACE_1_OUT_PARA("s:%d", llc_data->current_sapi ); + PSEND (hCommSNDCP, ll_status_ind); + } + + return; +} /* u_send_ll_status_ind() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : u_send_ll_xid_cnf ++------------------------------------------------------------------------------ +| Description : This procedure allocates an LL_XID_CNF primitive, fills in +| tlli, sapi and L3 parameter (if being negotiated), and sends +| this primitive to SNDCP +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_send_ll_xid_cnf (void) +{ + TRACE_FUNCTION( "u_send_ll_xid_cnf" ); + + if (llc_data->decoded_l3_xid.valid EQ TRUE) + { + PALLOC_SDU (ll_xid_cnf, LL_XID_CNF, (USHORT)(llc_data->decoded_l3_xid.length * 8)); + + ll_xid_cnf->sdu.l_buf = llc_data->decoded_l3_xid.length * 8; + ll_xid_cnf->sdu.o_buf = 0; + + memcpy (ll_xid_cnf->sdu.buf, + llc_data->decoded_l3_xid.value, + llc_data->decoded_l3_xid.length); + + ll_xid_cnf->sapi = llc_data->current_sapi; + + ll_xid_cnf->n201_u = *(llc_data->n201_u); + ll_xid_cnf->n201_i = *(llc_data->n201_i); + + TRACE_2_OUT_PARA("s:%d xid-len:%d", llc_data->current_sapi, llc_data->decoded_l3_xid.length ); + PSEND (hCommSNDCP, ll_xid_cnf); + } + else + { + PALLOC_SDU (ll_xid_cnf, LL_XID_CNF, 0); + + ll_xid_cnf->sdu.l_buf = 0; + ll_xid_cnf->sdu.o_buf = 0; + + ll_xid_cnf->sapi = llc_data->current_sapi; + + ll_xid_cnf->n201_u = *(llc_data->n201_u); + ll_xid_cnf->n201_i = *(llc_data->n201_i); + + TRACE_2_OUT_PARA("s:%d xid-len:%d", llc_data->current_sapi, 0 ); + PSEND (hCommSNDCP, ll_xid_cnf); + } + + return; +} /* u_send_ll_xid_cnf() */ + + +/* ++------------------------------------------------------------------------------ +| Function : u_send_ll_establish_ind ++------------------------------------------------------------------------------ +| Description : This procedure allocates an LL_ESTABLISH_IND primitive, fills +| in all necessary parameters using global LLC values (or in case +| of L-3 XID parameters, using the parameters of received XID +| cmd/res), and sends this primitive to SNDCP +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_send_ll_establish_ind (void) +{ + USHORT len; + + TRACE_FUNCTION( "u_send_ll_establish_ind" ); + + if (llc_data->decoded_l3_xid.valid EQ TRUE) + { + len = (llc_data->decoded_l3_xid.length * 8); + } + else + { + len = 0; + } + + { + PALLOC_SDU (ll_establish_ind, LL_ESTABLISH_IND, len); + + if (llc_data->decoded_l3_xid.valid EQ TRUE) + { + ll_establish_ind->xid_valid = LL_XID_VALID; + + ll_establish_ind->sdu.o_buf = 0; + ll_establish_ind->sdu.l_buf = llc_data->decoded_l3_xid.length * 8; + + memcpy (ll_establish_ind->sdu.buf, + llc_data->decoded_l3_xid.value, + llc_data->decoded_l3_xid.length); + } + else + { + ll_establish_ind->xid_valid = LL_XID_INVALID; + } + + ll_establish_ind->sapi = llc_data->current_sapi; + + /* + * evaluate N201_U + */ + if (llc_data->u->requested_xid.n201_u.valid AND + llc_data->decoded_xid.n201_u.valid AND + !llc_xid_value_acceptable (llc_data->current_sapi, XID_N201_U, + llc_data->decoded_xid.n201_u.value)) + { + ll_establish_ind->n201_u = llc_data->u->requested_xid.n201_u.value; + } + else if (llc_data->u->requested_xid.n201_u.valid AND + !llc_data->decoded_xid.n201_u.valid AND + !llc_xid_value_acceptable (llc_data->current_sapi, XID_N201_U, + *(llc_data->n201_u))) + { + ll_establish_ind->n201_u = llc_data->u->requested_xid.n201_u.value; + } + else + { + ll_establish_ind->n201_u = *(llc_data->n201_u); + } + + /* + * evaluate N201_I + */ + if (llc_data->u->requested_xid.n201_i.valid AND + llc_data->decoded_xid.n201_i.valid AND + !llc_xid_value_acceptable (llc_data->current_sapi, XID_N201_I, + llc_data->decoded_xid.n201_i.value)) + { + ll_establish_ind->n201_i = llc_data->u->requested_xid.n201_i.value; + } + else if (llc_data->u->requested_xid.n201_i.valid AND + !llc_data->decoded_xid.n201_i.valid AND + !llc_xid_value_acceptable (llc_data->current_sapi, XID_N201_I, + *(llc_data->n201_i))) + { + ll_establish_ind->n201_i = llc_data->u->requested_xid.n201_i.value; + } + else + { + ll_establish_ind->n201_i = *(llc_data->n201_i); + } + + + TRACE_2_OUT_PARA("s:%d xid-len:%d", ll_establish_ind->sapi, len/8); + PSEND (hCommSNDCP, ll_establish_ind); + + return; + } +} /* u_send_ll_establish_ind() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : u_send_ll_establish_cnf ++------------------------------------------------------------------------------ +| Description : This procedure allocates an LL_ESTABLISH_CNF primitive, fills +| in all necessary parameters using global LLC values (or in case +| of L-3 XID parameters, using the parameters of received XID +| cmd/res), and sends this primitive to SNDCP +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_send_ll_establish_cnf (void) +{ + TRACE_FUNCTION( "u_send_ll_establish_cnf" ); + + if (llc_data->decoded_l3_xid.valid EQ TRUE) + { + PALLOC_SDU (ll_establish_cnf, LL_ESTABLISH_CNF, + (USHORT)(llc_data->decoded_l3_xid.length * 8)); + + ll_establish_cnf->xid_valid = LL_XID_VALID; + + ll_establish_cnf->sdu.o_buf = 0; + ll_establish_cnf->sdu.l_buf = llc_data->decoded_l3_xid.length * 8; + + memcpy (ll_establish_cnf->sdu.buf, + llc_data->decoded_l3_xid.value, + llc_data->decoded_l3_xid.length); + + ll_establish_cnf->sapi = llc_data->current_sapi; + + ll_establish_cnf->n201_u = *(llc_data->n201_u); + ll_establish_cnf->n201_i = *(llc_data->n201_i); + + TRACE_2_OUT_PARA("s:%d xid-len:%d", llc_data->current_sapi, llc_data->decoded_l3_xid.length ); + PSEND (hCommSNDCP, ll_establish_cnf); + } + else + { + PALLOC_SDU (ll_establish_cnf, LL_ESTABLISH_CNF, 0); + + ll_establish_cnf->xid_valid = LL_XID_INVALID; + + ll_establish_cnf->sapi = llc_data->current_sapi; + + ll_establish_cnf->n201_u = *(llc_data->n201_u); + ll_establish_cnf->n201_i = *(llc_data->n201_i); + + TRACE_2_OUT_PARA("s:%d xid-len:%d", llc_data->current_sapi, 0 ); + PSEND (hCommSNDCP, ll_establish_cnf); + } + + return; +} /* u_send_ll_establish_cnf() */ + + +/* ++------------------------------------------------------------------------------ +| Function : u_send_ll_release_ind ++------------------------------------------------------------------------------ +| Description : This procedure allocates an LL_RELEASE_IND primitive, fills +| in tlli, sapi and cause parameters, and sends this primitive +| to SNDCP +| +| Parameters : cause - LL error cause +| ++------------------------------------------------------------------------------ +*/ +#ifdef CC_CONCEPT +GLOBAL void u_send_ll_release_ind (USHORT cause) +#else +GLOBAL void u_send_ll_release_ind (UBYTE cause) +#endif +{ + TRACE_FUNCTION( "u_send_ll_release_ind" ); + + { + PALLOC (ll_release_ind, LL_RELEASE_IND); + + ll_release_ind->sapi = llc_data->current_sapi; +#ifdef LL_2to1 + ll_release_ind->ps_cause.ctrl_value = CAUSE_is_from_llc; + ll_release_ind->ps_cause.value.llc_cause = cause; +#else + ll_release_ind->cause = cause; +#endif + + TRACE_1_OUT_PARA("s:%d", llc_data->current_sapi ); + PSEND (hCommSNDCP, ll_release_ind); + } + + llc_data->u->release_requested = FALSE; + + return; +} /* u_send_ll_release_ind() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : u_send_ll_xid_ind ++------------------------------------------------------------------------------ +| Description : This procedure allocates an LL_XID_IND primitive, fills +| in all necessary parameters using global LLC values (or in case +| of L-3 XID parameters, using the parameters of received XID +| cmd/res), and sends this primitive to SNDCP +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_send_ll_xid_ind (void) +{ + TRACE_FUNCTION( "u_send_ll_xid_ind" ); + + + + if (llc_data->decoded_l3_xid.valid EQ TRUE) + { + PALLOC_SDU (ll_xid_ind, LL_XID_IND, (USHORT)(llc_data->decoded_l3_xid.length * 8)); + + llc_data->u->ll_xid_resp_pending = TRUE; + ll_xid_ind->xid_valid = LL_XID_VALID; + + ll_xid_ind->sdu.o_buf = 0; + ll_xid_ind->sdu.l_buf = llc_data->decoded_l3_xid.length * 8; + + memcpy (ll_xid_ind->sdu.buf, + llc_data->decoded_l3_xid.value, + llc_data->decoded_l3_xid.length); + + ll_xid_ind->sapi = llc_data->current_sapi; + + if (llc_data->u->requested_xid.n201_u.valid AND + !llc_xid_value_acceptable (llc_data->current_sapi, XID_N201_U, + llc_data->decoded_xid.n201_u.value)) + { + ll_xid_ind->n201_u = llc_data->u->requested_xid.n201_u.value; + } + else + { + ll_xid_ind->n201_u = *(llc_data->n201_u); + } + + switch (ll_xid_ind->sapi) + { + case LL_SAPI_3: + case LL_SAPI_5: + case LL_SAPI_9: + case LL_SAPI_11: + if (llc_data->u->requested_xid.n201_i.valid AND + !llc_xid_value_acceptable (llc_data->current_sapi, XID_N201_I, + llc_data->decoded_xid.n201_i.value)) + { + ll_xid_ind->n201_i = llc_data->u->requested_xid.n201_i.value; + } + else + { + ll_xid_ind->n201_i = *(llc_data->n201_i); + } + break; + + default: + ll_xid_ind->n201_i = 0; + break; + } + + /* + * Send primitive LL_XID_IND to either GMM, SNDCP, or GSMS, + * depending on SAPI. + */ + switch (ll_xid_ind->sapi) + { + case LL_SAPI_1: + TRACE_PRIM_TO("GMM"); + TRACE_2_OUT_PARA("s:%d xid-len:%d", ll_xid_ind->sapi, llc_data->decoded_l3_xid.length); + PSEND (hCommGMM, ll_xid_ind); + break; + case LL_SAPI_3: + case LL_SAPI_5: + case LL_SAPI_9: + case LL_SAPI_11: + TRACE_2_OUT_PARA("s:%d xid-len:%d", ll_xid_ind->sapi, llc_data->decoded_l3_xid.length); + PSEND (hCommSNDCP, ll_xid_ind); + break; + case LL_SAPI_7: +#ifdef LL_2to1 + TRACE_PRIM_TO("MM"); + TRACE_2_OUT_PARA("s:%d xid-len:%d", ll_xid_ind->sapi, llc_data->decoded_l3_xid.length); + PSEND (hCommMM, ll_xid_ind); +#else + TRACE_PRIM_TO("GSMS"); + TRACE_2_OUT_PARA("s:%d xid-len:%d", ll_xid_ind->sapi, llc_data->decoded_l3_xid.length); + PSEND (hCommGSMS, ll_xid_ind); +#endif + break; + default: + PFREE (ll_xid_ind); + TRACE_ERROR ("Invalid global SAPI value"); + break; + } + } + else + { + PALLOC_SDU (ll_xid_ind, LL_XID_IND, 0); + + llc_data->u->ll_xid_resp_pending = FALSE; + + ll_xid_ind->xid_valid = LL_XID_INVALID; + + ll_xid_ind->sapi = llc_data->current_sapi; + + ll_xid_ind->n201_u = *(llc_data->n201_u); + + switch (ll_xid_ind->sapi) + { + case LL_SAPI_3: + case LL_SAPI_5: + case LL_SAPI_9: + case LL_SAPI_11: + ll_xid_ind->n201_i = *(llc_data->n201_i); + break; + + default: + ll_xid_ind->n201_i = 0; + break; + } + + /* + * Send primitive LL_XID_IND to either GMM, SNDCP, or GSMS, + * depending on SAPI. + */ + switch (ll_xid_ind->sapi) + { + case LL_SAPI_1: + TRACE_PRIM_TO("GMM"); + TRACE_1_OUT_PARA("s:%d no l3-xid", ll_xid_ind->sapi); + PSEND (hCommGMM, ll_xid_ind); + break; + case LL_SAPI_3: + case LL_SAPI_5: + case LL_SAPI_9: + case LL_SAPI_11: + TRACE_1_OUT_PARA("s:%d no l3-xid", ll_xid_ind->sapi); + PSEND (hCommSNDCP, ll_xid_ind); + break; + case LL_SAPI_7: +#ifdef LL_2to1 + TRACE_PRIM_TO("MM"); + TRACE_1_OUT_PARA("s:%d no l3-xid", ll_xid_ind->sapi); + PSEND (hCommMM, ll_xid_ind); +#else + TRACE_PRIM_TO("GSMS"); + TRACE_1_OUT_PARA("s:%d no l3-xid", ll_xid_ind->sapi); + PSEND (hCommGSMS, ll_xid_ind); +#endif + break; + default: + PFREE (ll_xid_ind); + TRACE_ERROR ("invalid global SAPI value"); + break; + } + } + + return; +} /* u_send_ll_xid_ind() */ + + +/* ++------------------------------------------------------------------------------ +| Function : u_tag_xid_parameters ++------------------------------------------------------------------------------ +| Description : This procedure tags requested parameters +| +| +| Parameters : +| - send_ack_para- used to include/ignore the ack para in XID-FRAME +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_tag_xid_parameters (T_BIT cr_bit, BOOL send_ack_para) +{ + TRACE_FUNCTION( "u_tag_xid_parameters" ); + + if (cr_bit EQ MS_RESPONSE) + { + /* + * Do some special handling in case we want to set mD or mU to zero + * (= disable buffered bytes counting) and the peer does not. + */ + if (llc_data->decoded_xid.mu.valid) + { + u_handle_mX_zero_rsp ( llc_data->decoded_xid.mu.value, + llc_data->n201_i, + *(llc_data->mu), XID_MU_MAX, + llc_data->ku, XID_KU_MIN, XID_KU ); + } + + if (llc_data->decoded_xid.md.valid) + { + u_handle_mX_zero_rsp ( llc_data->decoded_xid.md.value, + llc_data->n201_i, + *(llc_data->md), XID_MD_MAX, + llc_data->kd, XID_KD_MIN, XID_KD ); + } + } + + /* + * Tag all possible requested XID parameter + */ + if (cr_bit EQ MS_COMMAND) + { + /* + * In case we are sending a command, we can include all + * parameters, as long they are valid. + */ + TAG_IF_REQUESTED (u->requested_xid.version. , XID_VERSION); + TAG_IF_REQUESTED (u->requested_xid.t200. , XID_T200); + TAG_IF_REQUESTED (u->requested_xid.n200. , XID_N200); + TAG_IF_REQUESTED (u->requested_xid.n201_u. , XID_N201_U); + TAG_IF_REQUESTED (requested_l3_xid-> , XID_LAYER_3); + if(send_ack_para) + { + TRACE_EVENT("COMMAND: ACK MODE PARAMETERS INCLUDED"); + TAG_IF_REQUESTED (u->requested_xid.n201_i. , XID_N201_I); + TAG_IF_REQUESTED (u->requested_xid.md. , XID_MD); + TAG_IF_REQUESTED (u->requested_xid.mu. , XID_MU); + TAG_IF_REQUESTED (u->requested_xid.kd. , XID_KD); + TAG_IF_REQUESTED (u->requested_xid.ku. , XID_KU); + } + else + { + llc_data->u->requested_xid.n201_i.valid = FALSE; + llc_data->u->requested_xid.md.valid = FALSE; + llc_data->u->requested_xid.mu.valid = FALSE; + llc_data->u->requested_xid.kd.valid = FALSE; + llc_data->u->requested_xid.ku.valid = FALSE; + } + + } + else + { + /* + * In case we are sending a response, we can include all valid + * parameters which are in line with the sense of negotiation. + */ + TAG_IF_REQUESTED_RSP (XID_SENSE_UP, n200, XID_N200); + TAG_IF_REQUESTED_RSP (XID_SENSE_DOWN, n201_u, XID_N201_U); + + if(send_ack_para) + { + TRACE_EVENT("RESPONSE: ACK MODE PARAMETERS INCLUDED"); + TAG_IF_REQUESTED_RSP (XID_SENSE_DOWN, n201_i, XID_N201_I); + TAG_IF_REQUESTED_RSP (XID_SENSE_DOWN, md, XID_MD); + TAG_IF_REQUESTED_RSP (XID_SENSE_DOWN, mu, XID_MU); + TAG_IF_REQUESTED_RSP (XID_SENSE_DOWN, kd, XID_KD); + TAG_IF_REQUESTED_RSP (XID_SENSE_DOWN, ku, XID_KU); + } + + if (llc_data->u->requested_xid.t200.valid) + { + if (llc_data->decoded_xid.t200.valid) + { + /* simple add parameter. Sense of negotiation is already checked */ + llc_data->u->xid_tag |= (0x00000001L << XID_T200); + } + else + { + /* Sense of negotiation compared with current values */ + if (llc_data->u->requested_xid.t200.value XID_SENSE_UP INT2XID(llc_data->t200->length)) + { + llc_data->u->xid_tag |= (0x00000001L << XID_T200); + } + } + } + /* + * L3 parameter cannot be included in response, if not included in + * request + */ + + /* + * If an XID parameter which was not included in the SGSN command, + * but included in the MS Response, must be included in every Response + * until the parameter is explicitly negotiated by the SGSN + */ + + if(llc_data->u->xid_tag_negotiate) + { + llc_data->u->xid_tag |= llc_data->u->xid_tag_negotiate; + } + } +} /* u_tag_xid_parameters() */ + +/* ++------------------------------------------------------------------------------ +| Function : u_send_xid ++------------------------------------------------------------------------------ +| Description : This procedure allocates a LL_UNITDATA_REQ primitive, fills in +| the required parameters, builds an U frame header containing an +| XID command/response (depending on the cr_bit setting), inserts +| all XID parmameters that are to be negotiated, and sends this +| primitive to TX. If a command frame is being sent (see cr_bit), +| T200 has to be started _before_ the primitive is sent to TX, +| because otherwise the primitive may not be valid anymore. +| +| NOTE: T200 must not be running, when an XID command is to be +| sent. This must be ensured by the caller of u_send_xid(). +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_send_xid (T_BIT cr_bit) +{ +#ifdef LL_DESC + T_desc3* desc3; +#endif + USHORT byte_len = 0; + + TRACE_FUNCTION( "u_send_xid" ); + + /* + * Calculate bit length of tagged XID parameters. First, add + * the size of each tagged parameter. The size of layer-3 + * parameters is variable, so add the given length in octets. + */ + ADD_IF_TAGGED (byte_len, XID_VERSION); + ADD_IF_TAGGED (byte_len, XID_T200); + ADD_IF_TAGGED (byte_len, XID_N200); + ADD_IF_TAGGED (byte_len, XID_N201_U); + /*Acknowledge Mode Parameters will be ignored in XID FRAME: + ADD_IF_TAGGED (byte_len, XID_N201_I); + ADD_IF_TAGGED (byte_len, XID_MD); + ADD_IF_TAGGED (byte_len, XID_MU); + ADD_IF_TAGGED (byte_len, XID_KD); + ADD_IF_TAGGED (byte_len, XID_KU); + */ + if (llc_data->u->xid_tag & (0x00000001L << XID_LAYER_3)) + { + byte_len += llc_data->requested_l3_xid->length + 2; + } + + /* + * Add data header and FCS field to the XID response size to get + * the overall data size. + */ + byte_len += U_HDR_SIZE + FCS_SIZE; + + { +#ifndef LL_DESC + PALLOC_SDU (ll_unitdesc_req, LL_UNITDATA_REQ, (USHORT)(byte_len*8)); +#else + PALLOC (ll_unitdesc_req, LL_UNITDESC_REQ); + + desc3 = llc_palloc_desc(byte_len, 0); + + ll_unitdesc_req->desc_list3.first = (ULONG)desc3; + ll_unitdesc_req->desc_list3.list_len = desc3->len; +#endif + ll_unitdesc_req->sapi = llc_data->current_sapi; + ll_unitdesc_req->tlli = llc_data->tlli_new; + /* + * LLC does not know the QoS profile. + */ + ll_unitdesc_req->ll_qos = llc_data->cur_qos; + TRACE_EVENT_P1("peak throughput = %d",llc_data->cur_qos.peak); + + /* + * LLC signalling frames are always sent with highest priority. + */ + ll_unitdesc_req->radio_prio = llc_data->cur_radio_prio; + TRACE_EVENT_P1("radio priority = %d",llc_data->cur_radio_prio); + +#ifdef REL99 + /* + * From 24.008 & 23.060 it is interpreted that for all signalling data, a + * predefined PFI LL_PFI_SIGNALING shall be used. + */ + ll_unitdesc_req->pkt_flow_id = llc_data->cur_pfi; + TRACE_EVENT_P1("packet flow id = %d",llc_data->cur_pfi); + +#endif /* REL99 */ + /* + * No attach to primitive necessary. For retransmission prim + * data is copied in T200 (if requested). + */ + ll_unitdesc_req->attached_counter = CCI_NO_ATTACHE; + + /* + * Label U_SEND_XID_CONT + */ + + /* + * pf_bit must always be 1 when XID cmd/res are being sent + */ + u_build_u_frame + ( +#ifndef LL_DESC + &ll_unitdesc_req->sdu, +#else + &ll_unitdesc_req->desc_list3, +#endif + cr_bit, llc_data->current_sapi, 1, U_XID + ); + + u_insert_xid + ( +#ifndef LL_DESC + &ll_unitdesc_req->sdu, +#else + &ll_unitdesc_req->desc_list3, +#endif + cr_bit + ); + + if (cr_bit EQ MS_COMMAND) + { + /* + * remember that an XID command is currently being sent + */ + llc_data->u->xid_pending = TRUE; + + /* + * T200 has to be started !before! the primitive is sent to TX. + */ + sig_u_t200_start_req (ll_unitdesc_req, GRLC_DTACS_DEF); + } + + /* + * U frames are always sent with default cause + */ + sig_u_tx_data_req (ll_unitdesc_req, GRLC_DTACS_DEF); + } + + if (cr_bit EQ MS_RESPONSE) + { + llc_init_requested_xid_sapi(llc_data->current_sapi); + } + + return; +} /* u_send_xid() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : u_handle_optimization ++------------------------------------------------------------------------------ +| Description : This procedure adds the values of the requested XID parameter +| to the decoded XID structure, if they are not included (as an +| optimization issue). +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void u_handle_optimization (void) +{ + + TRACE_FUNCTION ("u_handle_optimization"); + + + if (llc_data->u->xid_tag_sent & (0x00000001L << XID_VERSION) AND + llc_data->decoded_xid.version.valid == FALSE ) + { + llc_data->decoded_xid.version.valid = TRUE; + llc_data->decoded_xid.version.value = llc_data->u->requested_xid.version.valid + ? llc_data->u->requested_xid.version.value + : llc_data->version; + } + + if (llc_data->u->xid_tag_sent & (0x00000001L << XID_T200) AND + llc_data->decoded_xid.t200.valid == FALSE ) + { + llc_data->decoded_xid.t200.valid = TRUE; + llc_data->decoded_xid.t200.value = llc_data->u->requested_xid.t200.valid + ? llc_data->u->requested_xid.t200.value + : ((USHORT)INT2XID (llc_data->t200->length)); + } + + if (llc_data->u->xid_tag_sent & (0x00000001L << XID_N200) AND + llc_data->decoded_xid.n200.valid == FALSE ) + { + llc_data->decoded_xid.n200.valid = TRUE; + llc_data->decoded_xid.n200.value = llc_data->u->requested_xid.n200.valid + ? llc_data->u->requested_xid.n200.value + : *(llc_data->n200); + } + + if (llc_data->u->xid_tag_sent & (0x00000001L << XID_N201_U) AND + llc_data->decoded_xid.n201_u.valid == FALSE ) + { + llc_data->decoded_xid.n201_u.valid = TRUE; + llc_data->decoded_xid.n201_u.value = llc_data->u->requested_xid.n201_u.valid + ? llc_data->u->requested_xid.n201_u.value + : *(llc_data->n201_u); + } + + if (llc_data->u->xid_tag_sent & (0x00000001L << XID_N201_I) AND + llc_data->decoded_xid.n201_i.valid == FALSE ) + { + llc_data->decoded_xid.n201_i.valid = TRUE; + llc_data->decoded_xid.n201_i.value = llc_data->u->requested_xid.n201_i.valid + ? llc_data->u->requested_xid.n201_i.value + : *(llc_data->n201_i); + } + + if (llc_data->u->xid_tag_sent & (0x00000001L << XID_MD) AND + llc_data->decoded_xid.md.valid == FALSE ) + { + llc_data->decoded_xid.md.valid = TRUE; + llc_data->decoded_xid.md.value = llc_data->u->requested_xid.md.valid + ? llc_data->u->requested_xid.md.value + : *(llc_data->md); + } + + if (llc_data->u->xid_tag_sent & (0x00000001L << XID_MU) AND + llc_data->decoded_xid.mu.valid == FALSE ) + { + llc_data->decoded_xid.mu.valid = TRUE; + llc_data->decoded_xid.mu.value = llc_data->u->requested_xid.mu.valid + ? llc_data->u->requested_xid.mu.value + : *(llc_data->mu); + } + + if (llc_data->u->xid_tag_sent & (0x00000001L << XID_KD) AND + llc_data->decoded_xid.kd.valid == FALSE ) + { + llc_data->decoded_xid.kd.valid = TRUE; + llc_data->decoded_xid.kd.value = llc_data->u->requested_xid.kd.valid + ? llc_data->u->requested_xid.kd.value + : *(llc_data->kd); + } + + if (llc_data->u->xid_tag_sent & (0x00000001L << XID_KU) AND + llc_data->decoded_xid.ku.valid == FALSE ) + { + llc_data->decoded_xid.ku.valid = TRUE; + llc_data->decoded_xid.ku.value = llc_data->u->requested_xid.ku.valid + ? llc_data->u->requested_xid.ku.value + : *(llc_data->ku); + } + + + /* + * Layer 3 XID must be included in resonse, if it was included in request + */ + +} /* u_handle_optimization() */ + +