linux之基于UDP的网络聊天室

精选原创

三六九头 2024-05-13 00:01:28 ©著作权

文章标签 客户端服务器 UDP 网络聊天室 文章分类 代码人生 指尖人生

©著作权归作者所有：来自51CTO博客作者三六九头的原创作品，请联系作者获取转载授权，否则将追究法律责任

一、基于UDP的网络聊天室

1.服务器端

sock.hpp

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<string.h>
#include<unistd.h>
uint16_t defaultport=3333;
class Socket
{
public:
    Socket()
    {

    }
    void Init()
    {
        //1.创建套接字
        sockfd_=socket(AF_INET,SOCK_DGRAM,0);
        if(sockfd_<0)
        {
            std::cout<<"socket fail\n";
        }
        std::cout<<"socket success\n";
        sockaddr_in server;
        server.sin_family=AF_INET;
        server.sin_addr.s_addr=INADDR_ANY;//inaddr_any
        server.sin_port=htons(port_);
        //2.绑定套接字
        socklen_t addrlen=sizeof(server);
        if(bind(sockfd_,(sockaddr*)&server,addrlen)<0)
        {
            std::cout<<"bind fail\n";
        } 
        std::cout<<"bind success\n";


    }

    public:
    int sockfd_;
    uint16_t port_;

};

chatroom_server.hpp

#pragma once
#include "socket.hpp"
#include <unordered_map>
#include <string>
class ChatRoom
{
public:
    ChatRoom(uint16_t port=defaultport)
    {
        server.port_=port;
        server.Init();
        pthread_t rtid, wtid;

        int sockfd = server.sockfd_;
    }
    void Run()
    {
        while (1)
        {

            sockaddr_in client; // 储存客户端信息
            memset(&client, 0, sizeof(client));
            char buffer[1024];
            socklen_t addr_len = sizeof(client);
            ssize_t n = recvfrom(server.sockfd_, buffer, sizeof(buffer), 0, (sockaddr *)&client, &addr_len);
            if (n < 0)
            {
                std::cout << "read fail\n";
                continue;
            }
 
            buffer[n] = '\0';
            std::string clientip = std::to_string(ntohl(client.sin_addr.s_addr));
            uint16_t clientport = ntohl(client.sin_port);

            CheckClient(clientip, clientport, client);
            Broadcast(clientip, clientport, buffer);
        }
    }
    void CheckClient(std::string clientip, uint16_t clientport, sockaddr_in &client) // 已有成员信息无需添加
    {
        //服务器收到某一个客户端的信息，判断该客户端是否是自己的用户
        //如果不是，则添加
        auto pos = clients.find(clientip);
        if (pos == clients.end())
        {
            clients.insert({clientip, client});
            std::cout << "new client added,client ip is:" << clientip << ",clientport is:" << clientport << std::endl;
        }
    }
    void Broadcast(std::string clientip, uint16_t clientport, std::string info) // 任意成员发的消息都需要广播
    {   //将当前客户端的信息发送给所有客户端
        //std::cout<<"member size is:"<<clients.size()<<std::endl;
        for (auto client : clients)
        {
            std::string massage; // 将读取到的
            massage += "clientip:";
            massage += clientip;
            // 先将ip地址网络转主机，再转字符串
            massage += ",clientport:";
            massage += std::to_string(clientport);
            massage += ",client say:";
            massage += info;
            socklen_t len = sizeof(client.second);
            sendto(server.sockfd_, massage.c_str(), massage.size(), 0, (sockaddr *)(&client.second), len);
        }
    }

public:
    Socket server;
    std::unordered_map<std::string, struct sockaddr_in> clients;
};

server.cc

#include"chatroom_server.hpp"
void Useage()
{
    std::cout<<"./process port\n";
}
int main(int argc,char* args[])
{
    if(argc!=2)
    {
        Useage();
    }
    std::string port=args[1];
    uint16_t netport=std::stoi(port);
    ChatRoom ser(netport);//创建时已经创建和绑定套接字
    ser.Run();//接收信息和广播,死循环
    return 0;
}

2.客户端

myclient.cc

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <strings.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>

using namespace std;

void Usage(std::string proc)
{
    std::cout << "\n\rUsage: " << proc << " serverip serverport\n"
              << std::endl;
}

struct ThreadData
{
    struct sockaddr_in server;
    int sockfd;
    std::string serverip;
};

void *recv_message(void *args)
{
    ThreadData *td = static_cast<ThreadData *>(args);
    char buffer[1024];
    while (true)
    {
        memset(buffer, 0, sizeof(buffer));
        struct sockaddr_in temp;
        socklen_t len = sizeof(temp);

        ssize_t s = recvfrom(td->sockfd, buffer, 1023, 0, (struct sockaddr *)&temp, &len);
        if (s > 0)
        {
            buffer[s] = 0;
            cerr << buffer << endl;
        }
    }
}

void *send_message(void *args)
{
    ThreadData *td = static_cast<ThreadData *>(args);
    string message;
    socklen_t len = sizeof(td->server);

    std::string welcome = td->serverip;
    welcome += " comming...";
    sendto(td->sockfd, message.c_str(), message.size(), 0, (struct sockaddr *)&(td->server), len);

    while (true)
    {
        cout << "Please Enter@ ";
        getline(cin, message);

        // std::cout << message << std::endl;
        // 1. 数据 2. 给谁发
        sendto(td->sockfd, message.c_str(), message.size(), 0, (struct sockaddr *)&(td->server), len);
    }
}

// 多线程
// ./udpclient serverip serverport
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(0);
    }
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);

    struct ThreadData td;
    bzero(&td.server, sizeof(td.server));
    td.server.sin_family = AF_INET;
    td.server.sin_port = htons(serverport); //?
    td.server.sin_addr.s_addr = inet_addr(serverip.c_str());

    td.sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (td.sockfd < 0)
    {
        cout << "socker error" << endl;
        return 1;
    }

    td.serverip = serverip;

    pthread_t recvr, sender;
    pthread_create(&recvr, nullptr, recv_message, &td);
    pthread_create(&sender, nullptr, send_message, &td);

    pthread_join(recvr, nullptr);
    pthread_join(sender, nullptr);

    close(td.sockfd);
    return 0;
}

客户端的读写必须是两个线程，只有这样，当前客户端才能收到从服务器广播而来的其他客户的消息。

3.效果演示

linux之基于UDP的网络聊天室_客户端