网络编程之多人聊天室

服务端代码 ： 

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <string.h>
#define MAX_CLNT 100
#define BUF_SIZE 1024

pthread_mutex_t mutx;          //定义互斥锁
int clnt_count = 0;            //统计客户端数量
int clnt_socks[MAX_CLNT];        //存储客户端对应的套接字

void send_msg(char* msg,int len);            
void* handle_clnt(void* arg);

int main(int argc,char **argv)
{
    printf("Hello World!\n");
    //保证输入格式正确
    if(argc < 3)
    {
        printf("Usage: %s <IP> <Port> \n",argv[0]);
        return 0;
    }
    //定义套接字
    int serv_sock,clnt_sock;
    int clnt_addr_size;
    pthread_t t_id;
    //初始化互斥锁
    pthread_mutex_init(&mutx,NULL);
    //创建字节流套接字
    serv_sock = socket(AF_INET,SOCK_STREAM,0);
    
    //准备通信地址
    struct sockaddr_in sAddr,cAddr;
    memset(&sAddr,0,sizeof(sAddr));
    sAddr.sin_family = AF_INET;
    sAddr.sin_port = htons(atoi(argv[2]));
    sAddr.sin_addr.s_addr = inet_addr(argv[1]);
    
    //绑定通信地址
    bind(serv_sock,(struct sockaddr*)&sAddr,sizeof(sAddr));
    //监听
    listen(serv_sock,5);

    while(1)
    {
        //等待连接
        clnt_addr_size = sizeof(cAddr);
        clnt_sock = accept(serv_sock,(struct sockaddr*)&cAddr,&clnt_addr_size);

        //对共享资源进行加锁
        pthread_mutex_lock(&mutx);
        //用一个数组专门存放套接字【有多人连接进来，连接一个存放一个】
        clnt_socks[clnt_count++] = clnt_sock;    
       //对共享资源进行解锁
       pthread_mutex_unlock(&mutx);

        //创建线程，用来为客户端服务
        pthread_create(&t_id,NULL,handle_clnt,(void*)&clnt_sock);
        pthread_detach(t_id);
        printf("Connected client IP: %s \n",inet_ntoa(cAddr.sin_addr));
    }

    close(serv_sock);
    return 0;
}

void* handle_clnt(void* arg)
{    
    //先将套接字强转回来
    int clnt_sock = *((int*)arg);
    int str_len = 0;
    int i;
    char msg[BUF_SIZE];

    //从套接字读数据到缓存区
    while((str_len = read(clnt_sock,msg,sizeof(msg))) != 0)
    {    //读
        send_msg(msg,str_len);
    }//读到0个字节，表示客户下线，退出循环

    //客户下线，移除其socket
    //上锁，封闭式的移除
    pthread_mutex_lock(&mutx);
    for(i = 0; i < clnt_count; i++)    //遍历所有客户
    {
        if(clnt_sock == clnt_socks[i])        //若某客户下线
        {
            while(i < clnt_count-1)        //若第i个后面还有人？？？
            {
                clnt_socks[i++] = clnt_socks[i];    //后面的依次往前移动一个位置
            }
            break;
        }
    }
    clnt_count--;
    pthread_mutex_unlock(&mutx);        //解锁
    close(clnt_sock);                //关闭该套接字
    printf("%d off line~~\n",clnt_sock);
    return NULL;
}

void send_msg(char* msg,int len)//发信息给所有人
{
    int i;
    //上锁，关闭共享资源
    pthread_mutex_lock(&mutx);
    for(i = 0; i < clnt_count; i++)
    {    //写自己读到的数据，发送给每个客户的
        write(clnt_socks[i],msg,len);
    }
    //解锁
    pthread_mutex_unlock(&mutx);
}

服务端：
准备工作：
    用一个数组统计连接进来的客户端的数量和存放他们的套接字
    即：每连接进来一个客户端，数组的成员加一，对应一个套接字
    
    
1.循环等待连接，每有一个客户端连接进来，上锁，让客户端数量加一，多保存一个套接字，解锁
2.创建一个线程，让他去为这个客户端服务
3.线程函数中，从这个客户端读取数据
4.若读到数据，就调用数据处理函数
5.数据处理函数中，上锁，用for循环封闭式给每个客户端发送自己读到的信息，发完解锁        
6.若读不到信息，上锁
a.在数组中遍历所有客户端        
b.若遇到下线的客户端    clnt_sock == clnt_socks[i]    【即若套接字对的上】
c.若他后面还有人，则把他的下一个人调到他的位置，所有人都循环前移一位

 

客户端代码：

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
    
#define NAME_SIZE 20
#define BUF_SIZE 1024

void* send_msg(void*arg);
void* read_msg(void*arg);

char name[NAME_SIZE] = "[DEFAULT]";
char msg[BUF_SIZE];
int main(int argc,char**argv)
{
    printf("Hello World!\n");
    int sock;
    struct sockaddr_in serv_addr;    //准备通信地址
    pthread_t snd_thread,rcv_thread;        //准备线程
    void* thread_return;
    //确保输入格式正确
    if(argc != 4)
    {
        printf("Usage: %s <IP> <Port> <Name> \n",argv[0]);
        return 0;
    }
    sprintf(name,"[%s]",argv[3]);    //确定昵称
    
    //1.创建字节流套接字
    sock = socket(AF_INET,SOCK_STREAM,0);
    
    //2.初始化并准备通信地址
    memset(&serv_addr,0,sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(atoi(argv[2]));
    serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
    
    //3.连接服务器
    int res = connect(sock,(struct sockaddr*)&serv_addr,sizeof(serv_addr));
    if(res < 0)
    {
        perror("connect ");
        return -1;
    }

    //4.创建线程
    //发送数据，将套接字强转后发送过去
    pthread_create(&snd_thread,NULL,send_msg,(void*)&sock);
    //接收数据，将套接字强转后发送过去
   pthread_create(&rcv_thread,NULL,read_msg,(void*)&sock);
    pthread_join(snd_thread,&thread_return);
    pthread_join(rcv_thread,&thread_return);

    close(sock);
    return 0;
}

void* send_msg(void *arg)
{    //发送数据
    //先将套接字强转回来
    int sock = *((int*)arg);
    //定义缓存区，用来存要发送的东西
    char name_msg[NAME_SIZE+BUF_SIZE];
    while(1)
    {
        fgets(msg,BUF_SIZE,stdin);    //以标准输入形式从键盘最多输入BUF_SIZE个字符
        if(!strcmp(msg,"q\n"))            //若输入为"q\n"
        {
            close(sock);        //关闭套接字
            exit(0);                //退出进程
        }
        sprintf(name_msg,"%s %s",name,msg);        //连接昵称和输入的字符
        write(sock,name_msg,strlen(name_msg));    //将连接后的东西发送给服务器(套接字)
    }
    return NULL;
}

void* read_msg(void *arg)
{    //接收数据
    //先将套接字强转回来
    int sock = *((int*)arg);    
    //定义缓存区，用来存要接收并打印的东西
    char name_msg[NAME_SIZE+BUF_SIZE];
    int str_len;
    while(1)
    {
        //从套接字(客户端)接收NAME_SIZE+BUF_SIZE-1个数据，存放到缓存区
        str_len = read(sock,name_msg,sizeof(name_msg)-1);
        if(str_len == -1)
        {
            //若读取出错，退出线程
            return (void*)-1;
        }
        name_msg[str_len] = 0;
        fputs(name_msg,stdout);    //打印接收到的东西
    }
    return NULL;
}