testcases/network/stress/ns-tools/ns-tcpserver.c

/******************************************************************************/
/*                                                                            */
/*   Copyright (c) International Business Machines  Corp., 2005               */
/*                                                                            */
/*   This program is free software;  you can redistribute it and/or modify    */
/*   it under the terms of the GNU General Public License as published by     */
/*   the Free Software Foundation; either version 2 of the License, or        */
/*   (at your option) any later version.                                      */
/*                                                                            */
/*   This program is distributed in the hope that it will be useful,          */
/*   but WITHOUT ANY WARRANTY;  without even the implied warranty of          */
/*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See                */
/*   the GNU General Public License for more details.                         */
/*                                                                            */
/*   You should have received a copy of the GNU General Public License        */
/*   along with this program;  if not, write to the Free Software             */
/*   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA  */
/*                                                                            */
/******************************************************************************/

/*
 * File:
 *	ns-tcpserver.c
 *
 * Description:
 *      This is TCP traffic server.
 *	Accept connections from the clients, then send tcp segments to clients
 *
 * Author:
 *	Mitsuru Chinen <mitch@jp.ibm.com>
 *
 * History:
 *	Oct 19 2005 - Created (Mitsuru Chinen)
 *---------------------------------------------------------------------------*/

#include "ns-traffic.h"

/*
 * Standard Include Files
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <time.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <netinet/tcp.h>

/*
 * Gloval variables
 */
struct sigaction handler;    /* Behavior for a signal */
int catch_sighup;       /* When catch the SIGHUP, set to non-zero */
int catch_sigpipe;      /* When catch the SIGPIPE, set to non-zero */

/*
 * Structure: server_info
 *
 * Description:
 *  This structure stores the information of a server
 */
struct server_info {
    sa_family_t family;		/* protocol family */
    char *portnum;		/* port number */
    int listen_sd;		/* socket descriptor for listening */
    int concurrent;		/* if non-zero, act as a concurrent server */
    size_t current_connection;	/* number of the current connection */
    size_t max_connection;	/* maximum connection number */
    size_t lost_connection;	/* number of lost connection */
    size_t small_sending;	/* if non-zero, in the small sending mode */
    size_t window_scaling;	/* if non-zero, in the window scaling mode */
};

/*
 * Function: usage()
 *
 * Descripton:
 *  Print the usage of this program. Then, terminate this program with
 *  the specified exit value.
 *
 * Argument:
 *  exit_value:	exit value
 *
 * Return value:
 *  This function does not return.
 */
void
usage(char *program_name, int exit_value)
{
    FILE *stream = stdout;	/* stream where the usage is output */

    if (exit_value == EXIT_FAILURE)
	stream = stderr;

    fprintf(stream, "%s [OPTION]\n"
		    "\t-f\tprotocol family\n"
		    "\t\t  4 : IPv4\n"
		    "\t\t  6 : IPv6\n"
		    "\t-p\tport number\n"
		    "\t-b\twork in the background\n"
		    "\t-c\twork in the concurrent server mode\n"
		    "\t-s\twork in the small sending mode\n"
		    "\t-w\twork in the window scaling mode\n"
		    "\t-o\tfilename where the server infomation is outputted\n"
		    "\t-d\twork in the debug mode\n"
		    "\t-h\tdisplay this usage\n"
		    ""
		    "*) Server works till it receives SIGHUP\n"
			, program_name);
    exit (exit_value);
}

/*
 * Function: set_signal_flag()
 *
 * Description:
 *  This function sets global variable according to the signal.
 *  Once a signal is caught, the signal is ignored after that.
 *
 * Argument:
 *  type: type of signal
 *
 * Return value:
 *  None
 */
void
set_signal_flag(int type)
{
    /* Set SIG_IGN against the caught signal */
    handler.sa_handler = SIG_IGN;
    if (sigaction(type, &handler, NULL) < 0)
	fatal_error("sigaction()");

    if (debug)
	fprintf(stderr, "Catch signal. type is %d\n", type);

    switch (type) {
	case SIGHUP:
	    catch_sighup = 1;
	    break;
	case SIGPIPE:
	    catch_sigpipe = 1;
	    break;
	default:
	    fprintf(stderr, "Unexpected signal (%d) is caught\n", type);
	    exit(EXIT_FAILURE);
    }
}

/*
 * Function: delete_zombies()
 *
 * Descripton:
 *  Delete the zombies
 *
 * Argument:
 *  info_p:	pointer to a server infomation
 *
 * Return value:
 *  None
 */
void
delete_zombies(struct server_info *info_p)
{
    int status;		/* exit value of a child */
    pid_t zombie_pid;   /* process id of a zombie */

    while (info_p->current_connection) {
	zombie_pid = waitpid((pid_t)-1, &status, WNOHANG);
	if (zombie_pid == (pid_t)-1)
	    fatal_error("waitpid()");
	else if (zombie_pid == (pid_t)0)
	    break;
	else {
	    --info_p->current_connection;
	    if (status != EXIT_SUCCESS) {
		++info_p->lost_connection;
		if (debug)
		    fprintf (stderr, "The number of lost conncections is %zu\n",
					info_p->lost_connection);
	    }
	}
    }
}

/*
 * Function: create_listen_socket()
 *
 * Descripton:
 *  Create a socket to listen for connections on a socket.
 *  The socket discripter is stored info_p->listen_sd.
 *
 * Argument:
 *  info_p:	pointer to a server infomation
 *
 * Return value:
 *  None
 */
void
create_listen_socket(struct server_info *info_p)
{
    int on;			/* on/off at an socket option */
    int err;			/* return value of getaddrinfo */
    struct addrinfo hints;	/* hints for getaddrinfo() */
    struct addrinfo *res;	/* pointer to addrinfo */

    /* Set the hints to addrinfo() */
    memset(&hints, '\0', sizeof(struct addrinfo));
    hints.ai_family = info_p->family;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;
    hints.ai_flags = AI_PASSIVE;

    /* Translate the network and service information of the server */
    err = getaddrinfo(NULL, info_p->portnum, &hints, &res);
    if (err) {
	fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(err));
	exit(EXIT_FAILURE);
    }
    if (res->ai_next) {
	fprintf(stderr, "getaddrinfo(): multiple address is found.");
	exit(EXIT_FAILURE);
    }

    /* Create a socket for listening. */
    info_p->listen_sd = socket(res->ai_family,
	    res->ai_socktype, res->ai_protocol);
    if (info_p->listen_sd < 0)
	fatal_error("socket()");

#ifdef IPV6_V6ONLY
    /* Don't accept IPv4 mapped address if the protocol family is IPv6 */
    if (res->ai_family == PF_INET6) {
	on = 1;
	if (setsockopt(info_p->listen_sd,
		    IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(int)))
	    fatal_error("setsockopt()");
    }
#endif

    /* Enable to reuse the socket */
    on = 1;
    if (setsockopt(info_p->listen_sd,
		SOL_SOCKET, SO_REUSEADDR, &on, sizeof(int)))
	fatal_error("setsockopt()");

    /* Disable the Nagle algorithm, when small sending mode */
    if (info_p->small_sending) {
	on = 1;
	if (setsockopt(info_p->listen_sd,
		    IPPROTO_TCP, TCP_NODELAY, &on, sizeof(int)))
	    fatal_error("setsockopt()");
	if (debug) {
	    fprintf(stderr, "small sending[on]\n");
	}
    }

    /* Maximize socket buffer, when window scaling mode */
    if (info_p->window_scaling)
	maximize_sockbuf(info_p->listen_sd);

    /* Bind to the local address */
    if (bind(info_p->listen_sd, res->ai_addr, res->ai_addrlen) < 0)
	fatal_error("bind()");
    freeaddrinfo(res);

    /* Start to listen for connections */
    if (listen(info_p->listen_sd, 5) < 0)
	fatal_error("listen()");
}

/*
 * Function: communicate_client()
 *
 * Descripton:
 *  Communicate with the connectted client.
 *  Currently, this function sends tcp segment in the specified second
 *  or recevie SIGHUP
 *
 * Argument:
 *  sock_fd: socket descriptor to communicate with client
 *  info_p:  pointer to a server infomation
 *
 * Return value:
 *  0:	    success
 *  other:  fail
 */
int
communicate_client(struct server_info *info_p, int sock_fd)
{
    char *sendmsg;		/* pointer to the message to send */
    int sndbuf_size;		/* size of the send buffer */
    socklen_t sock_optlen;		/* size of the result parameter */
    ssize_t sntbyte_size;	/* size of the sent byte */
    int ret = EXIT_SUCCESS;	/* The return value of this function */

    if (info_p->small_sending) {	/* small sending mode */
	sndbuf_size = 1;
    } else {
	sock_optlen = sizeof(sndbuf_size);
	if (getsockopt(sock_fd, SOL_SOCKET, SO_SNDBUF, &sndbuf_size, &sock_optlen) < 0) {
	    perror("getsockopt()");
	    if (close(sock_fd))
		fatal_error("close()");
	    return EXIT_FAILURE;
	}
    }
    if (debug)
	fprintf(stderr, "sndbuf size is %d\n", sndbuf_size);

    /* Define the message */
    sendmsg = (char *)malloc(sndbuf_size);
    if (sendmsg == NULL) {
	fprintf(stderr, "malloc() is failed.\n");
	if (close(sock_fd))
	    fatal_error("close()");
	return EXIT_FAILURE;
    }

    /* Set a signal handler against SIGHUP and SIGPIPE */
    handler.sa_handler = set_signal_flag;
    if (sigaction(SIGHUP, &handler, NULL) < 0)
	fatal_error("sigaction()");
    if (sigaction(SIGPIPE, &handler, NULL) < 0)
	fatal_error("sigaction()");

    /* Send the message */
    for (;;) {
	sntbyte_size = send(sock_fd, sendmsg, sndbuf_size, 0);

	/* Catch SIGPIPE */
	if (catch_sigpipe) {
	    if (debug)
	      fprintf(stderr, "The client closed the connection.\n");
	    break;
	}

	/* Catch SIGHUP */
	if (catch_sighup)
	    break;

	if (sntbyte_size < (ssize_t)0) {
	    if (errno == EPIPE) {
	      if (debug)
		fprintf(stderr, "The client closed the connection.\n");
	    } else {
		printf ("errno=%d\n", errno);
		perror("send()");
		ret = EXIT_FAILURE;
	    }
	    break;
	}
    }

    free(sendmsg);
    if (close(sock_fd))
	fatal_error("close()");
    return ret;
}

/*
 * Function: handle_client()
 *
 * Descripton:
 *  Accept a connection from a client, then fork to communicate the client
 *
 * Argument:
 *  info_p:	pointer to a server infomation
 *
 * Return value:
 *  0:	    success
 *  other:  fail
 */
int
handle_client(struct server_info *info_p)
{
    int ret = EXIT_SUCCESS;	/* return value of this function */
    int do_accept = 1;		/* if non-zero, accept connection */
    fd_set read_fds;		/* list of file descriptor for reading */
    int max_read_fd = 0;	/* maximum number in the read fds */

    info_p->current_connection = 0;
    FD_ZERO(&read_fds);
    FD_SET(info_p->listen_sd, &read_fds);
    max_read_fd = info_p->listen_sd;

    /* Catch SIGHUP */
    handler.sa_handler = set_signal_flag;
    if (sigaction(SIGHUP, &handler, NULL) < 0)
	fatal_error("sigaction()");

    /* Loop to wait a new connection */
    for (;;) {
	if (do_accept) {
	    int data_sd;	/* socket descriptor for send/recv data */
	    socklen_t client_addr_len;	/* length of `client_addr' */
	    struct sockaddr_storage client_addr;    /* address of a client */
	    int select_ret;	/* return value of select() */
	    fd_set  active_fds;	/* list of the active file descriptor */
	    struct timeval select_timeout;	/* timeout for select() */

	    /* When catch SIGHUP, no more connection is acceptted. */
	    if (catch_sighup) {
		do_accept = 0;
		if (close(info_p->listen_sd))
		    fatal_error("close()");
		continue;
	    }

	    /* Check a connection is requested */
	    active_fds = read_fds;
	    select_timeout.tv_sec = 0;	    /* 0.5 sec */
	    select_timeout.tv_usec = 500000;

	    select_ret = select(max_read_fd + 1,
		    &active_fds, NULL, NULL, &select_timeout);
	    if (select_ret < 0) {
		do_accept = 0;
		if (!catch_sighup) {
		    perror("select()");
		    ret = EXIT_FAILURE;
		}
		if (close(info_p->listen_sd))
		    fatal_error("close()");
		continue;
	    } else if (select_ret == 0) {	    /* select() is timeout */
		if (info_p->concurrent)
		    delete_zombies(info_p);
		continue;
	    }

	    /* Accetpt a client connection */
	    if (FD_ISSET(info_p->listen_sd, &active_fds)) {
		client_addr_len = sizeof(struct sockaddr_storage);
		data_sd = accept(info_p->listen_sd,
			(struct sockaddr *)&client_addr, &client_addr_len);
		if (data_sd < 0) {
		    do_accept = 0;
		    if (!catch_sighup) {
			perror("accept()");
			ret = EXIT_FAILURE;
		    }
		    if (close(info_p->listen_sd))
			fatal_error("close()");
		    continue;
		}
		if (debug)
		    fprintf(stderr, "called accept(). data_sd=%d\n", data_sd);

		/* Handle clients */
		if (info_p->concurrent) {	/* concurrent server. */
		    pid_t child_pid;
		    child_pid = fork();
		    if (child_pid < 0) {	/* fork() is failed. */
			perror("fork()");
			if (close(data_sd))
			    fatal_error("close()");
			if (close(info_p->listen_sd))
			    fatal_error("close()");
			do_accept = 0;
			continue;
		    } else if (child_pid == 0) {	/* case of a child */
			int exit_value;
			if (close(info_p->listen_sd))
			    fatal_error("close()");
			exit_value = communicate_client(info_p, data_sd);
			if (debug)
			    fprintf(stderr, "child(%d) exits. value is %d\n",
				    getpid(), exit_value);
			exit(exit_value);
		    } else {				/* case of the parent */
			if (close(data_sd))
			    fatal_error("close()");

			++info_p->current_connection;
			if (info_p->max_connection < info_p->current_connection) {
			    info_p->max_connection = info_p->current_connection;
			    if (debug)
				fprintf (stderr, "The maximum connection is updated. The number is %zu.\n", info_p->max_connection);
			}
			delete_zombies(info_p);
		    }
		} else {			/* repeat server */
		    ret = communicate_client(info_p, data_sd);
		    if (ret != EXIT_SUCCESS)
		      if (close(info_p->listen_sd))
			fatal_error("close()");
		    break;
		}
	    }
	} else {
	    /* case where new connection isn't accepted. */
	    if (info_p->concurrent)
		delete_zombies(info_p);
	    if (info_p->current_connection == 0)
		break;
	}
    }
    return ret;
}

/*
 *
 *  Function: main()
 *
 */
int
main(int argc, char *argv[])
{
    char *program_name = argv[0];
    int optc;			/* option */
    struct server_info server;	/* server information */
    int ret = EXIT_SUCCESS;	/* exit value */
    int background = 0;	/* If non-zero work in the background */
    FILE *info_fp = stdout;	/* FILE pointer to a information file */

    debug = 0;

    /* Initilalize the server information */
    memset(&server, '\0', sizeof(struct server_info));
    server.family = PF_UNSPEC;
    server.portnum = NULL;

    /* Retrieve the options */
    while ((optc = getopt(argc, argv, "f:p:bcswo:dh")) != EOF) {
	switch (optc) {
	    case 'f':
		if (strncmp(optarg, "4", 1) == 0)
		    server.family = PF_INET;	/* IPv4 */
		else if (strncmp(optarg, "6", 1) == 0)
		    server.family = PF_INET6;	/* IPv6 */
		else {
		    fprintf(stderr, "protocol family should be 4 or 6.\n");
		    usage(program_name, EXIT_FAILURE);
		}
		break;

	    case 'p':
		{
		    unsigned long int num;
		    num = strtoul(optarg, NULL, 0);
		    if (num < PORTNUMMIN || PORTNUMMAX < num) {
			fprintf(stderr, "The range of port is from %u to %u\n",
				PORTNUMMIN, PORTNUMMAX);
			usage(program_name, EXIT_FAILURE);
		    }
		    server.portnum = strdup(optarg);
		}
		break;

	    case 'b':
		background = 1;
		break;

	    case 'c':
		server.concurrent = 1;
		break;

	    case 's':
		server.small_sending = 1;
		break;

	    case 'w':
		server.window_scaling = 1;
		break;

	    case 'o':
		if ((info_fp = fopen(optarg, "w")) == NULL) {
		    fprintf(stderr, "Cannot open %s\n", optarg);
		    exit(EXIT_FAILURE);
		}
		break;

	    case 'd':
		debug = 1;
		break;

	    case 'h':
		usage(program_name, EXIT_SUCCESS);
		break;

	    default:
		usage(program_name, EXIT_FAILURE);
	}
    }

    /* Check the family is spefied. */
    if (server.family == PF_UNSPEC) {
	fprintf (stderr, "protocol family should be specified.\n");
	usage(program_name, EXIT_FAILURE);
    }

    /* Check the port number is specfied. */
    if (server.portnum == NULL) {
	server.portnum = (char *)calloc(6, sizeof(char));
	sprintf(server.portnum, "%u", PORTNUMMIN);
    }

    /* If -b option is specified, work as a daemon */
    if (background)
	if (daemon(0, 0) < 0)
	    fatal_error("daemon()");

    /* At first, SIGHUP is ignored. default with SIGPIPE */
    handler.sa_handler = SIG_IGN;
    if (sigfillset(&handler.sa_mask) < 0)
	fatal_error("sigfillset()");
    handler.sa_flags = 0;

    if (sigaction(SIGHUP, &handler, NULL) < 0)
	fatal_error("sigaction()");

    /* Create a listen socket */
    create_listen_socket(&server);

    /* Output any server information to the information file */
    fprintf(info_fp, "PID: %u\n", getpid());
    fflush(info_fp);
    if (info_fp != stdout)
	if (fclose(info_fp))
	    fatal_error("fclose()");

    /* Handle one or more tcp clients. */
    ret = handle_client(&server);
    exit (ret);
}