server.c

vxworks的tcp server的实例程序

/* echoServer.c - TCP echo server program */

/* Copyright 1984-1997 Wind River Systems, Inc. */

/*
modification history
--------------------
01g,06nov97,mm   added copyright.
01f,29Sep97,mm   changed printf  
01e,29Sep97,mm   cast arg1 of `bzero', cast arg 4 of `setsockopt', cast arg 2 of                 `bind', cast arg 2 of `accept'
01d,26Sep97,mm   added forward declaration STATUS echoTcpForever
01c,17Sep97,mm   deleted variable int numToRead from the function echoTcpForever
01b,17Sep97,mm   added include <stdio.h> <errnoLib.h> <usrLib.h> 
01a,07Feb94,ms   cleaned up for VxDemo.
*/

#include "sockLib.h"
#include <socket.h>
#include <errnoLib.h>
#include <usrLib.h>
#include <string.h>
#include <stdio.h>
#include "in.h"
#include "ioLib.h"
#include "netinet/tcp.h"

LOCAL int echoServerPort = 7001; /* default port num - should be greater */

/* Change the default keepidle time (timeout for probing the idle connection)
 * from several hours to few minutes.
 */
IMPORT int tcp_keepidle = 1; 


/*****************************************************************************
 * echoTcpServerRun - Runs the TCP server task for echo service
 *
 * DESCRIPTION
 *
 *     The TCP echo service specifies that a server must accept incoming
 *     requests, read data from the connection, an write the data back 
 *     over the connection until the client terminates the transfer.
 *
 *     Echo server merely returns all the data it receives from a client.
 *     Echo services are important tools that network managers use to test
 *     reachability (to make sure the connection works), debug protocol 
 *     software, and identify routing problems.
 *
 *     This also demonstrates the usage of SO_REUSEADDR, SO_KEEPALIVE,
 *     TCP_NODELAY and SO_LINGER set socket options.
 * 
 * EXAMPLE:
 *
 *     Run this echoTcpServerRun task on one VxWorks system as follows
 *     before starting the echoTcpClientRun task from another VxWorks system.
 *     The other half of the demonstration is in echoClient.c.
 *
 *     sp (echoTcpServerRun, port)
 *
 *     where port is the port number used by the echoTcpServer (should be
 *     greater than 5000).
 *
 *     example:
 *     -> sp (echoTcpServerRun, 7001)
 *
 */

/* forward declaration */

STATUS echoTcpForever();

void echoTcpServerRun 
    (
    int port			/* port number; 0 to use the last used one */
    )
    {

    if (port != 0)
	echoServerPort = port;

    FOREVER
	if (echoTcpForever () == ERROR)
            {
            printf ("echoTcpServerRun: echoTcpForever failed\n");
            return;
            }
    }


/*****************************************************************************
 * echoTcpServer - the TCP server task for echo service
 *
 */

STATUS echoTcpForever ()

    {
    struct sockaddr_in	serverAddr;            /* server's address */
    struct sockaddr_in	newConnAddr;    /* client's address */
    int 		sock;           /* socket fd */
    int 		newConnection;  /* socket fd */
    int 		len;            /* length of newConnAddr */ 
    int 		numRead;        /* number of bytes read */
    int 		optionVal;      /* value of setsocket option */
    struct linger 	linger;         /* amount of time to SO_LINGER */
    char 		buffer [1024];  /* data buffer */

    /* Zero out the sock_addr structures.
     * This MUST be done before the socket calls.
     */
    bzero ((char *) &serverAddr, sizeof (serverAddr));
    bzero (buffer, sizeof (buffer));

    /* open the TCP socket */
    sock = socket (AF_INET, SOCK_STREAM, 0);

    if (sock < 0)
	{
	perror ("socket");
	return (ERROR);
	}

     optionVal = 1; /* Turn ON the diff. setsockopt options */

    /* Specify the SO_REUSEADDR option  to bind a stream socket to a local  
     * port  that may be still bound to another stream socket that may be 
     * hanging around with a "zombie" protocol control block whose context
     * is  not yet freed from previous sessions.
     */
    if (setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, (char *) &optionVal,
		    sizeof(optionVal)) == ERROR)
	{
	perror ("echoTcpForever: setsockopt SO_REUSEADDR failed");
	close (sock);
	return (ERROR);
	}

    /* Specify the SO_KEEPALIVE option, and the transport protocol (TCP)  
     * initiates  a timer to detect a dead connection which prevents an
     * an application from  hanging on an invalid connection.
     */
    if (setsockopt (sock, SOL_SOCKET, SO_KEEPALIVE, (char *) &optionVal,
		    sizeof(optionVal)) == ERROR)
	{
	perror ("echoTcpForever: setsockopt SO_KEEPALIVE failed");
	close (sock);
	return (ERROR);
	}

    /* Specify the TCP_NODELAY option for protocols such as X Window System 
     * Protocol that require immediate delivery of many small messages. 
     *
     * By default VxWorks uses congestion avoidance algorithm 
     * for virtual  terminal  protocols and  bulk  data  transfer  
     * protocols. When the TCP_NODELAY option is turned on and there are 
     * segments to be sent out, TCP  bypasses  the  congestion
     * avoidance  algorithm  and sends the segments out if there 
     * is enough space in the send window.
     */
    if (setsockopt (sock, IPPROTO_TCP, TCP_NODELAY, (char *) &optionVal,
		    sizeof(optionVal)) == ERROR)
	{
	perror ("echoTcpForever: setsockopt TCP_NODELAY failed");
	close (sock);
	return (ERROR);
	}

    
    linger.l_onoff = 1;  /* Turn ON the SO_LINGER option */
    linger.l_linger = 0;/* Use default amount of time to shutdown i.e
                          the default value of TCP_LINGERTIME in tcp_timer.h*/ 

    /* Specify the SO_LINGER option to perform a  "graceful" close.
     * A graceful close occurs when a connection is shutdown, TCP  will  
     * try  to  make sure that all the unacknowledged data in transmission 
     * channel are acknowledged and the peer is shutdown properly by going 
     * through an elaborate  set  of  state transitions. 
     */
    if (setsockopt (sock, SOL_SOCKET, SO_LINGER, (char *) &linger, sizeof (linger))
	== ERROR)
	{
	perror ("echoTcpForever: setsockopt SO_LINGER failed");
	close (sock);
	return (ERROR);
	}

    /* Set up our internet address, and bind it so the client can connect. */
    serverAddr.sin_family      = AF_INET;
    serverAddr.sin_port        = htons (echoServerPort);
    serverAddr.sin_addr.s_addr = INADDR_ANY;

    printf ("\nBinding SERVER :%x\n", serverAddr.sin_port);
    if (bind (sock, (struct sockaddr *) &serverAddr, sizeof (serverAddr)) < 0)
	{
	perror ("bind");
	close (sock);
	return (ERROR);
	}

    /* Listen for the client to connect to us. */
    printf ("Listening to client\n");
    if (listen (sock, 5) < 0)
	{
	perror ("listen");
	close (sock);
	return (ERROR);
	}

    /* The client has connected.  Accept, and receive chars */
    len = sizeof (newConnAddr);
    newConnection = accept (sock, (struct sockaddr  *) &newConnAddr, &len);
    if (newConnection == ERROR)
        {
        perror ("accept failed");
        close (sock);
        return (ERROR);
        }

    /*  read data from the connection, and write the data back 
     *  over the connection until the client terminates the transfer.
     */
		
    while ((numRead = recv (newConnection, buffer, sizeof (buffer), 0)) > 0)
	{
	    printf ("buffer is - %s and numRead = %d\n", buffer, numRead);
	    send (newConnection, buffer, numRead, 0);
	 /*   buffer[0] = '\0';
	    numRead = 0;*/
        } 
    /* When the peer end of the TCP socket is closed, recv system 
     * call will return 0 bytes (means  EOF in TCP). When the connection is  
     * broken, recv will return ERROR with errno set to ETIMEDOUT.
     */
    numRead = recv (newConnection, buffer, sizeof (buffer), 0);

    if (numRead == 0)
        {
        printf ("No more bytes to read \n");
        printf ("Closing the sockets\n");
        }
    else
        {
        printErrno (errnoGet ());
        close (newConnection);
        close (sock);
        return (ERROR);
        }

    /* close the sockets */
    close (newConnection);
    close (sock);
    return (OK);
    }