FreeCalypso > hg > fc-tourmaline
view src/g23m-gprs/sm/sm_memory_handler.c @ 221:5bf097aeaad7
LLS: when turning off all LEDs on boot, skip LED-C
Having LLS turn off LED-A and LED-B on boot is normally unnecessary
(they should already be off in Iota), but it is harmless, hence this
logic is kept for robustness. However, having LLS read-modify-write
the BCICTL2 register (to turn off LED-C) creates a potential race
condition with FCHG writes to this register, especially in the case
when baseband switch-on is caused by VCHG and charging is expected
to start right away. Furthermore, control of the charging LED itself
(on those hw targets that have it) is the responsibility of the FCHG
SWE, hence LLS should leave it alone.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Mon, 26 Apr 2021 21:55:13 +0000 |
parents | fa8dc04885d8 |
children |
line wrap: on
line source
/*---------------------------------------------------------------------------- | Project : 3G PS | Module : SM +----------------------------------------------------------------------------- | Copyright 2003 Texas Instruments. | All rights reserved. | | This file is confidential and a trade secret of Texas | Instruments . | 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. +----------------------------------------------------------------------------- | Purpose: Memory allocation function definition for the SM Entity. | For design details, see: | 8010.908 SM Detailed Specification +---------------------------------------------------------------------------*/ /*==== DECLARATION CONTROL =================================================*/ /*==== INCLUDES =============================================================*/ #include "sm.h" #include "sm_tft.h" /*==== CONSTS ===============================================================*/ /*==== TYPES ================================================================*/ /*==== LOCALS ===============================================================*/ /*==== PRIVATE FUNCTIONS ====================================================*/ /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : sm_pfree +------------------------------------------------------------------------------ | Description : PFREE macro replacement | | Parameters : data - memory to free +------------------------------------------------------------------------------ */ void sm_pfree(/*@only@*/ /*@null@*/ /*@out@*/ void *data) { if (data != NULL) { vsi_c_pfree((T_VOID_STRUCT **)&data FILE_LINE_MACRO); } } /* +------------------------------------------------------------------------------ | Function : sm_mfree +------------------------------------------------------------------------------ | Description : Wrapper for MFREE macro | | Parameters : data - memory to free +------------------------------------------------------------------------------ */ static void sm_mfree(/*@only@*/ /*@out@*/ /*@null@*/ void *data) { if (data != NULL) { MFREE(data); } } /* +------------------------------------------------------------------------------ | Function : sm_allocate_context_data +------------------------------------------------------------------------------ | Description : Allocate an instance of SM_CONTEXT_DATA | | Parameters : None +------------------------------------------------------------------------------ */ struct T_SM_CONTEXT_DATA *sm_allocate_context_data(void) { struct T_SM_CONTEXT_DATA *context; context = (struct T_SM_CONTEXT_DATA *) M_ALLOC((U32)sizeof(struct T_SM_CONTEXT_DATA)); return context; } /* +------------------------------------------------------------------------------ | Function : sm_assign_context_data_to_nsapi +------------------------------------------------------------------------------ | Description : Assign a non-zero context data structure to an NSAPI index in | sm_context_array. | | Parameters : context - Context data | nsapi - Index at which to insert data +------------------------------------------------------------------------------ */ void sm_assign_context_data_to_nsapi(/*@only@*/struct T_SM_CONTEXT_DATA *context, int /*@alt U8@*/ nsapi) { TRACE_ASSERT(context != NULL); TRACE_ASSERT(sm_data.sm_context_array[nsapi - (int)NAS_NSAPI_5] == NULL); sm_data.sm_context_array[nsapi - (int)NAS_NSAPI_5] = context; } /* +------------------------------------------------------------------------------ | Function : sm_get_context_data_from_nsapi +------------------------------------------------------------------------------ | Description : Returns a context data structure for the given NSAPI index. | Returns NULL, if the context is inactive. | | Parameters : nsapi - Index at which to fetch data +------------------------------------------------------------------------------ */ struct T_SM_CONTEXT_DATA * sm_get_context_data_from_nsapi(int /*@alt U8@*/ nsapi) { TRACE_ASSERT((T_NAS_nsapi)nsapi >= NAS_NSAPI_5 && nsapi <= NAS_NSAPI_15); /*lint -e{661} sm_context_array causes out of bounds access, it does not! */ return sm_data.sm_context_array[nsapi - (int)NAS_NSAPI_5]; } /* +------------------------------------------------------------------------------ | Function : sm_assign_context_data_to_nsapi +------------------------------------------------------------------------------ | Description : Returns a context data structure for the given TI value. | Returns NULL, if the context is inactive. | | Parameters : ti - TI value identifying the context +------------------------------------------------------------------------------ */ /*@null@*/struct T_SM_CONTEXT_DATA * sm_get_context_data_from_ti(int /*@alt U8@*/ ti) { int index; /* First, search sm_context_array: */ for (index = 0; index < SM_MAX_NSAPI_OFFSET; index++) { if (sm_data.sm_context_array[index] != NULL && (sm_data.sm_context_array[index]->ti & SM_TI_MASK) == (ti & SM_TI_MASK)) { return sm_data.sm_context_array[index]; } } /* Next, try in sm_pending_mt_array: */ for (index = 0; index < SM_MAX_NSAPI_OFFSET; index++) { if (sm_data.sm_pending_mt_array[index] != NULL && sm_data.sm_pending_mt_array[index]->ti == ti) { return sm_data.sm_pending_mt_array[index]; } } /* None found: return NULL */ return NULL; } /* +------------------------------------------------------------------------------ | Function : sm_free_context_data +------------------------------------------------------------------------------ | Description : Free context data memory. Calls de-initialization functions | in state machines. | | Parameters : context - Context data +------------------------------------------------------------------------------ */ void sm_free_context_data(/*@only@*/struct T_SM_CONTEXT_DATA *context) { if (context != NULL) { sm_user_plane_control_exit (context); sm_network_control_exit (context); sm_context_deactivate_control_exit(context); sm_context_control_exit (context); TRACE_ASSERT(context->apn == NULL); TRACE_ASSERT(context->requested_pco == NULL); TRACE_ASSERT(context->negotiated_pco == NULL); TRACE_ASSERT(context->requested_tft.ptr_tft_pf == NULL); TRACE_ASSERT(context->active_tft.ptr_tft_pf == NULL); TRACE_ASSERT(context->coded_msg == NULL); sm_mfree(context); } } /* +------------------------------------------------------------------------------ | Function : sm_free_context_data_by_nsapi +------------------------------------------------------------------------------ | Description : Frees context identified by NSAPI. Uses sm_free_context_data() | | Parameters : nsapi - NSAPI +------------------------------------------------------------------------------ */ void sm_free_context_data_by_nsapi(int /*@alt U8@*/ nsapi) { U16 index; TRACE_ASSERT((T_NAS_nsapi)nsapi >= NAS_NSAPI_5 && nsapi <= NAS_NSAPI_15); index = sm_nsapi_to_index((U16)nsapi); sm_free_context_data(sm_data.sm_context_array[index]); sm_data.sm_context_array[index] = NULL; } /* +------------------------------------------------------------------------------ | Function : sm_insert_mt_context_data +------------------------------------------------------------------------------ | Description : Allocates and inserts context data structure in | sm_pending_mt_array. | | Parameters : ti - TI value identifying context +------------------------------------------------------------------------------ */ /*@observer@*/ /*@null@*/ struct T_SM_CONTEXT_DATA * sm_insert_mt_context_data(int /*@alt U8@*/ ti) { int index, insert_index = -1; struct T_SM_CONTEXT_DATA *context; for (index = 0; index < SM_MAX_NSAPI_OFFSET; index++) { if (insert_index < 0 && sm_data.sm_pending_mt_array[index] == NULL) { insert_index = index; } if (sm_data.sm_pending_mt_array[index] != NULL && sm_data.sm_pending_mt_array[index]->ti == ti) { (void)TRACE_EVENT_P1("ERROR: Tried to overwrite MT context data for TI=%d!", ti); return sm_data.sm_pending_mt_array[index]; } } context = sm_allocate_context_data(); if (context != NULL && insert_index >= 0) { memset(context, 0, sizeof(struct T_SM_CONTEXT_DATA)); context->ti = (U8)ti; sm_data.sm_pending_mt_array[insert_index] = context; } else if (insert_index < 0) { (void)TRACE_ERROR("ERROR: No free entries in MT context data array!"); } else { (void)TRACE_ERROR("ERROR: Unable to allocate memory for context data array!"); } return context; } /* +------------------------------------------------------------------------------ | Function : sm_extract_mt_context_data +------------------------------------------------------------------------------ | Description : Searches sm_pending_mt_array for the input TI. Returns the | address of the data structure found, if any; otherwise NULL. | If found, the entry in sm_pending_mt_array is reset to NULL. | | Parameters : ti - TI value identifying context +------------------------------------------------------------------------------ */ /*@null@*/ /*@only@*/struct T_SM_CONTEXT_DATA * sm_extract_mt_context_data(int /*@alt U8@*/ ti) { int index; for (index = 0; index < SM_MAX_NSAPI_OFFSET; index++) { if (sm_data.sm_pending_mt_array[index] != NULL && sm_data.sm_pending_mt_array[index]->ti == ti) { struct T_SM_CONTEXT_DATA *context; context = sm_data.sm_pending_mt_array[index]; sm_data.sm_pending_mt_array[index] = NULL; return context; } /* if */ } /* for */ return NULL; } /* +------------------------------------------------------------------------------ | Function : sm_free_pending_mt_context_by_index +------------------------------------------------------------------------------ | Description : Frees context in sm_pending_mt_array indentified by index | | Parameters : index - index in sm_pending_mt_array[] +------------------------------------------------------------------------------ */ void sm_free_pending_mt_context_by_index(U16 index) { TRACE_ASSERT(index < (U16)SM_MAX_NSAPI_OFFSET); /*lint -e{661} sm_context_array causes out of bounds access, it does not! */ sm_free_context_data(sm_data.sm_pending_mt_array[index]); /*lint -e{661} sm_context_array causes out of bounds access, it does not! */ sm_data.sm_pending_mt_array[index] = NULL; } /* +------------------------------------------------------------------------------ | Function : sm_linked_nsapis +------------------------------------------------------------------------------ | Description : Returns the nsapi_set of secondary contexts linked to this | context. | | Parameters : context - context data +------------------------------------------------------------------------------ */ U16 sm_linked_nsapis(U8 ti) { struct T_SM_CONTEXT_DATA *context; int nsapi; U16 linked_nsapis = 0; U8 linked_ti; context = sm_get_context_data_from_ti(ti); TRACE_ASSERT(context != NULL); if (context EQ NULL) return linked_nsapis; if (sm_is_secondary(context)) { linked_ti = context->linked_ti; } else { linked_ti = ti; } for (nsapi = (int)NAS_NSAPI_5; nsapi < NAS_SIZE_NSAPI; nsapi++) { context = sm_get_context_data_from_nsapi(nsapi); if (context != NULL && context->ti != (U8)ti && context->ti != linked_ti && sm_is_secondary(context) && context->linked_ti == (U8)ti) { linked_nsapis = sm_add_nsapi_to_nsapi_set(nsapi, linked_nsapis); } /* if */ } /* for */ return linked_nsapis; } /* +------------------------------------------------------------------------------ | Function : sm_free_coded_msg +------------------------------------------------------------------------------ | Description : Stores a coded message in context data. | Used for retransmissions (i.e. in case of time-outs, resume | after suspension). | | Parameters : context - context data | msg - coded message +------------------------------------------------------------------------------ */ void sm_allocate_and_copy_coded_msg(struct T_SM_CONTEXT_DATA *context, U8 est_cause, /*@in@*/ T_sdu *msg) { U32 msg_len; #ifdef DEBUG_VERBOSE (void)TRACE_FUNCTION("sm_allocate_and_copy_coded_msg"); #endif msg_len = (U32)(msg->l_buf >> 3); if (context->coded_msg != NULL) { sm_free_coded_msg(context); } TRACE_ASSERT(context->coded_msg == NULL); /* Allocate space for T_sdu (l_buf and o_buf) + air interface message octets */ context->coded_msg = (T_sdu *)M_ALLOC(msg_len + (U32)offsetof(T_sdu, buf)); if (context->coded_msg == NULL) { return; } /* coded_msg->o_buf is always 0. So we store the only external parameter * in there (est_cause). */ context->coded_msg->l_buf = msg->l_buf; context->coded_msg->o_buf = (U16)est_cause; memcpy(context->coded_msg->buf, &msg->buf[(msg->o_buf >> 3)], (size_t)msg_len); } /* +------------------------------------------------------------------------------ | Function : sm_free_coded_msg +------------------------------------------------------------------------------ | Description : Frees the coded message stored for this NSAPI, if any. | | Parameters : context - context data +------------------------------------------------------------------------------ */ void sm_free_coded_msg(struct T_SM_CONTEXT_DATA *context) { #ifdef DEBUG_VERBOSE (void)TRACE_FUNCTION("sm_free_coded_msg"); #endif if (context->coded_msg != NULL) { sm_mfree(context->coded_msg); } context->coded_msg = NULL; } /*====================================================================== * Network Control Memory Handler Functions *======================================================================*/ /* +------------------------------------------------------------------------------ | Function : sm_nw_allocate_and_copy_*_pco +------------------------------------------------------------------------------ | Description : Allocate and copy requested or negotiated PCO data structure. | | Parameters : context - context data | pco_len - PCO data length | pco - PCO data +------------------------------------------------------------------------------ */ void sm_nw_allocate_and_copy_requested_pco(/*@special@*/ struct T_SM_CONTEXT_DATA *context, size_t /*@alt U8,U16@*/ pco_len, /*@unique@*/ U8 *pco) { TRACE_ASSERT(context->requested_pco == NULL); context->requested_pco = (T_SM_pco *)M_ALLOC((U32)(pco_len + 1)); TRACE_ASSERT(context->requested_pco != NULL); context->requested_pco->c_pco_value = (U8)pco_len; memcpy(context->requested_pco->pco_value, pco, (size_t)pco_len); } void sm_nw_allocate_and_copy_negotiated_pco(/*@special@*/ struct T_SM_CONTEXT_DATA *context, size_t /*@alt U8@*/ pco_len, /*@unique@*/ U8 *pco) { TRACE_ASSERT(context->negotiated_pco == NULL); context->negotiated_pco = (T_SM_pco *)M_ALLOC((U32)(pco_len + 1)); TRACE_ASSERT(context->negotiated_pco != NULL); context->negotiated_pco->c_pco_value = (U8)pco_len; memcpy(context->negotiated_pco->pco_value, pco, (size_t)pco_len); } /* +------------------------------------------------------------------------------ | Function : sm_nw_free_*_pco +------------------------------------------------------------------------------ | Description : Free requested or negotiated PCO data structure | | Parameters : context - context data +------------------------------------------------------------------------------ */ void sm_nw_free_requested_pco(/*@special@*/struct T_SM_CONTEXT_DATA *context) { if (context->requested_pco != NULL) { sm_mfree(context->requested_pco); context->requested_pco = NULL; } } void sm_nw_free_negotiated_pco(/*@special@*/struct T_SM_CONTEXT_DATA *context) { if (context->negotiated_pco != NULL) { sm_mfree(context->negotiated_pco); context->negotiated_pco = NULL; } } /* +------------------------------------------------------------------------------ | Function : sm_nw_allocate_and_copy_apn +------------------------------------------------------------------------------ | Description : Allocate and copy APN data structure. Inserted into context | data structure. | | Parameters : context - Context data | apn - APN data structure +------------------------------------------------------------------------------ */ void sm_nw_allocate_and_copy_apn(/*@special@*/ struct T_SM_CONTEXT_DATA *context, U8 c_apn, /*@unique@*/ U8 *apn) { #ifdef DEBUG_VERBOSE (void)TRACE_FUNCTION("sm_nw_allocate_and_copy_apn"); #endif TRACE_ASSERT(context->apn == NULL); context->apn = (T_SMREG_apn *)M_ALLOC((U32)sizeof(T_SMREG_apn)); TRACE_ASSERT(context->apn != NULL); context->apn->c_apn_buf = c_apn; memcpy(context->apn->apn_buf, apn, (size_t)c_apn); } /* +------------------------------------------------------------------------------ | Function : sm_nw_free_apn +------------------------------------------------------------------------------ | Description : Free APN data structure | | Parameters : context - Context data +------------------------------------------------------------------------------ */ void sm_nw_free_apn(/*@special@*/ struct T_SM_CONTEXT_DATA *context) { #ifdef DEBUG_VERBOSE (void)TRACE_FUNCTION("sm_nw_free_apn"); #endif if (context->apn != NULL) { sm_mfree(context->apn); context->apn = NULL; } } /* +------------------------------------------------------------------------------ | Function : sm_nw_is_address_and_apn_equal +------------------------------------------------------------------------------ | Description : Compare requested IP address and APN with incoming ditto | | Parameters : context - Context data | address - incoming IP address | v_apn - valid flag for APN | apn - APN value (void if v_apn == FALSE) +------------------------------------------------------------------------------ */ BOOL sm_nw_is_address_and_apn_equal(struct T_SM_CONTEXT_DATA *context, T_NAS_ip *context_address, T_M_SM_address *msg_address, U8 v_apn, T_M_SM_apn *apn) { /* Compare IP address */ if (context_address->ctrl_ip_address == NAS_is_ip_not_present) { return FALSE; } else if (msg_address->pdp_type_org == (U8)M_SM_IETF_ORG && context->pdp_type == msg_address->pdp_type_no) { if (context->pdp_type == (U8)SMREG_PDP_IPV4) { if (msg_address->c_add_info == (U8)NAS_SIZE_IPv4_ADDR && memcmp(context_address->ip_address.ipv4_addr.a4, msg_address->add_info, (size_t)NAS_SIZE_IPv4_ADDR) == 0) { /* IP address equal: FALLTHROUGH */ } else { return FALSE; } } else if (context->pdp_type == (U8)SMREG_PDP_IPV6) { if (msg_address->c_add_info == (U8)NAS_SIZE_IPv6_ADDR && memcmp(context_address->ip_address.ipv6_addr.a6, msg_address->add_info, (size_t)NAS_SIZE_IPv6_ADDR) == 0) { /* IP address equal: FALLTHROUGH */ } else { return FALSE; } } else { /* Bogus pdp_type */ return FALSE; } } else { return FALSE; } /* Compare APN */ if (v_apn == (U8)TRUE) { /* Incoming APN present: Requested APN must also be present, and have same length and values */ if (context->apn != NULL) { if (context->apn->c_apn_buf == apn->c_apn_value) { if (memcmp(context->apn->apn_buf, apn->apn_value, (size_t)apn->c_apn_value) == 0) { return TRUE; } } } return FALSE; } else { /* If incoming APN is absent, equality depends on the presence of a requested APN */ return (context->apn == NULL); } } /* +------------------------------------------------------------------------------ | Function : sm_nw_allocate_and_copy_requested_tft +------------------------------------------------------------------------------ | Description : Allocate and copy TFT data structure. Inserted into context | data structure. | | Parameters : context - Context data | tft - TFT data structure +------------------------------------------------------------------------------ */ void sm_nw_allocate_and_copy_requested_tft(/*@special@*/ struct T_SM_CONTEXT_DATA *context, /*@in@*/ T_NAS_tft *tft) { #ifdef DEBUG_VERBOSE (void)TRACE_FUNCTION("sm_nw_allocate_and_copy_requested_tft"); #endif /* Free TFT memory if a TFT was already present but with a different * number of elements. */ if (context->requested_tft.ptr_tft_pf != NULL && context->requested_tft.c_tft_pf != tft->c_tft_pf) { sm_nw_free_requested_tft(context); } /* Allocate memory if TFT was not present before, or if it was freed above.*/ if (context->requested_tft.ptr_tft_pf == NULL) { context->requested_tft.c_tft_pf = tft->c_tft_pf; context->requested_tft.ptr_tft_pf = (T_NAS_tft_pf *) M_ALLOC((U32)sizeof(T_NAS_tft_pf) * (U32)context->requested_tft.c_tft_pf); TRACE_ASSERT(context->requested_tft.ptr_tft_pf != NULL); } memcpy(context->requested_tft.ptr_tft_pf, tft->ptr_tft_pf, sizeof(T_NAS_tft_pf) * (size_t)context->requested_tft.c_tft_pf); context->requested_tft.tft_precence_mask = sm_tft_precence_mask(tft->ptr_tft_pf, tft->c_tft_pf); } /* +------------------------------------------------------------------------------ | Function : sm_nw_allocate_active_tft +------------------------------------------------------------------------------ | Description : Allocate active TFT data structure. Inserted into context | data structure. | | Parameters : context - Context data +------------------------------------------------------------------------------ */ void sm_nw_allocate_active_tft(/*@special@*/struct T_SM_CONTEXT_DATA *context) { #ifdef DEBUG_VERBOSE (void)TRACE_FUNCTION("sm_nw_allocate_active_tft"); #endif TRACE_ASSERT (context->active_tft.ptr_tft_pf == NULL); context->active_tft.c_tft_pf = (U8)0; context->active_tft.ptr_tft_pf = (T_NAS_tft_pf *) M_ALLOC((U32)sizeof(T_NAS_tft_pf) * (U32)NAS_SIZE_TFT_FILTER); TRACE_ASSERT(context->active_tft.ptr_tft_pf != NULL); context->active_tft.tft_precence_mask = (U8)0; } /* +------------------------------------------------------------------------------ | Function : sm_nw_free_requested_tft +------------------------------------------------------------------------------ | Description : Free TFT data structure | | Parameters : context - Context data +------------------------------------------------------------------------------ */ void sm_nw_free_requested_tft(/*@special@*/struct T_SM_CONTEXT_DATA *context) { #ifdef DEBUG_VERBOSE (void)TRACE_FUNCTION("sm_nw_free_requested_tft"); #endif if (context->requested_tft.ptr_tft_pf != NULL) { sm_mfree(context->requested_tft.ptr_tft_pf); context->requested_tft.ptr_tft_pf = NULL; context->requested_tft.c_tft_pf = (U8)0; context->requested_tft.tft_precence_mask = (U8)0; } } /* +------------------------------------------------------------------------------ | Function : sm_nw_free_active_tft +------------------------------------------------------------------------------ | Description : Free TFT data structure | | Parameters : context - Context data +------------------------------------------------------------------------------ */ void sm_nw_free_active_tft(/*@special@*/struct T_SM_CONTEXT_DATA *context) { #ifdef DEBUG_VERBOSE (void)TRACE_FUNCTION("sm_nw_free_active_tft"); #endif if (context->active_tft.ptr_tft_pf != NULL) { sm_mfree(context->active_tft.ptr_tft_pf); context->active_tft.ptr_tft_pf = NULL; context->active_tft.c_tft_pf = (U8)0; context->active_tft.tft_precence_mask = (U8)0; } } /* +------------------------------------------------------------------------------ | Function : sm_nw_store_requested_address +------------------------------------------------------------------------------ | Description : Utility function which stores the IP address requested from | the network. | | Parameters : context - context data | pdp_type - PDP type number | ctrl_ip_address - IP address type | ip_address - IP address (void if ctrl_ip_address == NAS_is_ip_not_present) +------------------------------------------------------------------------------ */ void sm_nw_store_requested_address(struct T_SM_CONTEXT_DATA *context, U8 pdp_type, T_NAS_ctrl_ip_address ctrl_ip_address, T_NAS_ip_address *ip_address) { context->pdp_type = pdp_type; context->requested_address.ctrl_ip_address = ctrl_ip_address; if (ctrl_ip_address != NAS_is_ip_not_present) { if (pdp_type == (U8)SMREG_PDP_PPP || (pdp_type == (U8)SMREG_PDP_IPV4 && ctrl_ip_address != NAS_is_ipv4) || (pdp_type == (U8)SMREG_PDP_IPV6 && ctrl_ip_address != NAS_is_ipv6)) { (void)TRACE_ERROR("Mismatching pdp_type and ip_address controller field in SMREG_PDP_ACTIVATE_REQ - using union controller!"); } switch (ctrl_ip_address) { case NAS_is_ipv4: context->pdp_type = (U8)SMREG_PDP_IPV4; memcpy(context->requested_address.ip_address.ipv4_addr.a4, ip_address->ipv4_addr.a4, (size_t)NAS_SIZE_IPv4_ADDR); break; case NAS_is_ipv6: context->pdp_type = (U8)SMREG_PDP_IPV6; memcpy(context->requested_address.ip_address.ipv6_addr.a6, ip_address->ipv6_addr.a6, (size_t)NAS_SIZE_IPv6_ADDR); break; default: break; } } } /* +------------------------------------------------------------------------------ | Function : sm_nw_store_negotiated_address +------------------------------------------------------------------------------ | Description : Utility function which stores the address received from the | network. | | Parameters : context - context data | v_address - valid flag for address | address - IP address (void if v_address == FALSE) +------------------------------------------------------------------------------ */ void sm_nw_store_negotiated_address(struct T_SM_CONTEXT_DATA *context, T_M_SM_address *address, U8 v_address) { if (v_address == (U8)TRUE && address->pdp_type_org == (U8)M_SM_IETF_ORG) { /* Update PDP type from message */ context->pdp_type = address->pdp_type_no; if (address->pdp_type_no == (U8)M_SM_IP4_TYPE) { if (address->c_add_info != (U8)NAS_SIZE_IPv4_ADDR) { (void)TRACE_EVENT_P1("Warning: IPv4 address has length %d != 4!", (int)address->c_add_info); } context->negotiated_address.ctrl_ip_address = NAS_is_ipv4; memcpy(&context->negotiated_address.ip_address, &address->add_info, (size_t)NAS_SIZE_IPv4_ADDR); } else if (address->pdp_type_no == (U8)M_SM_IP6_TYPE) { if (address->c_add_info != (U8)NAS_SIZE_IPv6_ADDR) { (void)TRACE_EVENT_P1("Warning: IPv6 address has length %d != 16!", (int)address->c_add_info); } context->negotiated_address.ctrl_ip_address = NAS_is_ipv6; memcpy(&context->negotiated_address.ip_address, &address->add_info, (size_t)NAS_SIZE_IPv6_ADDR); } else { (void)TRACE_EVENT_P1("ERROR: Invalid PDP type %d; address discarded!", address->pdp_type_no); } } else { /* Check for static IP address allocation/request; * PDP addr IE is not included in this case [3G 24.008, 9.5.2.1] */ switch (context->requested_address.ctrl_ip_address) { case NAS_is_ipv4: context->pdp_type = (U8)SMREG_PDP_IPV4; context->negotiated_address.ctrl_ip_address = NAS_is_ipv4; memcpy(context->negotiated_address.ip_address.ipv4_addr.a4, context->requested_address .ip_address.ipv4_addr.a4, (size_t)NAS_SIZE_IPv4_ADDR); break; case NAS_is_ipv6: context->pdp_type = (U8)SMREG_PDP_IPV6; context->negotiated_address.ctrl_ip_address = NAS_is_ipv6; memcpy(context->negotiated_address.ip_address.ipv6_addr.a6, context->requested_address .ip_address.ipv6_addr.a6, (size_t)NAS_SIZE_IPv6_ADDR); break; default: /* PPP or other non-IP address context; i.e. no static address alloc. */ context->negotiated_address.ctrl_ip_address = NAS_is_ip_not_present; } } } /* +------------------------------------------------------------------------------ | Function : sm_nw_copy_negotiated_address_to_requested +------------------------------------------------------------------------------ | Description : Utility function which copies the address received from the | network to be the requested address. Used for context | reactivations, which must use the negotiated IP address. | | Parameters : context - context data +------------------------------------------------------------------------------ */ void sm_nw_copy_negotiated_address_to_requested(struct T_SM_CONTEXT_DATA *context) { sm_nw_store_requested_address(context, context->pdp_type, context->negotiated_address.ctrl_ip_address, &context->negotiated_address.ip_address); } /* +------------------------------------------------------------------------------ | Function : sm_is_address_changed_with_reactivation +------------------------------------------------------------------------------ | Description : Utility function which compares the address of the air message | and the address already stored in the context. This function | is useful only in PDP REACTIVATION cases. If the addresses | are not equal the function returns false and the pdp context | gets deactivated. | | Parameters : context - context data, air message address +------------------------------------------------------------------------------ */ BOOL sm_is_address_changed_with_reactivation(struct T_SM_CONTEXT_DATA *context, T_M_SM_address *address, U8 v_address) { BOOL result = FALSE; if (sm_is_context_pending_reactivation(context)) { if (v_address == (U8)TRUE && address->pdp_type_org == (U8)M_SM_IETF_ORG) { if ( (address->pdp_type_no == (U8)M_SM_IP4_TYPE) && (context->negotiated_address.ctrl_ip_address == NAS_is_ipv4) ) { if (memcmp(&context->negotiated_address.ip_address, &address->add_info, (size_t)NAS_SIZE_IPv4_ADDR) != 0) { result = TRUE; } } else if ( (address->pdp_type_no == (U8)M_SM_IP6_TYPE) && (context->negotiated_address.ctrl_ip_address == NAS_is_ipv6) ) { if (memcmp(&context->negotiated_address.ip_address, &address->add_info, (size_t)NAS_SIZE_IPv6_ADDR) != 0) { result = TRUE; } } } /* Clear the pending reactivation flag. We don't need this anymore. */ sm_set_context_pending_reactivation(context, FALSE); } if (result == TRUE) { (void)TRACE_EVENT_P1( "PDP address changed with reactivation. Deactivate nsapi %d", context->nsapi ); } return result; } /*==== END OF FILE ==========================================================*/