网络编程的基本流程对于服务端是这样:
服务器:
socket——创建socket对象。
bind——绑定本机ip+port。
listen——监听来电,若在监听到来电,则建立起连接。
accept——再创建一个socket对象给其收发消息。原因是现实中服务端都是面对多个客户端,那么为了区分各个客户端,则每个客户端都需再分配一个socket对象进行收发消息。
read、write——就是收发消息了。消息就是协议,这里通过protobuf来解析。
客户端
socket——创建socket对象。
connect——根据服务端ip+port,发起连接请求。
write、read——建立连接后,就可发收消息了。
图文如下:
接下来按照上述流程,我们用boost::asio逐步介绍。
所谓终端节点就是用来通信的端对端的节点,可以通过ip地址和端口构造,其的节点可以连接这个终端节点做通信。
如果我们是客户端,我们可以通过对端的ip和端口构造一个endpoint,用这个endpoint和其通信。
#include"asio_demo.h"
int32_t BoostAsio::ClientEndPoint(std::string& raw_ip_address) {
//step1:Assume that the client application has already
// obtained the IP-address and the protocol port number.
//std::string raw_ip_address = "127.0.0.1";
uint16_t port_num = 9273;
// Used to store information about error that happens
// while parsing the raw IP-address.
boost::system::error_code ec;
//Step 2. Using IP protocol version independent address
// representation.
boost::asio::ip::address ip_address = boost::asio::ip::address::from_string(raw_ip_address, ec);
if (0 != ec.value()) {
std::cout << "Failed to parse the Ip Adress,error_code = " << ec.value() << " . Message: " << ec.message();
return ec.value();
}
// Step 3.
boost::asio::ip::tcp::endpoint ep(ip_address, port_num);
// Step 4. The endpoint is ready and can be used to specify a
// particular server in the network the client wants to
// communicate with.
}
这段代码是一个使用 Boost.Asio 库创建 TCP 客户端端点的示例。以下是代码中每个步骤的解释:
包含语句: 代码包含了 “asio_demo.h” 头文件。这个头文件可能包含了 Boost.Asio 库的声明和必要的包含。
ClientEndPoint 函数: 这个函数用于使用 Boost.Asio 创建 TCP 客户端端点。这个函数用于使用 Boost.Asio 创建 TCP 客户端端点,并接受一个 IP 地址字符串作为输入参数。
步骤 1: 客户端应用程序假设已经获取了原始 IP 地址(在本例中是 “127.0.0.1”)和端口号(9273),以便与服务器通信。
步骤 2: Boost.Asio 提供了从字符串表示转换为 IP 地址的方法。在这里,它使用 boost::asio::ip::address::from_string 函数将原始 IP 地址字符串转换为 ip::address 对象。error_code 参数用于检查在解析过程中是否发生了错误。
步骤 3: boost::asio::ip::tcp::endpoint 类表示一个端点(IP 地址和端口号),可以用于指定网络中的特定服务器。使用解析后的 IP 地址和端口号创建了 ep 对象。
步骤 4: 此时,ep 对象表示客户端端点,可以用于连接指定的服务器上的 TCP。然而,代码并没有显示实际连接过程或与服务器的任何通信,因此它只是为将来使用而准备端点。
请注意,这段代码似乎是更大程序的一部分,所提供的片段并没有显示客户端实际如何与服务器交互或执行网络通信。Boost.Asio 库通常用于在 C++ 中进行异步网络编程,允许开发人员创建高效和可扩展的网络应用程序。
如果是服务端,则只需根据本地地址绑定就可以生成endpoint:
int32_t BoostAsio::ServerEndPoint(uint16_t& port_num) {
// Step 1. Here we assume that the server application has
//already obtained the protocol port number.
//uint16_t port_num = 9273;
// Step 2. Create special object of asio::ip::address class
// that specifies all IP-addresses available on the host. Note
// that here we assume that server works over IPv6 protocol.
boost::asio::ip::address ip_address = boost::asio::ip::address_v6::any();
//Step 3.
boost::asio::ip::tcp::endpoint ep(ip_address, port_num);
// Step 4. The endpoint is created and can be used to
// specify the IP addresses and a port number on which
// the server application wants to listen for incoming
// connections.
return 0;
}
这段代码是一个使用 Boost.Asio 库创建 TCP 服务器端点的示例。以下是代码中每个步骤的解释:
ServerEndPoint 函数: 这个函数用于使用 Boost.Asio 创建 TCP 服务器端点,并且传入一个端口号作为参数。
步骤 1: 服务器应用程序已经获得了一个协议端口号,并将这个端口号作为参数传递给函数。
步骤 2: 使用 Boost.Asio 的 ip::address_v6::any() 函数创建了一个特殊的 ip::address 对象,表示服务器将监听主机上的所有可用 IPv6 地址。这意味着服务器将监听所有可用的网络接口。
步骤 3: 使用步骤 2 中创建的 IP 地址和传入的端口号,创建了一个 boost::asio::ip::tcp::endpoint 对象 ep,表示服务器端点。
步骤 4: 此时,ep 对象表示一个可以用于监听传入连接请求的 TCP 端点,其 IP 地址为所有可用的 IPv6 地址,而端口号由函数参数 port_num 决定。
最后,函数返回一个值,这里是 0,表示函数执行成功。
总之,这段代码允许你通过传入一个端口号来创建一个服务器端点,然后服务器可以用这个端点在特定的 IP 地址和端口上监听传入的连接请求。
服务器和客户端所用的通信的socket都是一样的。创建socket分为4步:
int32_t BoostAsio::CreateTcpSocket() {
// Step 1. An instance of 'io_service' class is required by
// socket constructor.
boost::asio::io_context context;
// Step 2. Creating an object of 'tcp' class representing
// a TCP protocol with IPv4 as underlying protocol.
boost::asio::ip::tcp protocol = boost::asio::ip::tcp::v4();
// Step 3. Instantiating an active TCP socket object.
boost::asio::ip::tcp::socket sock(context);
// Used to store information about error that happens
// while opening the socket.
boost::system::error_code ec;
// Step 4. Opening the socket.
sock.open(protocol, ec);
if (0 != ec.value()) {
//Failed to open the socket
std::cout << "Failed to open the socket,error_code = " << ec.value() << ". Message: " << ec.message();
return ec.value();
}
return 0;
}
这段代码是使用 Boost.Asio 库创建一个 TCP 套接字的过程,让我们逐步解释:
io_context 创建: 首先,通过创建 boost::asio::io_context 类的实例 context,用于管理异步 I/O 操作。
协议选择: 选择使用 IPv4 的 TCP 协议,这里使用 boost::asio::ip::tcp::v4() 创建 tcp 对象来表示。
创建套接字: 创建了一个 boost::asio::ip::tcp::socket 对象 sock,它代表一个 TCP 套接字。
错误处理对象: 创建一个 boost::system::error_code 对象 ec,用于存储可能在打开套接字时发生的错误信息。
打开套接字: 使用 sock.open(protocol, ec) 打开套接字。如果套接字打开过程中发生错误,会将错误码存储在 ec 中,然后检查 ec 是否非零,如果非零则表示打开套接字失败,输出错误信息。
返回结果: 最后返回一个整数值,表示操作的结果。如果返回值为 0,表示套接字创建并打开成功。
这段代码演示了如何使用 Boost.Asio 库来创建并打开一个 TCP 套接字,并在过程中处理错误情况。这对于进行网络通信的程序非常有用,因为可以通过异步操作来管理网络连接和数据传输。
服务端,我们还需要生成一个acceptor的socket,用来监听接收新来自客户端的连接。
int32_t BoostAsio::CreateAcceptSocket() {
// Step 1. An instance of 'io_service' class is required by
// socket constructor.
boost::asio::io_context context;
// Step 2. Creating an object of 'tcp' class representing
// a TCP protocol with IPv6 as underlying protocol.
boost::asio::ip::tcp protocol = boost::asio::ip::tcp::v6();
// Step 3. Instantiating an acceptor socket object.
boost::asio::ip::tcp::acceptor accept(context);
// Used to store information about error that happens
// while opening the acceptor socket.
boost::system::error_code ec;
// Step 4. Opening the acceptor socket.
accept.open(protocol, ec);
if (0 != ec.value()) {
std::cout << "Failed to open the accept socket!" << " Error code = " << ec.value() << " . Message: " << ec.message();
return ec.value();
}
return 0;
}
这段代码是使用 Boost.Asio 库创建一个监听套接字**(acceptor socket)**的过程,让我们逐步解释:
io_context 创建: 通过创建 boost::asio::io_context 类的实例 context,用于管理异步 I/O 操作。
协议选择: 选择使用 IPv6 的 TCP 协议,这里使用 boost::asio::ip::tcp::v6() 创建 tcp 对象来表示。
创建接收套接字: 创建了一个 boost::asio::ip::tcp::acceptor 对象 accept,它代表一个接收来自客户端连接监听套接字。
错误处理对象: 创建一个 boost::system::error_code 对象 ec,用于存储可能在打开监听套接字时发生的错误信息。
打开接收套接字: 使用 accept.open(protocol, ec) 打开监听套接字。如果在打开过程中发生错误,会将错误码存储在 ec 中,然后检查 ec 是否非零,如果非零则表示打开监听套接字失败,输出错误信息。
返回结果: 最后返回一个整数值,表示操作的结果。如果返回值为 0,表示监听套接字创建并打开成功。
这段代码演示了如何使用 Boost.Asio 库来创建并打开一个监听套接字,用于接受传入的连接请求。监听套接字通常用于服务器端,用于等待客户端的连接。
对于accept类型的socket,服务器要将其绑定到指定的断点,所有连接这个端点的连接都可以被接收到。
int32_t BoostAsio::BindAcceptSocket(uint16_t& port_num) {
// Step 1. Here we assume that the server application has
// already obtained the protocol port number.
// Step 2. Creating an endpoint.
boost::asio::ip::tcp::endpoint ep(boost::asio::ip::address_v4::any(), port_num);
// Used by 'accept' class constructor.
boost::asio::io_context context;
// Step 3. Creating and opening an acceptor socket.
boost::asio::ip::tcp::acceptor accept(context, ep.protocol());
boost::system::error_code ec;
// Step 4. Binding the acceptor socket.
accept.bind(ep, ec);
// Handling errors if any.
if (0 != ec.value()) {
std::cout << "Failed to bind the accept socket!" << "Error code : " << ec.value() << ". Message:" << ec.message();
return ec.value();
}
return 0;
}
这段代码演示了使用 Boost.Asio 库创建创建并绑定一个监听套接字 (acceptor socket) 的过程,让服务器可以监听指定端口号上的连接请求。下面是代码的解释:
创建端点: 通过创建 boost::asio::ip::tcp::endpoint 对象 ep,指定了一个 IP 地址为 boost::asio::ip::address_v4::any(),表示监听所有可用的 IPv4 地址。port_num 则是提前获取到的端口号。
io_context 创建: 创建了 boost::asio::io_context 类的实例 context,用于管理异步 I/O 操作。
创建和打开监听套接字: 使用 boost::asio::ip::tcp::acceptor 对象的构造函数创建了一个监听套接字 accept,并指定了 ep.protocol()(即 IPv4)。
错误处理对象: 创建一个 boost::system::error_code 对象 ec,用于存储可能在绑定监听套接字时发生的错误信息。
绑定监听套接字: 使用 accept.bind(ep, ec) 绑定监听套接字到指定的 IP 地址和端口。如果在绑定过程中发生错误,会将错误码存储在 ec 中,然后检查 ec 是否非零,如果非零则表示绑定监听套接字失败,输出错误信息。
返回结果: 最后返回一个整数值,表示操作的结果。如果返回值为 0,表示监听套接字绑定成功。
这段代码展示了如何使用 Boost.Asio 库创建一个绑定到指定 IP 地址和端口的监听套接字,用于等待客户端的连接请求。
作为客户端可以连接服务器指定的端点**(ip+端口)** 进行连接。
int32_t BoostAsio::ClientConnectServer(std::string& raw_ip_address, uint16_t& port_num) {
// Step 1. Assume that the client application has already
// obtained the IP address and protocol port number of the
// target server.
try {
// Step 2. Creating an endpoint designating
// a target server application.
boost::asio::ip::tcp::endpoint ep(boost::asio::ip::address::from_string(raw_ip_address), port_num);
boost::asio::io_context context;
// Step 3. Creating and opening a socket.
boost::asio::ip::tcp::socket socket(context, ep.protocol());
// Step 4. Connecting a socket.
socket.connect(ep);
// At this point socket 'sock' is connected to
// the server application and can be used
// to send data to or receive data from it.
}
// Overloads of asio::ip::address::from_string() and
// asio::ip::tcp::socket::connect() used here throw
// exceptions in case of error condition.
catch (boost::system::system_error& e) {
std::cout << "Error occured! Error code = " << e.code() << " .Message:" << e.what();
return e.code().value();
}
return 0;
}
这段代码实现了一个客户端连接服务器的过程。下面是代码的解释:
创建端点: 通过使用 boost::asio::ip::address::from_string(raw_ip_address) 将提供的 IP 地址字符串解析为 IP 地址对象,并使用 port_num 作为端口号,创建了一个 boost::asio::ip::tcp::endpoint 对象 ep,该对象指定了要连接的服务器的终端。
io_context 创建: 创建了 boost::asio::io_context 类的实例 context,用于管理异步 I/O 操作。
创建和打开套接字: 使用 boost::asio::ip::tcp::socket 对象的构造函数创建了一个客户端套接字 socket,并指定了 ep.protocol(),即服务器的协议类型。
连接套接字: 使用 socket.connect(ep) 方法来连接服务器。这一步骤将客户端的套接字与服务器的套接字建立连接,从此客户端可以通过该套接字与服务器进行通信。
错误处理: 使用 try-catch 语句来捕获可能发生的异常。如果连接过程中发生错误,会抛出 boost::system::system_error 异常。在 catch 块中,会输出错误信息,包括错误码和错误消息。
返回结果: 最后返回一个整数值,表示操作的结果。如果返回值为 0,表示连接成功。
这段代码用于在客户端创建套接字并连接到服务器,以便与服务器进行数据交换。
当有客户端连接时,服务器需要接收连接:
int32_t BoostAsio::ServerAcceptClientConnect(uint16_t& port_num) {
// The size of the queue containing the pending connection
// requests.
//连接队列
const int BACKLOG_SIZE = 30;
// Step 1. Here we assume that the server application has
// already obtained the protocol port number.
// Step 2. Creating a server endpoint.
boost::asio::ip::tcp::endpoint ep(boost::asio::ip::address_v4::any(), port_num);
boost::asio::io_context context;
try {
// Step 3. Instantiating and opening an acceptor socket.
boost::asio::ip::tcp::acceptor accept(context, ep.protocol());
// Step 4. Binding the acceptor socket to the
// server endpint.
accept.bind(ep);
// Step 5. Starting to listen for incoming connection
// requests.
accept.listen(BACKLOG_SIZE);
// Step 6. Creating an active socket.
boost::asio::ip::tcp::socket socket(context);
// Step 7. Processing the next connection request and
// connecting the active socket to the client.
accept.accept(socket);
// At this point 'sock' socket is connected to
//the client application and can be used to send data to
// or receive data from it.
}
catch (boost::system::system_error& e) {
std::cout << "Error occured! Error code = " << e.code() << ". Message: " << e.what();
return e.code().value();
}
return 0;
}
这段代码实现了服务器接受客户端连接的过程。以下是代码的解释:
连接队列大小: 定义了连接队列中待处理的连接请求的最大数量,通过 const int BACKLOG_SIZE = 30; 定义。
创建服务器端点: 使用 boost::asio::ip::tcp::endpoint 对象创建一个服务器端点对象 ep,使用 boost::asio::ip::address_v4::any() 表示服务器可以绑定到任何可用的 IPv4 地址,同时使用提供的 port_num 作为端口号。
io_context 创建: 创建了 boost::asio::io_context 类的实例 context,用于管理异步 I/O 操作。
实例化和打开接受套接字: 使用 boost::asio::ip::tcp::acceptor 构造函数创建一个接受套接字 accept,并指定协议类型。
绑定接受套接字: 使用 accept.bind(ep) 方法将接受套接字绑定到服务器端点。
开始监听连接请求: 使用 accept.listen(BACKLOG_SIZE) 方法开始监听传入的连接请求,并指定连接队列的大小。
创建活动套接字并处理连接请求: 创建一个活动套接字 socket,并使用 accept.accept(socket) 方法来处理下一个连接请求,并将活动套接字与客户端连接,进行协议传输。
错误处理: 使用 try-catch 语句来捕获可能发生的异常。如果发生错误,会抛出 boost::system::system_error 异常。在 catch 块中,会输出错误信息,包括错误码和错误消息。
返回结果: 最后返回一个整数值,表示操作的结果。如果返回值为 0,表示连接成功。
这段代码用于在服务器端创建接受套接字,绑定端点并开始监听连接请求,然后处理下一个连接请求并与客户端建立连接,以便进行数据交换。
IPv4(Internet Protocol version 4) 和IPv6(Internet Protocol version 6) 是互联网通信中使用的两种不同版本的IP协议,它们有以下主要区别:
地址长度:
地址数量:
地址表示:
地址类型:
协议特性:
包头大小:
部署和过渡:
总体来说,IPv6是为了解决IPv4地址耗尽问题而设计的,它提供了更大的地址空间和更多的功能,逐渐在全球范围内推广和部署。
0.0.0.0地址:
127.0.0.1: