UDP客户端服务器通信

在这篇博客中，我们将探索 UDP（用户数据报协议） 通信，简要地说，UDP 是一种无连接、快速但不可靠的通信协议，适用于需要快速数据传输但对丢包容忍的场景，比如视频流和在线游戏。就像《我是如此相信》的图片所表达的那样，UDP 没有过多的保障机制，它直接、简单、快捷，就像信念一样，直接而坚定。

1、网络协议中的下三层主要解决的是，数据安全可靠得发送到远端机器

2、用户使用应用层软件，完成数据的发送和接收，先把软件启动起来，那就是进程，因此网络通信的本质就是进程间的通信。

一、认识端口号

端口号无论是客户端还是服务器，都能唯一的标识该主机上的一个特定应用层的进程，ip地址唯一的标识一个主机，端口号只能用来标识该主机上的唯一进程。IP+Port能够标识全网唯一的进程。

二、套接字

客户端和服务器通信的时候就好像插头和插座的关系

端口号VS进程pid，但是pid已经可以唯一标识一个进程，为什么还要端口号？

1、不是所有的进程都要网络通信

2、pid属于操作系统中的进程管理，但是要是系统出问题，网络部分也要改，牵一发而动全身，因此要解耦。

我们的客户端怎么知道服务器的端口号？每个服务器的端口必须是众所周知的，被客户端知道。

一个进程可以绑定多个端口号，一个端口号不可以被多个进程绑定。经过哈希找的进程就不一样了

2、套接字的种类：域间（本地通信）、原始（编写网络工具，抓包）和网络套接字

三、UDP和TCP

TCP（Transmission Control Protocol，传输控制协议）网络必须连通

面向连接：在数据传输之前，发送端和接收端需要通过三次握手建立连接。这一过程确保了双方都准备好进行数据传输，并且知道对方的存在和状态，为可靠的数据传输奠定基础。例如，当你使用浏览器访问一个网站时，浏览器与网站服务器之间会先建立 TCP 连接，然后才开始传输网页数据.
可靠性高：TCP 协议通过多种机制来确保数据的准确无误传输。它使用确认机制，接收方在收到数据后会向发送方发送确认消息，发送方只有在收到确认后才会继续发送下一部分数据，否则会重传未确认的数据。同时，TCP 还具备重传机制，对于在传输过程中丢失或损坏的数据，发送方会自动重新发送，直到数据被正确接收。此外，流量控制和拥塞控制也是 TCP 保证可靠性的重要手段，它可以根据网络状况和接收方的处理能力，动态调整数据传输的速率，避免网络拥塞导致数据丢失.
数据有序：TCP 会对数据进行编号和排序，确保数据按照发送的顺序到达接收端。即使数据在网络中经过不同的路径传输，到达接收端时也会被正确地重组，保证应用程序能够接收到完整、有序的数据。例如，在文件传输过程中，文件的各个部分会按照顺序依次传输并在接收端正确拼接。
适用于多种应用：由于其可靠性高，TCP 适用于对数据准确性要求严格的应用场景，如文件传输（FTP）、电子邮件（SMTP、POP3 等）、远程登录（Telnet）、网页浏览（HTTP、HTTPS）等，这些应用需要确保数据的完整性和准确性，不容许数据丢失或出错。

UDP（User Datagram Protocol，用户数据报协议）

无连接：UDP 在发送数据之前不需要与接收方建立连接，发送方可以随时向目标地址发送数据报。这使得 UDP 的传输过程更加简单、快速，减少了连接建立和拆除的开销1.
不可靠传输：UDP 不提供数据传输的可靠性保证，它不会对数据进行确认、重传或排序等操作。数据报在网络中可能会出现丢失、重复或乱序的情况，并且 UDP 本身不会对这些问题进行处理，而是由应用层来负责处理数据的可靠性问题。不过，在一些对实时性要求较高但对数据准确性要求相对较低的应用中，这种不可靠性是可以接受的，例如在线游戏中的玩家位置信息更新、视频会议中的语音和视频数据传输等，偶尔丢失一两个数据包不会对整体效果产生太大影响1.
低延迟：由于不需要建立连接和进行复杂的可靠性控制，UDP 的传输延迟相对较低，能够快速地将数据发送到目标地址。这对于实时性要求高的应用非常有利，如音频流、视频流等实时多媒体应用，可以在保证一定流畅度的前提下，尽可能减少延迟1.
高效性：UDP 协议的头部开销较小，只有 8 个字节，相比 TCP 的 20 个字节头部，UDP 可以在相同的网络带宽下传输更多的数据，提高了数据传输的效率1.
适用于特定应用：UDP 常用于一些对实时性和效率要求较高，但对数据可靠性要求相对较低的应用场景，如网络视频会议、在线游戏、音频流播放、实时监控等。例如，在网络视频会议中，即使偶尔丢失一些视频帧，也不会对会议的进行产生严重影响，而较低的延迟可以保证参会者之间的交互更加流畅。

四、网络字节序

1、判断是小端还是大端小权重放到小地址就是小端（小小小）

大端：数据的高位字节存于低地址，低位字节存于高地址。

程序：判断机器是大端还是小端？

#include <stdio.h>
int main() {int num = 0x12345678;char *ptr = (char *)&num;if (*ptr == 0x78) {printf("Little - Endian\n");} else if (*ptr == 0x12) {printf("Big - Endian\n");} else {printf("Error\n");}return 0;
}

2、网络规定都是大端，低地址高字节

五、UDP客户端服务器通信

步骤：1、创建UDP套接字下面为创建套接字的接口 socket

第一个参数表示的是使用的协议家族，域到底是什么，第二个表示定义的套接字类型，流，还是数据报，第三个参数表示协议参数，填0就行

返回值 On success, a file descriptor for the new socket is returned. On error, -1 is returned, and errno is set appropriately.

2、绑定 bind

插入：如何快速地将整数ip转为字符串？比如12345667转为0.0.36.123 ，我们经常用的就是点分十进制，但是我们要知道如何转换。有接口inet_addr

【0，255】.【0，255】.【0，255】.【0，255】

struct ip
{uint8_t part1;  //占一个字节uint8_t part2;uint8_t part3;uint8_t part4;
}
int src_ip=12345678;
struct ip *p=(struct ip*)src_ip; //由于 src_ip 是一个 32 位的整数，而 struct ip 是一个包含四个 uint8_t 类型字段的结构体，直接把 src_ip 赋值给 struct ip 类型的变量是不可能的（类型不兼容）。但是，通过指针，我们可以将 src_ip 的内存解释为 struct ip 类型，并按字节访问它。
to_string(p->part1)+"."+to_string(p->part2)+"."+to_string(p->part3)+"."+to_string(p->part4);就把四字节转换为字符串风格的ip
结果是0.0.3.182

字符串转整数 ”192.168.50.100“ ”192“ ”168“”50“”100“

//192.168.50.100 转换为 123455556
uint32_t Ip; 4个字节
struct ip* x=(struct ip*)&Ip;
x->part1=stoi("192");
x->part2=stoi("168");
x->part3=stoi("50");
x->part4=stoi("100");

查看服务器启动的命令：netstat -nau

一个关于ip

云服务器禁止直接bind公网ip，一个机器可能有多个ip，bind(IP:0),IP为0叫做任意地址绑定凡是发给我这台主机的数据，我们都要根据端口号向上交付。

一个关于port

【0，1023】属于系统内定的端口号，一般都要有固定的应用层协议使用 http:80 https:443 mysql:3306 我们绑定1024以上的

结论：IP地址绑定0，端口号绑定1024以上的

六、程序实现

Log.hpp
#pragma once#include <iostream>
#include <time.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>#define SIZE 1024#define Info 0
#define Debug 1
#define Warning 2
#define Error 3
#define Fatal 4#define Screen 1
#define Onefile 2
#define Classfile 3#define LogFile "log.txt"class Log
{
public:Log(){printMethod = Screen;path = "./log/";}void Enable(int method){printMethod = method;}std::string levelToString(int level){switch (level){case Info:return "Info";case Debug:return "Debug";case Warning:return "Warning";case Error:return "Error";case Fatal:return "Fatal";default:return "None";}}// void logmessage(int level, const char *format, ...)// {//     time_t t = time(nullptr);//     struct tm *ctime = localtime(&t);//     char leftbuffer[SIZE];//     snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d %d:%d:%d]", levelToString(level).c_str(),//              ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday,//              ctime->tm_hour, ctime->tm_min, ctime->tm_sec);//     // va_list s;//     // va_start(s, format);//     char rightbuffer[SIZE];//     vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);//     // va_end(s);//     // 格式：默认部分+自定义部分//     char logtxt[SIZE * 2];//     snprintf(logtxt, sizeof(logtxt), "%s %s\n", leftbuffer, rightbuffer);//     // printf("%s", logtxt); // 暂时打印//     printLog(level, logtxt);// }void printLog(int level, const std::string &logtxt){switch (printMethod){case Screen:std::cout << logtxt << std::endl;break;case Onefile:printOneFile(LogFile, logtxt);break;case Classfile:printClassFile(level, logtxt);break;default:break;}}void printOneFile(const std::string &logname, const std::string &logtxt){std::string _logname = path + logname;int fd = open(_logname.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0666); // "log.txt"if (fd < 0)return;write(fd, logtxt.c_str(), logtxt.size());close(fd);}void printClassFile(int level, const std::string &logtxt){std::string filename = LogFile;filename += ".";filename += levelToString(level); // "log.txt.Debug/Warning/Fatal"printOneFile(filename, logtxt);}~Log(){}void operator()(int level, const char *format, ...){time_t t = time(nullptr);struct tm *ctime = localtime(&t);char leftbuffer[SIZE];snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d %d:%d:%d]", levelToString(level).c_str(),ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday,ctime->tm_hour, ctime->tm_min, ctime->tm_sec);va_list s;va_start(s, format);char rightbuffer[SIZE];vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);va_end(s);// 格式：默认部分+自定义部分char logtxt[SIZE * 2];snprintf(logtxt, sizeof(logtxt), "%s %s", leftbuffer, rightbuffer);// printf("%s", logtxt); // 暂时打印printLog(level, logtxt);}private:int printMethod;std::string path;
};// int sum(int n, ...)
// {
//     va_list s; // char*
//     va_start(s, n);//     int sum = 0;
//     while(n)
//     {
//         sum += va_arg(s, int); // printf("hello %d, hello %s, hello %c, hello %d,", 1, "hello", 'c', 123);
//         n--;
//     }//     va_end(s); //s = NULL
//     return sum;
// }

Main.cc
#include "UdpServer.hpp"
#include <memory>
#include "Log.hpp"
Log log;void Usage(std::string proc)
{std::cout<<"\n\rUsage:"<<proc<<"proc[1024+]"<<std::endl;
}
//./udpserver port
//"192.168.1.123"点分十进制字符串风格的ip地址，一共占了13个字节
int main(int argc,char *argv[])
{if(argc!=2){Usage(argv[0]);exit(0);}uint16_t port=std::stoi(argv[1]);  //字符串转整数std::unique_ptr<UdpServer> svr(new UdpServer());svr->Init();svr->Run();return 0;
}

Makefile
.PHONY:all
all:Udpserver Udpclient
Udpserver:Main.ccg++ -o $@ $^ -std=c++11
Udpclient:UdpClient.ccg++ -o $@ $^ -std=c++11
.PHONY:
clean: rm -f Udpserver Udpclient

Udpclient
#include<iostream>
#include<unistd.h>
#include<cstdlib>
#include<sys/types.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
using namespace std;
void Usage(std::string proc)
{std::cout<<"\n\rUsage:"<<proc<<"serverip serverport"<<std::endl;
}
// ./udpclient serverip serverport 启动客户端的时候，必须要是ip和端口号是是什么
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 sockaddr_in server;bzero(&server, sizeof(server));server.sin_family = AF_INET;server.sin_port = htons(serverport);server.sin_addr.s_addr = inet_addr(serverip.c_str());socklen_t len = sizeof(server);int sockfd=socket(AF_INET,SOCK_DGRAM,0);//client要绑定，要有自己的IP和端口，只不过不需要用户显示的bind,一般由os随机选择！肯定是客户端先向服务器发起请求，端口号能唯一标识客户端就行，随机分配，但是服务器的端口号必须要准确知道，不然客户端绑定哪一个//系统什么时候给我Bind，首次放松数据的时候就绑定，sendtostring message;char buffer[1024];//接收时候的bufferwhile(1){cout<<"Please Enter@";std::getline(cin,message);cout<<message<<endl;//1.数据 2.给谁发 &server 发送给serversendto(sockfd,message.c_str(),message.size(),0,(struct sockaddr*)&server,len);struct sockaddr_in temp;socklen_t len=sizeof(temp);//服务器发消息处理了之后，再给客户端发回来，客户端就要去接收ssize_t s=recvfrom(sockfd,buffer,1023,0,(struct sockaddr*)&temp,&len);  //倒数第二个是谁发的if(s>0){buffer[s]=0;}cout<<buffer<<endl;}close(sockfd);return 0;
};

Udpserver
#pragma once
#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<string.h>
#include<string>
#include<netinet/in.h>
#include<arpa/inet.h>
#include "Log.hpp"
extern Log log;
enum{SOCKET_ERR=1,BIND_ERR=2
};
uint16_t defaultport=8080;
std::string defaultip="0.0.0.0";
const int size=1024;
class UdpServer
{
public:UdpServer(const uint16_t &port=defaultport,const std::string &ip=defaultip):port_(port),sockfd_(0),ip_(ip),isrunning_(false)//一个服务器要启动起来，端口号要有，Ip地址也要有{}void Init(){sockfd_=socket(AF_INET,SOCK_DGRAM,0);//创建套接字if(sockfd_<0){log(Fatal,"socket create error,sockfd:%d",sockfd_);exit(SOCKET_ERR);}printf("socket create success,sockfd:%d\n",sockfd_);log(Info,"socket create success,sockfd:%d",sockfd_);struct sockaddr_in local;bzero(&local,sizeof(local));//把结构体里面的内容全部清零 ,第二个参数是缓冲区的大小local.sin_family=AF_INET;local.sin_port=htons(port_); //我要给你发数据，你必须知道我的端口号，我要把我的端口号发给你，因此端口号是需要在网络中传输的，必须是网络字节序列//local.sin_addr.s_addr=inet_addr(ip_.c_str());  //1.string->uint32_t   将string转char* string.c_str()local.sin_addr.s_addr=INADDR_ANY;//0,任意绑定，因为是全0，主机转网络不需要做bind(sockfd_,(const struct sockaddr *)&local,sizeof(local));}//服务器应该周而复始的运行void Run(){isrunning_=true;char inbuffer[size];while (isrunning_){
//完成一次收和一次发struct sockaddr_in client;//客户端信息socklen_t len =sizeof(client);//从哪个套接字中读,读到的消息放到哪里,读多大，谁给发的，结构体大小ssize_t n=recvfrom(sockfd_,inbuffer,sizeof(inbuffer)-1,0,(sockaddr*)&client,&len);if(n<0){log(Warning,"recvform error");continue;}inbuffer[n]=0;//对字符串进行加工std::string info=inbuffer;std::string echo_string="server echo#"+info;//再把数据发送回给对方 string的长度  string.size//你本地的套接字；发送的字符串和长度；默认为0；输入性参数，我知道对方是谁，因为当时对方给我发过消息sendto(sockfd_,echo_string.c_str(),echo_string.size(),0,(const sockaddr*)&client,len);}}~UdpServer(){if(sockfd_>0)  close(sockfd_);}
private:int sockfd_;//网络文件描述符uint16_t port_; //端口号是两个字节，16个比特位,服务器要有自己的端口号std::string ip_;//任意地址绑定，填为0bool isrunning_;
};

改进版：

Main.cc
#include "UdpServer.hpp"
#include <memory>
#include <cstdio>
#include "Log.hpp"
Log log;void Usage(std::string proc)
{std::cout<<"\n\rUsage:"<<proc<<"proc[1024+]"<<std::endl;
}
std::string Handler(const std::string &str)
{std::string res="Server get a message:";res+=str;return res;//服务器收到消息，回调式的调用你传进来的方法，把数进行加工，加工处理完后返回，最后把这个结果发出去
}
std::string ExecuteCommand(const std::string &cmd)
{// SafeCheck(cmd);FILE* fp=popen(cmd.c_str(),"r");if(nullptr==fp){perror("popen");return "error";}std::string result;//从fp中把命令执行结果都拿出来char buffer[4096];while(true){char * res=fgets(buffer,4096,fp);//读到一行if(nullptr==res) break;result+=buffer;}return result;pclose(fp);
}
//./udpserver port
//"192.168.1.123"点分十进制字符串风格的ip地址，一共占了13个字节
int main(int argc,char *argv[])
{if(argc!=2){Usage(argv[0]);exit(0);}uint16_t port=std::stoi(argv[1]);  //字符串转整数std::unique_ptr<UdpServer> svr(new UdpServer());svr->Init();svr->Run(ExecuteCommand);return 0;
}

Udpserver.hpp
#pragma once
#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<string.h>
#include<string>
#include<netinet/in.h>
#include<arpa/inet.h>
#include <functional>
#include "Log.hpp"
using func_t=std::function<std::string(const std::string&)>; //返回值为string，参数为const std::string&的函数传递给Udpserver
//等价于typedef std::function<std::string(const std::string&)> func_t;
extern Log log;
enum{SOCKET_ERR=1,BIND_ERR=2
};
uint16_t defaultport=8080;
std::string defaultip="0.0.0.0";
const int size=1024;
class UdpServer
{
public:UdpServer(const uint16_t &port=defaultport,const std::string &ip=defaultip):port_(port),sockfd_(0),ip_(ip),isrunning_(false)//一个服务器要启动起来，端口号要有，Ip地址也要有{}void Init(){sockfd_=socket(AF_INET,SOCK_DGRAM,0);//创建套接字if(sockfd_<0){log(Fatal,"socket create error,sockfd:%d",sockfd_);exit(SOCKET_ERR);}printf("socket create success,sockfd:%d\n",sockfd_);log(Info,"socket create success,sockfd:%d",sockfd_);struct sockaddr_in local;bzero(&local,sizeof(local));//把结构体里面的内容全部清零 ,第二个参数是缓冲区的大小local.sin_family=AF_INET;local.sin_port=htons(port_); //我要给你发数据，你必须知道我的端口号，我要把我的端口号发给你，因此端口号是需要在网络中传输的，必须是网络字节序列//local.sin_addr.s_addr=inet_addr(ip_.c_str());  //1.string->uint32_t   将string转char* string.c_str()local.sin_addr.s_addr=INADDR_ANY;//0,任意绑定，因为是全0，主机转网络不需要做bind(sockfd_,(const struct sockaddr *)&local,sizeof(local));}//服务器应该周而复始的运行//这样的好处是实现代码的分层void Run(func_t func)//运行的时候需要用户传进来一个怎么处理数据的方法{isrunning_=true;char inbuffer[size];while (isrunning_){
//完成一次收和一次发struct sockaddr_in client;//客户端信息socklen_t len =sizeof(client);//从哪个套接字中读,读到的消息放到哪里,读多大，谁给发的，结构体大小ssize_t n=recvfrom(sockfd_,inbuffer,sizeof(inbuffer)-1,0,(sockaddr*)&client,&len);if(n<0){log(Warning,"recvform error");continue;}inbuffer[n]=0;std::string info=inbuffer;std::string echo_string =func(info);sendto(sockfd_,echo_string.c_str(),echo_string.size(),0,(const sockaddr*)&client,len);}}~UdpServer(){if(sockfd_>0)  close(sockfd_);}
private:int sockfd_;//网络文件描述符uint16_t port_; //端口号是两个字节，16个比特位,服务器要有自己的端口号std::string ip_;//任意地址绑定，填为0bool isrunning_;
};