一、引入

在上一章【网络编程】socket套接字中我们讲述了TCP/UDP协议，这一篇就是简单实现一个UDP协议的网络服务器。
我们也讲过其实网络通信的本质就是进程间通信。而进程间通信无非就是读和写（IO）。
所以现在我们就要写一个服务端（server）接收数据，客户端（client）发送数据。

二、服务端实现

通过上一章的介绍，要通信首先需要有IP地址，和绑定端口号。

uint16_t _port;
std::string _ip;

2.1 创建套接字socket

在通信之前要先把网卡文件打开。

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>int socket(int domain, int type, int protocol);RETURN VALUE
On success, a file descriptor for the new socket is returned.  
On error, -1 is returned, and errno is set appropriately.

这个函数的作用是打开一个文件，把文件和网卡关联起来。

参数介绍：

domain：一个域，标识了这个套接字的通信类型（网络或者本地）。

只用关注上面两个类，第一个AF_UNIX表示本地通信，而AF_INET表示网络通信。
type：套接字提供服务的类型。

这一章我们讲的式UDP，所以使用SOCK_DGRAM。
protocol：想使用的协议，默认为0即可，因为前面的两个参数决定了，就已经决定了是TCP还是UDP协议了。

返回值：

成功则返回打开的文件描述符（指向网卡文件），失败返回-1。

而从这里我们就联想到系统中的文件操作，未来各种操作都要通过这个文件描述符，所以在服务端类中还需要一个成员变量表示文件描述符。

static const std::string defaultip = "0.0.0.0";// 默认IPclass UDPServer
{
public:UDPServer(const uint16_t& port, const std::string ip = defaultip): _port(port), _ip(ip), _sockfd(-1){}void InitServer(){// 创建套接字_sockfd = socket(AF_INET, SOCK_DGRAM, 0);if(_sockfd == -1){std::cerr << "socket error" << errno << " : " << strerror(errno) << std::endl;exit(1);}}
private:uint16_t _port;std::string _ip;int _sockfd;
};

创建完套接字后我们还需要绑定IP和端口号。

2.2 绑定bind

#include <sys/socket.h>int bind(int socket, const struct sockaddr *address,socklen_t address_len);RETURN VALUE
Upon successful completion, bind() shall return 0; 
otherwise, -1 shall be returned and errno set to indicate the error.

参数介绍：

socket：创建套接字的返回值。
address：通用结构体（上一章【网络编程】socket套接字有详细介绍）。
address_len：传入结构体的长度。

所以我们要先定义一个sockaddr_in结构体填充数据，在传递进去。

struct sockaddr_in {short int sin_family;           // 地址族，一般为AF_INET或PF_INETunsigned short int sin_port;    // 端口号，网络字节序struct in_addr sin_addr;        // IP地址unsigned char sin_zero[8];      // 用于填充，使sizeof(sockaddr_in)等于16
};

创建结构体后要先清空数据（初始化），我们可以用memset，系统也提供了接口：

#include <strings.h>void bzero(void *s, size_t n);

填充端口号的时候要注意端口号是两个字节的数据，涉及到大小端问题。

大小端转化接口：

#include <arpa/inet.h>
// 主机序列转网络序列
uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
// 网络序列转主机序列
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);

对于IP，首先我们要先转成整数，再要解决大小端问题。
系统给了直接能解决这两个问题的接口：

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>int inet_aton(const char *cp, struct in_addr *inp);in_addr_t inet_addr(const char *cp);// 点分十进制字符串in_addr_t inet_network(const char *cp);char *inet_ntoa(struct in_addr in);struct in_addr inet_makeaddr(int net, int host);in_addr_t inet_lnaof(struct in_addr in);in_addr_t inet_netof(struct in_addr in);

这里的inet_addr就是把一个点分十进制的字符串转化成整数再进行大小端处理。

整体代码：

void InitServer()
{// 创建套接字_sockfd = socket(AF_INET, SOCK_DGRAM, 0);if(_sockfd == -1){std::cerr << "socket error" << errno << " : " << strerror(errno) << std::endl;exit(1);}// 绑定IP与portstruct sockaddr_in si;bzero(&si, sizeof si);si.sin_family = AF_INET;// 协议家族si.sin_port = htons(_port);// 端口号,注意大小端问题si.sin_addr.s_addr = inet_addr(_ip.c_str());// ip// 绑定int n = bind(_sockfd, (struct sockaddr*)&si, sizeof si);assert(n != -1);
}

2.3 启动服务器

首先要知道服务器要死循环，永远不退出，除非用户删除。站在操作系统的角度，服务器是常驻内存中的进程。

而我们启动服务器的时候要传递进去IP和端口号。

int main(int argc, char* argv[])
{if(argc != 3){std::cout << "incorrect number of parameters" << std::endl;exit(1);}std::string ip = argv[1];uint16_t port = atoi(argv[2]);std::unique_ptr<UDPServer> ptr(new UDPServer(port, ip));return 0;
}

那么IP该怎么传递呢？

2.4 IP的绑定

这里的127.0.0.1叫做本地环回

它的作用就是用来做服务器代码测试的，意思就是如果我们绑定的IP是127.0.0.1的话，在应用层发送的消息不会进入物理层，也就不会发送出去。

当我们运行起来后想要查看网络情况就可以用指令netstat
后边也可以附带参数：

-a：显示所有连线中的Socket；
-e：显示网络其他相关信息；
-i：显示网络界面信息表单；
-l：显示监控中的服务器的Socket；
-n：直接使用ip地址(数字)，而不通过域名服务器；
-p：显示正在使用Socket的程序识别码和程序名称；
-t：显示TCP传输协议的连线状况；
-u：显示UDP传输协议的连线状况；

那我们如果想要全网通信呢？该用什么IP呢？难道是云服务器上的公网IP吗？

但是我们发现绑定不了。
因为云服务器是虚拟化服务器（不是真实的IP），不能直接绑定公网IP。

既然公网IP邦绑定不了，那么内网IP（局域网IP）呢？


答案是可以，说明这个IP是属于这个服务器的
但是这里不是一个内网的就无法找到。

所以现在的问题是服务器启动后怎么收到信息呢？（消息已经发送到主机，现在要向上交付）
实际上，一款服务器不建议指明一个IP。因为可能服务器有很多IP，如果我们绑定了一个比如说IP1，那么其他进程发送给IP2服务器就收不到了。

这里的INADDR_ANY实际上就是0，这样绑定后，发送到这台主机上所有的数据，只要是访问绑定的端口（8080）的，服务器都能收到。这样就不会因为绑定了一个具体的IP而漏掉其他IP的信息

static const std::string defaultip = "0.0.0.0";// 默认IP

所以现在我们就不需要传递IP了。

2.5 读取数据recvfrom

服务端要获取到用户端发送过来的数据。

#include <sys/types.h>
#include <sys/socket.h>ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,struct sockaddr *src_addr, socklen_t *addrlen);

参数说明：

sockfd：从哪个套接字读。
buf：数据放入的缓冲区。
len：缓冲区长度。
flags：读取方式。 0代表阻塞式读取。
src_addr和addrlen：输出型参数，返回对应的消息内容是从哪一个客户端发出的。第一个是自己定义的结构体，第二个是结构体长度。

void start()
{char buf[1024];while(1){struct sockaddr_in peer;socklen_t len = sizeof peer;sssize_t s = recvfrom(_sockfd, buf, sizeof buf - 1, 0, (struct sockaddr*)&peer, &len);}
}

现在我们想要知道是谁发送过来的消息，信息都被保存到了peer结构体中，我们知道IP信息在peer.sin_addr.s_addr中，首先这是一个网络序列，要转成主机序列，其次为了方便观察，要把它转换成点分十进制。
而这两个操作系统给了一个接口能够解决：

char *inet_ntoa(struct in_addr in);

同样获取端口号的时候也要由网络序列转成主机序列：

uint16_t ntohs(uint16_t netshort);

整体代码：

void start()
{char buf[1024];while(1){struct sockaddr_in peer;socklen_t len = sizeof peer;ssize_t s = recvfrom(_sockfd, buf, sizeof buf - 1, 0, (struct sockaddr*)&peer, &len);if(s > 0){std::string cip = inet_ntoa(peer.sin_addr);uint16_t cport = ntohs(peer.sin_port);std::string msg = buf;std::cout << " [" << cip << "@" << cport << " ]# " << msg << std::endl;}}
}

现在只需要等待用户端发送数据即可。

三、用户端实现

首先我们要发送数据，就得知道客户端的IP和port。
而这里的IP就必须指明。

uint16_t _serverport;
std::string _serverip;
int _sockfd;

这里的IP和port指的是要发送给谁。

创建套接字就跟前面的一样：

// 创建套接字
_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if(_sockfd == -1)
{std::cerr << "socket error" << errno << " : " << strerror(errno) << std::endl;exit(1);
}

3.1 绑定问题

这里的客户端必须绑定IP和端口，来表示主机唯一性和进程唯一性。
但是不需要显示的bind。

那么为什么前面服务端必须显示的绑定port呢？

因为服务器的端口号是众所周知的，不能改变，如果变了就找不到服务器了。

而客户端只需要有就可以，只用标识唯一性即可。
举个例子：

我们手机上有很多的app，而每个服务端是一家公司写的，但是客户端却是多个公司写的。如果我们绑定了特定的端口，万一两个公司都用了同一个端口号呢？这样就直接冲突了。

所以操作系统会自动形成端口进行绑定。（在发送数据的时候自动绑定）
所以创建客户端我们只用创建套接字即可。

void InitClient()
{// 创建套接字_sockfd = socket(AF_INET, SOCK_DGRAM, 0);if(_sockfd == -1){std::cerr << "socket error" << errno << " : " << strerror(errno) << std::endl;exit(1);}
}

3.2 发送数据sendto

#include <sys/types.h>
#include <sys/socket.h>ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,const struct sockaddr *dest_addr, socklen_t addrlen);

这里的参数和上面的recvfrom差不多，而这里的结构体内部我们要自己填充目的IP和目的端口号。

void start()
{struct sockaddr_in si;bzero(&si, sizeof(si));si.sin_family = AF_INET;si.sin_addr.s_addr = inet_addr(_serverip.c_str());si.sin_port = htons(_serverport);std::string msg;while(1){std::cout << "Please input: ";std::cin >> msg;sendto(_sockfd, msg.c_str(), msg.size(), 0, (struct sockaddr*)&si, sizeof si);}
}

当然这里是同一台主机之间测试，如果是不同的机器，我们传递参数的时候就要传递公网IP，例如我们这台云服务器的公网IP是：

我们在运行的时候：

./UDPClient 43.143.106.44 8080

四、源码

// UDPServer.hpp
#pragma once 
#include <iostream>
#include <string>
#include <cerrno>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <strings.h>
#include <netinet/in.h>
#include <string.h>
#include <cassert>
#include <functional>static const std::string defaultip = "0.0.0.0";// 默认IPclass UDPServer
{
public:UDPServer(const uint16_t& port, const std::string ip = defaultip): _port(port), _ip(ip), _sockfd(-1){}void InitServer(){// 创建套接字_sockfd = socket(AF_INET, SOCK_DGRAM, 0);if(_sockfd == -1){std::cerr << "socket error" << errno << " : " << strerror(errno) << std::endl;exit(1);}// 绑定IP与portstruct sockaddr_in si;bzero(&si, sizeof si);si.sin_family = AF_INET;// 协议家族si.sin_port = htons(_port);// 端口号,注意大小端问题// si.sin_addr.s_addr = inet_addr(_ip.c_str());// ipsi.sin_addr.s_addr = INADDR_ANY;// 绑定int n = bind(_sockfd, (struct sockaddr*)&si, sizeof si);assert(n != -1);}void start(){char buf[1024];while(1){struct sockaddr_in peer;socklen_t len = sizeof peer;ssize_t s = recvfrom(_sockfd, buf, sizeof(buf) - 1, 0, (struct sockaddr*)&peer, &len);if(s > 0){buf[s] = 0;// 结尾std::string cip = inet_ntoa(peer.sin_addr);uint16_t cport = ntohs(peer.sin_port);std::string msg = buf;std::cout << "[" << cip << "@" << cport << "]# " << msg << std::endl;}}}
private:uint16_t _port;std::string _ip;int _sockfd;
};// UDPServer.cc
#include "UDPServer.hpp"
#include <memory>int main(int argc, char* argv[])
{if(argc != 2){std::cout << "incorrect number of parameters" << std::endl;exit(1);}uint16_t port = atoi(argv[1]);std::unique_ptr<UDPServer> ptr(new UDPServer(port));ptr->InitServer();ptr->start();return 0;
}// UDPClient.hpp
#pragma once 
#include <iostream>
#include <string>
#include <cerrno>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <strings.h>
#include <netinet/in.h>
#include <string.h>
#include <cassert>class UDPClient
{
public:UDPClient(const std::string& serverip, const uint16_t& port): _serverip(serverip), _serverport(port), _sockfd(-1){}void InitClient(){// 创建套接字_sockfd = socket(AF_INET, SOCK_DGRAM, 0);if(_sockfd == -1){std::cerr << "socket error" << errno << " : " << strerror(errno) << std::endl;exit(1);}}void start(){struct sockaddr_in si;bzero(&si, sizeof(si));si.sin_family = AF_INET;si.sin_addr.s_addr = inet_addr(_serverip.c_str());si.sin_port = htons(_serverport);std::string msg;while(1){std::cout << "Please input: ";std::cin >> msg;sendto(_sockfd, msg.c_str(), msg.size(), 0, (struct sockaddr*)&si, sizeof si);}}
private:uint16_t _serverport;std::string _serverip;int _sockfd;
};// UDPClient.cc
#include "UDPClient.hpp"
#include <memory>int main(int argc, char* argv[])
{if(argc != 3){std::cout << "incorrect number of parameters" << std::endl;exit(1);}std::string ip = argv[1];uint16_t port = atoi(argv[2]);std::unique_ptr<UDPClient> ptr(new UDPClient(ip, port));ptr->InitClient();ptr->start();return 0;
}

---

---