【Linux网络编程】基于UDP实现多人聊天室

最新推荐文章于 2024-07-04 17:27:49 发布
最新推荐文章于 2024-07-04 17:27:49 发布
阅读量3.4k 收藏 83
点赞数 32
分类专栏： 网络编程 文章标签： udp 网络 linux 运维 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65835264/article/details/126452989
版权

文章目录

一、UDP的概念

1.1 UDP

UDP(User Datagram Protocol)用户数据报协议，是不可靠的无连接的协议。在数据发送前，因为不需要进行连接，所以可以进行高效率的数据传输。

数据报格式套接字SOCK_DGRAM

1.2 UDP特点

采用UDP只管发送数据而不去验证发送数据的正确性，不论传输是否被接收，数据流是否有丢失，都不再重新发送，特征如下：

  1. 强调快速传输而非传输顺序；
  2. 传输的数据可能丢失也可能损毁；
  3. 限制每次传输的数据大小；
  4. 数据的发送和接收是并发的。

二. 采用UDP实现多人聊天室原因

数据报套接字采用的是UDP(User Datagram Protocol)协议，本次聊天室采用UDP协议虽然可能会导致数据丢失，但是聊天并不去强调内容的正确性，而应该强调实时性和并发，并且数据丢失只是小概率事件。

三、多人聊天室项目功能

  1. 当有用户加入群聊上线时，将登录消息发给在线的所有人
  2. 当有用户在线发送消息时，将消息发给在线的所有人
  3. 当有用户退出群聊时，将用户退出消息发给在线的所有人
  4. 服务器可以发送系统公告消息

四、实现多人聊天室项目流程分析

4.1 前期准备

4.1.1 定义结构体

由于客户端给服务器发送的数据内容较多，所以需要定义结构体来发送:

typedef struct
{
    char code; //操作码 'L' 登录  'C' 群聊  'Q' 退出
    char name[32];
    char txt[128];
} msg_t;

code相当于一个协议，用来确定将要进行的操作。
code为 ‘L’ 登录 ‘C’ 群聊 ‘Q’ 退出

name[32]用来保存登录用户名;

txt[128]用来保存发送的信息；

4.1.2 定义链表

服务器要给在线的所有客户端发送数据，需要将每一个客户端的信息保存，使用链表来保。

typedef struct _NODE
{
    struct sockaddr_in c_addr;//数据域
    struct _NODE *next;//指针域
} node_t;

数据域:客户端的网络信息结构体；

指针域:保存下一个结点的地址；

4.2 多人聊天室服务器

服务器既可以发送系统信息，又可以接收客户端信息并处理，可以使用多进程或者多线程；
本次使用多进程实现多人聊天室服务器。

pid_t pid;
pid = fork();
if (pid == -1)
{
    //创建错误
}
else if (pid == 0)
{
    //子进程
    //接受数据并处理
}
else if (pid > 0)
{
    //父进程
    //发系统消息
}

4.2.1 接收客户端发来的消息并进行处理

子进程循环接收客户端发来的消息，通过switch判断code所存的协议，执行特定的功能函数。

  1. 登录操作函数
  2. 群聊操作函数
  3. 退出操作函数

4.2.2 聊天室群公告功能

将父进程视为一个客户端，向子进程发送消息给所有在线的用户。

4.3 多人聊天室客户端

客户端登录之后，为了实现一边发送数据一边接收数据，可以使用多进程或者多线程；
本次使用多进程实现多人聊天室客户端。代码框架同上。

4.3.1 接收服务器发来的消息并进行处理

子进程循环接受服务器发来的消息，并将其打印在终端上。

4.3.2 向服务器发送消息

父进程循环向服务器发送群聊的消息，如果当消息为 “quit” 时进行用户退出群聊操作。

五、多人聊天室流程图

5.1 服务器流程图

服务器流程图

5.2 客户端流程图

客户端流程图

六、根据多人聊天室流程模块化进行代码实现

宏定义打印错误信息，进行健壮性判断。

#define PRINT_ERR(msg)                                  \
do                                                      \
{                                                       \
    printf("%s,%d,%s\n", __FILE__, __LINE__, __func__); \
    perror(msg);                                        \
    exit(-1);                                           \
} while (0)

入参合理性判断 可执行文件 ip地址 端口号

if (argc != 3)
{
    printf("age:%s ip port\n", argv[0]);
    return -1;
}

6.1 服务器代码实现

6.1.1 创建套接字

int sockfd;
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
    PRINT_ERR("socket error");
}

6.1.2 创建服务器网络信息结构体

struct sockaddr_in serviceaddr;
memset(&serviceaddr, 0, sizeof(serviceaddr));
serviceaddr.sin_family = AF_INET;
serviceaddr.sin_addr.s_addr = inet_addr(argv[1]);
serviceaddr.sin_port = htons(atoi(argv[2]));
socklen_t serviceaddr_len = sizeof(serviceaddr);

6.1.3 将服务器网络信息结构体与套接字绑定

if (bind(sockfd, (struct sockaddr *)&serviceaddr, serviceaddr_len) == -1)
{
    PRINT_ERR("bind error");
}

6.1.4 创建客户端网络信息结构体

struct sockaddr_in clientaddr;
memset(&clientaddr, 0, sizeof(clientaddr));
socklen_t clientaddr_len = sizeof(clientaddr);

6.1.5 子进程内部实现代码

  1. 使用链表头节点函数，定义链表头节点
//创建链表头节点函数
void creat_link(node_t **head)
{
    *head = (node_t *)malloc(sizeof(node_t));
}

//定义链表头节点
node_t *phead = NULL;
creat_link(&phead);
phead->next = NULL;
  1. 循环接受客户端发来的信息并通过switch进行判断执行哪个功能函数
while (1)
{
    memset(&msg, 0, sizeof(msg));//清空操作
    memset(&clientaddr, 0, sizeof(clientaddr));//清空操作
    if ((recvfrom(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&clientaddr, &clientaddr_len)) == -1)
    {
        PRINT_ERR("recvfrom error");
    }
    printf("%8s : [%s]\n", msg.name, msg.txt);
    switch (msg.code)
    {
    case 'L':
        do_register(sockfd, msg, clientaddr, phead);
        break;
    case 'C':
        do_group_chat(sockfd, msg, clientaddr, phead);
        break;
    case 'Q':
        quit_group_chat(sockfd, msg, clientaddr, phead);
        break;
    }
}
  1. 注册操作函数

注册时，遍历链表将用户登录信息发给所以在线的用户，并将自己的客户端网络信息结构体头插进入链表中。

int do_register(int sockfd, msg_t msg, struct sockaddr_in clientaddr, node_t *phead)
{
    //遍历链表将登录信息发送给所以人
    node_t *p = phead;
    while (p->next != NULL)
    {
        p = p->next;
        if (sendto(sockfd, &msg, sizeof(msg_t), 0, (struct sockaddr *)&(p->c_addr), sizeof(p->c_addr)) == -1)
        {
            PRINT_ERR("recvfrom error");
        }
    }
    //将登录的客户端信息插入保存在链表
    //头插
    //定义一个新的指针保存客户端信息
    node_t *newp = NULL;
    creat_link(&newp);
    newp->c_addr = clientaddr;
    newp->next = phead->next;
    phead->next = newp;
    return 0;
}
  1. 群聊操作函数

群聊时通过遍历，将txt中的信息发送给处了自己以外的所有在线用户

int do_group_chat(int sockfd, msg_t msg, struct sockaddr_in clientaddr, node_t *phead)
{
    //遍历链表，将消息发给除自己之外的所有人
    node_t *p = phead;
    while (p->next != NULL)
    {
        p = p->next;
        //判断链表客户端信息是否是自己
        //是自己就不发送
        if (memcmp(&(p->c_addr), &clientaddr, sizeof(clientaddr)))
        {
            if (sendto(sockfd, &msg, sizeof(msg_t), 0, (struct sockaddr *)&(p->c_addr), sizeof(p->c_addr)) == -1)
            {
                PRINT_ERR("recvfrom error");
            }
        }
    }
    return 0;
}
  1. 退出操作函数

退出时，遍历链表将退出信息发送给除自己以外的所有在线用户，并将自己的客户端网络信息结构体在链表中删除。

int quit_group_chat(int sockfd, msg_t msg, struct sockaddr_in clientaddr, node_t *phead)
{
    node_t *p = phead;

    while (p->next != NULL)
    {
        //判断链表客户端信息是否是自己
        //是自己就不发送并且将自己的客户端信息在链表内删除
        if (memcmp(&(p->next->c_addr), &clientaddr, sizeof(clientaddr)))
        {
            p = p->next;
            if (sendto(sockfd, &msg, sizeof(msg_t), 0, (struct sockaddr *)&(p->c_addr), sizeof(p->c_addr)) == -1)
            {
                PRINT_ERR("recvfrom error");
            }
        }
        else
        {
            node_t *pnew;
            pnew = p->next;
            p->next = pnew->next;
            pnew->next = NULL;
            free(pnew);
            pnew = NULL;
        }
    }
    return 0;
}

6.1.6 父进程内部实现代码

父进程视为一个客户端，向子进程发送消息，遍历链表给所有在线的用户。

msg.code='C';
strcpy(msg.name,"server");
while(1)
{
    fgets(msg.txt,128,stdin);
    msg.txt[strlen(msg.txt)-1]='\0';
    if(sendto(sockfd,&msg,sizeof(msg_t),0,(struct sockaddr *)&serviceaddr,serviceaddr_len)==-1)
    {
        PRINT_ERR("sendto error");
    }
}

代码结束前，在最后记得关闭套接字close(sockfd);

6.2 客户端代码实现

6.2.1 前两部与服务器一样

6.2.2 给服务器发送登录数据包

msg_t msg;
memset(&msg, 0, sizeof(msg_t));
msg.code = 'L';
printf("请输入用户名：");
fgets(msg.name, 32, stdin);
msg.name[strlen(msg.name) - 1] = '\0';

strcpy(msg.txt, "加入群聊");
if (sendto(sockfd, &msg, sizeof(msg_t), 0, (struct sockaddr *)&serviceaddr, serviceaddr_len) == -1)
{
    PRINT_ERR("sendto error");
}

6.2.3 子进程内部实现代码

循环接收服务器发来的数据，并将其打印在终端上。

while (1)
{
    //每次循环前将msg置零
    memset(&msg, 0, sizeof(msg));
    //接受服务器发过来的信息并打印到终端上
    if (recvfrom(sockfd, &msg, sizeof(msg_t), 0, NULL, NULL) == -1)
    {
        PRINT_ERR("recvfrom error");
    }
    printf("%8s:[%s]\n", msg.name, msg.txt);
}

6.2.4 父进程内部实现代码

先将协议设置为群聊，将终端输入的数据发送给服务器，当终端输入"quit"时，将协议设置为退出，并将退出群聊发送给服务器。
如果退出向终端输入"quit"时，退出循环。

while (1)
{   
    //memset会把name清除
    msg.code = 'C';
    fgets(msg.txt, 128, stdin);
    msg.txt[strlen(msg.txt) - 1] = '\0';
    if (strcmp(msg.txt, "quit") == 0)
    {
        msg.code = 'Q';
        strcpy(msg.txt, "退出群聊");
    }
    if (sendto(sockfd, &msg, sizeof(msg_t), 0, (struct sockaddr *)&serviceaddr, serviceaddr_len) == -1)
    {
        PRINT_ERR("sendto error");
    }
    if (strcmp(msg.txt, "退出群聊") == 0)
    {
        break;
    }
}

6.2.5 退出程序

给子进程发送杀死信号，等待回收子进程，关闭套接字。

kill(pid,SIGKILL);
wait(NULL);
close(sockfd);

七、结果展示和总结

7.1 结果展示

用户之间聊天成功
在这里插入图片描述
系统发送公告成功
在这里插入图片描述
退出群聊成功
在这里插入图片描述
成功实现基于UDP的多人聊天室。

7.2 缺点与不足

没有对客户端断连采取更为健壮的处理，应该再客户端捕获一下客户端因为ctrl+c而结束的信号，在捕获之后发送数据包给服务器，让服务器对客户端退出行为，做出删除保存客户信息结构体的行为。还有就是没有添加数据库的使用。

7.3 总结

整体项目并不复杂，只需要想清楚service和client分别需要做什么事。画好流程图，就会很清晰的将思路缕顺。从而只需要模块化的完成相应代码即可。

server为了保存每次连入进来的client信息，使用了链表，对链表的操作就是简单的插入，删除操作。

这算是最近学习中实现的一个稍微综合一点的项目，虽然不多，却也有所收获，便发布一篇帖子去记录，代码中可能有许多不规范的地方，逻辑可能并不严谨，还请各位不吝赐教。

八、UDP实现多人聊天室服务器源代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
//宏定义打印错误信息
#define PRINT_ERR(msg)                                      \
    do                                                      \
    {                                                       \
        printf("%s,%d,%s\n", __FILE__, __LINE__, __func__); \
        perror(msg);                                        \
        exit(-1);                                           \
    } while (0)

typedef struct
{
    char code; //操作码 'L' 登录  'C' 群聊  'Q' 退出
    char name[32];
    char txt[128];
} msg_t;
//链表结构体
typedef struct _NODE
{
    struct sockaddr_in c_addr;
    struct _NODE *next;
} node_t;

void creat_link(node_t **head);
int do_register(int sockfd, msg_t msg, struct sockaddr_in clientaddr, node_t *phead);
int do_group_chat(int sockfd, msg_t msg, struct sockaddr_in clientaddr, node_t *phead);
int quit_group_chat(int sockfd, msg_t msg, struct sockaddr_in clientaddr, node_t *phead);

int main(int argc, const char *argv[])
{
    //入参合理性判断
    if (argc != 3)
    {
        printf("age:%s ip port\n", argv[0]);
        return -1;
    }
    //创建套接字
    int sockfd;
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
    {
        PRINT_ERR("socket error");
    }
    //创建服务器网络信息结构体
    struct sockaddr_in serviceaddr;
    memset(&serviceaddr, 0, sizeof(serviceaddr));
    serviceaddr.sin_family = AF_INET;
    serviceaddr.sin_addr.s_addr = inet_addr(argv[1]);
    serviceaddr.sin_port = htons(atoi(argv[2]));
    socklen_t serviceaddr_len = sizeof(serviceaddr);
    //将服务器网络信息结构体与套接字绑定
    if (bind(sockfd, (struct sockaddr *)&serviceaddr, serviceaddr_len) == -1)
    {
        PRINT_ERR("bind error");
    }
    //创建客户端网络信息结构体
    struct sockaddr_in clientaddr;
    memset(&clientaddr, 0, sizeof(clientaddr));
    socklen_t clientaddr_len = sizeof(clientaddr);
    msg_t msg;
    //创建父子进程
    pid_t pid;
    pid = fork();
    if (pid == -1)
    {
        PRINT_ERR("fork error");
    }
    else if (pid == 0)
    {
        //子进程
        //接受数据并处理

        //定义链表头节点
        node_t *phead = NULL;
        creat_link(&phead);
        phead->next = NULL;

        while (1)
        {
            memset(&msg, 0, sizeof(msg));
            memset(&clientaddr, 0, sizeof(clientaddr));
            if ((recvfrom(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&clientaddr, &clientaddr_len)) == -1)
            {
                PRINT_ERR("recvfrom error");
            }
            printf("%8s : [%s]\n", msg.name, msg.txt);
            switch (msg.code)
            {
            case 'L':
                do_register(sockfd, msg, clientaddr, phead);
                break;
            case 'C':
                do_group_chat(sockfd, msg, clientaddr, phead);
                break;
            case 'Q':
                quit_group_chat(sockfd, msg, clientaddr, phead);
                break;
            }
        }
    }
    else if (pid > 0)
    {
        //父进程
        //发系统消息
        msg.code='C';
        strcpy(msg.name,"server");
        while(1)
        {
            fgets(msg.txt,128,stdin);
            msg.txt[strlen(msg.txt)-1]='\0';
            if(sendto(sockfd,&msg,sizeof(msg_t),0,(struct sockaddr *)&serviceaddr,serviceaddr_len)==-1)
            {
                PRINT_ERR("sendto error");
            }
        }
    }
    close(sockfd);
    return 0;
}
//创建链表头节点函数
void creat_link(node_t **head)
{
    *head = (node_t *)malloc(sizeof(node_t));
}
//登录操作
int do_register(int sockfd, msg_t msg, struct sockaddr_in clientaddr, node_t *phead)
{
    //遍历链表将登录信息发送给所以人
    node_t *p = phead;
    while (p->next != NULL)
    {
        p = p->next;
        if (sendto(sockfd, &msg, sizeof(msg_t), 0, (struct sockaddr *)&(p->c_addr), sizeof(p->c_addr)) == -1)
        {
            PRINT_ERR("recvfrom error");
        }
    }
    //将登录的客户端信息插入保存在链表
    //头插
    //定义一个新的指针保存客户端信息
    node_t *newp = NULL;
    creat_link(&newp);
    newp->c_addr = clientaddr;
    newp->next = phead->next;
    phead->next = newp;
    return 0;
}

int do_group_chat(int sockfd, msg_t msg, struct sockaddr_in clientaddr, node_t *phead)
{
    //遍历链表，将消息发给除自己之外的所有人
    node_t *p = phead;
    while (p->next != NULL)
    {
        p = p->next;
        //判断链表客户端信息是否是自己
        //是自己就不发送
        if (memcmp(&(p->c_addr), &clientaddr, sizeof(clientaddr)))
        {
            if (sendto(sockfd, &msg, sizeof(msg_t), 0, (struct sockaddr *)&(p->c_addr), sizeof(p->c_addr)) == -1)
            {
                PRINT_ERR("recvfrom error");
            }
        }
    }
    return 0;
}
//退出群聊操作
int quit_group_chat(int sockfd, msg_t msg, struct sockaddr_in clientaddr, node_t *phead)
{
    node_t *p = phead;

    while (p->next != NULL)
    {
        //判断链表客户端信息是否是自己
        //是自己就不发送并且将自己的客户端信息在链表内删除
        if (memcmp(&(p->next->c_addr), &clientaddr, sizeof(clientaddr)))
        {
            p = p->next;
            if (sendto(sockfd, &msg, sizeof(msg_t), 0, (struct sockaddr *)&(p->c_addr), sizeof(p->c_addr)) == -1)
            {
                PRINT_ERR("recvfrom error");
            }
        }
        else
        {
            node_t *pnew;
            pnew = p->next;
            p->next = pnew->next;
            pnew->next = NULL;
            free(pnew);
            pnew = NULL;
        }
    }
    return 0;
}

九、UDP实现多人聊天室客户端源代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
//宏定义打印错误信息
#define PRINT_ERR(msg)                                      \
    do                                                      \
    {                                                       \
        printf("%s,%d,%s\n", __FILE__, __LINE__, __func__); \
        perror(msg);                                        \
        exit(-1);                                           \
    } while (0)

typedef struct
{
    char code; //操作码 'L' 登录  'C' 群聊  'Q' 退出
    char name[32];
    char txt[128];
} msg_t;

int main(int argc, const char *argv[])
{
    //入参合理性判断
    if (argc != 3)
    {
        printf("age:%s ip port\n", argv[0]);
        return -1;
    }
    //创建套接字
    int sockfd;
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
    {
        PRINT_ERR("socket error");
    }
    //创建服务器网络信息结构体
    struct sockaddr_in serviceaddr;
    memset(&serviceaddr, 0, sizeof(serviceaddr));
    serviceaddr.sin_family = AF_INET;
    serviceaddr.sin_addr.s_addr = inet_addr(argv[1]);
    serviceaddr.sin_port = htons(atoi(argv[2]));
    socklen_t serviceaddr_len = sizeof(serviceaddr);
    //给服务器发送登录数据包
    msg_t msg;
    memset(&msg, 0, sizeof(msg_t));
    msg.code = 'L';
    printf("请输入用户名：");
    fgets(msg.name, 32, stdin);
    msg.name[strlen(msg.name) - 1] = '\0';

    strcpy(msg.txt, "加入群聊");
    if (sendto(sockfd, &msg, sizeof(msg_t), 0, (struct sockaddr *)&serviceaddr, serviceaddr_len) == -1)
    {
        PRINT_ERR("sendto error");
    }
    //创建父子进程
    pid_t pid;
    pid = fork();
    if (pid == -1)
    {
        PRINT_ERR("fork error");
    }
    else if (pid == 0)
    {
        //子进程
        //接受数据并处理
        while (1)
        {
            //每次循环前将msg置零
            memset(&msg, 0, sizeof(msg));
            //接受服务器发过来的信息并打印到终端上
            if (recvfrom(sockfd, &msg, sizeof(msg_t), 0, NULL, NULL) == -1)
            {
                PRINT_ERR("recvfrom error");
            }
            printf("%8s:[%s]\n", msg.name, msg.txt);
        }
    }
    else if (pid > 0)
    {
        //父进程
        //发送消息
        while (1)
        {   
            //memset会把name清除
            msg.code = 'C';
            fgets(msg.txt, 128, stdin);
            msg.txt[strlen(msg.txt) - 1] = '\0';
            if (strcmp(msg.txt, "quit") == 0)
            {
                msg.code = 'Q';
                strcpy(msg.txt, "退出群聊");
            }
            if (sendto(sockfd, &msg, sizeof(msg_t), 0, (struct sockaddr *)&serviceaddr, serviceaddr_len) == -1)
            {
                PRINT_ERR("sendto error");
            }
            if (strcmp(msg.txt, "退出群聊") == 0)
            {
                break;
            }
        }
        kill(pid,SIGKILL);
        wait(NULL);
        close(sockfd);
    }
    return 0;
}
夜猫徐
关注
专栏目录
Linux c 基于UDP实现简单的多人聊天室
RED_STARRR的博客
01-11 3464
1.数据报格式套接字 数据报格式套接字(代码为SOCK_DGRAM)，采用此方法计算机只管发送数据而不去验证发送数据的正确性，不论传输是否被接收，数据流是否有丢失，都不再重新发送，特征如下： 1.强调快速传输而非传输顺序； 2.传输的数据可能丢失也可能损毁； 3.限制每次传输的数据大小； 4.数据的发送和接收是并发的。 总之，数据报套接字是一种不可靠的、不按顺序传递的、以追求速度为目的的套接字。 以上总结于套接字有哪些类型？socket有哪些类型？ 2.采用UDP协议 而数据报套接字采
C语言 基于UDP的局域网多人聊天室的简单代码
Nerens的博客
01-23 4260
[C]基于UDP的局域网多人聊天室的简单代码 ..编程小白,代码可能比较冗长,请各位大佬指出不足 [*･ω･]运行现象思路程序源码(LINUX)1.head.h(头文件)2.datalink.c (存放着各种自定义函数接口)3.server.c(服务端)4.client.c(客户端)5.Makefile()代码中的不足之处废话 运行现象 1.当客户端(client)打开,输入昵称后服务器(server)端以及客户端的现象 2.当客户端发送消息,以及服务端发送消息,以及客户端退出时现象 思路 1.因为
【Linux开发实战指南】基于UDP协议的即时聊天室：快速构建登陆、聊天与退出功能
最新发布
LKHzzzzz的博客
07-04 684
与TCP（传输控制协议）相比，UDP具有较低的传输延迟，因为省去了建立连接和确认接收等过程，适用于对实时性要求较高、但能容忍一定数据丢失的场景，如在线视频、语音通话、DNS查询等。子进程继承了父进程的大部分属性，如环境变量、打开的文件描述符等，但拥有独立的内存空间、PID（进程ID）和调度优先级。信号是一种异步通知事件，可以由硬件异常（如断电）、操作系统（如杀死进程的SIGKILL）或一个进程向另一个进程发送（如使用。在操作系统中，当一个进程创建新进程时，原始进程称为父进程，新创建的进程称为子进程。
linux下基于UDP协议的聊天室
11-02
基于UDP协议的聊天室，linux下开发完成，在控制台下运行。
Linux下基于UDP实现的聊天室
qq_48633111的博客
01-14 721
/*######################################################################## # File Name: server.c # Author: tanyaduckal # mail: 2295375354@qq.com # Created Time: 2022年01月08日 星期六 15时54分17秒 ####################################################################.
linux下基于udp协议的聊天室（私聊、群聊、广播）
11-19
UDPchatroom =========== ##linux下基于UDP的控制台聊天室 make编译 服务器窗口运行：./chatServer 客服端窗口执行./chatClient localhost 8888 1 1是用户id，只能是数字1-9，localhost可以换成主机ip或者127.0.0.1 客户端：群聊格式：0+信息内容（如：0hi） 私聊格式：用户id+信息内容（如：1hello） 服务器：广播格式：0+信息内容（如：0hi） 注：如果make时遇到File `Makefile' has modification time 32 s in the future， 重设系统时间，设置为和PC机大致相同。 ================================================================================= name： 邱意 QQ： 178673693 time： 2014.11.19 version：1.0
udp-聊天室 for linux
03-29
linux 下 基于udp协议的一个在线聊天室 上线 下线 通知
Linux UDP简单聊天室
Y1172215784的博客
08-23 442
服务器端： #include<stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <arpa/inet.h> #include <netinet/in.h> #include <stdlib.h> #include <pthread.h&g...
linux多人聊天室程序（udp协议）
08-14
总之，通过理解UDP协议的工作原理和Linux网络编程，我们可以构建出一个简单的多人聊天室应用。通过`udpser.c` 和 `udpcli.c` 文件的实现，我们可以学习到如何在Linux环境中使用UDP进行通信，并实现多客户端的实时...
基于Linux的多人聊天系统
01-08
在IT领域，构建基于Linux的多人聊天系统是一项常见的任务，尤其对于学习网络编程和系统设计的学生及开发者来说。这样的系统通常涉及到并发处理、网络通信协议、数据传输安全等多个关键知识点。下面将详细介绍这些...
基于Linux的TCP多人聊天室
05-24
Ubuntu16.04 Linux平台 C语言编写，采用CS模型，TCP、UDP网络协议实现的内网多人聊天室。 服务器：采用多线程以及线程锁处理客户端的所有请求以及信息转发任务。服务端实时显示客户的登录与登出信息；保存客户上传的共享文件（网盘功能）；保存客户的账号密码信息，记录在线用户。 客户端：打开时可选择登录或者注册，登陆成功后由服务端记录为在线用户，同一个账号同一时间只能登录一个，后登录的会将已经在线的同个账号挤下线（异地登陆）。登陆后可以选择群聊、私聊、上传文件到共享网盘、查看网盘的文件或下载、选择指定在线用户发送文件。多线程实时显示接收到的消息并显示来源，接收到文件发送请求后可选择是否接收。
java 通过UDP实现一对多聊天室
12-12
使用java通过UDP实现一对多聊天室，而且有窗口
基于UDP的多人聊天
01-02
这是一个用MFC做的有界面的基于UDP的多人聊天系统，原创，一个课设成果
java udp多人聊天室
06-12
基于Java udp协议实现的图形界面的多人聊天室 ps：客户端登陆是输入的用户名只能是两个字的姓名
Linux下多人聊天室（完整版）
05-13
比较基础的代码,分客户端和服务器.实现客户端的通信,而服务器转发的功能
UDP实现多人聊天室
qq_39773004的博客
08-11 1361
概述 先运行接收方，避免收不到一开始的数据造成数据丢失 1.接收方Receiver package d03_chat; import java.net.DatagramPacket; import java.net.DatagramSocket; /** * zt * 2020/8/11 * 10:13 * 接收方 * * System.out.println(dp.getAddress().getHostAddress()+":"+data); * getAddress方法和getHos
【linux项目】多人聊天室
qq_44109833的博客
02-23 1307
多人聊天室 搭建一个可以实现多个用户同时在线聊天的多人聊天室 客户端 1.注册用户信息 bool Register() 89 { 90 if(!connect_server()) 91 { 92 return false; 93 } 94 9
linux下 UDP 实现聊天室
u011388214的专栏
07-18 1010
/*********************************客户端***************************************/ #include #include #include #include #include #include #include #include #include typedef struct soc
Linux下基于UDP的简易多人聊天室创建——群聊、私聊、上线通知（Socket编程）
qq_43212988的博客
06-22 6880
Linux下基于UDP的简易多人聊天室创建（Socket编程）OSI和TCP/IP：关于TCP/IP协议关于UDP协议UDP编程的一般步骤[^2]Socket套接字网络编程UDP网络聊天室实现功能概述服务器编程客户端编程运行结果总结遇到的问题服务器编程客户端编程 OSI和TCP/IP： OSI 模型本身不是网络体系结构的全部内容,它并未确切地描述用于各层的协议和服务,仅提出每一层应该做什么。不过OSI 已经为各层制定了标准,但并不是参考模型的一部分,而作为单独的国际标准公布的。 TCP/IP 是一组用于实现
Java UDP编程实现多人聊天室示例
本篇资源是关于Java网络编程实践的一个示例，主要讲解如何利用用户数据报协议（User Datagram Protocol, UDP）实现一个简单的多人聊天室功能。该教程分为两个部分：发送端（SendDemo）和接收端（ReceiveDemo）。 1....
评论 26
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

夜猫徐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值