ssp_ping.c

abstract rtos

#ifdef __cplusplus
extern "C"{
#endif 

#include "syscfg.h"
#include "aos.h"


#include "ssp_ping.h"
#include "../ker/ssp_msg.h"

#include "cli/cli_pub.h"
#if( AOS_INCLUDE_SMP_SNMP == TRUE )
#include "snmp/include/mib_def.h"
#include "snmp/include/snmp_if_pub.h"
#endif

#if( CONFIG_BOARD_GMPU == TRUE || CONFIG_BOARD_EIA == TRUE )

struct aping_task_s ap_tsk[APING_TASK_NUM];
extern U16 g_lcm_rel_udp_port;


VOID aping_out_string(  struct aping_s *apingp , S8 *szStr, U32 end_flag );



U32  aping_init_proc( START_ORDER_E order )
{
    U32 i;
    
    switch( order )
    {
        case STARTUP_INITIAL:    
            for( i=0; i<APING_TASK_NUM; i++ )
            {
                ap_tsk[i].task_id = U32_BUTT;
                msg_que_init( &ap_tsk[i].q1 );
            }

            break;
            
        case STARTUP_LOAD_DATA:  
            break;
            
        case STARTUP_GO:         
            
             break;


        default:
            break;
    }

    return AOS_SUCC;
}


VOID aping_msg_proc( MSG_S *msg, VOID*pvMsgBuf )
{
    AOS_ASSERT( NULL != msg && NULL != pvMsgBuf );

    if( NULL == msg || NULL == pvMsgBuf )
    {
        return;
    }

    if( MPE_APING != msg->dstMpe || LOCAL_PROCESSOR_ID != msg->dstProcessorId )
    {
        return;
    }

    switch( msg->srcMpe )
    {
        case MPE_APING:
            if( AOS_SUCC != aping_compatible_handle(pvMsgBuf,msg->ulSize) )
            {
                return;
            }
            aping_cmd( (struct aping_s *)pvMsgBuf );
            break;

        default:
            break;
    }
}

VOID aping_cmd( struct aping_s *apingp )
{
    switch( apingp->prim )
    {
        case XPING_GO:
            xping_go_handle( apingp );
            break;

        case APING_GO:
            aping_go_handle( apingp );
            break;

        case APING_BACK:
            aping_back_handle( apingp );
            break;

        case XPING_BACK:
            xping_back_handle( apingp );
            break;
            
        default:
            AOS_ASSERT(0);
            break;
    }
}


VOID aos_ping(U32 argc, S8* argv[])
{
    U32 ulIndex, arg_idx, arg_val, ping_count = 3;
    U32 aping_paras[3][3], aping_paras_num = 0;


     
    aos_atoul(argv[0], &ulIndex);

    
    if ( (3 == argc && '?' == argv[2][0]) || ( argc <3 ) )
    { 
        cli_out_string(ulIndex, "\r\nsyntax:\r\n"); 
        cli_out_string(ulIndex, "aping {eia no | eix | ip addr [port] } {eia no | eix | ip addr [port]} [-c count]\r\n");
        
        return ;
    }

    aping_paras_num = 0;
    arg_idx = 2;

#if( CONFIG_BOARD_EIA == TRUE )
    aping_paras[aping_paras_num][0] = APING_R_EIA;
    aping_paras[aping_paras_num][1] = LOCAL_PROCESSOR_ID;
    aping_paras_num++;
#else ( CONFIG_BOARD_GMPU == TRUE )
    aping_paras[aping_paras_num][0] = APING_R_EIX;
    aping_paras[aping_paras_num][1] = LOCAL_PROCESSOR_ID;
    aping_paras_num++;
#endif
    
    while( arg_idx < argc && aping_paras_num < 3 )
    {
        if( 0 == aos_stricmp( argv[arg_idx], "eia" ) )
        {
            arg_idx++;
            if( arg_idx < argc )
            {
                if( 0 == aos_atoul( argv[arg_idx], &arg_val ) )
                {
                    arg_idx++;
                    aping_paras[aping_paras_num][0] = APING_R_EIA;
                    aping_paras[aping_paras_num][1] = arg_val;
                    aping_paras_num++;
                }
                else
                {
                    cli_out_string(ulIndex, "\r\neiano invalid!\r\n");
                    return;
                }
            }
            else
            {
                cli_out_string(ulIndex, "\r\neiano not input!\r\n");
                return;
            }
        }
        else if( 0 == aos_stricmp( argv[arg_idx], "eix" ) )
        {
            arg_idx++;
            aping_paras[aping_paras_num][0] = APING_R_EIX;
            aping_paras[aping_paras_num][1] = 0;
            aping_paras_num++;
        }
        else if( 0 == aos_stricmp( argv[arg_idx], "ip" ) )
        {
            arg_idx++;
            if( 0 == aos_strtoipaddr( argv[arg_idx], &arg_val ) )
            {
                arg_idx++;
                aping_paras[aping_paras_num][0] = APING_R_IP;
                aping_paras[aping_paras_num][1] = arg_val;

                
                if( arg_idx < argc )
                {
                    if( argv[arg_idx][0] >= '0' && argv[arg_idx][0] <= '9' )
                    {
                        if( 0 == aos_atoul( argv[arg_idx], &arg_val ) )
                        {
                            arg_idx++;
                            if( arg_val >= U16_BUTT )
                            {
                                cli_out_string(ulIndex, "\r\nudp port invalid!\r\n");
                                return;
                            }
                            aping_paras[aping_paras_num][0] |= APING_R_IP_EX;
                            aping_paras[aping_paras_num][2] = arg_val;
                        }
                        else
                        {
                            cli_out_string(ulIndex, "\r\nudp port invalid!\r\n");
                            return;
                        }
                    }
                }
                aping_paras_num++;
                
            }
            else
            {
                cli_out_string(ulIndex, "\r\nipaddr invalid!\r\n");
                return;
            }
        }
        else
        {
            break;
        }
    }

    if( arg_idx < argc )
    {
        
        if( (arg_idx + 2) == argc )
        {
            if( 0 == aos_stricmp( argv[arg_idx], "-c" ) )
            {
                arg_idx++;
                if( 0 == aos_atoul( argv[arg_idx], &ping_count ) )
                {
                    if( ping_count > APING_MAX_COUNT )
                    {
                        ping_count = APING_MAX_COUNT;
                    }
                }
                else
                {
                    cli_out_string(ulIndex, "\r\nInvalid ping count!\r\n");
                    return;
                }
            }
            else
            {
                cli_out_string(ulIndex, "\r\nInvalid parameter!\r\n");
                return;
            }
        }
        else
        {
            cli_out_string(ulIndex, "\r\nInvalid parameter!\r\n");
            return;
        }
    }

    if( aping_paras_num < 2 )
    {
        cli_out_string(ulIndex, "\r\nToo few parameters!\r\n");
        return;
    }
    
    if( aping_paras[0][0] == aping_paras[1][0] )
    {
        cli_out_string(ulIndex, "\r\naping from eia/eix direct to eia/eix no supported!\r\n");
        return;
    }

    aos_ping_ex( ulIndex, aping_paras_num, aping_paras, ping_count );
}


VOID aos_xping(U32 argc, S8* argv[])
{
    U32 ulIndex, arg_idx, arg_val, ping_count = 3;
    U32 aping_paras[3][3] = {0,}, aping_paras_num = 0;


     
    aos_atoul(argv[0], &ulIndex);

    
    if ( (3 == argc && '?' == argv[2][0]) || ( argc <3 ) )
    { 
        cli_out_string(ulIndex, "\r\nsyntax:\r\n"); 
        cli_out_string(ulIndex, "xping eia no {eix | ip addr [port]} {eia no | ip addr [port]} [-c count]\r\n");
        
        return ;
    }

    aping_paras_num = 0;
    arg_idx = 2;
    
    while( arg_idx < argc && aping_paras_num < 3 )
    {
        if( 0 == aos_stricmp( argv[arg_idx], "eia" ) )
        {
            arg_idx++;
            if( arg_idx < argc )
            {
                if( 0 == aos_atoul( argv[arg_idx], &arg_val ) )
                {
                    arg_idx++;
                    aping_paras[aping_paras_num][0] = APING_R_EIA;
                    aping_paras[aping_paras_num][1] = arg_val;
                    aping_paras_num++;
                }
                else
                {
                    cli_out_string(ulIndex, "\r\neiano invalid!\r\n");
                    return;
                }
            }
            else
            {
                cli_out_string(ulIndex, "\r\neiano not input!\r\n");
                return;
            }
        }
        else if( 0 == aos_stricmp( argv[arg_idx], "eix" ) )
        {
            arg_idx++;
            aping_paras[aping_paras_num][0] = APING_R_EIX;
            aping_paras[aping_paras_num][1] = 0;
            aping_paras_num++;
        }
        else if( 0 == aos_stricmp( argv[arg_idx], "ip" ) )
        {
            arg_idx++;
            if( 0 == aos_strtoipaddr( argv[arg_idx], &arg_val ) )
            {
                arg_idx++;
                aping_paras[aping_paras_num][0] = APING_R_IP;
                aping_paras[aping_paras_num][1] = arg_val;

                
                if( arg_idx < argc )
                {
                    if( argv[arg_idx][0] >= '0' && argv[arg_idx][0] <= '9' )
                    {
                        if( 0 == aos_atoul( argv[arg_idx], &arg_val ) )
                        {
                            arg_idx++;
                            if( arg_val >= U16_BUTT )
                            {
                                cli_out_string(ulIndex, "\r\nudp port invalid!\r\n");
                                return;
                            }
                            aping_paras[aping_paras_num][0] |= APING_R_IP_EX;
                            aping_paras[aping_paras_num][2] = arg_val;
                        }
                        else
                        {
                            cli_out_string(ulIndex, "\r\nudp port invalid!\r\n");
                            return;
                        }
                    }
                }
                aping_paras_num++;                
            }
            else
            {
                cli_out_string(ulIndex, "\r\nipaddr invalid!\r\n");
                return;
            }
        }
        else
        {
            break;
        }

    }
    
    if( arg_idx < argc )
    {
        
        if( (arg_idx + 2) == argc )
        {
            if( 0 == aos_stricmp( argv[arg_idx], "-c" ) )
            {
                arg_idx++;
                if( 0 == aos_atoul( argv[arg_idx], &ping_count ) )
                {
                    if( ping_count > APING_MAX_COUNT )
                    {
                        ping_count = APING_MAX_COUNT;
                    }
                }
                else
                {
                    cli_out_string(ulIndex, "\r\nInvalid ping count!\r\n");
                    return;
                }
            }
            else
            {
                cli_out_string(ulIndex, "\r\nInvalid parameter!\r\n");
                return;
            }
        }
        else
        {
            cli_out_string(ulIndex, "\r\nInvalid parameter!\r\n");
            return;
        }
    }

    if( aping_paras_num < 2 )
    {
        cli_out_string(ulIndex, "\r\nToo few parameters!\r\n");
        return;
    }
    
    if( APING_R_EIA != aping_paras[0][0] )
    {
        cli_out_string(ulIndex, "\r\nfirst parameter must be eia\r\n");
        return;
    }
    
    if( APING_R_EIA == aping_paras[1][0] )
    {
        cli_out_string(ulIndex, "\r\nxping from eia direct to eia no supported!\r\n");
        return;
    }


    aping_paras[0][0] |= XPING_R_X;

    aos_ping_ex( ulIndex, aping_paras_num, aping_paras, ping_count );

}


VOID aos_ping_ex( U32 ulCliIndex, U32 aping_paras_num, U32 aping_paras[3][3], U32  ping_count )
{
    MSG_S msg;
    struct aping_s *apingp;
    U32 i, hms,task_id;

    apingp = aos_msg_alloc( MPE_APING, sizeof(struct aping_s) );
    if( NULL == apingp )
    {
        return;
    }

    aos_memset( apingp, 0, sizeof(struct aping_s) );

    apingp->prim      = APING_GO;
    apingp->total_r   = (U8)aping_paras_num;
    apingp->cli_index = (U8)ulCliIndex;
    apingp->next_r    = 0;                
    apingp->seq       = AOS_HTONS((U16)ping_count);
    apingp->xping_result = 0;
    apingp->ping_task = 0;
    aos_time_get_ms( &hms, &apingp->delay);

    i = 0;
    apingp->aping_r[i][0] = AOS_HTONL(aping_paras[i][0]);
    apingp->aping_r[i][1] = AOS_HTONL(aping_paras[i][1]);
    if( aping_paras[i][0] & APING_R_IP_EX )
    {
        apingp->aping_p[i] = AOS_HTONS((U16)aping_paras[i][2]);
    }

    i++;
    apingp->aping_r[i][0] = AOS_HTONL(aping_paras[i][0]);
    apingp->aping_r[i][1] = AOS_HTONL(aping_paras[i][1]);
    if( aping_paras[i][0] & APING_R_IP_EX )
    {
        apingp->aping_p[i] = AOS_HTONS((U16)aping_paras[i][2]);
    }

    i++;
    apingp->aping_r[i][0] = AOS_HTONL(aping_paras[i][0]);
    apingp->aping_r[i][1] = AOS_HTONL(aping_paras[i][1]);
    if( aping_paras[i][0] & APING_R_IP_EX )
    {
        apingp->aping_p[i] = AOS_HTONS((U16)aping_paras[i][2]);