FreeCalypso > hg > fc-selenite
view src/g23m-fad/ppp/ppp_frxf.c @ 158:8fe0cde2fd79
doc/Compiling: update for SE J100 target and fc-host-tools-r10
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Sun, 17 Mar 2019 07:20:28 +0000 |
parents | d393cd9bb723 |
children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | 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 PPP and implements all | procedures and functions as described in the | SDL-documentation (FRX-statemachine) +----------------------------------------------------------------------------- */ #define ENTITY_PPP /*==== INCLUDES =============================================================*/ #include "typedefs.h" /* to get Condat data types */ #include "vsi.h" /* to get a lot of macros */ #include "macdef.h" /* to get a lot of macros */ #include "custom.h" /* to get a lot of macros */ /*lint -efile(766,gsm.h) */ #include "gsm.h" /* to get a lot of macros */ /*lint -efile(766,cnf_ppp.h) */ #include "cnf_ppp.h" /* to get cnf-definitions */ /*lint -efile(766,mon_ppp.h) */ #include "mon_ppp.h" /* to get mon-definitions */ #include "prim.h" /* to get the definitions of used SAP and directions */ #include "dti.h" /* to get the DTILIB definitions */ #include "ppp.h" /* to get the global entity definitions */ #include "ppp_ptxs.h" /* to get signal interface from ptx */ #include "ppp_arbf.h" /* to get arb functions */ #include <string.h> /* to get memcpy */ #ifdef PPP_HDLC_TRACE #include <stdio.h> /* to get sprintf */ #endif /* PPP_HDLC_TRACE */ /*==== CONST ================================================================*/ /*==== LOCAL VARS ===========================================================*/ /*==== PRIVATE FUNCTIONS ====================================================*/ /*==== PUBLIC FUNCTIONS =====================================================*/ #ifndef PPP_INT_RAM /* +------------------------------------------------------------------------------ | Function : frx_init +------------------------------------------------------------------------------ | Description : The function frx_init() initializes Frame Receive (FRX) | | Parameters : no parameters | +------------------------------------------------------------------------------ */ GLOBAL void frx_init () { TRACE_FUNCTION( "frx_init" ); ppp_data->frx.frame_complete = FALSE; ppp_data->frx.stored_packet = NULL; ppp_data->frx.received_data = NULL; ppp_data->frx.store_state = FRX_ADD_ERROR; ppp_data->frx.data_flow_state = FRX_DATA_FLOW_DEAD; #ifdef PPP_HDLC_TRACE ppp_data->frx.hdlc_frame = NULL; #endif /* PPP_HDLC_TRACE */ INIT_STATE( PPP_SERVICE_FRX , FRX_DEAD ); } /* frx_init() */ #endif /* PPP_INT_RAM */ #ifndef PPP_FLASH_ROM /* +------------------------------------------------------------------------------ | Function : frx_add_desc +------------------------------------------------------------------------------ | Description : The function frx_add_desc() appends the given | generic data descriptor to the already received descriptors. | The function removes transparent characters and calculates | the fcs. | | Parameters : no parameters | +------------------------------------------------------------------------------ */ GLOBAL void frx_add_desc () { UBYTE store_state; UBYTE currentbyte; USHORT fcs; UBYTE escape; USHORT s_offset; USHORT s_size; UBYTE* destination; USHORT d_offset; USHORT d_size; USHORT* fcstab; T_desc2* source_desc; T_desc2* temp_desc; USHORT packet_len; #ifdef PPP_HDLC_TRACE T_desc2* trace_desc; T_desc2* trace_desc2; T_desc2* trace_desc3; USHORT trace_pos; char buf[100]; USHORT i; #endif /* PPP_HDLC_TRACE */ TRACE_FUNCTION( "frx_add_desc" ); #ifdef PPP_HDLC_TRACE /* * trace HDLC frame * the goal is to trace out only erroneous PPP frames * if a correct PPP frame is received * we just release the stored copy of this frame without tracing */ /* * set source pointer */ trace_desc = ppp_data->frx.received_data; trace_pos = ppp_data->frx.proceed_data; switch(ppp_data->frx.store_state) { case FRX_ADD_ERROR: /* * we trace out each byte til the first HDLC flag */ /* * release old stored HDLC frame * this should not be necessary */ MFREE_DESC2(ppp_data->frx.hdlc_frame); ppp_data->frx.hdlc_frame = NULL; /* * trace incomming data until the first HDLC flag */ while((trace_desc) && (trace_pos >= trace_desc->len)) { trace_desc = (T_desc2*)trace_desc->next; trace_pos = 0; } if((trace_desc) && (trace_desc->buffer[trace_pos] NEQ PPP_HDLC_FLAG)) { TRACE_EVENT("waiting for next HDLC flag:"); i = 0; do { i+= sprintf(&buf[i], "0x%02x, ", trace_desc->buffer[trace_pos]); trace_pos++; while((trace_desc) && (trace_pos >= trace_desc->len)) { trace_desc = (T_desc2*)trace_desc->next; trace_pos = 0; } if(i > 80) { TRACE_EVENT( buf ); i = 0; } } while((trace_desc) && (trace_desc->buffer[trace_pos] NEQ PPP_HDLC_FLAG)); if(i > 0) { TRACE_EVENT( buf ); i = 0; } } break; case FRX_ADD_HDLC_BEGIN: /* * we store just the first HDLC flag and fall through * to the default case to store the complete PPP frame */ /* * release old stored HDLC frame */ MFREE_DESC2(ppp_data->frx.hdlc_frame); ppp_data->frx.hdlc_frame = NULL; if(trace_desc) { /* * allocate first descriptor to store new HDLC frame */ MALLOC(trace_desc2, (USHORT)(sizeof(T_desc2) - 1 + FRX_ADD_SMALL_PACKET_SIZE)); trace_desc2->len = 0; trace_desc2->next = (ULONG)NULL; ppp_data->frx.hdlc_frame = trace_desc2; /* * store first HDLC flag */ TRACE_EVENT_P2("start flag found in desc=0x%08x: pos=%d", trace_desc, trace_pos); trace_desc2->buffer[trace_desc2->len] = trace_desc->buffer[trace_pos]; trace_desc2->len++; trace_pos++; while((trace_desc) && (trace_pos >= trace_desc->len)) { trace_desc = (T_desc2*)trace_desc->next; trace_pos = 0; } } /* fall through */ default: /* * to store the complete PPP frame */ /* * set destination pointer */ trace_desc2 = ppp_data->frx.hdlc_frame; while(trace_desc2->next NEQ (ULONG)NULL) { trace_desc2 = (T_desc2*)trace_desc2->next; } /* * set source pointer */ while((trace_desc) && (trace_pos >= trace_desc->len)) { trace_desc = (T_desc2*)trace_desc->next; trace_pos = 0; } if(trace_desc) { /* * store HDLC frame */ while((trace_desc) && (trace_desc->buffer[trace_pos] NEQ PPP_HDLC_FLAG)) { if(trace_desc2->len >= FRX_ADD_SMALL_PACKET_SIZE) { MALLOC(trace_desc3, (USHORT)(sizeof(T_desc2) - 1 + FRX_ADD_SMALL_PACKET_SIZE)); trace_desc3->len = 0; trace_desc3->next = (ULONG)NULL; trace_desc2->next = (ULONG)trace_desc3; trace_desc2 = trace_desc3; } trace_desc2->buffer[trace_desc2->len] = trace_desc->buffer[trace_pos]; trace_desc2->len++; trace_pos++; while((trace_desc) && (trace_pos >= trace_desc->len)) { trace_desc = (T_desc2*)trace_desc->next; trace_pos = 0; } } /* * store last HDLC flag */ if(trace_desc) { if(trace_desc2->len >= FRX_ADD_SMALL_PACKET_SIZE) { MALLOC(trace_desc3, (USHORT)(sizeof(T_desc2) - 1 + FRX_ADD_SMALL_PACKET_SIZE)); trace_desc3->len = 0; trace_desc3->next = (ULONG)NULL; trace_desc2->next = (ULONG)trace_desc3; trace_desc2 = trace_desc3; } TRACE_EVENT_P2("stop flag found in desc=0x%08x pos=%d", trace_desc, trace_pos); trace_desc2->buffer[trace_desc2->len] = trace_desc->buffer[trace_pos]; trace_desc2->len++; trace_pos++; } } break; } #endif /* PPP_HDLC_TRACE */ /* * copy all important values into local variables */ store_state = ppp_data->frx.store_state; fcs = ppp_data->frx.calc_fcs; escape = ppp_data->frx.escape; source_desc = ppp_data->frx.received_data; s_offset = ppp_data->frx.proceed_data; fcstab = ppp_data->fcstab; /* * set destination pointer */ destination = NULL; d_offset = 0; d_size = 0; switch(store_state) { case FRX_ADD_INFORMATION: case FRX_ADD_FCS1: case FRX_ADD_FCS2: destination = ppp_data->frx.cur_desc->buffer; d_offset = ppp_data->frx.cur_desc->len; d_size = ppp_data->frx.cur_desc_size; break; } /*lint !e744 switch statement has no default */ /* * while there is still data to analyze and * a complete packet is not yet received */ while((source_desc) && (ppp_data->frx.frame_complete EQ FALSE)) { /* * while the current descriptor is not yet complete analyzed. * if a complete packet is analyzed we leave the loop via break command */ for(s_size = source_desc->len; s_offset < s_size; s_offset++) { /* * set current byte */ currentbyte = source_desc->buffer[s_offset]; /* * detect HDLC flag */ if(currentbyte EQ PPP_HDLC_FLAG) { if(store_state EQ FRX_ADD_ERROR) { #ifdef PPP_HDLC_TRACE /* * store next HDLC frame */ /* * release old stored HDLC frame */ MFREE_DESC2(ppp_data->frx.hdlc_frame); ppp_data->frx.hdlc_frame = NULL; /* * set source pointer */ trace_desc = source_desc; trace_pos = s_offset; /* * allocate first descriptor to store new HDLC frame */ MALLOC(trace_desc2, (USHORT)(sizeof(T_desc2) - 1 + FRX_ADD_SMALL_PACKET_SIZE)); trace_desc2->len = 0; trace_desc2->next = (ULONG)NULL; ppp_data->frx.hdlc_frame = trace_desc2; /* * store first HDLC flag */ TRACE_EVENT_P2("start flag found in desc=0x%08x pos=%d", trace_desc, trace_pos); trace_desc2->buffer[trace_desc2->len] = trace_desc->buffer[trace_pos]; trace_desc2->len++; trace_pos++; while((trace_desc) && (trace_pos >= trace_desc->len)) { trace_desc = (T_desc2*)trace_desc->next; trace_pos = 0; } if(trace_desc) { /* * store HDLC frame */ while((trace_desc) && (trace_desc->buffer[trace_pos] NEQ PPP_HDLC_FLAG)) { if(trace_desc2->len >= FRX_ADD_SMALL_PACKET_SIZE) { MALLOC(trace_desc3, (USHORT)(sizeof(T_desc2) - 1 + FRX_ADD_SMALL_PACKET_SIZE)); trace_desc3->len = 0; trace_desc3->next = (ULONG)NULL; trace_desc2->next = (ULONG)trace_desc3; trace_desc2 = trace_desc3; } trace_desc2->buffer[trace_desc2->len] = trace_desc->buffer[trace_pos]; trace_desc2->len++; trace_pos++; while((trace_desc) && (trace_pos >= trace_desc->len)) { trace_desc = (T_desc2*)trace_desc->next; trace_pos = 0; } } /* * store last HDLC flag */ if(trace_desc) { if(trace_desc2->len >= FRX_ADD_SMALL_PACKET_SIZE) { MALLOC(trace_desc3, (USHORT)(sizeof(T_desc2) - 1 + FRX_ADD_SMALL_PACKET_SIZE)); trace_desc3->len = 0; trace_desc3->next = (ULONG)NULL; trace_desc2->next = (ULONG)trace_desc3; trace_desc2 = trace_desc3; } TRACE_EVENT_P2("stop flag found in desc=0x%08x pos=%d", trace_desc, trace_pos); trace_desc2->buffer[trace_desc2->len] = trace_desc->buffer[trace_pos]; trace_desc2->len++; trace_pos++; } } #endif /* PPP_HDLC_TRACE */ store_state = FRX_ADD_HDLC_BEGIN; } /* * begin of frame detected */ if(store_state EQ FRX_ADD_HDLC_BEGIN) { /* * initialize new packet */ ppp_data->frx.stored_len = 0; d_offset = 0; ppp_data->frx.stored_ptype = 0x0000; fcs = PPP_INITFCS; escape = FALSE; store_state = FRX_ADD_ADDRESS; } /* * end of frame detected * no error occured, frame complete * if we are in INFORMATION state we have to keep in mind the FCS at MRU check */ else if(((ppp_data->frx.stored_len + d_offset) >= 4) && (((ppp_data->frx.stored_len + d_offset) <= ppp_data->mru) || (((ppp_data->frx.stored_len + d_offset) <= (ppp_data->mru + 2)) && (store_state EQ FRX_ADD_INFORMATION))) && (fcs EQ PPP_GOODFCS)) { /* * determine the length of the packet */ packet_len = 0; ppp_data->frx.stored_len += d_offset; ppp_data->frx.cur_desc->len = d_offset; switch(store_state) { case FRX_ADD_INFORMATION: packet_len = ppp_data->frx.stored_len - 2; break; case FRX_ADD_FCS1: packet_len = ppp_data->frx.stored_len - 1; break; case FRX_ADD_FCS2: packet_len = ppp_data->frx.stored_len; break; } /*lint !e744 switch statement has no default */ if(packet_len < ppp_data->frx.stored_len) { /* * remove FCS */ ppp_data->frx.stored_len = packet_len; temp_desc = ppp_data->frx.stored_packet; while(packet_len > temp_desc->len) { packet_len-= temp_desc->len; temp_desc = (T_desc2*)temp_desc->next; } temp_desc->len = packet_len; /* * free the rest of packet */ arb_discard_packet((T_desc2*)temp_desc->next); temp_desc->next = (ULONG)NULL; } #ifdef PPP_HDLC_TRACE /* * remove stored HDLC frame because of correct reception * the storage of the next PPP frame is done * in the next call of frx_add_desc() */ MFREE_DESC2(ppp_data->frx.hdlc_frame); ppp_data->frx.hdlc_frame = NULL; #endif /* PPP_HDLC_TRACE */ /* * esape loop */ ppp_data->frx.frame_complete = TRUE; store_state = FRX_ADD_HDLC_BEGIN; break; } /* * end of frame detected * error occured, discard frame */ else { /* * error traces */ if(((ppp_data->frx.stored_len + d_offset) >= 4) && (fcs NEQ PPP_GOODFCS)) { TRACE_EVENT("ERROR HDLC PACKET PPP FCS FAULT"); } else if((ppp_data->frx.stored_len + d_offset) > ppp_data->mru) { TRACE_EVENT_P3("ERROR PPP PACKET TO LONG stored_len=%d d_offset=%d mru=%d", ppp_data->frx.stored_len, d_offset, ppp_data->mru); } #ifdef PPP_HDLC_TRACE if((ppp_data->frx.stored_len + d_offset) > 0) { /* * trace HDLC frame and store next frame */ TRACE_EVENT("wrong HDLC frame:"); i = 0; trace_pos = 0; trace_desc2 = ppp_data->frx.hdlc_frame; while(trace_desc2) { i+= sprintf(&buf[i], "0x%02x, ", trace_desc2->buffer[trace_pos]); trace_pos++; if(trace_desc2->len <= trace_pos) { trace_desc2 = (T_desc2*)trace_desc2->next; trace_pos = 0; } if(i > 80) { TRACE_EVENT( buf ); i = 0; } } if(i > 0) { TRACE_EVENT( buf ); i = 0; } } /* * release stored HDLC frame */ MFREE_DESC2(ppp_data->frx.hdlc_frame); ppp_data->frx.hdlc_frame = NULL; /* * store next HDLC frame */ /* * set source pointer */ trace_desc = source_desc; trace_pos = s_offset; /* * allocate first descriptor to store new HDLC frame */ MALLOC(trace_desc2, (USHORT)(sizeof(T_desc2) - 1 + FRX_ADD_SMALL_PACKET_SIZE)); trace_desc2->len = 0; trace_desc2->next = (ULONG)NULL; ppp_data->frx.hdlc_frame = trace_desc2; /* * store first HDLC flag */ TRACE_EVENT_P2("start flag found in desc=0x%08x pos=%d", trace_desc, trace_pos); trace_desc2->buffer[trace_desc2->len] = trace_desc->buffer[trace_pos]; trace_desc2->len++; trace_pos++; while((trace_desc) && (trace_pos >= trace_desc->len)) { trace_desc = (T_desc2*)trace_desc->next; trace_pos = 0; } if(trace_desc) { /* * store HDLC frame */ while((trace_desc) && (trace_desc->buffer[trace_pos] NEQ PPP_HDLC_FLAG)) { if(trace_desc2->len >= FRX_ADD_SMALL_PACKET_SIZE) { MALLOC(trace_desc3, (USHORT)(sizeof(T_desc2) - 1 + FRX_ADD_SMALL_PACKET_SIZE)); trace_desc3->len = 0; trace_desc3->next = (ULONG)NULL; trace_desc2->next = (ULONG)trace_desc3; trace_desc2 = trace_desc3; } trace_desc2->buffer[trace_desc2->len] = trace_desc->buffer[trace_pos]; trace_desc2->len++; trace_pos++; while((trace_desc) && (trace_pos >= trace_desc->len)) { trace_desc = (T_desc2*)trace_desc->next; trace_pos = 0; } } /* * store last HDLC flag */ if(trace_desc) { if(trace_desc2->len >= FRX_ADD_SMALL_PACKET_SIZE) { MALLOC(trace_desc3, (USHORT)(sizeof(T_desc2) - 1 + FRX_ADD_SMALL_PACKET_SIZE)); trace_desc3->len = 0; trace_desc3->next = (ULONG)NULL; trace_desc2->next = (ULONG)trace_desc3; trace_desc2 = trace_desc3; } TRACE_EVENT_P2("stop flag found in desc=0x%08x pos=%d", trace_desc, trace_pos); trace_desc2->buffer[trace_desc2->len] = trace_desc->buffer[trace_pos]; trace_desc2->len++; trace_pos++; } } #endif /* PPP_HDLC_TRACE */ /* * remove receiced packet because of an error * decrease source offset beacause the HDLC end flag * can also be the HDLC start flag of the next frame */ s_offset--; arb_discard_packet(ppp_data->frx.stored_packet); ppp_data->frx.stored_packet = NULL; store_state = FRX_ADD_HDLC_BEGIN; } } /* * detect Control Escape octet */ else if((currentbyte EQ PPP_HDLC_ESCAPE) && (escape EQ FALSE)) { escape = TRUE; } /* * usual octet */ else { /* * bit 5 complement for the octet followed by Control Escape */ if(escape EQ TRUE) { currentbyte^= 0x20; escape = FALSE; } /* * calculate FCS */ #ifdef _SIMULATION_ fcs = (fcs << 8) + currentbyte; /*lint !e734 Loss of precision */ #else /* _SIMULATION_ */ fcs = (fcs >> 8) ^ fcstab[(fcs ^ currentbyte) & 0xff]; #endif /* _SIMULATION_ */ /* * store the packet and determine the protocol */ switch(store_state) { case FRX_ADD_INFORMATION: if(d_offset >= d_size) { if((ppp_data->frx.stored_len + d_offset) < ppp_data->mru) { /* * allocate new descriptor */ switch(ppp_data->frx.stored_ptype) { case DTI_PID_LCP: case DTI_PID_PAP: case DTI_PID_CHAP: case DTI_PID_IPCP: /* * allocate a big descriptor, copy the data into the new * one and free the small descriptor */ MALLOC (ppp_data->frx.stored_packet, (USHORT)(sizeof(T_desc2) - 1 + ppp_data->mru)); memcpy(ppp_data->frx.stored_packet->buffer, destination, d_offset); /*lint !e668 Possibly passing a null pointer */ MFREE(ppp_data->frx.cur_desc); ppp_data->frx.cur_desc = ppp_data->frx.stored_packet; ppp_data->frx.cur_desc->next = (ULONG)NULL; destination = ppp_data->frx.cur_desc->buffer; d_size = ppp_data->mru; break; default: /* * allocate a new small descriptor */ MALLOC (temp_desc, (USHORT)(sizeof(T_desc2) - 1 + FRX_ADD_SMALL_PACKET_SIZE)); ppp_data->frx.cur_desc->next = (ULONG)temp_desc; ppp_data->frx.cur_desc->len = d_offset; ppp_data->frx.cur_desc = temp_desc; ppp_data->frx.cur_desc->next = (ULONG)NULL; ppp_data->frx.stored_len += d_offset; destination = ppp_data->frx.cur_desc->buffer; d_offset = 0; d_size = FRX_ADD_SMALL_PACKET_SIZE; break; } } else if((ppp_data->frx.stored_len + d_offset) >= (ppp_data->mru + 2)) { /* * remove receiced packet because it is to long */ arb_discard_packet(ppp_data->frx.stored_packet); ppp_data->frx.stored_packet = NULL; store_state = FRX_ADD_ERROR; TRACE_EVENT("ERROR PPP: HDLC packet to long"); #ifdef PPP_HDLC_TRACE /* * trace HDLC frame */ TRACE_EVENT("wrong HDLC frame:"); i = 0; trace_pos = 0; trace_desc2 = ppp_data->frx.hdlc_frame; while(trace_desc2) { i+= sprintf(&buf[i], "0x%02x, ", trace_desc2->buffer[trace_pos]); trace_pos++; if(trace_desc2->len <= trace_pos) { trace_desc2 = (T_desc2*)trace_desc2->next; trace_pos = 0; } if(i > 80) { TRACE_EVENT( buf ); i = 0; } } if(i > 0) { TRACE_EVENT( buf ); i = 0; } /* * release stored HDLC frame */ MFREE_DESC2(ppp_data->frx.hdlc_frame); ppp_data->frx.hdlc_frame = NULL; #endif /* PPP_HDLC_TRACE */ break; } else if((ppp_data->frx.stored_len + d_offset) >= (ppp_data->mru + 1)) { d_offset--; store_state = FRX_ADD_FCS2; break; } else { store_state = FRX_ADD_FCS1; break; } } /* * copy data */ destination[d_offset] = currentbyte; /*lint !e613 Possible use of null pointer */ /* * increase destination offset */ d_offset++; break; case FRX_ADD_CONTROL: if(currentbyte EQ 0x03) store_state = FRX_ADD_PROTOCOL1; else { TRACE_EVENT("ERROR PPP: wrong HDLC control field"); #ifdef PPP_HDLC_TRACE /* * trace HDLC frame */ TRACE_EVENT("wrong HDLC frame:"); i = 0; trace_pos = 0; trace_desc2 = ppp_data->frx.hdlc_frame; while(trace_desc2) { i+= sprintf(&buf[i], "0x%02x, ", trace_desc2->buffer[trace_pos]); trace_pos++; if(trace_desc2->len <= trace_pos) { trace_desc2 = (T_desc2*)trace_desc2->next; trace_pos = 0; } if(i > 80) { TRACE_EVENT( buf ); i = 0; } } if(i > 0) { TRACE_EVENT( buf ); i = 0; } /* * release stored HDLC frame */ MFREE_DESC2(ppp_data->frx.hdlc_frame); ppp_data->frx.hdlc_frame = NULL; #endif /* PPP_HDLC_TRACE */ store_state = FRX_ADD_ERROR; } break; case FRX_ADD_ADDRESS: if(currentbyte EQ 0xff) { store_state = FRX_ADD_CONTROL; break; } /* * address and control field compression detected */ /* fall through */ case FRX_ADD_PROTOCOL1: if((currentbyte & 0x01) EQ 0) { ppp_data->frx.stored_ptype = currentbyte; ppp_data->frx.stored_ptype = (ppp_data->frx.stored_ptype << 8); /*lint !e734 Loss of precision */ store_state = FRX_ADD_PROTOCOL2; break; } /* * protocol field compression detected */ /* fall through */ case FRX_ADD_PROTOCOL2: if(currentbyte & 0x01) { /* * store protocol */ ppp_data->frx.stored_ptype|= currentbyte; /* * allocate new packet */ d_size = FRX_ADD_SMALL_PACKET_SIZE; /* * Allocate the necessary size for the data descriptor. * The size is calculated as follows: * - take the size of a descriptor structure * - subtract one because of the array buffer[1] to get * the size of descriptor control information * - add number of octets of descriptor data */ MALLOC (ppp_data->frx.stored_packet, (USHORT)(sizeof(T_desc2) - 1 + d_size)); ppp_data->frx.cur_desc = ppp_data->frx.stored_packet; ppp_data->frx.cur_desc->next = (ULONG)NULL; destination = ppp_data->frx.cur_desc->buffer; d_offset = 0; store_state = FRX_ADD_INFORMATION; } else { TRACE_EVENT("ERROR PPP: wrong HDLC protocol field"); #ifdef PPP_HDLC_TRACE /* * trace HDLC frame */ TRACE_EVENT("wrong HDLC frame:"); i = 0; trace_pos = 0; trace_desc2 = ppp_data->frx.hdlc_frame; while(trace_desc2) { i+= sprintf(&buf[i], "0x%02x, ", trace_desc2->buffer[trace_pos]); trace_pos++; if(trace_desc2->len <= trace_pos) { trace_desc2 = (T_desc2*)trace_desc2->next; trace_pos = 0; } if(i > 80) { TRACE_EVENT( buf ); i = 0; } } if(i > 0) { TRACE_EVENT( buf ); i = 0; } /* * release stored HDLC frame */ MFREE_DESC2(ppp_data->frx.hdlc_frame); ppp_data->frx.hdlc_frame = NULL; #endif /* PPP_HDLC_TRACE */ store_state = FRX_ADD_ERROR; } break; case FRX_ADD_FCS1: store_state = FRX_ADD_FCS2; break; case FRX_ADD_FCS2: /* * remove receiced packet because its to long */ arb_discard_packet(ppp_data->frx.stored_packet); ppp_data->frx.stored_packet = NULL; store_state = FRX_ADD_ERROR; TRACE_EVENT("ERROR PPP: HDLC packet to long"); #ifdef PPP_HDLC_TRACE /* * trace HDLC frame */ TRACE_EVENT("wrong HDLC frame:"); i = 0; trace_pos = 0; trace_desc2 = ppp_data->frx.hdlc_frame; while(trace_desc2) { i+= sprintf(&buf[i], "0x%02x, ", trace_desc2->buffer[trace_pos]); trace_pos++; if(trace_desc2->len <= trace_pos) { trace_desc2 = (T_desc2*)trace_desc2->next; trace_pos = 0; } if(i > 80) { TRACE_EVENT( buf ); i = 0; } } if(i > 0) { TRACE_EVENT( buf ); i = 0; } /* * release stored HDLC frame */ MFREE_DESC2(ppp_data->frx.hdlc_frame); ppp_data->frx.hdlc_frame = NULL; #endif /* PPP_HDLC_TRACE */ break; case FRX_ADD_ERROR: /* * we wait for the next HDLC flag */ break; case FRX_ADD_HDLC_BEGIN: TRACE_ERROR("ERROR: frx_add_desc(): in FRX_ADD_HDLC_BEGIN state without HDLC flag"); break; default: TRACE_ERROR("ERROR: frx_add_desc(): wrong state"); break; } } } /* * check if current descriptor is complete analyzed */ if(s_offset >= s_size) { temp_desc = (T_desc2*)source_desc->next; MFREE(source_desc); source_desc = temp_desc; s_offset = 0; } } /* * store important values in global variables */ switch(store_state) { case FRX_ADD_INFORMATION: case FRX_ADD_FCS1: case FRX_ADD_FCS2: ppp_data->frx.cur_desc->len = d_offset; break; } /*lint !e744 switch statement has no default */ ppp_data->frx.store_state = store_state; ppp_data->frx.calc_fcs = fcs; ppp_data->frx.escape = escape; ppp_data->frx.received_data = source_desc; ppp_data->frx.cur_desc_size = d_size; ppp_data->frx.proceed_data = s_offset; } /*lint !e550 fcstab not accessed in _SIMULATION_ frx_add_desc() */ #endif /* PPP_FLASH_ROM */ #ifndef PPP_INT_RAM /* +------------------------------------------------------------------------------ | Function : frx_detect_frame +------------------------------------------------------------------------------ | Description : The function frx_detect_frame() detects begin and end of | PPP frames. | | Parameters : no parameters | +------------------------------------------------------------------------------ */ GLOBAL void frx_detect_frame () { UBYTE* source; UBYTE* destination; T_desc2* temp_desc1; T_desc2* temp_desc2; TRACE_FUNCTION( "frx_detect_frame" ); /* * copy received data stream pointer */ temp_desc1 = ppp_data->frx.received_data; /* * set destination pointer if necessary */ if(ppp_data->frx.store_state EQ FRX_ADD_INFORMATION) { /* * to avoid erroneuos code generation of target compiler, * it is written in two lines instead of one */ destination = ppp_data->frx.cur_desc->buffer; destination+= ppp_data->frx.cur_desc->len; } /* * while there is still data to analyze and * a complete frame is not yet received */ while((temp_desc1) && (ppp_data->frx.frame_complete EQ FALSE)) { /* * set source pointer */ source = &temp_desc1->buffer[ppp_data->frx.proceed_data]; /* * We count down the length of the current descriptor. * while the current descriptor is not yet complete analyzed and * a complete frame is not yet received */ while((temp_desc1->len) && (ppp_data->frx.frame_complete EQ FALSE)) { switch(ppp_data->frx.store_state) { case FRX_ADD_ERROR: /* * search for next HDLC flag */ while((temp_desc1->len) && (*source NEQ PPP_HDLC_FLAG)) { /* * increase source pointer */ source++; temp_desc1->len--; ppp_data->frx.proceed_data++; } if(temp_desc1->len EQ 0) /*lint !e661 Possible access of out-of-bounds pointer */ /* * end of descriptor reached * analyze next descriptor */ break; ppp_data->frx.store_state = FRX_ADD_HDLC_BEGIN; /* fall through */ case FRX_ADD_HDLC_BEGIN: /* * create new packet (frame) to store detected frame */ ppp_data->frx.stored_len = 0; ppp_data->frx.stored_ptype = DTI_PID_UOS; ppp_data->frx.cur_desc_size = FRX_ADD_SMALL_PACKET_SIZE; /* * Allocate the necessary size for the data descriptor. The size is * calculated as follows: * - take the size of a descriptor structure * - subtract one because of the array buffer[1] to get the size of * descriptor control information * - add number of octets of descriptor data */ MALLOC (ppp_data->frx.stored_packet, (USHORT)(sizeof(T_desc2) - 1 + FRX_ADD_SMALL_PACKET_SIZE)); ppp_data->frx.cur_desc = ppp_data->frx.stored_packet; ppp_data->frx.cur_desc->len = 0; ppp_data->frx.cur_desc->next = (ULONG)NULL; destination = ppp_data->frx.cur_desc->buffer; *destination = *source; /*lint !e613 Possible use of null pointer */ /* * increase source pointer */ source++; /*lint !e613 Possible use of null pointer */ temp_desc1->len--; ppp_data->frx.proceed_data++; /* * increase destination pointer */ ppp_data->frx.stored_len++; destination++; ppp_data->frx.cur_desc->len++; ppp_data->frx.store_state = FRX_ADD_INFORMATION; break; case FRX_ADD_INFORMATION: /* * copy data */ while((temp_desc1->len) && (ppp_data->frx.stored_len < ppp_data->mru) && (ppp_data->frx.cur_desc->len < ppp_data->frx.cur_desc_size) && (*source NEQ PPP_HDLC_FLAG)) { /* * copy data */ *destination = *source; /*lint !e644 destination may not have been initialized */ /* * increase source pointer */ source++; temp_desc1->len--; ppp_data->frx.proceed_data++; /* * increase destination pointer */ ppp_data->frx.stored_len++; destination++; ppp_data->frx.cur_desc->len++; } /* * analyze why the loop is left */ if(ppp_data->frx.stored_len < ppp_data->mru) /*lint !e661 Possible access of out-of-bounds pointer */ { if(ppp_data->frx.cur_desc->len >= ppp_data->frx.cur_desc_size) { /* * allocate a new small descriptor */ MALLOC (temp_desc2, (USHORT)(sizeof(T_desc2) - 1 + FRX_ADD_SMALL_PACKET_SIZE)); ppp_data->frx.cur_desc->next = (ULONG)temp_desc2; ppp_data->frx.cur_desc = (T_desc2*)ppp_data->frx.cur_desc->next; ppp_data->frx.cur_desc->len = 0; ppp_data->frx.cur_desc->size = 0; ppp_data->frx.cur_desc->offset = 0; ppp_data->frx.cur_desc->next = (ULONG)NULL; ppp_data->frx.cur_desc_size = FRX_ADD_SMALL_PACKET_SIZE; destination = ppp_data->frx.cur_desc->buffer; } if((temp_desc1->len) && (*source EQ PPP_HDLC_FLAG)) /*lint !e613 Possible use of null pointer */ { /* * end of frame detected */ ppp_data->frx.store_state = FRX_ADD_HDLC_BEGIN; /* * copy HDLC flag */ *destination = *source; /*lint !e613 Possible use of null pointer */ /* * increase length values */ ppp_data->frx.stored_len++; ppp_data->frx.cur_desc->len++; /* * check for correct length */ if(ppp_data->frx.stored_len > 2) { /* * no error occured, frame complete */ ppp_data->frx.frame_complete = TRUE; } else { /* * remove receiced packet because its to short */ arb_discard_packet(ppp_data->frx.stored_packet); ppp_data->frx.stored_packet = NULL; } } } else { /* * remove receiced packet because its to long */ arb_discard_packet(ppp_data->frx.stored_packet); ppp_data->frx.stored_packet = NULL; ppp_data->frx.store_state = FRX_ADD_ERROR; } break; } /*lint !e744 switch statement has no default */ } if(temp_desc1->len EQ 0) { temp_desc2 = (T_desc2*)temp_desc1->next; MFREE(temp_desc1); temp_desc1 = temp_desc2; ppp_data->frx.proceed_data = 0; } } /* * store received data stream pointer */ ppp_data->frx.received_data = temp_desc1; } /* frx_detect_frame() */ /* +------------------------------------------------------------------------------ | Function : frx_send_pack_ready_mode() +------------------------------------------------------------------------------ | Description : send as many packets to ptx as can be extracted from received frame. | Frx is in ready mode. | | Parameters : no parameters | +------------------------------------------------------------------------------ */ GLOBAL void frx_send_pack_ready_mode () { T_desc2* temp_desc; TRACE_FUNCTION( "frx_send_pack_ready_mode ()" ); while( ppp_data->frx.frame_complete EQ TRUE AND ppp_data->frx.data_flow_state EQ FRX_DATA_FLOW_READY) { /* * to avoid any side effects * first reset all necessary variables and then call the signal */ ppp_data->frx.frame_complete = FALSE; temp_desc = ppp_data->frx.stored_packet; ppp_data->frx.stored_packet = NULL; sig_frx_ptx_packet_ind(ppp_data->frx.stored_ptype, ppp_data->frx.stored_len, temp_desc); frx_add_desc(); } } /* +------------------------------------------------------------------------------ | Function : frx_send_pack_transp_mode +------------------------------------------------------------------------------ | Description : send as many packets to ptx as can be extracted from received frame. | Frx is in transparent mode . | | Parameters : no parameters | +------------------------------------------------------------------------------ */ GLOBAL void frx_send_pack_transp_mode () { T_desc2* temp_desc; TRACE_FUNCTION( "frx_send_pack_transp_mode ()" ); while( ppp_data->frx.frame_complete EQ TRUE AND ppp_data->frx.data_flow_state EQ FRX_DATA_FLOW_READY) { /* * to avoid any side effects * first reset all necessary variables and then call the signal */ ppp_data->frx.frame_complete = FALSE; temp_desc = ppp_data->frx.stored_packet; ppp_data->frx.stored_packet = NULL; sig_frx_ptx_packet_ind(ppp_data->frx.stored_ptype, ppp_data->frx.stored_len, temp_desc); frx_detect_frame(); } } #endif /* PPP_INT_RAM */