ssp_ping.c

abstract rtos

            apingp0->prim  = XPING_BACK;
            apingp0->delay = 0;
            apingp0->xping_result = XPING_FAIL;
            xping_back(apingp0);
        }

        return;
    }

    szFrom[0] = 0;
    if( is_aping )
    {
        str= szFrom;
        ping_mode = AOS_NTOHL( apingp0->aping_r[1][0] );
        if( ping_mode & APING_R_EIA )
        {
            l = aos_sprintf( str, "[eia %u", AOS_NTOHL( apingp0->aping_r[1][1] ) );
        }
        else if( ping_mode & APING_R_EIX )
        {
            l = aos_sprintf( str, "[eix" );
        }
        else
        {
            if( ping_mode & APING_R_IP_EX )
            {
                l = aos_sprintf( str, "[ip %A:%u", apingp0->aping_r[1][1], AOS_HTONS(apingp0->aping_p[1]) );
            }
            else
            {
                l = aos_sprintf( str, "[ip %A", apingp0->aping_r[1][1] );
            }
        }
        str += l;
        if( apingp0->total_r > 2 )
        {
            ping_mode = AOS_NTOHL( apingp0->aping_r[2][0] ); 
            if( ping_mode & APING_R_EIA )
            {
                l = aos_sprintf( str, " - eia %u", AOS_NTOHL( apingp0->aping_r[2][1] ) );
            }
            else if( ping_mode & APING_R_EIX )
            {
                l = aos_sprintf( str, " - eix" );
            }
            else
            {
                if( ping_mode & APING_R_IP_EX )
                {
                    l = aos_sprintf( str, " - ip %A:%u", apingp0->aping_r[2][1], AOS_HTONS(apingp0->aping_p[2]) );
                }
                else
                {
                    l = aos_sprintf( str, " - ip %A", apingp0->aping_r[2][1] );
                }
                
            }

            str += l;
        }

        aos_sprintf( str, "]" );

    }

    ap_tsk[i].task_id = aos_task_self();
    msg_que_init( &ap_tsk[i].q1 );

    apingp0->ping_task = (U8)ap_tsk[i].task_id;
    aping_count = AOS_NTOHS(apingp0->seq);
    if( aping_count > APING_MAX_COUNT )
    {
        aping_count = APING_MAX_COUNT;
    }
    else if( !aping_count )
    {
        aping_count= 3;
    }
    aping_seq   = (U16)-1;
    apingp0->next_r = 0;
    apingp0->seq    = 0;
    apingp0->delay  = 0;

    while( aping_count )
    {
        if( is_aping )
        {
    		if( 255 != apingp0->cli_index
             && CLI_CTL_C == cli_out_iscontinue(apingp0->cli_index) )
    		{
    			break;            
    		}
        }
        aping_count--;
        aping_seq++;
        apingp0->seq = AOS_HTONS(aping_seq);
        aos_time_get_ms( &hms, &apingp0->delay );        
        aping_go( apingp0 );
        
        
        ret = aos_event_wait( APING_BACK_EVENT, AOS_WAIT_ANY, 5000, &ulEvent );
        if( AOS_SUCC != ret )
        {
            lost_cnt++;
            if( is_aping )
            {
                aos_sprintf( szBuf, "\r\nAping-%s timeout,seq=%u", szFrom, aping_seq );
                aping_out_string( apingp0, szBuf, 0 );
            }
            else
            {
                xpingp = aos_msg_alloc( MPE_APING, sizeof(struct aping_s) );
                if( NULL != xpingp )
                {
                    aos_memcpy( xpingp, apingp0, sizeof(struct aping_s) );
                    xpingp->prim   = XPING_BACK;
                    xpingp->delay  = 0;
                    xpingp->xping_result = XPING_TIMEOUT;
                    
                    xping_back( xpingp );
                }
            }

            continue;
        }
retry:        
        mb = msg_deque( &ap_tsk[i].q1 );
        if( NULL == mb )
        {
            continue;
        }

        apingp = (struct aping_s *)mb->data;
        msg_free(mb);
        ping_mode = AOS_NTOHL( apingp->aping_r[0][0] );
        seq       = AOS_NTOHS( apingp->seq );

        
        aos_time_get_ms( &hms, &lms );
        
        delay = lms - apingp->delay;

        if( max_delay < delay )
        {
            max_delay = delay;
        }

        if( min_delay > delay )
        {
            min_delay = delay;
        }
        else if( 0 == min_delay )
        {
            min_delay = delay;
        }

        back_cnt++;
        delay_total += delay;

        if( !(ping_mode & XPING_R_X) )
        {
            AOS_ASSERT(is_aping);
            aos_sprintf( szBuf, "\r\nAping-%s reply,seq=%u, time < %ums", szFrom, seq, delay );
            aping_out_string( apingp, szBuf, 0 );
            aos_msg_free(apingp);
        }
        else
        {
            
            apingp->prim   = XPING_BACK;
            apingp->delay = AOS_HTONL(delay);
            apingp->xping_result = XPING_REPORT;
            
            xping_back( apingp );
        }

        apingp = NULL;

        aos_task_delay(0);

        goto retry;
    }

    mb = msg_deque( &ap_tsk[i].q1 );
    while( NULL != mb )
    {
        apingp = (struct aping_s *)mb->data;
        msg_free(mb);    
        aos_msg_free( apingp );
    }

    send_cnt = aping_seq+1;

    lost_percent = send_cnt?lost_cnt*100/send_cnt:0;
    average_delay = back_cnt ? delay_total/back_cnt : 0;

    if( is_aping )
    {
        aos_sprintf( szBuf, "\r\n\r\n    Packet: Send = %u, Recv = %u, Lost = %u(%u%% loss)", send_cnt, back_cnt, lost_cnt, lost_percent );
        aping_out_string( apingp0, szBuf, 0 );

        aos_sprintf( szBuf, "\r\nRound trip: Minimum = %ums, Maximum = %ums, Average = %ums", min_delay, max_delay, average_delay );
        aping_out_string( apingp0, szBuf, 1 );
    }
    else
    {
        
        xpingp = aos_msg_alloc( MPE_APING, sizeof(struct aping_s) );
        if( NULL != xpingp )
        {
            aos_memcpy( xpingp, apingp0, sizeof(struct aping_s) );
            xpingp->prim   = XPING_BACK;
            xpingp->delay  = 0;
            xpingp->xping_result = XPING_END;

            xpingp->aping_b[0][0] = AOS_HTONL( send_cnt );
            xpingp->aping_b[0][1] = AOS_HTONL( back_cnt );
            xpingp->aping_b[1][0] = AOS_HTONL( lost_cnt );
            xpingp->aping_b[1][1] = AOS_HTONL( min_delay );
            xpingp->aping_b[2][0] = AOS_HTONL( max_delay );
            xpingp->aping_b[2][1] = AOS_HTONL( average_delay );
            
            xping_back( xpingp );
        }
    }

    aos_msg_free( apingp0 );
    ap_tsk[i].task_id = U32_BUTT;
}

U32 aping_compatible_handle( VOID *p, U32 size )
{
    struct aping_old_s *apingp;
    U32 i, ping_mode;
    
    if( size != sizeof(struct aping_s) && size != sizeof(struct aping_old_s) )
    {
        return AOS_FAIL;
    }


    apingp = (struct aping_old_s*)p;
    if( apingp->total_r > 3 )
    {
        return AOS_FAIL;
    }

    
    if( size == sizeof(struct aping_old_s) )
    {
        for( i = apingp->next_r; i < apingp->total_r; i++ )
        {
            ping_mode = AOS_NTOHL( apingp->aping_r[i][0] );
            if( ping_mode & APING_R_IP_EX )
            {
                ping_mode &= ~APING_R_IP_EX;
                apingp->aping_r[i][0] = AOS_HTONL(ping_mode);
            }
        }
    }

    return AOS_SUCC;
}


VOID aping_hook4lcm( VOID *aping, VOID *addr , U32 tcp_mode )
{
    struct aping_s *apingp;
	SOCKADDRIN_S *addrp;
    U32 udp_port;

    apingp = (struct aping_s *)aping;
    addrp  = (SOCKADDRIN_S*)addr;
    
    if( apingp->next_r < 3 )
    {
        udp_port = (U32)AOS_NTOHS(addrp->sin_usPort);
        apingp->aping_b[apingp->next_r][0] = addrp->sin_stAddr.s_ulAddr;
        apingp->aping_b[apingp->next_r][1] = AOS_HTONL(udp_port);
    }

    tcp_mode = tcp_mode;
}

VOID aping_out_string(  struct aping_s *apingp , S8 *szStr, U32 end_flag )
{
    U32 trapnode[] = {1 , 3 , 6 , 1 , 4 , 1 , 15668 , 1 , 3 , 7 , 2 , 5};
    VOID* pMsgS;

    if( NULL == apingp )
    {
        return;
    }
    
    if( 255 != apingp->cli_index )
    {
        cli_out_string( apingp->cli_index , szStr );
        return;
    }

#if( AOS_INCLUDE_SMP_SNMP == TRUE )
    
    
    
    if( snmp_if_alloc_msg( &pMsgS ) != 0 )
    {
        return;
    }

    
    
    
    snmp_if_addpara2msg( &pMsgS, 0, SME_OBJECT_IDENTIFER, (U32)trapnode, 12*sizeof(U32) );

    
    if( APING_R_EIA & apingp->aping_r[0][0] )
    {
        if( apingp->aping_r[0][1] >= dev_get_base_eiano_for_sip_eia() )
        {
            snmp_if_addpara2msg( &pMsgS, 0, SME_INTEGER,   PING_DEV_SIPPHONE, sizeof(U32) );
        }
        else
        {
            snmp_if_addpara2msg( &pMsgS, 0, SME_INTEGER,   PING_DEV_EIA, sizeof(U32) );
        }
    }
    else
    {
        snmp_if_addpara2msg( &pMsgS, 0, SME_INTEGER,   PING_DEV_PLAT, sizeof(U32) );
    }
    
    snmp_if_addpara2msg( &pMsgS, 0, SME_INTEGER,  apingp->aping_r[0][1], sizeof(U32) );
    
    snmp_if_addpara2msg( &pMsgS, 0, SME_INTEGER,  end_flag, sizeof(U32) );
    
    snmp_if_addpara2msg( &pMsgS, 0, SME_OCTET_STRING,  (U32)szStr, aos_strlen(szStr) );

    
    
    
    snmp_trap_send_msg( pMsgS );
#endif
}

#if( AOS_INCLUDE_SMP_SNMP == TRUE )
VOID aos_start_ping(PING_PARAM *pstPingParam)
{
    U32 argc = 0, is_xping = 0;
    S8  str_ary[20][32];
    S8  *argv[20];
    
    if( NULL == pstPingParam )
    {
        AOS_ASSERT(0);
        return;
    }

    for( argc = 0; argc < 20; argc++ )
    {
        argv[argc] = &str_ary[argc];
    }
    argc = 0;
    
    aos_sprintf( argv[argc], "%d", 255 ); 
    argc++;

    argv[argc][0] = 0;
    argc++;
    
    switch( pstPingParam->ucDevType )
    {
        case PING_DEV_EIA:
        case PING_DEV_SIPPHONE:
            is_xping = 1;
            
            aos_strcpy( argv[argc], "eia" );
            argc++;

            if( PING_DEV_SIPPHONE == pstPingParam->ucDevType )
            {
                aos_sprintf( argv[argc], "%d", pstPingParam->usDevNo + dev_get_base_eiano_for_sip_eia() );
            }
            else
            {
                aos_sprintf( argv[argc], "%d", pstPingParam->usDevNo );
            }
            argc++;

            if( PING_DEV_EIA == pstPingParam->ucDstType 
             || PING_DEV_SIPPHONE == pstPingParam->ucDstType )
            {
                aos_strcpy( argv[argc], "eix" );
                argc++;
            }
            
            break;

        case PING_DEV_PLAT:
            if( PING_DEV_PLAT == pstPingParam->ucDstType )
            {
                return;
            }
            break;

        default:
            AOS_ASSERT(0);
            return;
    }

    switch( pstPingParam->ucDstType )
    {
        case PING_DEV_EIA:
        case PING_DEV_SIPPHONE:
            aos_strcpy( argv[argc], "eia" );
            argc++;

            if( PING_DEV_SIPPHONE == pstPingParam->ucDevType )
            {
                aos_sprintf( argv[argc], "%d", pstPingParam->usDevNo + dev_get_base_eiano_for_sip_eia() );
            }
            else
            {
                aos_sprintf( argv[argc], "%d", pstPingParam->usDevNo );
            }
            argc++;
            break;

        case PING_DEV_PLAT:
            aos_strcpy( argv[argc], "eix" );
            argc++;
            break;

        case PING_DEV_IP:
            aos_strcpy( argv[argc], "ip" );
            argc++;

            aos_sprintf( argv[argc], "%A", pstPingParam->ulDstIpAddr );
            argc++;

            if( 0 < pstPingParam->usDstPort && pstPingParam->usDstPort < U16_BUTT )
            {
                aos_sprintf( argv[argc], "%d", pstPingParam->usDstPort );
                argc++;
            }
            break;

        default:
            AOS_ASSERT(0);
            return;
    }    

    if( pstPingParam->ulCount < 1000 )
    {
        aos_strcpy( argv[argc], "-c" );
        argc++;

        aos_sprintf( argv[argc], "%d", pstPingParam->ulCount );
        argc++;
    }

    if( is_xping )
    {
        aos_xping( argc, argv );        
    }
    else
    {
        aos_ping( argc, argv );
    }
}

#endif

#endif

#ifdef __cplusplus
}
#endif