-#define xBUFFER_CACHE_SIZE 10\r
-#define xMAX_FAULT_INJECTION_RATE 15\r
-#define xMIN_FAULT_INJECTION_RATE 3\r
-#define xNUM_FAULT_TYPES 1\r
-\r
-static NetworkBufferDescriptor_t *xNetworkBufferCache[ xBUFFER_CACHE_SIZE ] = { 0 };\r
-\r
-#define xFAULT_LOG_SIZE 2048\r
-uint32_t ulInjectedFault[ xFAULT_LOG_SIZE ];\r
-uint32_t ulFaultLogIndex = 0;\r
-\r
-static BaseType_t prvCachePacket( NetworkBufferDescriptor_t *pxNetworkBufferIn )\r
-{\r
-BaseType_t x, xReturn = pdFALSE;\r
-\r
- for( x = 0; x < xBUFFER_CACHE_SIZE; x++ )\r
- {\r
- if( xNetworkBufferCache[ x ] == NULL )\r
- {\r
- xNetworkBufferCache[ x ] = pxNetworkBufferIn;\r
- xReturn = pdTRUE;\r
- break;\r
- }\r
- }\r
-\r
- return xReturn;\r
-}\r
-/*-----------------------------------------------------------*/\r
-\r
-static NetworkBufferDescriptor_t *prvGetCachedPacket( void )\r
-{\r
-BaseType_t x;\r
-NetworkBufferDescriptor_t *pxReturn = NULL;\r
-\r
- for( x = ( xBUFFER_CACHE_SIZE - 1 ); x >= 0; x-- )\r
- {\r
- if( xNetworkBufferCache[ x ] != NULL )\r
- {\r
- pxReturn = xNetworkBufferCache[ x ];\r
- xNetworkBufferCache[ x ] = NULL;\r
- break;\r
- }\r
- }\r
-\r
- return pxReturn;\r
-}\r
-/*-----------------------------------------------------------*/\r
-\r
-static NetworkBufferDescriptor_t *prvDuplicatePacket( NetworkBufferDescriptor_t * pxOriginalPacket, const uint8_t *pucPacketData )\r
-{\r
-NetworkBufferDescriptor_t *pxReturn;\r
-\r
- /* Obtain a new descriptor. */\r
- pxReturn = pxGetNetworkBufferWithDescriptor( pxOriginalPacket->xDataLength, 0 );\r
-\r
- if( pxReturn != NULL )\r
- {\r
- /* Copy in the packet data. */\r
- pxReturn->xDataLength = pxOriginalPacket->xDataLength;\r
- memcpy( pxReturn->pucEthernetBuffer, pucPacketData, pxOriginalPacket->xDataLength );\r
- }\r
-\r
- return pxReturn;\r
-}\r
-/*-----------------------------------------------------------*/\r
-\r
-static NetworkBufferDescriptor_t *prvRxFaultInjection( NetworkBufferDescriptor_t *pxNetworkBufferIn, const uint8_t *pucPacketData )\r
-{\r
-static uint32_t ulCallCount = 0, ulNextFaultCallCount = 0;\r
-NetworkBufferDescriptor_t *pxReturn = pxNetworkBufferIn;\r
-IPStackEvent_t xRxEvent = { eNetworkRxEvent, NULL };\r
-uint32_t ulFault;\r
-\r
-return pxNetworkBufferIn;\r
-\r
- ulCallCount++;\r
-\r
- if( ulCallCount > ulNextFaultCallCount )\r
- {\r
- xApplicationGetRandomNumber( &( ulNextFaultCallCount ) );\r
- ulNextFaultCallCount = ulNextFaultCallCount % xMAX_FAULT_INJECTION_RATE;\r
- if( ulNextFaultCallCount < xMIN_FAULT_INJECTION_RATE )\r
- {\r
- ulNextFaultCallCount = xMIN_FAULT_INJECTION_RATE;\r
- }\r
-\r
- ulCallCount = 0;\r
-\r
- xApplicationGetRandomNumber( &( ulFault ) );\r
- ulFault = ulFault % xNUM_FAULT_TYPES;\r
-\r
- if( ulFaultLogIndex < xFAULT_LOG_SIZE )\r
- {\r
- ulInjectedFault[ ulFaultLogIndex ] = ulFault;\r
- ulFaultLogIndex++;\r
- }\r
-\r
- switch( ulFault )\r
- {\r
- case 0:\r
- /* Just drop the packet. */\r
- vReleaseNetworkBufferAndDescriptor( pxNetworkBufferIn );\r
- pxReturn = NULL;\r
- break;\r
-\r
- case 1:\r
- /* Store the packet in the cache for later. */\r
- if( prvCachePacket( pxNetworkBufferIn ) == pdTRUE )\r
- {\r
- /* The packet may get sent later, it is not being sent\r
- now. */\r
- pxReturn = NULL;\r
- }\r
- break;\r
-\r
- case 2:\r
- /* Send a cached packet. */\r
- pxReturn = prvGetCachedPacket();\r
- if( pxReturn != NULL )\r
- {\r
- /* A cached packet was obtained so drop the original\r
- packet. */\r
- vReleaseNetworkBufferAndDescriptor( pxNetworkBufferIn );\r
- }\r
- else\r
- {\r
- /* Could not obtain a packet from the cache so just return\r
- the packet that was passed in. */\r
- pxReturn = pxNetworkBufferIn;\r
- }\r
- break;\r
-\r
- case 4:\r
-\r
- /* Send a duplicate of the packet right away. */\r
- pxReturn = prvDuplicatePacket( pxNetworkBufferIn, pucPacketData );\r
-\r
- /* Send the original packet to the stack. */\r
- xRxEvent.pvData = ( void * ) pxNetworkBufferIn;\r
- if( xSendEventStructToIPTask( &xRxEvent, ( TickType_t ) 0 ) == pdFAIL )\r
- {\r
- vReleaseNetworkBufferAndDescriptor( pxNetworkBufferIn );\r
- }\r
- break;\r
-\r
- case 5:\r
-\r
- /* Send both a cached packet and the current packet. */\r
- xRxEvent.pvData = ( void * ) prvGetCachedPacket();\r
- if( xRxEvent.pvData != NULL )\r
- {\r
- if( xSendEventStructToIPTask( &xRxEvent, ( TickType_t ) 0 ) == pdFAIL )\r
- {\r
- vReleaseNetworkBufferAndDescriptor( pxNetworkBufferIn );\r
- }\r
- }\r
- break;\r
-\r
- case 6:\r
- case 7:\r
- case 8:\r
- /* Store the packet in the cache for later. */\r
- if( prvCachePacket( pxNetworkBufferIn ) == pdTRUE )\r
- {\r
- /* The packet may get sent later, it is not being sent\r
- now. */\r
- pxReturn = NULL;\r
- }\r
- break;\r
- }\r
- }\r
-\r
- return pxReturn;\r
-}\r
-/*-----------------------------------------------------------*/\r
+#define xBUFFER_CACHE_SIZE 10
+#define xMAX_FAULT_INJECTION_RATE 15
+#define xMIN_FAULT_INJECTION_RATE 3
+#define xNUM_FAULT_TYPES 1
+
+static NetworkBufferDescriptor_t *xNetworkBufferCache[ xBUFFER_CACHE_SIZE ] = { 0 };
+
+#define xFAULT_LOG_SIZE 2048
+uint32_t ulInjectedFault[ xFAULT_LOG_SIZE ];
+uint32_t ulFaultLogIndex = 0;
+
+static BaseType_t prvCachePacket( NetworkBufferDescriptor_t *pxNetworkBufferIn )
+{
+BaseType_t x, xReturn = pdFALSE;
+
+ for( x = 0; x < xBUFFER_CACHE_SIZE; x++ )
+ {
+ if( xNetworkBufferCache[ x ] == NULL )
+ {
+ xNetworkBufferCache[ x ] = pxNetworkBufferIn;
+ xReturn = pdTRUE;
+ break;
+ }
+ }
+
+ return xReturn;
+}
+/*-----------------------------------------------------------*/
+
+static NetworkBufferDescriptor_t *prvGetCachedPacket( void )
+{
+BaseType_t x;
+NetworkBufferDescriptor_t *pxReturn = NULL;
+
+ for( x = ( xBUFFER_CACHE_SIZE - 1 ); x >= 0; x-- )
+ {
+ if( xNetworkBufferCache[ x ] != NULL )
+ {
+ pxReturn = xNetworkBufferCache[ x ];
+ xNetworkBufferCache[ x ] = NULL;
+ break;
+ }
+ }
+
+ return pxReturn;
+}
+/*-----------------------------------------------------------*/
+
+static NetworkBufferDescriptor_t *prvDuplicatePacket( NetworkBufferDescriptor_t * pxOriginalPacket, const uint8_t *pucPacketData )
+{
+NetworkBufferDescriptor_t *pxReturn;
+
+ /* Obtain a new descriptor. */
+ pxReturn = pxGetNetworkBufferWithDescriptor( pxOriginalPacket->xDataLength, 0 );
+
+ if( pxReturn != NULL )
+ {
+ /* Copy in the packet data. */
+ pxReturn->xDataLength = pxOriginalPacket->xDataLength;
+ memcpy( pxReturn->pucEthernetBuffer, pucPacketData, pxOriginalPacket->xDataLength );
+ }
+
+ return pxReturn;
+}
+/*-----------------------------------------------------------*/
+
+static NetworkBufferDescriptor_t *prvRxFaultInjection( NetworkBufferDescriptor_t *pxNetworkBufferIn, const uint8_t *pucPacketData )
+{
+static uint32_t ulCallCount = 0, ulNextFaultCallCount = 0;
+NetworkBufferDescriptor_t *pxReturn = pxNetworkBufferIn;
+IPStackEvent_t xRxEvent = { eNetworkRxEvent, NULL };
+uint32_t ulFault;
+
+return pxNetworkBufferIn;
+
+ ulCallCount++;
+
+ if( ulCallCount > ulNextFaultCallCount )
+ {
+ xApplicationGetRandomNumber( &( ulNextFaultCallCount ) );
+ ulNextFaultCallCount = ulNextFaultCallCount % xMAX_FAULT_INJECTION_RATE;
+ if( ulNextFaultCallCount < xMIN_FAULT_INJECTION_RATE )
+ {
+ ulNextFaultCallCount = xMIN_FAULT_INJECTION_RATE;
+ }
+
+ ulCallCount = 0;
+
+ xApplicationGetRandomNumber( &( ulFault ) );
+ ulFault = ulFault % xNUM_FAULT_TYPES;
+
+ if( ulFaultLogIndex < xFAULT_LOG_SIZE )
+ {
+ ulInjectedFault[ ulFaultLogIndex ] = ulFault;
+ ulFaultLogIndex++;
+ }
+
+ switch( ulFault )
+ {
+ case 0:
+ /* Just drop the packet. */
+ vReleaseNetworkBufferAndDescriptor( pxNetworkBufferIn );
+ pxReturn = NULL;
+ break;
+
+ case 1:
+ /* Store the packet in the cache for later. */
+ if( prvCachePacket( pxNetworkBufferIn ) == pdTRUE )
+ {
+ /* The packet may get sent later, it is not being sent
+ now. */
+ pxReturn = NULL;
+ }
+ break;
+
+ case 2:
+ /* Send a cached packet. */
+ pxReturn = prvGetCachedPacket();
+ if( pxReturn != NULL )
+ {
+ /* A cached packet was obtained so drop the original
+ packet. */
+ vReleaseNetworkBufferAndDescriptor( pxNetworkBufferIn );
+ }
+ else
+ {
+ /* Could not obtain a packet from the cache so just return
+ the packet that was passed in. */
+ pxReturn = pxNetworkBufferIn;
+ }
+ break;
+
+ case 4:
+
+ /* Send a duplicate of the packet right away. */
+ pxReturn = prvDuplicatePacket( pxNetworkBufferIn, pucPacketData );
+
+ /* Send the original packet to the stack. */
+ xRxEvent.pvData = ( void * ) pxNetworkBufferIn;
+ if( xSendEventStructToIPTask( &xRxEvent, ( TickType_t ) 0 ) == pdFAIL )
+ {
+ vReleaseNetworkBufferAndDescriptor( pxNetworkBufferIn );
+ }
+ break;
+
+ case 5:
+
+ /* Send both a cached packet and the current packet. */
+ xRxEvent.pvData = ( void * ) prvGetCachedPacket();
+ if( xRxEvent.pvData != NULL )
+ {
+ if( xSendEventStructToIPTask( &xRxEvent, ( TickType_t ) 0 ) == pdFAIL )
+ {
+ vReleaseNetworkBufferAndDescriptor( pxNetworkBufferIn );
+ }
+ }
+ break;
+
+ case 6:
+ case 7:
+ case 8:
+ /* Store the packet in the cache for later. */
+ if( prvCachePacket( pxNetworkBufferIn ) == pdTRUE )
+ {
+ /* The packet may get sent later, it is not being sent
+ now. */
+ pxReturn = NULL;
+ }
+ break;
+ }
+ }
+
+ return pxReturn;
+}
+/*-----------------------------------------------------------*/
projects / freertos / blobdiff