【网络编程】利用套接字实现一个简单的网络通信(UDP实现聊天室 附上源码)

【网络编程】利用套接字实现一个简单的网络通信(UDP实现聊天室 附上源码)_第1张图片

网络编程套接字

  • 预备知识
    • 理解源IP地址和目的IP地址
    • 认识端口号
    • 理解 "端口号" 和 "进程ID"
    • 简单认识TCP协议
    • 简单认识UDP协议
    • 什么是网络字节序
  • 相关函数端口介绍
    • socket相关API介绍
    • sockaddr结构
    • sockaddr_in结构
  • 简单的UDP网络程序
    • log.hpp 日志文件
    • udpClient.cc 客户端
    • udpServer.cc 服务器
    • makefile文件
    • 运行:

预备知识

理解源IP地址和目的IP地址

源IP地址(Source IP Address):

源IP地址是数据包发送方(或数据流出发点)的唯一标识符。它用于在互联网或本地网络中定位发送数据包的设备或主机。源IP地址是数据包的出发点,即数据从这个地址开始传送,向目的IP地址指示的设备发送。
在TCP/IP协议中,源IP地址通常由发送方的操作系统或网络栈分配,并在数据包的IP首部中进行标记。

目的IP地址(Destination IP Address):

目的IP地址是数据包的接收方(或数据流的目标点)的唯一标识符。它用于在互联网或本地网络中定位接收数据包的设备或主机。目的IP地址是数据包的终点,即数据传输的目标地址,数据包应该传输到这个地址。
在TCP/IP协议中,目的IP地址通常由应用程序或网络栈设置,并在数据包的IP首部中进行标记。
这两个地址在数据包传输过程中起着非常重要的作用,确保数据从源设备正确地传递到目标设备,实现网络通信。IP地址是一个32位的二进制数,通常用点分十进制表示(例如,192.168.0.1),其中前24位表示网络地址,后8位表示主机地址。

认识端口号

端口号(port)是传输层协议的内容.
端口号是一个2字节16位的整数;
端口号用来标识一个进程, 告诉操作系统, 当前的这个数据要交给哪一个进程来处理;
IP地址 + 端口号能够标识网络上的某一台主机的某一个进程;
一个端口号只能被一个进程占用.

理解 “端口号” 和 “进程ID”

  • 端口号(Port Number)和进程ID(Process ID)是在计算机网络和操作系统中用于不同目的的标识符。

端口号:

端口号是在计算机网络中用于标识特定进程或服务的数字。 它是一个16位的无符号整数,取值范围是0到65535。
在TCP/IP网络中,每个传输控制协议(TCP)和用户数据报协议(UDP)的通信端点都与一个端口号相关联。 这样,计算机上的不同进程或服务可以通过不同的端口号进行通信,从而实现多个应用程序的并发运行。
例如,HTTP服务通常使用端口号80,HTTPS使用端口号443,SMTP使用端口号25等。

进程ID:

进程ID是操作系统中用于标识运行中进程(或线程)的唯一标识符。 它是一个非负整数,通常由操作系统在进程创建时分配。
在多任务操作系统中,每个运行中的进程都有一个唯一的进程ID,操作系统通过进程ID来跟踪和管理不同的进程。
进程ID的范围通常由操作系统定义,可以是一个较小的数值范围,也可以是一个较大的范围。

区别:

端口号是在计算机网络中用于标识不同进程或服务的通信端点,用于实现多个应用程序的并发运行。 进程ID是操作系统中用于标识运行中进程的唯一标识符,用于跟踪和管理不同的进程。
端口号是在网络通信中使用的,而进程ID是在操作系统层级使用的。
端口号是一个16位的数字,进程ID是一个非负整数。

简单认识TCP协议

传输层协议
有连接
可靠传输
面向字节流

简单认识UDP协议

传输层协议
无连接
不可靠传输
面向数据报

什么是网络字节序

网络字节序是一种在计算机网络中使用的固定字节顺序,用于在不同计算机体系结构和操作系统之间传递数据。 在计算机内部,不同的体系结构(例如x86、ARM、SPARC等)和操作系统(例如Windows、Linux、iOS等)可能使用不同的字节顺序,这可能导致在网络通信中出现问题。

为了解决这个问题,网络通信中使用了统一的字节顺序,即网络字节序。 网络字节序采用大端字节序(Big-Endian)表示法,其中较高的字节位于较低的内存地址上,较低的字节位于较高的内存地址上。

举例说明:

假设一个16位整数0x1234(十进制为4660)在内存中存储为两个字节:0x12和0x34。

在大端字节序中,较高的字节(0x12)存储在较低的内存地址,较低的字节(0x34)存储在较高的内存地址。 即内存地址由高到低,数据依次为0x12 0x34。
在小端字节序中,较低的字节(0x34)存储在较低的内存地址,较高的字节(0x12)存储在较高的内存地址。 即内存地址由高到低,数据依次为0x34 0x12。

在网络通信中,发送方将数据转换为网络字节序后发送,接收方收到数据后将其转换为本地字节序进行处理,以保证在不同计算机体系结构和操作系统之间正确地传递数据。 常用的网络编程库(例如Socket编程)通常会自动处理字节序的转换。

相关函数端口介绍

socket相关API介绍

  • man手册
    【网络编程】利用套接字实现一个简单的网络通信(UDP实现聊天室 附上源码)_第2张图片

Socket(套接字)是一种用于网络通信的编程接口,它允许计算机之间通过网络传输数据。 在Socket编程中,我们可以使用一组API函数来创建、绑定、连接、发送和接收数据等操作。

  • 以下是常用的Socket API函数及其参数:
  1. socket()函数:
  • 描述:创建一个新的套接字。
  • 参数:int socket(int domain, int type, int protocol)
  • domain:套接字的地址族,常用的有AF_INET(IPv4)和AF_INET6(IPv6)。
  • type:套接字的类型,常用的有SOCK_STREAM(流式套接字,用于TCP)和SOCK_DGRAM(数据报套接字,用于UDP)。
  • protocol:使用的协议,通常为0(自动选择与type相关的默认协议)。
  1. bind()函数:
  • 描述:将套接字绑定到一个特定的地址和端口。
  • 参数:int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
  • sockfd:套接字描述符。
  • addr:指向要绑定的地址结构的指针,通常是struct sockaddr_in(IPv4)或struct sockaddr_in6(IPv6)。
  • addrlen:地址结构的长度。
  1. connect()函数:
  • 描述:建立与远程服务器的连接。
  • 参数:int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
  • sockfd:套接字描述符。
  • addr:指向目标服务器地址的指针,通常是struct sockaddr_in(IPv4)或struct sockaddr_in6(IPv6)。
  • addrlen:地址结构的长度。
  1. listen()函数:
  • 描述:将套接字设置为监听模式,准备接受连接请求。
  • 参数:int listen(int sockfd, int backlog)
  • sockfd:套接字描述符。
  • backlog:请求队列的最大长度,即等待接受连接的连接数。
  1. accept()函数:
  • 描述:接受连接请求,创建一个新的套接字用于与客户端通信。
  • 参数:int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
  • sockfd:监听套接字描述符。
  • addr:指向客户端地址的指针,用于存储客户端的信息。
  • addrlen:地址结构的长度。
  1. send()函数:
  • 描述:发送数据。
  • 参数:ssize_t send(int sockfd, const void *buf, size_t len, int flags)
  • sockfd:套接字描述符。
  • buf:要发送的数据缓冲区。
  • len:要发送的数据长度。
  • flags:发送标志,通常为0。
  1. recv()函数:
  • 描述:接收数据。
  • 参数:ssize_t recv(int sockfd, void *buf, size_t len, int flags)
  • sockfd:套接字描述符。
  • buf:接收数据的缓冲区。
  • len:要接收的数据长度。
  • flags:接收标志,通常为0。
  1. close()函数:
  • 描述:关闭套接字。
  • 参数:int close(int sockfd)
  • sockfd:套接字描述符。

使用Socket API时,通常的流程是创建一个套接字、绑定到一个地址和端口(可选)、监听连接请求(可选)、接受连接请求、发送和接收数据,最后关闭套接字。 服务器端和客户端使用不同的套接字操作,服务器端用于监听连接请求和处理客户端请求,而客户端用于建立连接和发送请求给服务器端。

sockaddr结构

sockaddr 是一个通用的套接字地址结构,在Socket编程中经常用于存储网络地址信息。由于不同的协议族(IPv4、IPv6等)具有不同的地址结构,因此 sockaddr 用作地址结构的基类,而实际使用时通常会使用具体的子结构 sockaddr_in(IPv4)或 sockaddr_in6(IPv6)。

struct sockaddr {
    sa_family_t sa_family;      // 地址族,通常为 AF_INET 或 AF_INET6
    char sa_data[14];           // 存放地址信息的缓冲区,不同协议族具有不同的结构
};

在实际使用时,通常会将 sockaddr 结构转换为适合当前协议族的具体地址结构。例如,在IPv4协议中,使用 sockaddr_in 结构,其定义如下:

struct sockaddr_in {
    sa_family_t sin_family;     // 地址族,固定为 AF_INET
    in_port_t sin_port;         // 16位端口号,使用网络字节序
    struct in_addr sin_addr;    // 32位IPv4地址,使用网络字节序
    char sin_zero[8];           // 不使用,填充字段
};

在IPv6协议中,使用 sockaddr_in6 结构,其定义如下:

struct sockaddr_in6 {
    sa_family_t sin6_family;     // 地址族,固定为 AF_INET6
    in_port_t sin6_port;         // 16位端口号,使用网络字节序
    uint32_t sin6_flowinfo;      // 流标识,通常为0
    struct in6_addr sin6_addr;   // 128位IPv6地址,使用网络字节序
    uint32_t sin6_scope_id;      // 接口范围标识
};

在使用 结构时,通常需要进行类型转换,将其转换为适用于当前协议族的地址结构,并根据需要填充具体的地址信息,然后传递给套接字相关的函数使用。

sockaddr_in结构

sockaddr_in 是用于存储IPv4地址的套接字地址结构,是在网络编程中非常常用的结构。它用于在IPv4协议族中表示网络地址和端口号。下面是 sockaddr_in 结构的定义:

struct sockaddr_in {
    sa_family_t sin_family;     // 地址族,固定为 AF_INET
    in_port_t sin_port;         // 16位端口号,使用网络字节序
    struct in_addr sin_addr;    // 32位IPv4地址,使用网络字节序
    char sin_zero[8];           // 不使用,填充字段
};

其中,各字段的含义如下:

sin_family:地址族,固定为 AF_INET,表示IPv4地址族。
sin_port:16位端口号,使用网络字节序,需要使用 htons 函数进行字节序转换。
sin_addr:32位IPv4地址,使用网络字节序,需要使用 inet_pton 函数将点分十进制形式的IPv4地址转换为网络字节序。
sin_zero:不使用,填充字段,通常设置为0。
使用 结构时,通常先将IPv4地址和端口号填充到该结构中,然后将其转换为通用的 sockaddr_insockaddr 结构,在套接字相关的函数中使用。

例如,在服务器端绑定一个IPv4地址和端口号,可以这样做:

#include 
#include 
#include 

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("socket");
        return -1;
    }

    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080); // 将端口号转换为网络字节序
    inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr); // 将IPv4地址转换为网络字节序
    memset(server_addr.sin_zero, 0, sizeof(server_addr.sin_zero));

    if (bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(sockfd);
        return -1;
    }

    // 其他操作...
    close(sockfd);
    return 0;
}

注意,在使用 sockaddr_in 结构时,需要包含 头文件,并且要进行网络字节序的转换。

简单的UDP网络程序

log.hpp 日志文件

#pragma once

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define DEBUG 0
#define NOTICE 1
#define WARINING 2
#define FATAL 3

const char *log_level[]={"DEBUG", "NOTICE", "WARINING", "FATAL"};

// logMessage(DEBUG, "%d", 10);
void logMessage(int level, const char *format, ...)
{
    assert(level >= DEBUG);
    assert(level <= FATAL);

    char *name = getenv("USER");

    char logInfo[1024];
    va_list ap; // ap -> char*
    va_start(ap, format);

    vsnprintf(logInfo, sizeof(logInfo)-1, format, ap);

    va_end(ap); // ap = NULL


    FILE *out = (level == FATAL) ? stderr:stdout;

    fprintf(out, "%s | %u | %s | %s\n", \
        log_level[level], \
        (unsigned int)time(nullptr),\
        name == nullptr ? "unknow":name,\
        logInfo);

    // char *s = format;
    // while(s){
    //     case '%':
    //         if(*(s+1) == 'd')  int x = va_arg(ap, int);
    //     break;
    // }
}

udpClient.cc 客户端

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

struct sockaddr_in server;

static void Usage(std::string name)
{
    std::cout << "Usage:\n\t" << name << " server_ip server_port" << std::endl;
}

void *recverAndPrint(void *args)
{
    while (true)
    {
        int sockfd = *(int *)args;
        char buffer[1024];
        struct sockaddr_in temp;
        socklen_t len = sizeof(temp);
        ssize_t s = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr *)&temp, &len);
        if (s > 0)
        {
            buffer[s] = 0;
            std::cout << "server echo# " << buffer << std::endl;
        }
    }
}

// ./udpClient server_ip server_port
// 如果一个客户端要连接server必须知道server对应的ip和port
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    // 1. 根据命令行,设置要访问的服务器IP
    std::string server_ip = argv[1];
    uint16_t server_port = atoi(argv[2]);

    // 2. 创建客户端
    // 2.1 创建socket
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    assert(sockfd > 0);

    // 2.2 client 需不需要bind??? 需要bind,但是不需要用户自己bind,而是os自动给你bind
    // 所谓的"不需要",指的是: 不需要用户自己bind端口信息!因为OS会自动给你绑定,你也最好这么做!
    // 如果我非要自己bind呢?可以!严重不推荐!
    // 所有的客户端软件 <-> 服务器 通信的时候,必须得有 client[ip:port] <-> server[ip:port]
    // 为什么呢??client很多,不能给客户端bind指定的port,port可能被别的client使用了,你的client就无法启动了
    // 那么server凭什么要bind呢??server提供的服务,必须被所有人知道!server不能随便改变!
    // 2.2 填写服务器对应的信息

    bzero(&server, sizeof server);
    server.sin_family = AF_INET;
    server.sin_port = htons(server_port);
    server.sin_addr.s_addr = inet_addr(server_ip.c_str());

    pthread_t t;
    pthread_create(&t, nullptr, recverAndPrint, (void *)&sockfd);
    // 3. 通讯过程
    std::string buffer;
    while (true)
    {
        std::cerr << "Please Enter# ";
        std::getline(std::cin, buffer);
        // 发送消息给server
        sendto(sockfd, buffer.c_str(), buffer.size(), 0,
               (const struct sockaddr *)&server, sizeof(server)); // 首次调用sendto函数的时候,我们的client会自动bind自己的ip和port
    }

    close(sockfd);

    return 0;
}

udpServer.cc 服务器

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include "log.hpp"
static void Usage(const std::string porc)
{
    std::cout << "Usage:\n\t" << porc << " port [ip]" << std::endl;
}

class udpServer
{
    public:
    udpServer(int port, std::string ip = "") : port_((uint16_t)port), ip_(ip), sockfd_(-1)
    {
    }
    ~udpServer()
    {
    }

    void init()//初始化函数
    {
        //1.创建套接字
        sockfd_=socket(AF_INET,SOCK_DGRAM,0);
        //  参数1:套接字的协议族     `AF_INET`: IPv4协议族,用于Internet地址。
        //参数2:套接字类型    `SOCK_DGRAM`: 面向消息的套接字,用于不可靠的、固定长度的数据传输(如UDP)。
        //参数3:套接字的协议    0,让系统自动选择合适的协议。
        if(sockfd_<0) //创建失败 打印日志信息
        {
              logMessage(FATAL, "socket:%s:%d", strerror(errno), sockfd_);
            exit(1);
        }

        //到这说明 创建成功
         logMessage(DEBUG, "socket create success: %d", sockfd_);
         struct sockaddr_in local;  // local在哪里开辟的空间? 用户栈 -> 临时变量 -> 写入内核中
            bzero(&local, sizeof(local)); // memset
        // 填充协议家族,域
        local.sin_family = AF_INET;
        // 填充服务器对应的端口号信息,一定是会发给对方的,port_一定会到网络中
        local.sin_port = htons(port_);
        // 服务器都必须具有IP地址,"xx.yy.zz.aaa",字符串风格点分十进制 -> 4字节IP -> uint32_t ip
        // INADDR_ANY(0): 程序员不关心会bind到哪一个ip, 任意地址bind,强烈推荐的做法,所有服务器一般的做法
        // inet_addr: 指定填充确定的IP,特殊用途,或者测试时使用,除了做转化,还会自动给我们进行 h—>n
        local.sin_addr.s_addr = ip_.empty() ? htonl(INADDR_ANY) : inet_addr(ip_.c_str());
        // 2.2 bind 网络信息
        if (bind(sockfd_, (const struct sockaddr *)&local, sizeof(local)) == -1)
        {
            logMessage(FATAL, "bind: %s:%d", strerror(errno), sockfd_);
            exit(2);
        }
        logMessage(DEBUG, "socket bind success: %d", sockfd_);
        // done
    }

     void start()
    {
        // 服务器设计的时候,服务器都是死循环
        char inbuffer[1024];  //将来读取到的数据,都放在这里
        char outbuffer[1024]; //将来发送的数据,都放在这里
        while (true)
        {
            struct sockaddr_in peer;      //输出型参数
            socklen_t len = sizeof(peer); //输入输出型参数

            // demo2
            //  UDP无连接的
            //  对方给你发了消息,你想不想给对方回消息?要的!后面的两个参数是输出型参数
            ssize_t s = recvfrom(sockfd_, inbuffer, sizeof(inbuffer) - 1, 0,
                                 (struct sockaddr *)&peer, &len);
            if (s > 0)
            {
                inbuffer[s] = 0; //当做字符串
            }
            else if (s == -1)
            {
                logMessage(WARINING, "recvfrom: %s:%d", strerror(errno), sockfd_);
                continue;
            }
            // 读取成功的,除了读取到对方的数据,你还要读取到对方的网络地址[ip:port]
            std::string peerIp = inet_ntoa(peer.sin_addr);       //拿到了对方的IP
            uint32_t peerPort = ntohs(peer.sin_port); // 拿到了对方的port

            checkOnlineUser(peerIp, peerPort, peer); //如果存在,什么都不做,如果不存在,就添加

            // 打印出来客户端给服务器发送过来的消息
            logMessage(NOTICE, "[%s:%d]# %s", peerIp.c_str(), peerPort, inbuffer);

            // for(int i = 0; i < strlen(inbuffer); i++)
            // {
            //     if(isalpha(inbuffer[i]) && islower(inbuffer[i])) outbuffer[i] = toupper(inbuffer[i]);
            //     else outbuffer[i] = toupper(inbuffer[i]);
            // }
            messageRoute(peerIp, peerPort,inbuffer); //消息路由

            // 线程池!

            // sendto(sockfd_, outbuffer, strlen(outbuffer), 0, (struct sockaddr*)&peer, len);

            // demo1
            // logMessage(NOTICE, "server 提供 service 中....");
            // sleep(1);
        }
    }

    void checkOnlineUser(std::string &ip, uint32_t port, struct sockaddr_in &peer)
    {
        std::string key = ip;
        key += ":";
        key += std::to_string(port);
        auto iter = users.find(key);
        if(iter == users.end())
        {
            users.insert({key, peer});
        }
        else
        {
            // iter->first, iter->second->
            // do nothing
        }
    }

    void messageRoute(std::string ip, uint32_t port, std::string info)
    {

        std::string message = "[";
        message += ip;
        message += ":";
        message += std::to_string(port);
        message += "]# ";
        message += info;

        for(auto &user : users)
        {
            sendto(sockfd_, message.c_str(), message.size(), 0, (struct sockaddr*)&(user.second), sizeof(user.second));
        }
    }


    private:
    // 服务器必须得有端口号信息
    uint16_t port_;
    // 服务器必须得有ip地址
    std::string ip_;
    // 服务器的socket fd信息
    int sockfd_;
    // onlineuser
    std::unordered_map<std::string, struct sockaddr_in> users;

};
int main(int argc, char *argv[])
{
    if (argc != 2 && argc != 3) //反面:argc == 2 || argc == 3
    {
        Usage(argv[0]);
        exit(3);
    }
    uint16_t port = atoi(argv[1]);
    std::string ip;
    if (argc == 3)
    {
        ip = argv[2];
    }

    udpServer svr(port, ip);
    svr.init();
    svr.start();

    return 0;
}

makefile文件

.PHONY:all
all:udpClient udpServer

udpClient: UCPClient.cc
	g++ -o $@ $^ -std=c++11 -lpthread
udpServer:UDPServer.cc
	g++ -o $@ $^ -std=c++11

.PHONY:clean
clean:
	rm -f udpClient udpServer

运行:


设置对对应的端口号就行

【网络编程】利用套接字实现一个简单的网络通信(UDP实现聊天室 附上源码)_第3张图片

你可能感兴趣的:(Linux,网络,udp,服务器)