Linux C/TCP多线程网络聊天室

多线程TCP网络聊天室

我们都知道TCP是一种基于连接的传输协议，使用多线程来实现其实步骤很简单。
首先说明一下项目：服务端开启后，直接运行客户端可以加入聊天室，同时其他客户端可以接收到某某客户端进入聊天室的消息，如果有个客户端主动退出或者意外退出，其他客户端同样会收到某某客户端退出的消息，除了这两个注意的点以外其他就是正常聊天。
注：项目只是完成基本功能，涉及一些网络安全和一些网络加密方面我也不太懂。

客户端

主程序 main函数内部

首先创建网络套接字sockfd，sockfd我创建到全局变量里方便线程使用

sockfd = socket(AF_INET, SOCK_STREAM, 0); // 创建网络套接字

创建server的网络信息结构体并填充

struct sockaddr_in serverSock;
socklen_t serverLen = sizeof(struct sockaddr_in);
//地址为回环地址,如果想要使用其他地址请把htonl(INADDR_ANY)修改为inet_addr(IP),IP为自己地址
serverSock.sin_addr.s_addr = htonl(INADDR_ANY);
// 端口自行设置 
serverSock.sin_port = htons(PORT);
serverSock.sin_family = AF_INET;

连接服务端

connect(sockfd, (struct sockaddr *)&serverSock, serverLen);

接下来就是打印下说明，好让人知道已经连接到服务端了

printf("=====欢迎加入聊天室=====\n");
printf("  退出服务器请输入quit  \n");

接下来就是创建两个线程：接收消息和发送消息

pthread_t pthreadSend;
pthread_create(&pthreadSend, NULL, pthread_send, NULL);
pthread_t pthreadRecv;
pthread_create(&pthreadRecv, NULL, pthread_recv, NULL);

在线程创建完成之后我们不要让这个程序结束，否则主程序结束线程也就跟着结束了。

while(!quit);
return 0;

quit变量是一个全局变量，是用在发送端主动输入quit的时候传递变量来结束主程序。
到这里主程序已经结束，接下来就是两个线程的内部功能

接收线程

void *pthread_recv(void *arg)
{
    msg_t msg; // 接收消息的结构体，我会放到head.h文件中解释
    bzero(&msg, 0); // 初始化
    while (1) //循环
    {
    	/* 阻塞接收函数,ret返回值用处来表明接收消息是否正常 */
    	/* 同时也能知道其他客户端是否还在不在聊天室,比如下文的等于0 */
        int ret = recv(sockfd, &msg, sizeof(msg), 0); 
        if (ret > 0)
        {
        	/* type变量是一个区分,1为正常消息,0为不正常,通常是有客户端主动正常退出 */
            if (msg.type == 1 && strlen(msg.message) > 0)
            {
            	/* 打印消息同时打印是哪个客户端打印的 */
                printf("客户端(%s:%d):%s\n", inet_ntoa(msg.cli.client.sin_addr), ntohs(msg.cli.client.sin_port), msg.message);
            }
            else
            {
                printf("%s\n", msg.message);
            }
        }
        /* 为0就是某某客户端断开连接 */
        else if (ret == 0)
        {
            printf("%s\n", msg.message);
        }
    }
}

发送线程

void *pthread_send(void *arg)
{
    msg_t msg;
    bzero(&msg, 0);
    while (1)
    {
    	/* 读取输入 */
        scanf("%s", msg.message);
        /* 防止读取到一个回车就发送 */
        if (getchar() == '\n' && msg.message[0] != '\n')
        {
        	/* 安全起先还是加了一个\0 */
            int len = strlen(msg.message);
            msg.message[len + 1] = '\0';
            send(sockfd, &msg, sizeof(msg), 0);
            /* 如果是quit的话令quit变量为true,这样主程序会结束 */
            if (!strcmp(msg.message, "quit"))
            {
                quit = true;
                break;
            }
            memset(msg.message, 0, sizeof(msg.message));
        }
    }
}

到这里客户端代码结束。

服务端

服务端采用多线程的话,思路是这样的

服务端 main函数内部

int main()
{
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in serverSock;
    socklen_t serverLen = sizeof(struct sockaddr_in);
    serverSock.sin_addr.s_addr = htonl(INADDR_ANY);
    serverSock.sin_port = htons(PORT);
    serverSock.sin_family = AF_INET;
    bind(sockfd, (struct sockaddr *)&serverSock, serverLen);

    listen(sockfd, 0);

    pthread_t acceptPthread;
    pthread_create(&acceptPthread, NULL, pthread_accept, NULL);
    while (1)
        ;
    return 0;
}

main函数整体思路跟客户端是一致的,唯一区别就是只有一个接收线程,同时while(1)死循环,只是为了实现客户端主动退出,并未考虑服务端主动关闭。

服务端接收线程函数

void *pthread_accept(void *arg)
{
    struct sockaddr_in clientSock;
    socklen_t clientLen = sizeof(struct sockaddr_in);
    printf("===========聊天室已创建===========\n");
    while (1)
    {
        int acceptFd = accept(sockfd, (struct sockaddr *)&clientSock, &clientLen);
        /*pNode保存客户端信息,并将这个结构体传递给common的线程*/
        /*common线程是把客户端加入到链表中之后再创建的用于接收和转发聊天*/
        cli_t *pNode = (cli_t *)malloc(sizeof(cli_t));
        pNode->client = clientSock;
        pNode->fd = acceptFd;
        pNode->next = NULL;
        /*采用头插法*/
        if (phead.size > 0)
        {
            cli_t *p = phead.cli.next;
            phead.cli.next = pNode;
            pNode->next = p;
        }
        else if (phead.size == 0)
        {
            phead.cli.next = pNode;
        }
        phead.size++;
        pthread_t commonPthread;
        /*创建聊天线程*/
        pthread_create(&commonPthread, NULL, pthread_common, (void *)pNode);
        pthread_detach(commonPthread);
    }
}

服务端聊天线程

void *pthread_common(void *arg)
{
	/*传递过来的pNode结构体中包含客户端的信息*/
    cli_t *pNode = (cli_t *)arg;
    /*打印给服务端显示*/
    printf("客户端(%s:%d)加入聊天室\n", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
    /*如果客户端链表大于1就转发某某加入聊天室的信息,并通知其他客户端*/
    if (phead.size > 1)
    {
        cli_t *p = &phead.cli;
        msg_t msg;
        bzero(&msg, 0);
        msg.cli = *pNode;
        msg.type = 0;
        sprintf(msg.message, "客户端(%s:%d)加入聊天室", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
        while (p->next != NULL)
        {
            p = p->next;
            /*除自己外不用发*/
            if (p->fd == pNode->fd)
                continue;
            send(p->fd, &msg, sizeof(msg), 0);
        }
    }
    /*死循环,接收和转发消息或者处理客户端消息*/
    while (1)
    {
        msg_t msgs;
        bzero(&msgs, 0);
        int ret = recv(pNode->fd, &msgs, sizeof(msgs), 0);
        /* 这里对客户端链表上锁,以防止两个或多个客户端同时退出造成 */
        /* 服务端崩溃或者转发消息失败 */
        pthread_mutex_lock(&phead.lock);
        if (ret > 0)
        {
        	/*先对发来quit消息的客户端进行处理*/
            if (!strcmp("quit", msgs.message))
            {
                phead.size--;
                msgs.type = 0;
                printf("客户端(%s:%d)退出聊天室\n", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
                sprintf(msgs.message, "客户端(%s:%d)退出聊天室", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
                cli_t *p = &phead.cli;
                while (p->next != NULL)
                {
                    p = p->next;
                    if (p->fd == pNode->fd)
                    {
                        continue;
                    }
                    send(p->fd, &msgs, sizeof(msgs), 0);
                }
                /* 待消息转发结束之后解锁链表 */
                pthread_mutex_unlock(&phead.lock);
                /* 从链表中删除此客户端信息 */
                delNodeFromList(&phead, pNode->fd);
                /* 关闭此套接字 */
                close(pNode->fd);
                /* 线程结束 */
                pthread_cancel(pthread_self());
                bzero(&msgs, 0);
                break;
            }
            else // 如果不是quit就正常转发此客户端发来的消息
            {
                msgs.cli = *pNode;
                cli_t *p = &phead.cli;
                /* type = 1就是为了能够客户端那边打印客户端消息 */
                msgs.type = 1; 
                while (p->next != NULL)
                {
                    p = p->next;
                    if (p->fd == pNode->fd)
                        continue;
                    send(p->fd, &msgs, sizeof(msgs), 0);
                }
                /* 正常发送消息结束后解锁链表 */
                pthread_mutex_unlock(&phead.lock);
            }
        }
        /* 这就是ret小于等于0的情况了,表示客户端意外退出 */
        /* 其处理方法和上边quit的处理相同,不过就是发送消息改为了 */
        /* 意外退出而已 */
        else
        {
            phead.size--;
            msgs.type = 0;
            printf("客户端(%s:%d)意外退出聊天室\n", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
            sprintf(msgs.message, "客户端(%s:%d)意外退出聊天室", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
            cli_t *p = &phead.cli;
            while (p->next != NULL)
            {
                p = p->next;
                if (p->fd == pNode->fd)
                {
                    continue;
                }
                send(p->fd, &msgs, sizeof(msgs), 0);
            }
            pthread_mutex_unlock(&phead.lock);
            delNodeFromList(&phead, pNode->fd);
            pthread_cancel(pthread_self());
            close(pNode->fd);
            bzero(&msgs, 0);
            break;
        }
    }
}

服务端 链表删除客户端节点函数

void delNodeFromList(msg_t *phead, int fd)
{
    if (phead == NULL)
        return;
    cli_t *p = &phead->cli;
    cli_t *pDel = NULL;
    /* 遍历链表找到要删除客户端的节点令pDel指向它 */
    while (p->next != NULL)
    {
        if (p->next->fd == fd)
        {
            pDel = p->next;
            break;
        }
        p = p->next;
    }
    p->next = pDel->next;
    pDel->next = NULL;
    free(pDel);
    pDel = NULL;
}

服务端server.c文件

#include "../head.h"
msg_t phead;
int sockfd;

void delNodeFromList(msg_t *phead, int fd)
{
    if (phead == NULL)
        return;
    cli_t *p = &phead->cli;
    cli_t *pDel = NULL;
    /* 遍历链表找到要删除客户端的节点令pDel指向它 */
    while (p->next != NULL)
    {
        if (p->next->fd == fd)
        {
            pDel = p->next;
            break;
        }
        p = p->next;
    }
    p->next = pDel->next;
    pDel->next = NULL;
    free(pDel);
    pDel = NULL;
}

void *pthread_common(void *arg)
{
	/*传递过来的pNode结构体中包含客户端的信息*/
    cli_t *pNode = (cli_t *)arg;
    /*打印给服务端显示*/
    printf("客户端(%s:%d)加入聊天室\n", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
    /*如果客户端链表大于1就转发某某加入聊天室的信息,并通知其他客户端*/
    if (phead.size > 1)
    {
        cli_t *p = &phead.cli;
        msg_t msg;
        bzero(&msg, 0);
        msg.cli = *pNode;
        msg.type = 0;
        sprintf(msg.message, "客户端(%s:%d)加入聊天室", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
        while (p->next != NULL)
        {
            p = p->next;
            /*除自己外不用发*/
            if (p->fd == pNode->fd)
                continue;
            send(p->fd, &msg, sizeof(msg), 0);
        }
    }
    /*死循环,接收和转发消息或者处理客户端消息*/
    while (1)
    {
        msg_t msgs;
        bzero(&msgs, 0);
        int ret = recv(pNode->fd, &msgs, sizeof(msgs), 0);
        /* 这里对客户端链表上锁,以防止两个或多个客户端同时退出造成 */
        /* 服务端崩溃或者转发消息失败 */
        pthread_mutex_lock(&phead.lock);
        if (ret > 0)
        {
        	/*先对发来quit消息的客户端进行处理*/
            if (!strcmp("quit", msgs.message))
            {
                phead.size--;
                msgs.type = 0;
                printf("客户端(%s:%d)退出聊天室\n", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
                sprintf(msgs.message, "客户端(%s:%d)退出聊天室", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
                cli_t *p = &phead.cli;
                while (p->next != NULL)
                {
                    p = p->next;
                    if (p->fd == pNode->fd)
                    {
                        continue;
                    }
                    send(p->fd, &msgs, sizeof(msgs), 0);
                }
                /* 待消息转发结束之后解锁链表 */
                pthread_mutex_unlock(&phead.lock);
                /* 从链表中删除此客户端信息 */
                delNodeFromList(&phead, pNode->fd);
                /* 关闭此套接字 */
                close(pNode->fd);
                /* 线程结束 */
                pthread_cancel(pthread_self());
                bzero(&msgs, 0);
                break;
            }
            else // 如果不是quit就正常转发此客户端发来的消息
            {
                msgs.cli = *pNode;
                cli_t *p = &phead.cli;
                /* type = 1就是为了能够客户端那边打印客户端消息 */
                msgs.type = 1; 
                while (p->next != NULL)
                {
                    p = p->next;
                    if (p->fd == pNode->fd)
                        continue;
                    send(p->fd, &msgs, sizeof(msgs), 0);
                }
                /* 正常发送消息结束后解锁链表 */
                pthread_mutex_unlock(&phead.lock);
            }
        }
        /* 这就是ret小于等于0的情况了,表示客户端意外退出 */
        /* 其处理方法和上边quit的处理相同,不过就是发送消息改为了 */
        /* 意外退出而已 */
        else
        {
            phead.size--;
            msgs.type = 0;
            printf("客户端(%s:%d)意外退出聊天室\n", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
            sprintf(msgs.message, "客户端(%s:%d)意外退出聊天室", inet_ntoa(pNode->client.sin_addr), ntohs(pNode->client.sin_port));
            cli_t *p = &phead.cli;
            while (p->next != NULL)
            {
                p = p->next;
                if (p->fd == pNode->fd)
                {
                    continue;
                }
                send(p->fd, &msgs, sizeof(msgs), 0);
            }
            pthread_mutex_unlock(&phead.lock);
            delNodeFromList(&phead, pNode->fd);
            pthread_cancel(pthread_self());
            close(pNode->fd);
            bzero(&msgs, 0);
            break;
        }
    }
}

void *pthread_accept(void *arg)
{
    struct sockaddr_in clientSock;
    socklen_t clientLen = sizeof(struct sockaddr_in);
    printf("===========聊天室已创建===========\n");
    while (1)
    {
        int acceptFd = accept(sockfd, (struct sockaddr *)&clientSock, &clientLen);
        /*pNode保存客户端信息,并将这个结构体传递给common的线程*/
        /*common线程是把客户端加入到链表中之后再创建的用于接收和转发聊天*/
        cli_t *pNode = (cli_t *)malloc(sizeof(cli_t));
        pNode->client = clientSock;
        pNode->fd = acceptFd;
        pNode->next = NULL;
        /*采用头插法*/
        if (phead.size > 0)
        {
            cli_t *p = phead.cli.next;
            phead.cli.next = pNode;
            pNode->next = p;
        }
        else if (phead.size == 0)
        {
            phead.cli.next = pNode;
        }
        phead.size++;
        pthread_t commonPthread;
        /*创建聊天线程*/
        pthread_create(&commonPthread, NULL, pthread_common, (void *)pNode);
        pthread_detach(commonPthread);
    }
}
int main()
{
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in serverSock;
    socklen_t serverLen = sizeof(struct sockaddr_in);
    serverSock.sin_addr.s_addr = htonl(INADDR_ANY);
    serverSock.sin_port = htons(PORT);
    serverSock.sin_family = AF_INET;
    bind(sockfd, (struct sockaddr *)&serverSock, serverLen);

    listen(sockfd, 0);

    pthread_t acceptPthread;
    pthread_create(&acceptPthread, NULL, pthread_accept, NULL);
    while (1)
        ;
    return 0;
}

客户端client.c文件

#include "../head.h"
int sockfd;
int quit = 0;
void *pthread_recv(void *arg)
{
    msg_t msg; // 接收消息的结构体，我会放到head.h文件中解释
    bzero(&msg, 0); // 初始化
    while (1) //循环
    {
    	/* 阻塞接收函数,ret返回值用处来表明接收消息是否正常 */
    	/* 同时也能知道其他客户端是否还在不在聊天室,比如下文的等于0 */
        int ret = recv(sockfd, &msg, sizeof(msg), 0); 
        if (ret > 0)
        {
        	/* type变量是一个区分,1为正常消息,0为不正常,通常是有客户端主动正常退出 */
            if (msg.type == 1 && strlen(msg.message) > 0)
            {
            	/* 打印消息同时打印是哪个客户端打印的 */
                printf("客户端(%s:%d):%s\n", inet_ntoa(msg.cli.client.sin_addr), ntohs(msg.cli.client.sin_port), msg.message);
            }
            else
            {
                printf("%s\n", msg.message);
            }
        }
        /* 为0就是某某客户端断开连接 */
        else if (ret == 0)
        {
            printf("%s\n", msg.message);
        }
    }
}

void *pthread_send(void *arg)
{
    msg_t msg;
    bzero(&msg, 0);
    while (1)
    {
    	/* 读取输入 */
        scanf("%s", msg.message);
        /* 防止读取到一个回车就发送 */
        if (getchar() == '\n' && msg.message[0] != '\n')
        {
        	/* 安全起先还是加了一个\0 */
            int len = strlen(msg.message);
            msg.message[len + 1] = '\0';
            send(sockfd, &msg, sizeof(msg), 0);
            /* 如果是quit的话令quit变量为true,这样主程序会结束 */
            if (!strcmp(msg.message, "quit"))
            {
                quit = true;
                break;
            }
            memset(msg.message, 0, sizeof(msg.message));
        }
    }
}

int main()
{
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in serverSock;
    socklen_t serverLen = sizeof(struct sockaddr_in);
    serverSock.sin_addr.s_addr = htonl(INADDR_ANY);
    serverSock.sin_port = htons(PORT);
    serverSock.sin_family = AF_INET;

    connect(sockfd, (struct sockaddr *)&serverSock, serverLen);
    printf("=====欢迎加入聊天室=====\n");
    printf("  退出服务器请输入quit  \n");
    msg_t msg;
    bzero(&msg, 0);
    pthread_t pthreadSend;
    pthread_create(&pthreadSend, NULL, pthread_send, NULL);
    pthread_t pthreadRecv;
    pthread_create(&pthreadRecv, NULL, pthread_recv, NULL);
    while (!quit)
        ;
    return 0;
}

head.h头文件

#ifndef __HEAD_H__
#define __HEAD_H__
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <sys/types.h>
#include <sys/socket.h>

#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/ip.h>
#include <netinet/ip.h>
#include <pthread.h>
// 使用htonl(INADDR_ANY)的话下边的IP用不到了
// 当然可以修改为自己的IP,那就把htonl改为inet_addr(IP)
#define IP "127.0.0.1"
#define PORT 5212

typedef struct client
{
    struct sockaddr_in client;
    int fd;
    struct client *next;
}cli_t;

typedef struct msg
{
    pthread_mutex_t lock; // 锁
    char message[512]; // 发送和接收数据
    int type; // 类型
    cli_t cli; // 客户端信息结构体
    int size; // 链表大小
}msg_t;

#endif

Makefile文件编译两个可执行文件,cli和ser

all:
	gcc client.c -o cli -lpthread
	gcc server.c -o ser -lpthread
clean:
	rm -rf cli ser

最后效果

正常加入聊天室和聊天的效果

主动退出和意外退出的效果