UDP网络聊天室

最新推荐文章于 2024-07-06 16:00:29 发布
最新推荐文章于 2024-07-06 16:00:29 发布
阅读量484 收藏 1
点赞数 12
分类专栏： 项目 文章标签： 网络 udp 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/slander_1120/article/details/139177517
版权

前言

基于UDP的网络聊天室

一、项目需求

  1. 如果有用户登录，其他用户可以收到这个人的登录信息
  2. 如果有人发送信息，其他用户可以收到这个人的群聊信息
  3. 如果有人下线，其他用户可以收到这个人的下线信息
  4. 服务器可以发送系统信息

二、步骤

1.创建UDP服务器

1.1 头文件

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <math.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <semaphore.h>
 #include <wait.h>
 #include <signal.h>
 #include <sys/socket.h>
 #include <arpa/inet.h>
 #include <sys/ipc.h>
 #include <sys/sem.h>
 #include <semaphore.h>
 #include <sys/msg.h>
 #include <sys/shm.h>
 #include <sys/un.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <errno.h>
 #include <sys/select.h>
 #include <poll.h>
 #include <sqlite3.h>

1.2 定义宏 

#define BUFSIZE 1024//定义缓冲区大小
#define login_msg_len 20//定义登录消息长度

1.3 定义链表节点  数据传递消息类型

/*定义链表节点*/
typedef struct Node{
    char name[login_msg_len];
    struct sockaddr_in addr;
    struct Node *next;
}Node;

/*定义消息类型*/
typedef struct Msgtype{
    char type;
    char username[login_msg_len];
    char content[BUFSIZE];
}Msgtype;

1.4 声明函数

Node *create_node(in_port_t SER_PORT,const char * SER_IP_STR);/*创建单向链表*/
Node *add_node(char *name,struct sockaddr_in addr);/*向链表中添加节点*/
int print_msg(Msgtype *msg);/*打印消息类型*/
void broadcast(int sfd,Node *head,Msgtype *msg);/*广播消息*/
int is_exist(Node *head,Msgtype *msg);/*查找用户名是否存在*/
int is_empty(Node *head);/*链表判空*/
void insert_node(Node *head,char *name,struct sockaddr_in addr);/*头插法插入节点*/
void delete_node(Node *head,char *name);/*按用户名删除节点*/
void broadcast_system(int sfd,Node *head,char *input_buf);/*向所有客户端发送系统消息*/

1.5  创建单向链表

Node *create_node(in_port_t SER_PORT,const char * SER_IP_STR){
    Node *node=(Node*)malloc(sizeof(Node));
    if(node==NULL){
        perror("malloc");
        exit(1);
    }
    char *msg="system";
    for(int i=0;i<sizeof(msg);i++){
        node->name[i]=msg[i];
    }
    node->addr.sin_family=AF_INET;
    node->addr.sin_port=htons(SER_PORT);
    node->addr.sin_addr.s_addr=inet_addr(SER_IP_STR);
    node->next=NULL;
    return node;
}

1.6  向链表中加入节点

Node *add_node(char *name,struct sockaddr_in addr){
    Node *new_node=(Node*)malloc(sizeof(Node));
    if(new_node==NULL){
        perror("malloc");
        exit(1);
    }
    strcpy(new_node->name,name);
    new_node->addr=addr;
    new_node->next=NULL;
    return new_node;
}

1.7 对链表判空

int is_empty(Node *head){
    if(head==NULL){
        return 1;
    }
    return head->next==NULL?1:0;
}

1.8 插入节点

oid insert_node(Node *head,char *name,struct sockaddr_in addr){
    if(head==NULL){
        perror("head is null");
        exit(1);
    }   
    Node *new_node=add_node(name,addr);
    new_node->next=head->next;
    head->next=new_node;
    printf("%s进入聊天室\n",name);
}

1.9 判断数据模式

int print_msg(Msgtype *msg){
    switch(msg->type){
        case 'L':
            return 1;
        case 'C':
            return 2;
        case 'Q':
            return 3;
        default:
            return 0;
    }
}

2.0 查找用户是否存在

int is_exist(Node *head,Msgtype *msg){
    if(head==NULL){
        perror("head is null");
        exit(1);
    }
    if(is_empty(head)){
        return 0;
    }
    Node *p=head->next;
    while(p!=NULL){
        if(strcmp(p->name,msg->username)==0){
            return 1;
        }
        p=p->next;
    }
    return 0;
}

2.1 广播消息 

void broadcast(int sfd,Node *head,Msgtype *msg){
    if(head==NULL){
        perror("head is null");
        exit(1);
    }
    if(is_empty(head)){
        printf("聊天室为空\n");
        return;
    }
    Node *p=head->next;
    while(p!=NULL){
        /*发送消息*/
        if(strcmp(p->name,msg->username)!=0){
            sendto(sfd,msg,sizeof(Msgtype),0,(struct sockaddr*)&p->addr,sizeof(p->addr));
        }
        p=p->next;
       
    }
}

2.2 按用户名删除用户节点

void delete_node(Node *head,char *name){
    if(head==NULL){
        perror("head is null");
        exit(1);
    }
    if(is_empty(head)){
        printf("聊天室为空\n");
        return;
    }
    printf("%s退出聊天室\n",name);
    Node *p=head->next;
    Node *pre=head;
    while(p!=NULL){
        if(strcmp(p->name,name)==0){
            pre->next=p->next;
            free(p);
            return;
        }
        pre=p;
        p=p->next;
    }

2.3 广播系统信息

void broadcast_system(int sfd,Node *head,char *content){
    if(head==NULL){
        perror("head is null");
        exit(1);
    }
    if(is_empty(head)){
        printf("聊天室为空\n");
        return;
    }
    Msgtype msg;
    msg.type='C';
    strcpy(msg.username,"system");
    strcpy(msg.content,content);
    Node *p=head->next;
    while(p!=NULL){
        /*发送消息*/
        sendto(sfd,&msg,sizeof(Msgtype),0,(struct sockaddr*)&p->addr,sizeof(p->addr));
        p=p->next;
    }
    printf("system发送消息：%s\n",content);
}

2.4 创建套接字，绑定IP，端口信息


    /*获取IP地址和端口*/
    if(3>argc){
        printf("输入格式不对，请按照以下格式输入：./server ip port\n");
        exit(1);
    }
    const char *SER_IP_STR=argv[1];
    in_port_t SER_PORT=atoi(argv[2]);

    /*创建UDP套接字*/
    int sfd=-1;
    if((sfd=socket(AF_INET,SOCK_DGRAM,0))<0){
        perror("socket");
        exit(1);
    } 

    /*设置UDP服务器的地址*/
    struct sockaddr_in addr;
    memset(&addr,0,sizeof(addr));
    addr.sin_family=AF_INET;
    addr.sin_port=htons(SER_PORT);
    if(inet_aton(SER_IP_STR,&addr.sin_addr)==0){
        perror("inet_aton");
        exit(1);
    }

    /*绑定端口*/
    if(bind(sfd,(struct sockaddr*)&addr,sizeof(addr))<0){
        perror("bind");
        exit(1);
    }
    printf("bind success\n");

2.5 创建链表

/*创建链表*/
    Node *head=create_node(SER_PORT,SER_IP_STR);

2.6 使用poll实现并发执行

/*监控服务器响应*/
    struct pollfd pfd[2];
    pfd[0].fd = sfd;        // 监控套接字
    pfd[0].events = POLLIN; // 监控读事件
    pfd[1].fd = 0;          // 监控标准输入
    pfd[1].events = POLLIN; // 监控读事件

/*等待IO事件*/
        int ret=poll(pfd,2,-1);
        if(ret<0){
            perror("poll");
            exit(1);
        }else if (ret==0){
            printf("poll timeout\n");
            continue;
        }
if(pfd[0].revents==POLLIN){
}
if(pfd[1].revents==POLLIN){
}

2.7  创建接收客户端网络信息，数据信息的结构体

/*创建接收客户端网络信息的结构体*/
    struct sockaddr_in client_addr;
    socklen_t client_addr_len=sizeof(client_addr);

    /*创建客户端数据信息的结构体*/
    Msgtype client_msg;
    memset(&client_msg,0,sizeof(client_msg));

 2.8 接收数据处理

int recv_len=recvfrom(sfd,&client_msg,sizeof(client_msg),0,(struct sockaddr*)&client_addr,&client_addr_len);
            if(recv_len<0){
                perror("recvfrom");
                exit(1);
            }
            /*判断消息类型*/
            /*登录类型*/
            if(print_msg(&client_msg)==1){
                /*判断用户是否存在*/
                if(is_exist(head,&client_msg)){
                    /*向客户端发送用户名已存在消息*/
                    client_msg.type='E';
                    sendto(sfd,&client_msg,sizeof(client_msg),0,(struct sockaddr*)&client_addr,sizeof(client_addr));
                    continue;
                }else{
                    /*向链表中插入节点*/
                    insert_node(head,client_msg.username,client_addr);
                    /*向客户端发送登录成功消息*/
                    client_msg.type='L';
                    strcpy(client_msg.content,"进入聊天室");
                    /*向所有客户端发送登录消息*/
                    broadcast(sfd,head,&client_msg);
                }
            }else if (print_msg(&client_msg)==2){
                /*客户端数据传输类型*/
                /*向所有客户端发送消息*/
                printf("%s发送消息\n",client_msg.username);
                broadcast(sfd,head,&client_msg);
            }else if (print_msg(&client_msg)==3){
                /*客户端退出登录类型*/
                /*删除节点*/
                delete_node(head,client_msg.username);
                /*向客户端发送退出登录消息*/
                client_msg.type='Q';
                strcpy(client_msg.content,"退出聊天室");
                broadcast(sfd,head,&client_msg);
            }else{
                /*客户端消息类型错误*/
                char *msg="消息类型错误";
                for(int i=0;i<sizeof(msg);i++){
                    client_msg.content[i]=msg[i];
                }
                sendto(sfd,&client_msg,sizeof(client_msg),0,(struct sockaddr*)&client_addr,sizeof(client_msg));
                continue; 
            }

 2.9 发送数据处理

/*服务器终端输入*/
            char input_buf[BUFSIZE];
            fgets(input_buf,BUFSIZE,stdin);
            input_buf[strlen(input_buf)-1]='\0';
            /*判断客户端是否登录*/
            if(is_empty(head)){
                printf("聊天室为空，请等待其他用户登录\n");
                continue;
            }
            /*向所有客户端发送消息*/
            broadcast_system(sfd,head,input_buf);

 2.创建UDP客户端

1.1 定义宏

#define BUFSIZE 1024//定义缓冲区大小
#define login_msg_len 20//定义登录信息长度

1.2 定义数据信息结构体

typedef struct Msgtype{
    char type;
    char username[login_msg_len];
    char content[BUFSIZE];
}Msgtype;

1.3 创建套接字，绑定服务器

 /*获取IP地址和端口*/
    if(3>argc){
        printf("输入格式不对，请按照以下格式输入：./server ip port\n");
    }
    const char *SER_IP_STR=argv[1];
    int SER_PORT=atoi(argv[2]);

    /*创建UDP套接字*/
    int sfd=-1;
    if((sfd=socket(AF_INET,SOCK_DGRAM,0))<0){
        perror("socket");
        exit(1);
    }

    /*设置服务器地址*/
    struct sockaddr_in server_addr;
    memset(&server_addr,0,sizeof(server_addr));
    server_addr.sin_family=AF_INET;
    server_addr.sin_port=htons(SER_PORT);
    if(inet_aton(SER_IP_STR,&server_addr.sin_addr)==0){
        perror("inet_aton");
        exit(1);
    }
    socklen_t addr_len=sizeof(server_addr);

 1.4 创建客户端数据手收发结构体，用户登录信息结构体

/*创建客户端数据收发结构体*/
    Msgtype recv_msg;
    memset(&recv_msg,0,sizeof(recv_msg));
    Msgtype send_msg;
    memset(&send_msg,0,sizeof(send_msg));

    /*创建用户登录信息*/
    Msgtype login_msg;

1.5  用户登录

 /*登录服务器*/
        
        memset(&login_msg,0,sizeof(login_msg));
        login_msg.type='L';
        printf("请输入用户名：");
        fgets(login_msg.username, login_msg_len, stdin);
        login_msg.username[strcspn(login_msg.username, "\n")] = '\0'; // 去掉换行符

        /*发送登录信息*/
        if (sendto(sfd, &login_msg, sizeof(login_msg), 0, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
        {
            perror("sendto");
            exit(1);
        }

1.6 使用poll实现并发 

/*监控服务器响应*/
        struct pollfd pfd[2];
        pfd[0].fd = sfd;        // 监控套接字
        pfd[0].events = POLLIN; // 监控读事件
        pfd[1].fd = 0;          // 监控标准输入
        pfd[1].events = POLLIN; // 监控读事件;
/*等待IO事件*/
            int ret=poll(pfd,2,-1);
            if(ret<0){
                perror("poll");
                exit(1);
            }else if (ret==0)   
            {
                printf("poll timeout\n");
                continue;
            }
if(pfd[0].revents==POLLIN){
}
if(pfd[1].revents==POLLIN){
}

 1.7 根据条件进行并发执行终端输入，数据接收

if(pfd[0].revents==POLLIN){
                /*接收服务器消息*/
                int len=recvfrom(sfd, &recv_msg, sizeof(recv_msg), 0, (struct sockaddr *)&server_addr, &addr_len);
                if(len<0){
                    perror("recvfrom");
                    exit(1);
                }
                if(recv_msg.type=='L'){
                    printf("-----------%s加入聊天室----------\n",recv_msg.username);
                }else if(recv_msg.type=='C'){
                    printf("%s:%s\n",recv_msg.username,recv_msg.content);
                }else if (recv_msg.type=='Q') {
                    printf("------------%s%s---------------\n",recv_msg.username,recv_msg.content);
                }else{
                    printf("%s用户名已存在或服务器故障，请重新登录\n",login_msg.username);
                    break;
                }
            }
            if(pfd[1].revents==POLLIN){
                /*接收用户输入*/
                char input[BUFSIZE];
                fgets(input,BUFSIZE, stdin);
                input[strcspn(input, "\n")] = '\0'; // 去掉换行符
                if(strcmp(input,"quit")==0){
                    send_msg.type='Q';
                    sendto(sfd, &send_msg, sizeof(send_msg), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
                    break;//退出循环
                }else{
                    /*发送消息*/
                    memset(&send_msg,0,sizeof(send_msg));
                    send_msg.type='C';
                    strncpy(send_msg.username,login_msg.username,login_msg_len);
                    strncpy(send_msg.content,input,BUFSIZE);
                    sendto(sfd, &send_msg, sizeof(send_msg), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
                }
            }

 3.服务器最终程序

#include <myhead.h>
#define BUFSIZE 1024//定义缓冲区大小
#define login_msg_len 20//定义登录消息长度

/*定义链表节点*/
typedef struct Node{
    char name[login_msg_len];
    struct sockaddr_in addr;
    struct Node *next;
}Node;

/*定义消息类型*/
typedef struct Msgtype{
    char type;
    char username[login_msg_len];
    char content[BUFSIZE];
}Msgtype;

/*声明函数*/
Node *create_node(in_port_t SER_PORT,const char * SER_IP_STR);/*创建单向链表*/
Node *add_node(char *name,struct sockaddr_in addr);/*向链表中添加节点*/
int print_msg(Msgtype *msg);/*打印消息类型*/
void broadcast(int sfd,Node *head,Msgtype *msg);/*广播消息*/
int is_exist(Node *head,Msgtype *msg);/*查找用户名是否存在*/
int is_empty(Node *head);/*链表判空*/
void insert_node(Node *head,char *name,struct sockaddr_in addr);/*头插法插入节点*/
void delete_node(Node *head,char *name);/*按用户名删除节点*/
void broadcast_system(int sfd,Node *head,char *input_buf);/*向所有客户端发送系统消息*/

int main(int argc, char const *argv[])
{   
    /*获取IP地址和端口*/
    if(3>argc){
        printf("输入格式不对，请按照以下格式输入：./server ip port\n");
        exit(1);
    }
    const char *SER_IP_STR=argv[1];
    in_port_t SER_PORT=atoi(argv[2]);

    /*创建UDP套接字*/
    int sfd=-1;
    if((sfd=socket(AF_INET,SOCK_DGRAM,0))<0){
        perror("socket");
        exit(1);
    } 

    /*设置UDP服务器的地址*/
    struct sockaddr_in addr;
    memset(&addr,0,sizeof(addr));
    addr.sin_family=AF_INET;
    addr.sin_port=htons(SER_PORT);
    if(inet_aton(SER_IP_STR,&addr.sin_addr)==0){
        perror("inet_aton");
        exit(1);
    }

    /*绑定端口*/
    if(bind(sfd,(struct sockaddr*)&addr,sizeof(addr))<0){
        perror("bind");
        exit(1);
    }
    printf("bind success\n");
    /*创建链表*/
    Node *head=create_node(SER_PORT,SER_IP_STR);

    /*监控服务器响应*/
    struct pollfd pfd[2];
    pfd[0].fd = sfd;        // 监控套接字
    pfd[0].events = POLLIN; // 监控读事件
    pfd[1].fd = 0;          // 监控标准输入
    pfd[1].events = POLLIN; // 监控读事件

    /*创建接收客户端网络信息的结构体*/
    struct sockaddr_in client_addr;
    socklen_t client_addr_len=sizeof(client_addr);

    /*创建客户端数据信息的结构体*/
    Msgtype client_msg;
    memset(&client_msg,0,sizeof(client_msg));
    
    /*循环接收客户端信息*/
    while(1){
        /*等待IO事件*/
        int ret=poll(pfd,2,-1);
        if(ret<0){
            perror("poll");
            exit(1);
        }else if (ret==0){
            printf("poll timeout\n");
            continue;
        }
        if(pfd[0].revents==POLLIN){
            /*接收客户端登录信息*/
            int recv_len=recvfrom(sfd,&client_msg,sizeof(client_msg),0,(struct sockaddr*)&client_addr,&client_addr_len);
            if(recv_len<0){
                perror("recvfrom");
                exit(1);
            }
            /*判断消息类型*/
            /*登录类型*/
            if(print_msg(&client_msg)==1){
                /*判断用户是否存在*/
                if(is_exist(head,&client_msg)){
                    /*向客户端发送用户名已存在消息*/
                    client_msg.type='E';
                    sendto(sfd,&client_msg,sizeof(client_msg),0,(struct sockaddr*)&client_addr,sizeof(client_addr));
                    continue;
                }else{
                    /*向链表中插入节点*/
                    insert_node(head,client_msg.username,client_addr);
                    /*向客户端发送登录成功消息*/
                    client_msg.type='L';
                    strcpy(client_msg.content,"进入聊天室");
                    /*向所有客户端发送登录消息*/
                    broadcast(sfd,head,&client_msg);
                }
            }else if (print_msg(&client_msg)==2){
                /*客户端数据传输类型*/
                /*向所有客户端发送消息*/
                printf("%s发送消息\n",client_msg.username);
                broadcast(sfd,head,&client_msg);
            }else if (print_msg(&client_msg)==3){
                /*客户端退出登录类型*/
                /*删除节点*/
                delete_node(head,client_msg.username);
                /*向客户端发送退出登录消息*/
                client_msg.type='Q';
                strcpy(client_msg.content,"退出聊天室");
                broadcast(sfd,head,&client_msg);
            }else{
                /*客户端消息类型错误*/
                char *msg="消息类型错误";
                for(int i=0;i<sizeof(msg);i++){
                    client_msg.content[i]=msg[i];
                }
                sendto(sfd,&client_msg,sizeof(client_msg),0,(struct sockaddr*)&client_addr,sizeof(client_msg));
                continue; 
            }
        }
        if(pfd[1].revents==POLLIN){
            /*服务器终端输入*/
            char input_buf[BUFSIZE];
            fgets(input_buf,BUFSIZE,stdin);
            input_buf[strlen(input_buf)-1]='\0';
            /*判断客户端是否登录*/
            if(is_empty(head)){
                printf("聊天室为空，请等待其他用户登录\n");
                continue;
            }
            /*向所有客户端发送消息*/
            broadcast_system(sfd,head,input_buf);
        }
    }
    /*关闭套接字*/
    close(sfd);
    return 0;
}
/*创建单向链表*/
Node *create_node(in_port_t SER_PORT,const char * SER_IP_STR){
    Node *node=(Node*)malloc(sizeof(Node));
    if(node==NULL){
        perror("malloc");
        exit(1);
    }
    char *msg="system";
    for(int i=0;i<sizeof(msg);i++){
        node->name[i]=msg[i];
    }
    node->addr.sin_family=AF_INET;
    node->addr.sin_port=htons(SER_PORT);
    node->addr.sin_addr.s_addr=inet_addr(SER_IP_STR);
    node->next=NULL;
    return node;
}
/*向链表中添加节点*/
Node *add_node(char *name,struct sockaddr_in addr){
    Node *new_node=(Node*)malloc(sizeof(Node));
    if(new_node==NULL){
        perror("malloc");
        exit(1);
    }
    strcpy(new_node->name,name);
    new_node->addr=addr;
    new_node->next=NULL;
    return new_node;
}
/*链表判空*/
int is_empty(Node *head){
    if(head==NULL){
        return 1;
    }
    return head->next==NULL?1:0;
}
/*头插法插入节点*/
void insert_node(Node *head,char *name,struct sockaddr_in addr){
    if(head==NULL){
        perror("head is null");
        exit(1);
    }   
    Node *new_node=add_node(name,addr);
    new_node->next=head->next;
    head->next=new_node;
    printf("%s进入聊天室\n",name);
}
/*判断数据模式*/
int print_msg(Msgtype *msg){
    switch(msg->type){
        case 'L':
            return 1;
        case 'C':
            return 2;
        case 'Q':
            return 3;
        default:
            return 0;
    }
}
/*查找用户名是否存在*/
int is_exist(Node *head,Msgtype *msg){
    if(head==NULL){
        perror("head is null");
        exit(1);
    }
    if(is_empty(head)){
        return 0;
    }
    Node *p=head->next;
    while(p!=NULL){
        if(strcmp(p->name,msg->username)==0){
            return 1;
        }
        p=p->next;
    }
    return 0;
}
/*广播消息*/
void broadcast(int sfd,Node *head,Msgtype *msg){
    if(head==NULL){
        perror("head is null");
        exit(1);
    }
    if(is_empty(head)){
        printf("聊天室为空\n");
        return;
    }
    Node *p=head->next;
    while(p!=NULL){
        /*发送消息*/
        if(strcmp(p->name,msg->username)!=0){
            sendto(sfd,msg,sizeof(Msgtype),0,(struct sockaddr*)&p->addr,sizeof(p->addr));
        }
        p=p->next;
       
    }
}
/*按用户名删除节点*/
void delete_node(Node *head,char *name){
    if(head==NULL){
        perror("head is null");
        exit(1);
    }
    if(is_empty(head)){
        printf("聊天室为空\n");
        return;
    }
    printf("%s退出聊天室\n",name);
    Node *p=head->next;
    Node *pre=head;
    while(p!=NULL){
        if(strcmp(p->name,name)==0){
            pre->next=p->next;
            free(p);
            return;
        }
        pre=p;
        p=p->next;
    }
   
}
/*广播system消息*/
void broadcast_system(int sfd,Node *head,char *content){
    if(head==NULL){
        perror("head is null");
        exit(1);
    }
    if(is_empty(head)){
        printf("聊天室为空\n");
        return;
    }
    Msgtype msg;
    msg.type='C';
    strcpy(msg.username,"system");
    strcpy(msg.content,content);
    Node *p=head->next;
    while(p!=NULL){
        /*发送消息*/
        sendto(sfd,&msg,sizeof(Msgtype),0,(struct sockaddr*)&p->addr,sizeof(p->addr));
        p=p->next;
    }
    printf("system发送消息：%s\n",content);
}

 4.客户端最终程序

#include <myhead.h>
#define BUFSIZE 1024//定义缓冲区大小
#define login_msg_len 20//定义登录信息长度

/*定义消息类型*/
typedef struct Msgtype{
    char type;
    char username[login_msg_len];
    char content[BUFSIZE];
}Msgtype;

int main(int argc, char const *argv[])
{   
    /*获取IP地址和端口*/
    if(3>argc){
        printf("输入格式不对，请按照以下格式输入：./server ip port\n");
    }
    const char *SER_IP_STR=argv[1];
    int SER_PORT=atoi(argv[2]);

    /*创建UDP套接字*/
    int sfd=-1;
    if((sfd=socket(AF_INET,SOCK_DGRAM,0))<0){
        perror("socket");
        exit(1);
    }

    /*设置服务器地址*/
    struct sockaddr_in server_addr;
    memset(&server_addr,0,sizeof(server_addr));
    server_addr.sin_family=AF_INET;
    server_addr.sin_port=htons(SER_PORT);
    if(inet_aton(SER_IP_STR,&server_addr.sin_addr)==0){
        perror("inet_aton");
        exit(1);
    }
    socklen_t addr_len=sizeof(server_addr);

    /*创建客户端数据收发结构体*/
    Msgtype recv_msg;
    memset(&recv_msg,0,sizeof(recv_msg));
    Msgtype send_msg;
    memset(&send_msg,0,sizeof(send_msg));

    /*创建用户登录信息*/
    Msgtype login_msg;
    
    while (1)
    {
        /*登录服务器*/
        
        memset(&login_msg,0,sizeof(login_msg));
        login_msg.type='L';
        printf("请输入用户名：");
        fgets(login_msg.username, login_msg_len, stdin);
        login_msg.username[strcspn(login_msg.username, "\n")] = '\0'; // 去掉换行符

        /*发送登录信息*/
        if (sendto(sfd, &login_msg, sizeof(login_msg), 0, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
        {
            perror("sendto");
            exit(1);
        }

        /*监控服务器响应*/
        struct pollfd pfd[2];
        pfd[0].fd = sfd;        // 监控套接字
        pfd[0].events = POLLIN; // 监控读事件
        pfd[1].fd = 0;          // 监控标准输入
        pfd[1].events = POLLIN; // 监控读事件;

        while(1){
            /*等待IO事件*/
            int ret=poll(pfd,2,-1);
            if(ret<0){
                perror("poll");
                exit(1);
            }else if (ret==0)   
            {
                printf("poll timeout\n");
                continue;
            }

            if(pfd[0].revents==POLLIN){
                /*接收服务器消息*/
                int len=recvfrom(sfd, &recv_msg, sizeof(recv_msg), 0, (struct sockaddr *)&server_addr, &addr_len);
                if(len<0){
                    perror("recvfrom");
                    exit(1);
                }
                if(recv_msg.type=='L'){
                    printf("-----------%s加入聊天室----------\n",recv_msg.username);
                }else if(recv_msg.type=='C'){
                    printf("%s:%s\n",recv_msg.username,recv_msg.content);
                }else if (recv_msg.type=='Q') {
                    printf("------------%s%s---------------\n",recv_msg.username,recv_msg.content);
                }else{
                    printf("%s用户名已存在或服务器故障，请重新登录\n",login_msg.username);
                    break;
                }
            }
            if(pfd[1].revents==POLLIN){
                /*接收用户输入*/
                char input[BUFSIZE];
                fgets(input,BUFSIZE, stdin);
                input[strcspn(input, "\n")] = '\0'; // 去掉换行符
                if(strcmp(input,"quit")==0){
                    send_msg.type='Q';
                    sendto(sfd, &send_msg, sizeof(send_msg), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
                    break;//退出循环
                }else{
                    /*发送消息*/
                    memset(&send_msg,0,sizeof(send_msg));
                    send_msg.type='C';
                    strncpy(send_msg.username,login_msg.username,login_msg_len);
                    strncpy(send_msg.content,input,BUFSIZE);
                    sendto(sfd, &send_msg, sizeof(send_msg), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
                }
            }
        }
    }
    close(sfd);
    return 0;
}

slander_1120
关注
  • 12
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
UDP聊天室.zip
07-16
使用 Qt 基于 UDP 协议构建网络聊天室实例，包含 UdpServerDemo 和 UdpClientDemo 两部分程序，由于 UDP 方式不会建立连接，所以在服务端采用QList容器管理客户端状态。
TCP/UDP网络聊天室.zip
05-28
Java Swing开发的网络聊天室，模仿企鹅设计，实现一对一，一对多，多对多的聊天功能 （备注：使用idea开发出来，压缩的时候是刚买mac的时候，压缩程序有乱码，解决方案在文件夹的pdf中）
实现基于udp的网络聊天室
weixin_65799837的博客
03-25 91
【代码】实现基于udp的网络聊天室。
【基于UDP的网络聊天室】
sept_94的博客
09-24 1941
基于UDP的网络聊天室
udp.rar_UDP_UDP网络聊天室_UDP聊天室_java UDP聊天
09-22
在本项目“UDP网络聊天室”中，开发者使用UDP来实现实时的、低延迟的通信，特别适合对速度要求高的应用，如在线游戏、视频会议或实时聊天。 UDP聊天室的工作原理是基于广播或者多播的方式，每个参与者都会发送消息...
udp网络聊天室.rar
01-09
在该"udp网络聊天室"项目中，服务器采用了多进程的方式来处理客户端的消息请求。多进程模型意味着服务器可以同时处理多个客户端的连接，每个客户端连接都会被分配到一个独立的进程来处理，这样可以提高系统的并发...
udp实现聊天室项目
12-17
在这个“udp实现聊天室项目”中，我们主要探讨的是如何利用UDP（User Datagram Protocol）协议构建...此外，对于网络编程，特别是使用UDP时，还需要考虑如何处理可能的数据丢失、乱序等问题，以确保聊天室的正常运行。
UDP聊天室客户端
07-31
【UDP聊天室客户端】是一个基于C++编程语言实现的网络通信工具，主要利用了用户数据报协议（User Datagram Protocol，UDP）进行数据传输。UDP是一种无连接、不可靠的传输协议，它不保证数据包的顺序、不进行重传，...
2023-2024华为ICT大赛中国区 实践赛网络赛道 全国总决赛 理论部分真题
gaogao0305的博客
07-02 556
本文为2023-2024华为ICT大赛 中国区 全国总决赛 实践赛 网络赛道 理论部分考试真题，涵盖数通模块10题、安全模块7题、WLAN模块3题
Iperf基本用法
peterhunter0320的博客
07-04 300
Iperf支持TCP和UDP协议，可以用于点对点或客户端-服务器等模式的网络测试。在Windows系统中，您可以下载Iperf的预编译版本，并将其解压到任意文件夹中。以上是Iperf的一些基本用法，您可以根据实际需要调整各种参数来满足不同的测试需求。更多详细的使用方法和参数，您可以通过运行iperf3 -h命令来查看帮助文档。在Linux系统中，您可以使用包管理器安装Iperf。Iperf的使用非常灵活，可以通过命令行参数来调整测试的各种参数。iperf3 -c <服务器IP地址> -u -b 10M。
计算机网络
m0_65621281的博客
07-03 1065
为了保证传输的内容不被篡改，我们需要对内容计算出一个「指纹」，然后同内容一起传输给对方。对方收到后，先是对内容也计算出一个「指纹」，然后跟发送方发送的「指纹」做一个比较，如果「指纹」相同，说明内容没有被篡改，否则就可以判断出内容被篡改了。那么，在计算机里会用。
基于STM32设计的管道有害气体检测装置(ESP8266局域网)176
07-06 66
基于STM32设计的管道有害气体检测装置采用了一系列先进的传感器技术，针对多种有害气体进行检测，通过实时监测烟雾浓度、甲烷、一氧化碳、甲醛等有害气体的浓度以及温湿度等参数，并通过OLED显示和ESP8266上传数据至手机端，可以使相关工作人员及时了解管道环境的情况，采取相应的控制和调节措施，从而保障工作人员和公众的健康与安全。 为了确保传感器正常工作和数据的准确性，装置还引入了温湿度检测机制，因为气体传感器的性能受温湿度影响较大，适宜的温度和湿度条件能够确保传感器的稳定工作和数据准确性。
华为HCIP Datacom H12-821 卷28
QIN_yuexiang的博客
07-05 89
因此，路由器在收到一份来自源S发往组G的组播数据报文之后，首先会在组播转发表中查找有无相应的（S，G）组播转发表项：如果不存在（S，G）转发表项，则对该报文执行RPF检查，将检查到的RPF接口作为入接口，创建组播路由表项，下发到组播转发表中。AS_Set属性是一种无序的AS_Path属性，标明聚合路由所经过的AS号。在广播环境中，DIS 发送 hello 报文的周期更加的短，是普通ISIS路由器的1/3，普通ISIS路由器发送hello的时间为10s，所以DIS发送hello的周期是3.3s。
Linux：系统安全及应用
pangdongqiqi的博客
07-01 1202
通过su命令可以非常方便地切换为另一个用户，但前提条件是必须知道目标用户的登 录密码。例如，若要从zhangsan 用户切换为 root 用户，必须知道 root 用户的密码。对于生产环 境中的 Linux 服务器，每多一个人知道特权密码，其安全风险也就增加一分。有没有一种折中的办法，既可以让普通用户拥有一部分管理权限，又不需要将 root 用户的密码告诉他呢？答案是肯定的，使用 sudo命令就可以提升执行权限。
RedHat运维-LinuxSELinux基础4-端口绑定SELinux上下文
最新发布
a15735748145a的博客
07-06 503
12. 将60001/tcp端口上的SELinux上下文由http_port_t调整为gopher_port_t的方法是______________________；13. 将60002/tcp端口上的SELinux上下文由gopher_port_t调整为ssh_port_t的方法是______________________；14. 将60003/tcp端口上的SELinux上下文由ssh_port_t调整为http_port_t的方法是_______________________；
【计算机网络——1.2网络边缘】
2301_76758064的博客
07-03 788
流量阻塞控制：比如A和B互通，会走某条线路，C和D也会经过这条路，或者这条路的一部分，就很有可能阻塞，当信息量太大时，交换节点就会丢东西，信息就不完整，TCP检测线路阻塞情况，从而限值发送速率。其实就是端系统/主机，上面运行着分布式系统，那么这些运行的网络应用就是网络存在的理由，应用由端系统的基础设施（操作系统，硬件，实体协议，网络核心，包括对方主机的应用层下面的基础设施）支撑。不需要握手，直接发送，直接回应，不可靠（TCP的特性一个不占），但是效率高，应用一些不需要数据太准确方面(视频，语音)
常见网络攻击方式及防御方法
2301_76786857的博客
07-04 903
网络攻击对个人、组织和整个社会都带来了严重的威胁，因此必须采取有效的安全措施来保护网络系统和用户的信息安全。
AVIO自定义读写
qq_54017644的博客
07-05 177
AVIO编程实战---极精简代码
多用户udp网络聊天室
06-03
好的，您想了解多用户UDP网络聊天室方面的知识，我可以为您提供一些基本的信息。 UDP（User Datagram Protocol，用户数据报协议）是一种无连接的传输层协议，它不保证数据传输的可靠性和顺序性，但具有较高的传输速度和较低的网络延迟。多用户UDP网络聊天室是一种基于UDP协议实现的多人聊天系统，可以实现多个用户之间的实时通信。 实现多用户UDP网络聊天室需要考虑以下几个方面： 1. 用户注册和登录：用户需要提供用户名和密码进行注册和登录，服务器需要对用户进行身份验证。 2. 用户列表管理：服务器需要维护当前在线用户列表，并及时更新用户状态。 3. 群组管理：用户可以创建或加入不同的聊天群组，服务器需要维护群组列表，并实现群组成员的管理。 4. 消息发送和接收：用户可以发送消息到指定的聊天群组或其他在线用户，服务器需要将消息进行转发和处理。 5. 异常处理和安全性：服务器需要考虑网络异常、消息丢失等问题，并采取相应的措施保证系统的稳定性和安全性。 以上是实现多用户UDP网络聊天室的基本要点，具体实现过程还需要结合具体技术和编程语言进行设计和开发。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值