【LINUX/UNIX网络编程】之简单多线程服务器（多人群聊系统）

RT，Linux下使用c实现的多线程服务器。这个真是简单的不能再简单的了，有写的不好的地方，还希望大神轻拍。(＞﹏＜)

本学期Linux、unix网络编程的第四个作业。

先上实验要求：

【实验目的】

1、熟练掌握线程的创建与终止方法；

2、熟练掌握线程间通信同步方法；

3、应用套接字函数完成多线程服务器，实现服务器与客户端的信息交互。

【实验内容】

 通过一个服务器实现最多5个客户之间的信息群发。

服务器显示客户的登录与退出；

客户连接后首先发送客户名称，之后发送群聊信息；

客户输入bye代表退出，在线客户能显示其他客户的登录于退出。

实现提示：

1、服务器端：

主线程：

定义一个全局客户信息表ent，每个元素对应一个客户，存储：socket描述符、客户名、客户IP、客户端口、状态（初值为0）。

主线程循环接收客户连接请求，在ent中查询状态为0的元素，

    如果不存在状态为0的元素（即连接数超过最大连接数），向客户发送EXIT标志；

    否则，修改客户信息表中该元素的socket描述符、客户IP、客户端口号，状态为1（表示socket可用）；

同时创建一个通信线程并将客户索引号index传递给通信线程。

通信线程：

首先向客户端发送OK标志

循环接收客户发来信息，若信息长度为0，表示客户端已关闭，向所有在线客户发送该用户退出；

若信息为用户名，修改全局客户信息表ent中index客户的用户名name，并显示该用户登录；

若信息为退出，修改全局客户信息表ent中index客户状态为0，并显示该用户退出，终止线程；

同时查询全局客户信息表ent，向状态为1的客户发送接收的信息。

2、客户端：

根据用户从终端输入的服务器IP地址及端口号连接到相应的服务器；

连接成功后，接收服务端发来的信息，若为EXIT，则达到最大用户量，退出；

若为OK，可以通讯，首先先发送客户名称；

主进程循环从终端输入信息，并将信息发送给服务器；

当发送给服务器为bye后，程序退出。

同时创建一个线程负责接收服务器发来的信息，并显示，当接收的长度小于等于0时终止线程；

有了上一次多进程服务器的编写经验以后，写起多线程就简单多了。

照例还是绘制一下流程图，以方便我们理清思路。

好啦，现在可以开始撸代码了。

先实现一下用于通信的结构体clientmsg.h：（和多进程服务器是一样的）

//CLIENTMSG between server and client
#ifndef _clientmsg
#define _clientmsg

//USER MSG EXIT for OP of CLIENTMSG
#define EXIT -1
#define USER 1
#define MSG 2
#define OK 3

#ifndef CMSGLEN
#define CMSGLEN 100
#endif

struct CLIENTMSG{
    int OP;
    char username[20];
    char buf[CMSGLEN];
};

#endif

客户端程序看起来比较简单，咱们把它实现了，client.c：

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <unistd.h>
#include <pthread.h>
#include "clientmsg.h"

struct ARG{
    int sockfd;
    struct CLIENTMSG clientMsg;
};

void *func(void *arg);
void process_cli(int sockfd,struct CLIENTMSG clientMsg);
int main(){
    int sockfd;
    char ip[20];
    int port;
    pthread_t tid;
    struct sockaddr_in server;
    struct CLIENTMSG clientMsgSend;
    struct ARG *arg;
    /*---------------------socket---------------------*/
    if((sockfd = socket(AF_INET,SOCK_STREAM,0))== -1){
        perror("socket error
");
        exit(1);
    }

    /*---------------------connect--------------------*/
    printf("Please input the ip:
");
    scanf("%s",ip);
    printf("Please input the port:
");
    scanf("%d",&port);
    bzero(&server,sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(port);
    inet_aton(ip,&server.sin_addr);
    if(connect(sockfd,(struct sockaddr *)&server,sizeof(server))== -1){
        perror("connect() error
");
        exit(1);
    }
    recv(sockfd,&clientMsgSend,sizeof(clientMsgSend),0);
    if(clientMsgSend.OP == OK){
        //创建一个线程
        arg = (struct ARG *)malloc(sizeof(struct ARG));
        arg->sockfd = sockfd;
        pthread_create(&tid,NULL,func,(void *)arg);
        //主线程
        printf("Please input the username:
");
        scanf("%s",clientMsgSend.username);
        clientMsgSend.OP = USER;
        send(sockfd,&clientMsgSend,sizeof(clientMsgSend),0);
        while(1){
            clientMsgSend.OP = MSG;
            scanf("%s",clientMsgSend.buf);
            if(strcmp("bye",clientMsgSend.buf) == 0){
                clientMsgSend.OP = EXIT;
                send(sockfd,&clientMsgSend,sizeof(clientMsgSend),0);
                break;
            }
            send(sockfd,&clientMsgSend,sizeof(clientMsgSend),0);
        }
        pthread_cancel(tid);
    } 
    else{
        printf("以达到最大连接数！
");
    }
    /*------------------------close--------------------------*/
    close(sockfd);

    return 0;
}


void *func(void *arg){
    struct ARG  *info;
    info = (struct ARG *)arg;
    process_cli(info->sockfd,info->clientMsg);
    free(arg);
    pthread_exit(NULL);
}
void process_cli(int sockfd,struct CLIENTMSG clientMsg){
    int len;
    while(1){
                bzero(&clientMsg,sizeof(clientMsg));
                len =recv(sockfd,&clientMsg,sizeof(clientMsg),0);
                if(len > 0){
                    if(clientMsg.OP ==USER){
                        printf("the user %s is login.
",clientMsg.username );
                    }
                    else if(clientMsg.OP == EXIT){
                        printf("the user %s is logout.
",clientMsg.username);
                    }
                    else if(clientMsg.OP == MSG){
                        printf("%s: %s
",clientMsg.username,clientMsg.buf );
                    }
                }    
    }
}

然后是服务器端的实现，server.c：

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ipc.h>
#include <pthread.h>
#include "clientmsg.h"

struct Entity{
    int sockfd;
    char username[20];
    char buf[CMSGLEN];
    struct sockaddr_in client;
    int stat;
};

void *func(void *arg);
void communicate_process(int index);
struct Entity ent[5];

int main(){

    struct sockaddr_in server;
    struct sockaddr_in client;
    int listenfd,connetfd;
    char ip[20];
    int port;
    int addrlen;
    struct CLIENTMSG clientMsg;
    pthread_t tid;
    int *arg;
    /*---------------------socket-------------------*/
    if((listenfd = socket(AF_INET,SOCK_STREAM,0))== -1){
        perror("socket() error
");
        exit(1);
    }

    /*----------------------IO-----------------------*/
    printf("Please input the ip:
");
    scanf("%s",ip);
    printf("Please input the port:
");
    scanf("%d",&port);

    /*---------------------bind----------------------*/
    bzero(&server,sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(port);
    server.sin_addr.s_addr = inet_addr(ip);
    if(bind(listenfd,(struct sockaddr *)&server,sizeof(server))== -1){
        perror("bind() error
");
        exit(1);
    }

    /*----------------------listen-------------------*/
    if (listen(listenfd,5)== -1){
        perror("listen() error
");
        exit(1);
    }
    int i;
    for(i=0;i<5;i++){
        ent[i].stat = 0;
    }
    while(1){
        addrlen = sizeof(client);
        if((connetfd = accept(listenfd,(struct sockaddr *)&client,&addrlen))== -1){
            perror("accept() error
");
            exit(1);
        }
        int index = 5;
        for(i=0;i<5;i++){
            if(ent[i].stat == 0){
                index = i;
                break;
            }
        }
        if(index <= 4){    
            printf("connetfd:%d
",connetfd );
            ent[index].client = client;
            ent[index].sockfd = connetfd;
            ent[index].stat = 1;
            arg = malloc(sizeof(int));
            *arg = index;
            pthread_create(&tid,NULL,func,(void *)arg);

        }
        else{
            bzero(&clientMsg,sizeof(clientMsg));
            clientMsg.OP = EXIT;
            send(connetfd,&clientMsg,sizeof(clientMsg),0);
            close(connetfd);
        }

    }

    /*----------------------close-------------------*/
    
    close(listenfd);

    return 0;
}


/*----------------------------函数实现区----------------------------*/
void *func(void *arg){
    int *info ;
    info = (int *)arg;
    communicate_process( *info);
    pthread_exit(NULL);
}
void communicate_process(int index){
    struct CLIENTMSG sendMsg;
    struct CLIENTMSG recvMsg;
    printf("sockfd:%d
",ent[index].sockfd );
    sendMsg.OP = OK;
    send(ent[index].sockfd,&sendMsg,sizeof(sendMsg),0);

    while(1){
        bzero(&sendMsg,sizeof(sendMsg));
        bzero(&recvMsg,sizeof(recvMsg));
        int len =recv(ent[index].sockfd,&recvMsg,sizeof(recvMsg),0);
        if(len > 0){
            if(recvMsg.OP == USER){
                printf("user %s login from ip:%s,port:%d
",recvMsg.username,inet_ntoa(ent[index].client.sin_addr),ntohs(ent[index].client.sin_port) );
                bcopy(recvMsg.username,ent[index].username,strlen(recvMsg.username));
                sendMsg.OP = USER;
            }
            else if(recvMsg.OP == EXIT){
                printf("user %s is logout
",recvMsg.username );
                sendMsg.OP = EXIT;
                ent[index].stat = 0;
                int i;
                for(i=0;i<5;i++){
                     if(ent[i].stat == 1){
                         
                         send(ent[i].sockfd,&sendMsg,sizeof(sendMsg),0);
                     }
                 }
                break;
            }
            else if(recvMsg.OP == MSG){
                sendMsg.OP = MSG;
            }
            bcopy(recvMsg.username,sendMsg.username,strlen(recvMsg.username));
            bcopy(recvMsg.buf,sendMsg.buf,strlen(recvMsg.buf));
            int i;
            for(i=0;i<5;i++){
                 if(ent[i].stat == 1){
                     printf("stat 1...
");
                     send(ent[i].sockfd,&sendMsg,sizeof(sendMsg),0);
                 }
             }
        }
        else{
            continue;
        }
    }
}

最后是makefile文件：

main:server.o client.o 
    gcc server.o -oserver -lpthread
    gcc client.o -oclient -lpthread
server.o:server.c clientmsg.h
    gcc -c server.c
client.o:client.c clientmsg.h
    gcc -c client.c

如果程序中引入了#include <pthread.h>，要记得在编译的时候 加上 -lpthread。

下面上一下演示过程：（测试环境，Red Hat Enterprise Linux 6 + centos系Linux，ubuntu下可能会有些问题。）

首先先把服务端启动开来，为了方便测试，这里直接使用的是127.0.0.1的localhost。

然后启动两个客户端用来测试，在用户登录的时候客户端会有消息提醒。服务端会有日志打印输出客户端的名字和登录ip、端口。

客户可以发送消息了，如图发送与接收均正常。这里为了简单演示只是启动了2个。

输入bye以后即可退出聊天并下线。当有客户下线的时候，在线的客户端会收到下线提醒，客户端会有日志打印输出。