一个简单的并发回射服务器

client.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
 
void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(EXIT_FAILURE);
}
 
int main(int argc, char *argv[])
{
	if(argc != 3)
	{
		error_handling("usage: servIP Port");
	}		
    int sockfd, ret;
    struct sockaddr_in servaddr;
    servaddr.sin_family = AF_INET;
    //servaddr.sin_port = htons(8001);
	servaddr.sin_port = htons(atoi(argv[2]));
    //servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	if(inet_pton(AF_INET, argv[1],&servaddr.sin_addr) < 0){
		error_handling("port error");
	}	
	
 
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
 
    ret = connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
    if(ret == -1){
        perror("bind error.\n");
        exit(EXIT_FAILURE);
    }
     
    char recvbuf[1024] = {0};
    char sendbuff[1024] = {0};
 
    while(fgets(sendbuff, 1024, stdin) != NULL){
        write(sockfd, sendbuff, strlen(sendbuff));
        read(sockfd, recvbuf, 1024);
        printf("receive from %s:%d - ", inet_ntoa(servaddr.sin_addr), ntohs(servaddr.sin_port));
        fputs(recvbuf, stdout);
        memset(recvbuf, 0, 1024);
        memset(sendbuff, 0, 1024);
    }
     
    exit(0);
}

server.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <string.h>
 
 typedef void Sigfunc(int);
 
 Sigfunc *Signal(int signo, Sigfunc *func);
 
 void error_handling(char *message);
 void  sigChild(int signo);
 
int main(int argc, char *argv[])
{
	if(argc != 3)
	{
		error_handling("usage: IP Port");
	}
	
   //int socket(int domain, int type, int protocol);
    int listenfd, connfd;
    listenfd = socket(AF_INET, SOCK_STREAM, 0);
     
    struct sockaddr_in servaddr;
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(atoi(argv[2]));
    //servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	if(inet_pton(AF_INET, argv[1],&servaddr.sin_addr)<0){
		error_handling("ip error");
	}
 
    //int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
    if(bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1)
        error_handling("bind() error");
 
    if(listen(listenfd, 128) == -1)
        error_handling("listen() error");
	
	Signal(SIGCHLD, sigChild);
 
    struct sockaddr_in cliaddr;
    socklen_t clilen;
     
    
    char recvbuf[2014] = {0};
    int recvcount = 0;
 
    for(;;)
	{
        connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);
		if(errno == EINTR)
		{
			continue;
		}
		else if( connfd == -1)
		{
            perror("accept error.\n");
            exit(EXIT_FAILURE);
        }
        pid_t pid = fork();
     
        if(pid == 0)
		{
			close(listenfd);
            while(1)
			{
                recvcount = read(connfd, recvbuf,1024);
                if (recvcount == 0){
                    printf("%s:%d is over.\n", inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));
                    exit(0);
                }
                else if (recvcount == -1){
                    perror("read error.\n");
                    exit(EXIT_FAILURE);
                }
                printf("%d receive from %s:%d - ", getpid(), inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));
                fputs(recvbuf, stdout);
                write(connfd, recvbuf, strlen(recvbuf));
                memset(recvbuf, 0, 1024);
            }
			exit(EXIT_SUCCESS);
        }
        else 
		{
			close(connfd);						                 
        }   
    } 
    exit(EXIT_SUCCESS);
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(EXIT_FAILURE);
}

void  sigChild(int signo)
{
	pid_t pid;
	int stat;
	
	//pid = wait(&stat);
	while((pid = waitpid(-1, &stat, WNOHANG)) > 0)
	{
		printf("child %d terminated\n", pid);
	}
	return ;	
}


Sigfunc* Signal(int signo, Sigfunc *func)
{
	struct sigaction act, oact;
	
	act.sa_handler = func;
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	
	if(sigaction(signo, &act, &oact) < 0)
	{
		return (SIG_ERR);
	}
	
	return oact.sa_handler;
}