UTP聊天室项目

项目要求

利用UDP协议，实现一套聊天室软件。服务器端记录客户端的地址，客户端发送消息后，服务器群发给各个客户端软件。

● 客户端会不会知道其它客户端地址？

        不知道，服务器完成，服务器存储连接的客户端信息---》链表

● 有几种消息类型？

        登录、聊天、退出

● 客户端如何同时处理发送和接收？

        客户端不仅需要读取服务器消息，而且需要发送消息。读取需要调用recvfrom，发送需要先调用fgets，两个都是阻塞函数。所以必须使用多任务来同时处理，可以使用多进程或者多线程来处理。

头文件

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <signal.h>
#include <sys/wait.h>
enum tp
{
    login = 'L',
    chat = 'C',
    quit = 'Q',
};

//消息对应的结构体(同一个协议)
typedef struct MSG
{
    enum tp type;   // L C Q
    char name[32];  // 用户名
    char text[128]; // 消息正文
} msg_t;

//用户链表节点结构体
typedef struct node
{
    struct sockaddr_in caddr;
    struct node *next;
} node_t, *node_p;

聊天室服务器

#include "head.h"

// 创建链表
node_p creat_linklist()
{
    // 给头结点开辟空间
    node_p p = (node_p)malloc(sizeof(node_t));
    if (NULL == p)
    {
        perror("malloc err");
    }
    // 初始化头结点
    p->next = NULL;
    return p;
}

// 客户端上线功能：将用户上线消息发送给其他用户，并将用户信息添加到链表中
void push_chat(int sockfd, node_p p, msg_t msg, struct sockaddr_in caddr)
{
    sprintf(msg.text, "已上线");
    while (p->next != NULL)
    {
        p = p->next;
        sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&(p->caddr), sizeof(p->caddr));
    }
    node_p pnew = (node_p)malloc(sizeof(node_t));
    if (NULL == pnew)
    {
        perror("malloc err");
    }
    pnew->caddr = caddr;
    pnew->next = NULL;
    p->next = pnew;
}

// 聊天功能：转发消息到在链表中除了自己的所有用户
void chat_room(int sockfd, node_p p, msg_t msg, struct sockaddr_in caddr)
{
    while (p->next != NULL)
    {
        p = p->next;
        // memcmp:对比前后两个对应的地址(任意类型)的内容是否一致
        if (memcmp(&(p->caddr), &caddr, sizeof(caddr)) != 0)
            sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&(p->caddr), sizeof(p->caddr));
    }
}

// 客户端退出功能：将用户下线消息发送给其他用户，将下线用户从链表中删除
void pop_chat(int sockfd, node_p p, msg_t msg, struct sockaddr_in caddr)
{
    sprintf(msg.text, "已下线");
    while (p->next != NULL)
    {
        if (memcmp(&(p->next->caddr), &caddr, sizeof(caddr)) == 0)
        {
            node_p pdel = NULL;
            pdel = p->next;
            p->next = pdel->next;
            free(pdel);
            pdel = NULL;
        }
        else
        {
            p = p->next;
            sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&(p->caddr), sizeof(p->caddr));
        }
    }
}

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("usage:%s <端口号>\n", argv[0]);
        return -1;
    }
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        perror("socket err");
        return -1;
    }
    printf("sockfd:%d\n", sockfd);

    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
    int len = sizeof(caddr);

    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err");
        return -1;
    }
    printf("bind ok!\n");

    msg_t msg;
    node_p p = creat_linklist();

    while (1)
    {
        memset(msg.text, 0, sizeof(msg.text));
        int ret = recvfrom(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&caddr, &len);
        if (ret < 0)
        {
            perror("recvfrom err");
            return -1;
        }
        else
        {
            if (msg.type == 'L')
            {
                printf("%s上线\n", msg.name);
                printf("IP:%s PORT:%d\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));
                push_chat(sockfd, p, msg, caddr);
            }
            if (msg.type == 'C')
            {
                chat_room(sockfd, p, msg, caddr);
            }
            if (msg.type == 'Q')
            {
                printf("%s下线\n", msg.name);
                printf("IP:%s PORT:%d\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));
                pop_chat(sockfd, p, msg, caddr);
            }
        }
    }
    close(sockfd);
    return 0;
}

用户客户端

#include "head.h"

int main(int argc, char const *argv[])
{
    // IP地址和端口号通过命令行参数传参
    if (argc != 3)
    {
        printf("usage:%s <IP地址> <端口号>\n", argv[0]);
        return -1;
    }

    // 创建数据报套接字
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        perror("socket err");
        return -1;
    }
    printf("sockfd:%d\n", sockfd);

    // 指定网络信息
    struct sockaddr_in caddr;
    caddr.sin_family = AF_INET;
    caddr.sin_port = htons(atoi(argv[2]));
    caddr.sin_addr.s_addr = inet_addr(argv[1]);
    int len = sizeof(caddr);

    msg_t msg;      // 用于存储用户信息的结构体
    msg.type = 'L'; // 登录
    printf("请输入用户名:");
    fgets(msg.name, sizeof(msg.name), stdin);
    msg.name[strlen(msg.name) - 1] = '\0';
    if (sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&caddr, len) < 0)
    {
        perror("sendto err");
        return -1;
    }

    // 创建子进程
    pid_t pid = fork();
    if (fork < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0) // 子进程用于发送消息
    {
        while (1)
        {
            memset(msg.text, 0, sizeof(msg.text));
            printf("请输入消息:\n");
            fgets(msg.text, sizeof(msg.text), stdin);
            msg.text[strlen(msg.text) - 1] = '\0';
            if (strcmp(msg.text, "quit") == 0)
            {
                printf("退出\n");
                msg.type = 'Q';
                // 发送退出消息
                sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&caddr, len);
                kill(pid, SIGINT);
            }
            else
            {
                msg.type = 'C';
                // 发送正文消息
                sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&caddr, len);
            }
        }
    }
    else // 父进程用于接收消息
    {
        while (1)
        {
            if (recvfrom(sockfd, &msg, sizeof(msg), 0, NULL, NULL) < 0)
            {
                perror("recvfrom err");
                return -1;
            }
            printf("[%s]:%s\n", msg.name, msg.text);
        }
        wait(NULL);
        exit(0);
    }
    close(sockfd);
    return 0;
}