contest.c

本软件是TI公司免费提供的网络开发包 现在好象很难找到,有黑心的公司把它改一改,就卖价5000元,对网络开发和网络驱动开发有参考价值

    cnt = fdSelect( (int)s1, &ibits, 0, 0, 0 );

    if( !cnt )
        ConPrintf("Select returned NULL - This is an error\n");
    if( cnt < 0 )
    {
        tmp = fdError();
        if( fClose && tmp == EBADF )
        {
            ConPrintf("fdSelect correctly returned EBADF\n");
            s1 = INVALID_SOCKET;
        }
        else
            ConPrintf("fdSelect returned unexpected error code (%d)\n",tmp);
    }
    else
    {
        if( fClose )
            ConPrintf("Error: we should not be here!\n");

        if( FD_ISSET(s1, &ibits) )
        {
            ConPrintf("Socket is now readable\n");

            size = sizeof( sin1 );
            s2 = accept( s1, (PSA)&sin1, &size );
            if( s2 != INVALID_SOCKET )
                ConPrintf("Accept returned a socket - This is an error\n");

            if( fdError() == ECONNABORTED )
                ConPrintf("Accept correctly returned ECONNABORTED\n");
            else
                ConPrintf("Accept returned bad error code\n");
        }
    }

leave:
     if( s2 != INVALID_SOCKET )
         fdClose(s2);
     if( s1 != INVALID_SOCKET )
         fdClose(s1);

    ConPrintf("== End Test ==\n\n");
}

//----------------------------------------------------------------------
// CloseTask()
//
// Task to close a shared LISTEN socket
//----------------------------------------------------------------------
static void CloseTask( HANDLE hTaskParent, SOCKET s )
{
    fdOpenSession( TaskSelf() );

    ConPrintf("Child task spawned successfully - Calling fdClose()\n");

    // Shutting down listen for read should wake our parent
    fdClose(s);

    // Small delay so we can see the main thread quitting immediately
    // after the "Passed" message
    TaskSleep(2000);

    fdCloseSession( TaskSelf() );
    TaskExit();
}

//----------------------------------------------------------------------
// ShutdownTask()
//
// Task to shutdown a shared LISTEN socket
//----------------------------------------------------------------------
static void ShutdownTask( HANDLE hTaskParent, SOCKET s )
{
    fdOpenSession( TaskSelf() );

    ConPrintf("Child task spawned successfully - Calling shutdown()\n");

    // Shutting down listen for read should wake our parent
    shutdown( s, SHUT_RD );

    // Small delay so we can see the main thread quitting immediately
    // after the "Passed" message
    TaskSleep(2000);

    fdCloseSession( TaskSelf() );
    TaskExit();
}

//-------------------------------------------------------------------------
// StatusTest()
//
// Test the various status conditions of file descriptors
//-------------------------------------------------------------------------
static void StatusTest( IPN IPAddr )
{
    SOCKET stcpl      = INVALID_SOCKET;
    SOCKET stcp_peer  = INVALID_SOCKET;
    SOCKET stcp_child = INVALID_SOCKET;
    SOCKET stcp       = INVALID_SOCKET;
    SOCKET sudp       = INVALID_SOCKET;
    SOCKET pipe1      = INVALID_SOCKET;
    SOCKET pipe2      = INVALID_SOCKET;
    struct  sockaddr_in sin1;
    int    error,status,size;
    char   *buffer;

    buffer = mmAlloc(1024);
    if( !buffer )
    {
        ConPrintf("failed to allocate temp buffer\n");
        goto leave;
    }

    // Create TCP listen socket
    stcpl = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if( stcpl == INVALID_SOCKET )
    {
        ConPrintf("failed socket create (%d)\n",fdError());
        goto leave;
    }

    // Prepare address for bind
    bzero( &sin1, sizeof(struct sockaddr_in) );
    sin1.sin_family      = AF_INET;
    sin1.sin_len         = sizeof( sin1 );
    sin1.sin_addr.s_addr = IPAddr;
    sin1.sin_port        = htons(12345);

    // Bind the socket
    if( bind( stcpl, (PSA) &sin1, sizeof(sin1) ) < 0 )
    {
        ConPrintf("failed bind (%d)\n",fdError());
        goto leave;
    }

    // Start listening
    if( listen( stcpl, 1) < 0 )
    {
        ConPrintf("failed listen (%d)\n",fdError());
        goto leave;
    }

    //
    // Setting socket buffer sizes on a listening socket only
    // affects spawned sockets returned from accept()
    //

    // Set the TCP TX buffer to 1234;
    size = 1234;
    if( setsockopt( stcpl, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size) ) )
    {
        ConPrintf("failed setsockopt (%d)\n",fdError());
        goto leave;
    }
    // Set the TCP RX buffer to 4321;
    size = 4321;
    if( setsockopt( stcpl, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size) ) )
    {
        ConPrintf("failed setsockopt (%d)\n",fdError());
        goto leave;
    }

    // Create UDP socket
    sudp = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if( sudp == INVALID_SOCKET )
    {
        ConPrintf("failed socket create (%d)\n",fdError());
        goto leave;
    }

    // Set the UDP RX buffer to 1024;
    size = 1024;
    if( setsockopt( sudp, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size) ) )
    {
        ConPrintf("failed setsockopt (%d)\n",fdError());
        goto leave;
    }

    // Bind the socket
    if( bind( sudp, (PSA) &sin1, sizeof(sin1) ) < 0 )
    {
        ConPrintf("failed bind (%d)\n",fdError());
        goto leave;
    }

    // Connect the socket (to the same address)
    if( connect( sudp, (PSA) &sin1, sizeof(sin1) ) < 0 )
    {
        ConPrintf("failed connect (%d)\n",fdError());
        goto leave;
    }

    // Create the pipes
    if( pipe( &pipe1, &pipe2 ) != 0 )
    {
        ConPrintf("pipe create failed\n");
        goto leave;
    }

    // Create a TCP peer socket
    stcp_peer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if( stcp_peer == INVALID_SOCKET )
    {
        ConPrintf("failed socket create (%d)\n",fdError());
        goto leave;
    }

    ConPrintf("\nSocket Type Check\n");
    error = fdStatus( stcpl, FDSTATUS_TYPE, &status );
    ConPrintf("stcpl type is %d\n",status);
    error |= fdStatus( sudp, FDSTATUS_TYPE, &status );
    ConPrintf("sudp type is %d\n",status);
    error |= fdStatus( pipe1, FDSTATUS_TYPE, &status );
    ConPrintf("pipe1 type is %d\n",status);
    error |= fdStatus( stcp_peer, FDSTATUS_RECV, &status );
    ConPrintf("stcp_peer (unconnected) recv status = %d\n",status);
    error |= fdStatus( stcp_peer, FDSTATUS_SEND, &status );
    ConPrintf("stcp_peer (unconnected) send status = %d\n",status);

    ConPrintf("\nListening Status Check\n");

    // Get status of listen socket for recv
    error |= fdStatus( stcpl, FDSTATUS_RECV, &status );
    ConPrintf("stcpl connection available = %d\n",status);

    ConPrintf("Calling connect...\n");
    if( connect( stcp_peer, (PSA) &sin1, sizeof(sin1) ) < 0 )
    {
        ConPrintf("failed connect (%d)\n",fdError());
        goto leave;
    }

    // Get status of listen socket for recv
    error |= fdStatus( stcpl, FDSTATUS_RECV, &status );
    ConPrintf("stcpl connection available = %d\n",status);

    ConPrintf("Calling accept...\n");
    size = sizeof( sin1 );
    stcp_child = accept( stcpl, (PSA)&sin1, &size );
    if( stcp_child == INVALID_SOCKET )
    {
        ConPrintf("failed accept (%d)\n",fdError());
        goto leave;
    }

    // Get status of listen socket for recv
    error |= fdStatus( stcpl, FDSTATUS_RECV, &status );
    ConPrintf("stcpl connection available = %d\n",status);

    // Get some socket buffer status
    size = sizeof(size);
    error |= getsockopt(stcp_peer, SOL_SOCKET, SO_SNDBUF, &status, &size);
    ConPrintf("\nstcp_peer TCP send buffer size is %d\n",status);
    error |= getsockopt(stcp_peer, SOL_SOCKET, SO_RCVBUF, &status, &size);
    ConPrintf("stcp_peer TCP recv buffer size is %d\n",status);
    error |= getsockopt(stcp_child, SOL_SOCKET, SO_SNDBUF, &status, &size);
    ConPrintf("stcp_child TCP send buffer size is %d\n",status);
    error |= getsockopt(stcp_child, SOL_SOCKET, SO_RCVBUF, &status, &size);
    ConPrintf("stcp_child TCP recv buffer size is %d\n",status);
    error |= getsockopt(sudp, SOL_SOCKET, SO_SNDBUF, &status, &size);
    ConPrintf("sudp UDP send buffer size is %d\n",status);
    error |= getsockopt(sudp, SOL_SOCKET, SO_RCVBUF, &status, &size);
    ConPrintf("sudp UDP recv buffer size is %d\n",status);

    // Get some other status
    ConPrintf("\nCurrent RECV/SEND Status\n");
    error |= fdStatus( stcp_child, FDSTATUS_RECV, &status );
    ConPrintf("stcp_child recv status is %d\n",status);
    error |= fdStatus( sudp, FDSTATUS_RECV, &status );
    ConPrintf("sudp recv status is %d\n",status);
    error |= fdStatus( pipe2, FDSTATUS_RECV, &status );
    ConPrintf("pipe2 recv status is %d\n",status);

    error |= fdStatus( stcp_peer, FDSTATUS_SEND, &status );
    ConPrintf("stcp_peer send status is %d\n",status);
    error |= fdStatus( sudp, FDSTATUS_SEND, &status );
    ConPrintf("sudp send status is %d\n",status);
    error |= fdStatus( pipe1, FDSTATUS_SEND, &status );
    ConPrintf("pipe1 send status is %d\n",status);

    // Send 1024 bytes to everyone
    ConPrintf("\nCalling Send Data...\n");
    send( stcp_peer, buffer, 1024, 0 );
    send( sudp, buffer, 1024, 0 );
    send( pipe1, buffer, 1024, 0 );

    ConPrintf("\nCurrent RECV/SEND Status\n");
    error |= fdStatus( stcp_child, FDSTATUS_RECV, &status );
    ConPrintf("stcp_child recv status is %d\n",status);
    error |= fdStatus( sudp, FDSTATUS_RECV, &status );
    ConPrintf("sudp recv status is %d\n",status);
    error |= fdStatus( pipe2, FDSTATUS_RECV, &status );
    ConPrintf("pipe2 recv status is %d\n",status);

    error |= fdStatus( stcp_peer, FDSTATUS_SEND, &status );
    ConPrintf("stcp_peer send status is %d\n",status);
    error |= fdStatus( sudp, FDSTATUS_SEND, &status );
    ConPrintf("sudp send status is %d\n",status);
    error |= fdStatus( pipe1, FDSTATUS_SEND, &status );
    ConPrintf("pipe1 send status is %d\n",status);

    // Recv 1024 bytes from everyone
    ConPrintf("\nCalling Recv Data...\n");
    recv( stcp_child, buffer, 1024, 0 );
    recv( sudp, buffer, 1024, 0 );
    recv( pipe2, buffer, 1024, 0 );

    ConPrintf("\nCurrent RECV/SEND Status\n");
    error |= fdStatus( stcp_child, FDSTATUS_RECV, &status );
    ConPrintf("stcp_child recv status is %d\n",status);
    error |= fdStatus( sudp, FDSTATUS_RECV, &status );
    ConPrintf("sudp recv status is %d\n",status);
    error |= fdStatus( pipe2, FDSTATUS_RECV, &status );
    ConPrintf("pipe2 recv status is %d\n",status);

    error |= fdStatus( stcp_peer, FDSTATUS_SEND, &status );
    ConPrintf("stcp_peer send status is %d\n",status);
    error |= fdStatus( sudp, FDSTATUS_SEND, &status );
    ConPrintf("sudp send status is %d\n",status);
    error |= fdStatus( pipe1, FDSTATUS_SEND, &status );
    ConPrintf("pipe1 send status is %d\n",status);

    // Close peers
    ConPrintf("\nCalling close on receive side (tcp_child and pipe2)\n");
    fdClose( stcp_child );
    stcp_child = INVALID_SOCKET;
    fdClose( pipe2 );
    pipe2 = INVALID_SOCKET;

    ConPrintf("\nCurrent RECV/SEND Status\n");
    error |= fdStatus( stcp_peer, FDSTATUS_RECV, &status );
    ConPrintf("stcp_peer recv status is %d\n",status);
    error |= fdStatus( pipe1, FDSTATUS_RECV, &status );
    ConPrintf("pipe1 recv status is %d\n",status);

    error |= fdStatus( stcp_peer, FDSTATUS_SEND, &status );
    ConPrintf("stcp_peer send status is %d\n",status);
    error |= fdStatus( pipe1, FDSTATUS_SEND, &status );
    ConPrintf("pipe1 send status is %d\n",status);

    if( !error )
        ConPrintf("\nTest Complete - No errors detected\n\n");
    else
        ConPrintf("\nTest Completed with Errors!\n\n");

leave:
    if( stcpl      != INVALID_SOCKET)
        fdClose(stcpl);
    if( stcp_peer  != INVALID_SOCKET)
        fdClose(stcp_peer);
    if( stcp_child != INVALID_SOCKET)
        fdClose(stcp_child);
    if( stcp       != INVALID_SOCKET)
        fdClose(stcp);
    if( sudp       != INVALID_SOCKET)
        fdClose(sudp);
    if( pipe1      != INVALID_SOCKET)
        fdClose(pipe1);
    if( pipe2      != INVALID_SOCKET)
        fdClose(pipe2);

    if( buffer )
        mmFree(buffer);
}


//-------------------------------------------------------------------------
// PollCounter()
//
// This function counts in a loop. It is launched as a low priority
// task the first time the "test counter" command it used. The current
// counter can then be checked/cleared by typing the "test counter"
// command again. Note there is no way to unload the counting loop, and
// it will interfere with IDLE loop based operations.
//-------------------------------------------------------------------------
static void PollCounter()
{
    volatile int i;

    PollRunning = 1;

    for(;;)
    {
        for(i=0; i<10000; i++);
        PollCount++;
    }
}


//----------------------------------------------------------------------
// ShareRxTest()
//
// Test ECHO with a shared UDP socket using two tasks
//----------------------------------------------------------------------
static void ShareRxTest( IPN IPAddr )
{
    SOCKET  s = INVALID_SOCKET;
    SOCKET  s2 = INVALID_SOCKET;
    struct  sockaddr_in sin1;
    int     i;

    ConPrintf("\n== Start Shared RX UDP Socket Test ==\n");

    // Create test socket
    s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if( s == INVALID_SOCKET )
    {
        ConPrintf("failed socket create (%d)\n",fdError());
        goto leave;
    }

    // Prepare address for connect
    bzero( &sin1, sizeof(struct sockaddr_in) );
    sin1.sin_family      = AF_INET;
    sin1.sin_len         = sizeof( sin1 );
    sin1.sin_addr.s_addr = IPAddr;
    sin1.sin_port        = htons(1234);

    // Connect socket
    if ( bind( s, (PSA) &sin1, sizeof(sin1) ) < 0 )
    {
        ConPrintf("failed bind (%d)\n",fdError());
        goto leave;
    }

    // Create a thread to receive data
    if( !TaskCreate( UdpShareRX, "Receiver", OS_TASKPRINORM, 0x1000,
                     (UINT32)s, 1, 0 ) )
        goto leave;

    // Create a second thread to receive data
    if( !TaskCreate( UdpShareRX, "Receiver", OS_TASKPRINORM, 0x1000,
                     (UINT32)s, 2, 0 ) )
        goto leave;

    for( i=0; i<3; i++ )
    {
        ConPrintf("Sender sleeping...\n");
        TaskSleep(3000);

        ConPrintf("Sender sending...\n");

        // Create test socket
        s2 = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        if( s2 == INVALID_SOCKET )
        {
            ConPrintf("failed socket create (%d)\n",fdError());
            goto leave;
        }

        sendto( s2, (UINT8 *)&s2, 4, 0, &sin1, sizeof(sin1) );

        fdClose( s2 );
    }

    ConPrintf("Sender sleeping...\n");
    TaskSleep(3000);

    ConPrintf("Sender closing...\n");

leave:
    if( s != INVALID_SOCKET )
        fdClose( s );

    ConPrintf("== End Shared TCP Socket Echo Test ==\n\n");
}


//----------------------------------------------------------------------
// UdpShareRX()
//
// Task to receive data on a shared socket
//----------------------------------------------------------------------
static void UdpShareRX( SOCKET s, int index )
{
    int i;
    UINT8 buffer[32];

    fdOpenSession( TaskSelf() );

    ConPrintf("RX Child task %d spawned successfully\n",index);

    for(;;)
    {
        i= recv( s, buffer, 32, 0 );

        if( i < 0 )
        {
            ConPrintf("RX child task %d recv failed (%d)\n",index,fdError());
            break;
        }

        ConPrintf("RX child task %d received %d bytes\n",index,i);
    }

    fdCloseSession( TaskSelf() );
    TaskExit();
}