static void vActualDump()

in tools/tcp_utilities/tcp_dump_packets.c [526:701]
134 lines of code
22 McCabe index (conditional complexity)

    static void vActualDump( uint8_t * pucBuffer,
                             size_t uxLength,
                             BaseType_t xIncoming )
    {
        char pcString[ 513 ];
        size_t uxOffset;
        size_t uxIndex;
        size_t uxCompleteCount = 0;
        BaseType_t xUseIt = pdFALSE;

        usSourcePort = 0u;
        usDestinationPort = 0u;
        pcTypeString[ 0 ] = 0;
        ulTypeMask = 0uL;

        if( pxCurrentEntries == NULL )
        {
            return;
        }

        vDetermineMessageType( pucBuffer, xIncoming );

        for( uxIndex = 0; uxIndex < pxCurrentEntries->uxEntryCount; uxIndex++ )
        {
            if( pxCurrentEntries->xEntries[ uxIndex ].uxCount < pxCurrentEntries->xEntries[ uxIndex ].uxMax )
            {
                uint32_t ulMask = pxCurrentEntries->xEntries[ uxIndex ].ulMask;

                if( ( ulMask & ulTypeMask ) == ulMask )
                {
                    pxCurrentEntries->xEntries[ uxIndex ].uxCount++;
                    xUseIt = pdTRUE;
                }
            }
            else
            {
                uxCompleteCount++;
            }
        }

        FreeRTOS_printf( ( "prvWritePackets: done %d/%d : (%d,%d) (%d,%d) (%d,%d) (%d,%d)\n",
                           uxCompleteCount,
                           pxCurrentEntries->uxEntryCount,
                           pxCurrentEntries->xEntries[ 0 ].uxCount, pxCurrentEntries->xEntries[ 0 ].uxMax,
                           pxCurrentEntries->xEntries[ 1 ].uxCount, pxCurrentEntries->xEntries[ 1 ].uxMax,
                           pxCurrentEntries->xEntries[ 2 ].uxCount, pxCurrentEntries->xEntries[ 2 ].uxMax,
                           pxCurrentEntries->xEntries[ 3 ].uxCount, pxCurrentEntries->xEntries[ 3 ].uxMax ) );

        if( uxCompleteCount >= pxCurrentEntries->uxEntryCount )
        {
            FreeRTOS_printf( ( "prvWritePackets: all %lu packets have been collected\n", pxCurrentEntries->uxEntryCount ) );

            if( pxCurrentEntries != NULL )
            {
                FILE * outfile = fopen( pcCodeFileName, ( xFirstPacket != 0 ) ? "w" : "a+" );

                if( outfile == NULL )
                {
                    FreeRTOS_printf( ( "Can not create '%s'\n", pcCodeFileName ) );
                }
                else
                {
                    /*
                     *  Create a list with pointers to each network packet.
                     *  DumpPacket_t *xPacketList[ dumpPACKET_COUNT ] =
                     *  {
                     *      &xPacket_0000,
                     *      &xPacket_0001,
                     *      &xPacket_0002,
                     *      &xPacket_0003,
                     *  }
                     */
                    _fprintf( outfile, "\nDumpPacket_t *xPacketList[ dumpPACKET_COUNT ] =\n{\n" );

                    for( uxIndex = 0; uxIndex < uxNextPacketNumber; uxIndex++ )
                    {
                        _fprintf( outfile, "\t&xPacket_%04lu,\n", uxIndex );
                    }

                    _fprintf( outfile, "};\n" );
                    fclose( outfile );
                    vWriteHeaderFile();
                }

                pxCurrentEntries = NULL;

                /* Tell the thread and the function dump_packet() that packet
                 * dumping is ready. */
                xDumpingReady = pdTRUE;
            }

            return;
        }

        if( xUseIt == pdFALSE )
        {
            return;
        }

        printf( "prvWritePackets: Read %lu bytes, type %s\n", uxLength, pcTypeString );

        FILE * outfile = fopen( pcCodeFileName, ( xFirstPacket != 0 ) ? "w" : "a+" );

        if( outfile == NULL )
        {
            FreeRTOS_printf( ( "Can not create '%s'\n", pcCodeFileName ) );
            return;
        }

        if( xFirstPacket != 0 )
        {
            char * pcPtr;
            size_t xLength;

            vWriteHeaderFile( pcHeaderFileName );
            xLength = snprintf( pcString, sizeof pcString, pcHeaderCode, pcHeaderFileName );
            fwrite( pcString, 1u, xLength, outfile );
            xFirstPacket = pdFALSE;
        }

        _fprintf( outfile, "\n/* Packet_%04d */\n", uxNextPacketNumber );
        _fprintf( outfile, "uint8_t ucPacket_%04lx[ %lu ] =\n{\n", uxNextPacketNumber, uxLength );

        for( uxOffset = 0u; uxOffset < uxLength; )
        {
            size_t uxCurLength = 0u;
            size_t uxLast = uxOffset + dumpBYTES_PER_ROW;
            BaseType_t xFirst = pdTRUE;

            if( uxLast > uxLength )
            {
                uxLast = uxLength;
            }

            while( uxOffset < uxLast )
            {
                uxCurLength += snprintf( pcString + uxCurLength, sizeof pcString - uxCurLength, "%s0x%02x",
                                         ( uxCurLength == 0 ) ? "\t" : ", ", pucBuffer[ uxOffset ] );
                uxOffset++;
            }

            if( uxCurLength != 0u )
            {
                uxCurLength += snprintf( pcString + uxCurLength, sizeof pcString - uxCurLength, "%s\n",
                                         ( uxOffset == uxLength ) ? "\n};" : "," );
                fwrite( pcString, 1u, uxCurLength, outfile );
            }
        }

        _fprintf( outfile, "\n" );

        _fprintf( outfile,
                  "DumpPacket_t xPacket_%04lx =\n{\n"
                  "\t.pucData = ucPacket_%04lx,\n"
                  "\t.uxLength = %lu,\n"
                  "\t.ulType = 0x%lX, /* %s */\n",
                  uxNextPacketNumber, uxNextPacketNumber, uxLength, ulTypeMask, pcTypeString );

        if( usSourcePort != 0u )
        {
            _fprintf( outfile,
                      "\t.usSource = %u,\n", FreeRTOS_ntohs( usSourcePort ) );
        }

        if( usSourcePort != 0u )
        {
            _fprintf( outfile,
                      "\t.usDestination = %u,\n", FreeRTOS_ntohs( usDestinationPort ) );
        }

        _fprintf( outfile,
                  "};\n"
                  "/*-----------------------------------------------------------*/\n\n" );
        fclose( outfile );
        uxNextPacketNumber++;
    }