TCP套接字编程实现简单的并发服务器

unix中编写并发服务器程序最简单的方法就是fork一个子进程来服务每一个客户。

实现代码如下：

proto.h

定义client和server共同使用的协议格式，这里定义了tcp 服务器端的端口号，以及一些时间格式。

#ifndef TCPPROTO_H__
#define TCPPROTO_H__

#define SERVERPORT "1987"

#define FMT_STAMP "stamp:%lld\r\n"

#endif

client.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>

#include "proto.h"

int main(int argc,char *argv[])
{
        FILE *fp;
        int sd;
        long long stamp;
        struct sockaddr_in raddr;

        if(argc<2)
        {
                fprintf(stderr,"Usage:./client *.*.*.*\n");
                exit(1);
        }

        sd = socket(AF_INET,SOCK_STREAM,0);
        if(sd < 0)
        {
                perror("socket()");
                exit(1);
        }

        raddr.sin_family = AF_INET;
        raddr.sin_port = htons(atoi(SERVERPORT));
        inet_pton(AF_INET,argv[1],&raddr.sin_addr);

        if(connect(sd,(void *)&raddr,sizeof(raddr))<0)
        {
                perror("connect()");
                exit(1);
        }

        fp = fdopen(sd,"r+");
        if(fp == NULL)
        {
                perror("fdopen()");
                exit(1);
        }

        if(fscanf(fp,FMT_STAMP,&stamp)<1)
                fprintf(stderr,"Bad format!\n");
        else
                fprintf(stderr,"stamp = %lld\n",stamp);

        fclose(fp);
        return 0;
}

客户端实现了从监听套接字sd中读取时间，并在终端打印。在这里使用了socket()，connect()函数。

server.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>

#include "proto.h"

#define BUFSIZE 1024
#define STRSIZE 60

static void server_job(int connsd)
{
        char buf[BUFSIZE];
        int len;

        len = sprintf(buf,FMT_STAMP,(long long)time(NULL));

        if(send(connsd,buf,len,0)<0)
        {
                perror("send()");
                exit(1);
        }
}

int main(int argc, char *argv[])
{
        pid_t pid;
        int sd,connsd;
        struct sockaddr_in laddr,raddr;
        socklen_t raddr_len;
        char ipstr[STRSIZE];

        sd = socket(AF_INET,SOCK_STREAM,0);
        if(sd<0)
        {
                perror("socket()");
                exit(1);
        }

        laddr.sin_family = AF_INET;
        laddr.sin_port = htons(atoi(SERVERPORT));
        inet_pton(AF_INET,"0.0.0.0",&laddr.sin_addr);

        if(bind(sd,(void *)&laddr,sizeof(laddr)) <0)
        {
                perror("bind()");
                exit(1);
        }

        if(listen(sd,200) <0)
        {
                perror("listen()");
                exit(1);
        }

        raddr_len = sizeof(raddr);
        while(1)
        {
                pid_t pid;
                connsd = accept(sd,(void *)&raddr,&raddr_len);
                if(connsd <0)
                {
                        perror("accept()");
                        exit(1);
                }

                pid = fork();
                if(pid == 0)
                {
                        close(sd);
                        inet_ntop(AF_INET,&raddr.sin_addr,ipstr,STRSIZE);
                        printf("Client:%s:%d\n",ipstr,ntohs(raddr.sin_port));
                        server_job(connsd);
                        close(connsd);
                        exit(1);
                }
                close(connsd);
        }

        exit(0);
}

server端实现了一个并发服务器模型。首先使用函数socket()，bind()，listen()。在一个连接建立时，accept函数返回。接着fork一个子进程，然后由子进程服务客户端（通过已连接套接字connsd），父进程则等待另一个连接（通过过监听套接字sd）。新的客户由子进程服务，父进程就关闭已连接套接字。

server_job函数中通过已连接套接字connsd将时间发送至每一个客户，并且在服务器端打印客户端的IP和端口号。

在不同的机器上运行client，可以看到服务器端读取到客户端的IP和端口号，如下我的服务器端：

Client:192.168.0.94:49808
Client:192.168.0.93:59983
Client:192.168.0.94:49820
Client:192.168.0.93:59987

参考：

UNIX网络编程。

linux并发服务器模型：http://blog.chinaunix.net/uid-25906157-id-3170638.html