网络编程套接字

🐛预备知识
- 🦋理解源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手册

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

以下是常用的Socket API函数及其参数：

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相关的默认协议）。

bind()函数：

描述：将套接字绑定到一个特定的地址和端口。
参数：int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
sockfd：套接字描述符。
addr：指向要绑定的地址结构的指针，通常是struct sockaddr_in（IPv4）或struct sockaddr_in6（IPv6）。
addrlen：地址结构的长度。

connect()函数：

描述：建立与远程服务器的连接。
参数：int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
sockfd：套接字描述符。
addr：指向目标服务器地址的指针，通常是struct sockaddr_in（IPv4）或struct sockaddr_in6（IPv6）。
addrlen：地址结构的长度。

listen()函数：

描述：将套接字设置为监听模式，准备接受连接请求。
参数：int listen(int sockfd, int backlog)
sockfd：套接字描述符。
backlog：请求队列的最大长度，即等待接受连接的连接数。

accept()函数：

描述：接受连接请求，创建一个新的套接字用于与客户端通信。
参数：int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
sockfd：监听套接字描述符。
addr：指向客户端地址的指针，用于存储客户端的信息。
addrlen：地址结构的长度。

send()函数：

描述：发送数据。
参数：ssize_t send(int sockfd, const void *buf, size_t len, int flags)
sockfd：套接字描述符。
buf：要发送的数据缓冲区。
len：要发送的数据长度。
flags：发送标志，通常为0。

recv()函数：

描述：接收数据。
参数：ssize_t recv(int sockfd, void *buf, size_t len, int flags)
sockfd：套接字描述符。
buf：接收数据的缓冲区。
len：要接收的数据长度。
flags：接收标志，通常为0。

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 <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>

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 结构时，需要包含 <netinet/in.h> 头文件，并且要进行网络字节序的转换。

🐍 简单的UDP网络程序

🦎log.hpp 日志文件

#pragma once

#include <cstdio>
#include <ctime>
#include <cstdarg>
#include <cassert>
#include <cstring>
#include <cerrno>
#include <stdlib.h>

#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 <iostream>
#include <string>
#include <cstdlib>
#include <cassert>
#include <unistd.h>
#include <strings.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <pthread.h>

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 <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <stdlib.h>
#include <ctype.h>
#include <unordered_map>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#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