【网络编程】网络套接字&udp通用服务器和客户端

1.预备知识

认识端口号

端口号(port)是传输层协议的内容：

• 端口号是一个2字节16位的整数(uint16)
• 端口号用来标识主机上的一个进程
• IP地址+port能够标识网络上的某一台主机和某一个进程
• 一个端口号只能被一个进程占用

认识TCP协议

此处我们先对TCP(Transmission Control Protocol 传输控制协议) 有一个直观的认识，后面再详细讨论TCP的一些细节问题。

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

认识UDP协议

此处我们也是对UDP(User Datagram Protocol 用户数据报协议)有一个直观的认识，后面再详细讨论。

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

网络字节序

内存中的多字节数据相比于内存地址有大端和小端之分，磁盘文件中的多字节数据相比于文件中的偏移地址也有大端小端之分，网络数据流同样有大端和小端之分，那么如何定义网络数据流的地址呢？

• 发送主机通常将发送缓冲区中的数据按照内存地址从低到高顺序发出
• 接受主机把从网络上接到的字节序依次保存在接收缓冲区，也是按照内存地址从低到高的顺序保存
• 因此，网络数据流的地址应该这样规定：先发出的数据是低地址，后发出的数据是高地址
• TCP/UDP协议规定，网络数据流应该采用大端字节序，即低地址高字节
• 不管这台主机是大端机还是小端机，都会按照这个TCP/UDP规定的网络字节序来发送/接收数据
• 如果当前发送主机是小端，就需要先将数据转成大端；否则就忽略，直接发送即可

存储在内存中的数据有大端和小端之分，低位存储在低地址的是小端，低位存储在高地址的是大端。

为了使网络程序具有可移植性，使同样的C代码在大端和小端计算机上编译后都能正常的运行，可以调用以下库函数做网络字节序和主机字节序的转换。

#include <arpa/inet.h>
uint32_t htonl(unit32_t hostlong);
uint16_t htons(unit16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);

• 这些函数名很好记，h表示host，n表示network，l表示32位长整数，s表示16位短整数
• 例如htonl 表示将32位长整数从主机字节序转换为网络字节序，例如将IP地址转换后准备发送
• 如果主机是小端字节序，这些函数将参数做相应的大小端进行转换，然后返回
• 如果主机是大端字节序，这些函数不做转换，将参数原封不动的返回

2.socket编程接口

socket常见API

// 创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器)
int socket(int domain, int type, int protocol);
// 绑定端口号 (TCP/UDP, 服务器) 
int bind(int socket, const struct sockaddr *address, socklen_t address_len);
// 开始监听socket (TCP, 服务器)
int listen(int socket, int backlog);
// 接收请求 (TCP, 服务器)
int accept(int socket, struct sockaddr* address, socklen_t* address_len);
// 建立连接 (TCP, 客户端)
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

sockaddr结构

sockaddr是通用的网络接口，网络通信中经常使用到的是struct sockaddr_in。

• IPv4和IPv6的地址格式定义在netinet/in.h中，IPv4地址用sockaddr_in 结构体表示，包含16位地址类型，16位端口号和32位IP地址
• IPv4和IPv6地址类型分别定义为常数AF_INET、AF_INET6，这样主要取得某种sockaddr结构体的首地址，不需要知道具体是哪种类型的sockaddr结构体，就可以根据地址类型字段确定结构体中的内容
• sock API可以都用struct sockaddr*类型表示，在使用的时候需要强制转化成sockaddr_in，这样的好处是程序的通用性，可以接收IPv4，IPv6，以及UNIX Domain Socket各种类型的sockaddr结构体指针作为参数

sockaddr结构

sockaddr_in结构

虽然socket api的接口是sockaddr，但是真正在基于IPv4编程时，使用的数据结构是sockaddr_in；这个结构里主要有三部分信息：地址类型，端口号，IP地址。

in_addr结构

in_addr用来表示一个IPv4的IP地址，其实就是一个32位的整数；

3.简单的UDP网络程序

实现一个简单的英译汉功能

封装UdpSocket

udp_socket.hpp

#pragma once
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <cassert>
#include <string>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>


class UdpSocket
{
public:
    UdpSocket() : fd_(-1)
    {}
    bool Socket()
    {
        fd_ = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd_ < 0)
        {
            perror("socket");
            return false; //创建套接字失败
        }
        return true;
    }
    bool Close()
    {
        close(fd_); //关闭套接字
        return true;
    }
    bool Bind(const std::string &ip, uint16_t port)
    {
        sockaddr_in addr;              //用于网络传输
        addr.sin_family = AF_INET;     //地址类型-网络
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        addr.sin_port = htons(port);
        int ret = bind(fd_, (sockaddr *)&addr, sizeof(addr));
        if (ret < 0)
        {
            perror("bind");
            return false; //绑定失败
        }
        return true;
    }
    bool RecvFrom(std::string *buf, std::string *ip = NULL, uint16_t *port = NULL)
    {
        char tmp[1024 * 10] = {0};
        sockaddr_in peer;
        socklen_t len = sizeof(peer);
        ssize_t read_size = recvfrom(fd_, tmp,
                                     sizeof(tmp) - 1, 0, (sockaddr *)&peer, &len);
        if (read_size < 0)
        {
            perror("recvfrom");
            return false;
        }
        // 将读到的缓冲区内容放到输出参数中
        buf->assign(tmp, read_size);
        if (ip != NULL)
        {
            *ip = inet_ntoa(peer.sin_addr);
        }
        if (port != NULL)
        {
            *port = ntohs(peer.sin_port);
        }
        return true;
    }
    bool SendTo(const std::string &buf, const std::string &ip, uint16_t port)
    {
        sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        addr.sin_port = htons(port);
        ssize_t write_size = sendto(fd_, buf.data(), buf.size(), 
        0, (sockaddr *)&addr, sizeof(addr));
        if (write_size < 0)
        {
            perror("sendto");
            return false;
        }
        return true;
    }

private:
//socket函数是实现网络通信的重要工具，用于创建、绑定、监听、连接和关闭套接字，以及发送和接收数据。
    int fd_;  
};

udp通用服务器

#pragma once
#include "udp_socket.hpp"

// C 式写法
// typedef void (*Handler)(const std::string& req, std::string* resp);
// C++ 11 式写法, 能够兼容函数指针, 仿函数, 和 lamda
#include <functional>
typedef std::function<void(const std::string &, std::string *resp)> Handler;
class UdpServer
{
public:
    UdpServer()
    {
        assert(sock_.Socket());
    }
    ~UdpServer()
    {
        sock_.Close();
    }
    bool Start(const std::string &ip, uint16_t port, Handler handler)
    {
        // 1. 创建 socket
        // 2. 绑定端口号
        bool ret = sock_.Bind(ip, port);
        if (!ret)
        {
            return false;
        }
        // 3. 进入事件循环
        for (;;)
        {
            // 4. 尝试读取请求
            std::string req;
            std::string remote_ip;
            uint16_t remote_port = 0;
            bool ret = sock_.RecvFrom(&req, &remote_ip, &remote_port);
            if (!ret)
            {
                continue;
            }
            std::string resp;
            // 5. 根据请求计算响应
            handler(req, &resp);
            // 6. 返回响应给客户端
            sock_.SendTo(resp, remote_ip, remote_port);
            printf("[%s:%d] req: %s, resp: %s\n", remote_ip.c_str(), remote_port,
                   req.c_str(), resp.c_str());
        }
        sock_.Close();
        return true;
    }

private:
    UdpSocket sock_;
};

实现英译汉服务器

以上代码是对udp服务器进行通用接口的封装，基于以上封装，实现一个查字典的服务器就很容易了；

dict_server.cc

#include "udp_server.hpp"
#include <unordered_map>
#include <iostream>

std::unordered_map<std::string, std::string> g_dict;
void Translate(const std::string &req, std::string *resp)
{
    auto it = g_dict.find(req);
    if (it == g_dict.end())
    {
        *resp = "未查到!";
        return;
    }
    *resp = it->second;
}
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        printf("Usage ./dict_server [ip] [port]\n");
        return 1;
    }
    // 1. 数据初始化
    g_dict.insert(std::make_pair("hello", "你好"));
    g_dict.insert(std::make_pair("world", "世界"));
    g_dict.insert(std::make_pair("c++", "最好的编程语言"));
    // 2. 启动服务器
    UdpServer server;
    server.Start(argv[1], atoi(argv[2]), Translate);
    return 0;
}

UDP通用客户端

udp_client.hpp

#pragma once
#include "udp_socket.hpp"
class UdpClient
{
public:
    UdpClient(const std::string &ip, uint16_t port) : ip_(ip), port_(port)
    {
        assert(sock_.Socket());
    }
    ~UdpClient()
    {
        sock_.Close();
    }
    bool RecvFrom(std::string *buf)
    {
        return sock_.RecvFrom(buf);
    }
    bool SendTo(const std::string &buf)
    {
        return sock_.SendTo(buf, ip_, port_);
    }

private:
    UdpSocket sock_;
    // 服务器端的 IP 和 端口号
    std::string ip_;
    uint16_t port_;
};

实现英译汉客户端

dict_client.cpp

#include "udp_client.hpp"
#include <iostream>
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        printf("Usage ./dict_client [ip] [port]\n");
        return 1;
    }
    UdpClient client(argv[1], atoi(argv[2]));
    for (;;)
    {
        std::string word;
        std::cout << "请输入您要查的单词: ";
        std::cin >> word;
        if (!std::cin)
        {
            std::cout << "Good Bye" << std::endl;
            break;
        }
        client.SendTo(word);
        std::string result;
        client.RecvFrom(&result);
        std::cout << word << " 意思是 " << result << std::endl;
    }
    return 0;
}

4.地址转换函数

基于IPv4的socket网络编程，sockaddr_in中的成员struct in_addr sin_addr表示32位的IP地址，但是我们通常用点分十进制的字符串表示IP地址，以下函数可以在字符串表示和in_addr表示之间进行转换；

字符串转in_addr函数：

in_addr转字符串的函数：

其实inet_pton和inet_ntop不仅可以转换IPv4的in_addr，还可以转换IPv6的in6_addr，因此函数接口是void* addrptr。