linux socket 聊天室

linux socket 聊天室，本来这并不是我自己要做的，只是为了帮别人完成作业。刚好最近这段时间的课是关于socket编程，何不拿来练练手？

基于socket的聊天室早在开学初就有做过类似的，只不过当时用的java来实现，而且因为没有正式学过socket，代码只是搬用别人的，并没有深入理解。

单用户-服务的对话还是很好实现的，即使是多用户-服务，只要不是连续服务，服务端还是可以通过轮询的方式服务多个用户。问题就在于，常用socket I/O函数大都是阻塞的，这就意味着，单个线程只能服务于一个用户。于是自然而然的想到用多线程，然而多线程并不是最佳的解决方案，毕竟如果频繁的创建和销毁线程会造成一定的浪费。而利用select的多路复用，就能更好的解决。

客户端实现

客户端是很好实现的，只有2个I/O要通信，server socket和stdin，并且是fd值固定的，maxfdp直接取socket+1就行了。

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

#define BUF_SIZE 256 // 缓冲区长度
#define STDIN 0 // stdinfd
#define STDOUT 1 // stdoutfd
#define INVALID -1

/** 负责 socket 的初始化，连接到服务器 */
int socket_setup(const char *serv_ip, int serv_port)
{
    int rtn, sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in sockaddr;

    bzero(&sockaddr, sizeof(sockaddr));
    sockaddr.sin_family = AF_INET;
    sockaddr.sin_port = htons(serv_port);
    inet_pton(AF_INET, serv_ip, &sockaddr.sin_addr);

    rtn = connect(sockfd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));

    if (rtn == INVALID)
    {
        puts("Connection failure");
        exit(1);
    }
    else
    {
        puts("Connection successful");
        return sockfd;
    }
}

int main(int argc, const char *argv[])
{
    int i, read_size, sockfd = socket_setup(argv[1], atoi(argv[2]));
    char buffer[BUF_SIZE];
    fd_set fdset;

    while (true)
    {
        FD_ZERO(&fdset);
        FD_SET(STDIN, &fdset);
        FD_SET(sockfd, &fdset);
        select(sockfd + 1, &fdset, NULL, NULL, NULL);

        /** socket -> 标准输出 */
        if (FD_ISSET(sockfd, &fdset))
        {
            read_size = read(sockfd, buffer, BUF_SIZE);
            write(STDOUT, buffer, read_size);

            if (read_size == 0)
            {
                puts("Server close");
                exit(1);
            }
        }

        /** 标准输入 -> socket */
        if (FD_ISSET(STDIN, &fdset))
        {
            read_size = read(STDIN, buffer, BUF_SIZE);
            write(sockfd, buffer, read_size);
        }
    }

    return 0;
}

服务端实现

这个聊天室的实现难点是服务端，要能支持多用户聊天。

我的实现方法是，用一个结构体数组clients保存已连接的客户信息，使用遍历数组的方式广播消息，一般来说都能想到这点，重点是利用select实现多路复用。

因为客户socket是动态的，必须小心处理客户的连接/断开，当有用户连接时保存其socket，断开连接后将socket值为无效。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <unistd.h>
#include <time.h>
#include <sys/socket.h>
#include <arpa/inet.h>

#define TIME_SIZE 16 // 表示时间的字符串长度
#define IP_SIZE 16 // IP 字符串长度
#define BUF_SIZE 256 // 缓冲区大小
#define CLIENT_SIZE 8 // 允许的客户端数量
#define BACKLOG CLIENT_SIZE // listen 队列长度，等于允许的客户端数量
#define INVALID -1

/** 保存客户端连接信息结构体 */
struct CLIENT {
    int clientfd;
    struct sockaddr_in sockaddr;
    char ip[IP_SIZE];
    int port;
} clients[CLIENT_SIZE];

/** 初始化客户端列表 */
void init_clients(void)
{
    int i;

    for (i = 0; i< CLIENT_SIZE; i++)
        clients[i].clientfd = INVALID;
}

/** 向每一个已连接的用户广播消息 */
void broadcast(char *msg)
{
    int i;

    for (i = 0; i< CLIENT_SIZE; i++)
        if (clients[i].clientfd != INVALID)
            write(clients[i].clientfd, msg, strlen(msg));
}

/** 格式化要发送的消息 */
void strfmsg(int i, char *buffer, const char *msg)
{
    char curtime[TIME_SIZE];
    time_t curtime_t;
    struct tm *timeinfo;

    time(&curtime_t);
    timeinfo = localtime(&curtime_t);
    strftime(curtime, TIME_SIZE, "%X", timeinfo);

    sprintf(
        buffer,
        "<%s %s:%d> %s",
        curtime,
        clients[i].ip,
        clients[i].port,
        msg);
}

/** 新连接处理 */
void accept_connect(int listenfd)
{
    int connectfd, i;
    char buffer[BUF_SIZE];
    struct sockaddr_in clientaddr;
    socklen_t connectlen = sizeof(struct sockaddr_in);

    connectfd = accept(
        listenfd,
        (struct sockaddr *)&clientaddr,
        &connectlen);

    /** 记录连接者信息 */
    for (i = 0; i < CLIENT_SIZE; i++)
    {
        if (clients[i].clientfd == INVALID)
        {
            clients[i].clientfd = connectfd;
            memcpy(&clients[i].sockaddr, &clientaddr, connectlen);
            clients[i].port = ntohs(clients[i].sockaddr.sin_port);
            inet_ntop(
                AF_INET,
                &clients[i].sockaddr.sin_addr,
                clients[i].ip,
                IP_SIZE);

            strfmsg(i, buffer, "login\n");
            printf("%s", buffer);
            broadcast(buffer);

            break;
        }
    }

    /** 连接数超出 */
    if (i == CLIENT_SIZE)
    {
        strcpy(buffer, "Out of Number\n");
        write(connectfd, buffer, strlen(buffer));
        close(connectfd);
    }
}

/** 客户端消息处理 */
void chat(fd_set fdset)
{
    int sockfd, read_size, i;
    char read_buf[BUF_SIZE], send_buf[BUF_SIZE];

    for (i = 0; i < CLIENT_SIZE; i++)
    {
        sockfd = clients[i].clientfd;

        if (sockfd != INVALID && FD_ISSET(sockfd, &fdset))
        {
            read_size = read(sockfd, read_buf, BUF_SIZE - 1);

            if (read_size == 0)
            {
                /** 失去连接 */
                close(sockfd);
                clients[i].clientfd = INVALID;

                strfmsg(i, send_buf, "logout\n");
                printf("%s", send_buf);
                broadcast(send_buf);

                continue;
            }
            else
            {
                read_buf[read_size] = '\0';
                strfmsg(i, send_buf, read_buf);
                printf("%s", send_buf);
                broadcast(send_buf);
            }
        }
    }
}

/** 负责 socket 初始化，绑定监听端口 */
int socket_setup(int port)
{
    int rtn, listenfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in sockaddr;

    bzero(&sockaddr, sizeof(sockaddr));
    sockaddr.sin_family = AF_INET;
    sockaddr.sin_port = htons(port);
    sockaddr.sin_addr.s_addr= htonl(INADDR_ANY);

    rtn = bind(listenfd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));

    if (rtn == INVALID)
    {
        puts("Bind failure");
        exit(1);
    }

    if (listen(listenfd, BACKLOG) == INVALID)
    {
        puts("Listen failure");
        exit(1);
    }

    puts("Service startup");
    return listenfd;
}

int main(int argc, const char *argv[])
{
    int maxfdp, i, listenfd = socket_setup(atoi(argv[1]));
    fd_set fdset;

    init_clients();

    while (true)
    {
        FD_ZERO(&fdset);
        FD_SET(listenfd, &fdset);
        maxfdp = listenfd;

        /** 将可用的客户端 socket 加入 fdset，并计算 maxfdp */
        for (i = 0; i < CLIENT_SIZE; i++)
        {
            if (clients[i].clientfd != INVALID)
            {
                FD_SET(clients[i].clientfd, &fdset);

                if (clients[i].clientfd > maxfdp)
                    maxfdp = clients[i].clientfd;
            }
        }

        select(maxfdp + 1, &fdset, NULL, NULL, NULL);

        if (FD_ISSET(listenfd, &fdset))
            accept_connect(listenfd);

        chat(fdset);
    }

    return 0;
}