Linux网络编程--Udp套接字+实战 (万字详解，超详细！！)

套接字协议：

协议(protocol)：

创建套接字(Create Socket):

绑定服务器地址

开始通信

Udp服务器设计--V1

Udp服务器设计--V2 引入进程池待更新

套接字协议：

协议(protocol)：

如果2个距离很远的人想要进行交流，首先要决定的就是"我们该用什么工具来进行通话?" ：写信？手机？还是电脑？首先明确一点：能成功通信的双方一定是达成了某种共识的！如：2个人都是用网络进行通信，或者都是用书信交流，不可能存在一方使用书信，另一方使用手机这种“荒谬”的事情发生；换句话说，协议就是为了完成数据交换而定好的约定!

创建套接字(Create Socket):

在Linux中一切皆文件，使用系统调用socket函数创建返回一个套接字文件描述符(如果成功)

创建失败返回-1，错误码被设置。

函数原型：

使用socket函数需要包含对应头文件；

参数详解：

domian：套接字中使用的协议族，什么是协议族？说人话就是：番茄炒蛋和番茄炒米（参考卢老爷名言）都是属于用番茄做的菜一类，在套接字中，番茄就是协议族，番茄炒蛋就是协议族的一种类型，在套接字中，协议族常用的就2种：AF_INET和AF_INET6，分别对应ipv4和ipv6
type：套接字遵守的协议：udp还是tcp，设置为SOCK_DGRAM对应遵守UDP协议，设置为SOCK_STREAM对应遵守TCP协议
protocol：设置套接字的类型，非阻塞还是阻塞，是否能被子进程继承，设置为SOCK_NONBLOCK表示设置描述符非阻塞,设置SOCK_CLOEXEC表示不能被子进程继承

绑定服务器地址

套接字创建成功后，需要绑定自己的地址信息，使用系统调用的bind函数

函数原型：

参数详解：

sockfd：之前使用的创建套接字返回的描述符fd
addr：需要手动填充的服务器的地址信息，sockaddr本质上c语言的“拟基类”，我们要填充的其实不是sockaddr，而是它的"子类"：struct sockaddr_in，结构体原型：sin_addr中还有一个成员：s_addr，用于填充要绑定的ip，注意！在云服务器上只能绑定所有地址，即"0.0.0.0"; sin_family:地址族；sin_port：端口号，注意要从本地序列(uint16_t)转换成网络序列，可以使用函数::htons进行转换;sin_zero一般都填充为0即可，所以可以在刚创建出sockaddr_in时使用memset将结构体清零
addrlen：第二个参数的大小，使用sizeof计算即可

开始通信

UDP套接字较为简单，不需要其他操作，只要bind成功就可以直接进行通信

使用recvfron接收信息，sendto发送信息

Udp服务器设计--V1

目标：实现一个简单的Echo服务器，客户端发送什么info就返回什么样的info

先引入日志Log.hpp：

/*Log.hpp*/

#pragma once
#include <iostream>
#include <string>
#include <unistd.h>
#include <ctime>
#include <cstdarg>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <fstream>
#include <mutex>
#include <pthread.h>
#define _SCREEN_TYPE_ 1
#define _FILE_TYPE 2
namespace ns_log
{
    const std::string DEFAULTSTR = "Log.txt";

    enum
    {
        DEBUG = 1,
        INFO,
        WARNING,
        ERROR,
        FATAL
    };
    struct Logmessage
    {
        std::string _level; // 等级
        pid_t _pid;
        std::string _filename;   // 文件名
        int _filenumber;         // 行号
        std::string _curr_time;  // 获取日志信息出现的时间
        std::string _logmessage; // 信息
    };

    std::string LevelToString(int level)
    {
        switch (level)
        {
        case DEBUG:
            return "DEBUG";
            break;
        case INFO:
            return "INFO";
            break;
        case WARNING:
            return "WARNING";
            break;
        case ERROR:
            return "ERROR";
            break;
        case FATAL:
            return "FATAL";
            break;
        default:
            return "UNKNOW";
            break;
        }
    }
    std::string GetCurrTime()
    {
        time_t now_time = time(nullptr);
        struct tm *curr_time = localtime(&now_time);
        // 转换为string格式
        char buf[128];
        snprintf(buf, sizeof(buf), "%d-%02d-%02d %02d:%02d:%02d",
                 curr_time->tm_year + 1900, curr_time->tm_mon + 1, curr_time->tm_mday, curr_time->tm_hour, curr_time->tm_min, curr_time->tm_sec);
        return buf;
    }
    class Log
    {
        void LogMsgToScreen(const Logmessage &logmsg)
        {
            printf("[%s][%d][%s][%d][%s] %s",
                   logmsg._level.c_str(), logmsg._pid, logmsg._filename.c_str(), logmsg._filenumber, logmsg._curr_time.c_str(), logmsg._logmessage.c_str());
        }
        void LogMsgToFile(const Logmessage &logmsg)
        {
            char buf_info[2048] = "\0";
            snprintf(buf_info, sizeof(buf_info), "[%s][%d][%s][%d][%s] %s",
                     logmsg._level.c_str(), logmsg._pid, logmsg._filename.c_str(), logmsg._filenumber, logmsg._curr_time.c_str(), logmsg._logmessage.c_str());
            /*--系统调用版本--*/
            // int fd = open(_logfile.c_str(),O_CREAT | O_WRONLY | O_APPEND,0666);
            // if(fd < 0)
            // {
            //     perror("open");
            //     return;
            // }
            // write(fd,buf_info,sizeof(buf_info));

            /*--c++提供的fstream--*/
            std::ofstream out;
            out.open(_logfile, std::ios::out | std::ios::app | std::ios::binary);
            if (!out.is_open())
                return;
            out.write(buf_info, sizeof(buf_info));
            out.close();
        }
        void FlushLogMsg(int level, const Logmessage &logmsg)
        {
            // c++11的锁
            //  _mutex.lock();
            // RAII类型的锁
            std::unique_lock<std::mutex> lock(_mtx);
            if (_isopen && level == DEBUG)
                return;
            switch (_type)
            {
            case _SCREEN_TYPE_:
                LogMsgToScreen(logmsg);
                break;
            case _FILE_TYPE:
                LogMsgToFile(logmsg);
                break;
            }
        }

    public:
        Log(const std::string &logfile = DEFAULTSTR) : _logfile(logfile), _type(_SCREEN_TYPE_)
        {
        }
        void ModPrintFormat(int type)
        {
            std::unique_lock<std::mutex> lock(_mtx);
            _type = type;
        }
        void LogMessage(int level, std::string filename, int filenumber, const char *format, ...) // 注意-->可变函数参数
        {
            Logmessage msg;
            msg._level = LevelToString(level);
            msg._filename = filename;
            msg._pid = getpid();
            msg._filenumber = filenumber;
            msg._curr_time = GetCurrTime();
            // 注意：取出可变参数的固定写法
            va_list _ap;           // 创建变量,本质是一个指针
            va_start(_ap, format); // 将参数列表中离...最近的确定的参数传入
            char log_info[512];
            vsnprintf(log_info, sizeof(log_info), format, _ap);
            va_end(_ap); // 销毁_ap
            msg._logmessage = log_info;
            FlushLogMsg(level, msg);
        }
        ~Log()
        {
        }
        void EnableFiltration(bool flag)
        {
            _isopen = flag;
        }

    private:
        int _type;
        std::string _logfile;
        std::mutex _mtx;
        bool _isopen = false;
    };

    Log lg;
// 打开过滤器
#define EnabelFILTRATION()         \
    do                             \
    {                              \
        lg.EnableFiltration(true); \
    } while (0)
// 关闭过滤器
#define ClOSEFILTRATION             \
    do                              \
    {                               \
        lg.EnableFiltration(false); \
    } while (0)
#define LOG(level, format, ...)                                          \
    do                                                                   \
    {                                                                    \
        lg.LogMessage(level, __FILE__, __LINE__, format, ##__VA_ARGS__); \
    } while (0)

#define LOGTOSCREEN(level, format, ...)                                  \
    do                                                                   \
    {                                                                    \
        lg.ModPrintFormat(_SCREEN_TYPE_);                                \
        lg.LogMessage(level, __FILE__, __LINE__, format, ##__VA_ARGS__); \
    } while (0)

#define LOGTOFILE(level)               \
    do                                 \
    {                                  \
        lg.ModPrintFormat(_FILE_TYPE); \
    } while (0)

}

引入日志后，正式开始编写V1版本echo服务器：

V1--Udp_Server：

根据上文的udp套接字接口介绍，下面就直接上代码：

#pragma once
#include <iostream>
#include <string>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Log.hpp"
using namespace ns_log;
#define MAX_BUFFER_SIZE 4096
// Udp--无连接|不可靠|高性能|广播
// 云服务器bind--->0.0.0.0
/*这是一个echo服务器*/
class UdpServer
{
private:
    int _sockfd;
    uint16_t _port;
    bool _isrunning;
public:
    UdpServer(uint16_t port) : _port(port), _isrunning(false)
    {
        _sockfd = ::socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd < 0)
        {
            LOG(FATAL, "create socketfd failed!\n");
            abort();
        }
        LOG(DEBUG, "---create sockfd succsee,sockfd = %d---\n", _sockfd);
        // bind
        struct sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_port = ::htons(_port); // 本地序列转网络序列
        // bind任意ip
        addr.sin_addr.s_addr = INADDR_ANY;//INADDR_ANY--表示bind任意地址"0.0.0.0"
        int res = ::bind(_sockfd, (struct sockaddr *)&addr, sizeof(addr));
        if (res < 0)
        {
            LOG(FATAL, "server bind error!\n");
            abort();
        }
        LOG(DEBUG, "server bind success!\n");
    }
    void Start()
    {
        _isrunning = true;
        while (_isrunning)
        {
            char buff[MAX_BUFFER_SIZE];
            // 接收信息
            struct sockaddr_in peer;
      
            memset(&peer, 0, sizeof(peer));
            socklen_t len = sizeof(peer);
            ssize_t n = ::recvfrom(_sockfd, buff, sizeof(buff) - 1, 0, (struct sockaddr *)&peer, &len);
            if (n > 0)
            {
                buff[n] = 0;
                LOG(INFO, "client info#: %s\n", buff);
                // 发送
                std::string info = "[server][info]# ";
                info += buff;
                ssize_t n = ::sendto(_sockfd, info.c_str(), info.size(), 0,(struct sockaddr *)&peer, len);
            }
            else 
            {
                if(n == 0) continue;
                if(n < 0)
                {
                    LOG(ERROR,"recv error!\n");
                    break;
                }
            }
        }
    }
    void Close()
    {
        if(_sockfd > 0) ::close(_sockfd);
    }
    void Stop()
    {
        _isrunning = false;
    }
    ~UdpServer()
    {
    }
};

编写客户端代码：client.cc

对于客户端来说，需要bind要连接的服务器的ip地址和端口号，不能bind任意地址了

实现：

#include "Udp_Server.hpp"

bool Usage(int argc, char *argv[])
{
    if (argc != 3)
    {
        LOG(ERROR, "Usage:<./exe> <ip> <port>\n");
        return false;
    }
    return true;
}
int main(int argc, char *argv[])
{
    if (!Usage(argc, argv))
        return -1;
    std::string ip = argv[1];
    uint16_t port = atoi(argv[2]);
    int sockfd = ::socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        LOG(FATAL, "Create socket error!\n");
        return -2;
    }
    struct sockaddr_in server;
    // 将结构体清零
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    ::inet_pton(AF_INET, ip.c_str(), &server.sin_addr.s_addr);
    server.sin_port = ::htons(port);
    
    while(true)
    {
        std::string buffer;
        std::getline(std::cin,buffer);
        ssize_t n = ::sendto(sockfd,buffer.c_str(),buffer.size(),0,(struct sockaddr*)&server,sizeof(server));
        //接收信息
        char recvbuff[1024];
        struct sockaddr_in client;
        memset(&client,0,sizeof(client));
        socklen_t len = sizeof(client);
        n = ::recvfrom(sockfd,recvbuff,sizeof(recvbuff)-1,0,(struct sockaddr*)&client,&len);
        if(n > 0)
        {
            recvbuff[n] = 0;
            LOG(INFO,"%s\n",recvbuff);
            continue;
        }
        else
        {
            if(n == 0) continue;
            if(n < 0)
            {
                LOG(ERROR,"client recv error!\n");
                break;
            }
        }
    }
    return 0;
}

编写serevr.cc

#include"Udp_Server.hpp"
#include<memory>
bool Usage(int argc, char *argv[])
{
    if (argc != 2)
    {
        LOG(ERROR, "Usage:<./exe> <port>\n");
        return false;
    }
    return true;
}
int main(int argc, char *argv[])
{
    if (!Usage(argc, argv))
        return -1;
    uint16_t port = atoi(argv[1]);
    std::unique_ptr<UdpServer> server = std::make_unique<UdpServer>(port);
    server->Start();
    server->Stop();
    server->Close();
}

编写Makefile：

.PHONY:ALL
ALL:server client
server:server.cc
	g++ -o $@ $^ -std=c++14 
client:client.cc
	g++ -o $@ $^ -std=c++14	

.PHONY:clean
clean:
	rm -f server client

make编译即可；