socket的创建和连接 - Vafail的个人博客

网络编程基本流程#

网络编程的基本流程对于服务端是这样的
服务端
1）socket----创建socket对象。

2）bind----绑定本机ip+port。

3）listen----监听来电，若在监听到来电，则建立起连接。

4）accept----再创建一个socket对象给其收发消息。原因是现实中服务端都是面对多个客户端，那么为了区分各个客户端，则每个客户端都需再分配一个socket对象进行收发消息。

5）read、write----就是收发消息了。

对于客户端是这样的
客户端
1）socket----创建socket对象。

2）connect----根据服务端ip+port，发起连接请求。

3）write、read----建立连接后，就可发收消息了。

终端节点的创建#

所谓终端节点就是用来通信的端对端的节点，可以通过ip地址和端口构造，其的节点可以连接这个终端节点做通信.
如果我们是客户端，我们可以通过对端的ip和端口构造一个endpoint，用这个endpoint和其通信。

1
int  client_end_point() {
2
    // Step 1. Assume that the client application has already
3
    // obtained the IP-address and the protocol port number.
4
    std::string raw_ip_address = "127.0.0.1";
5
    unsigned short port_num = 3333;
6

7
    // Used to store information about error that happens
8
    // while parsing the raw IP-address.
9
    boost::system::error_code ec;
10
    // Step 2. Using IP protocol version independent address
11
    // representation.
12
    asio::ip::address ip_address =
13
        asio::ip::address::from_string(raw_ip_address, ec);
14

15
    if (ec.value() != 0) {
16
        // Provided IP address is invalid. Breaking execution.
17
        std::cout
18
            << "Failed to parse the IP address. Error code = "
19
            << ec.value() << ". Message: " << ec.message();
20
        return ec.value();
21
    }
22

23
    // Step 3.
24
    asio::ip::tcp::endpoint ep(ip_address, port_num);
25

26
    // Step 4. The endpoint is ready and can be used to specify a
27
    // particular server in the network the client wants to
28
    // communicate with.
29

30
    return 0;
31
}

如果是服务端，则只需根据本地地址绑定就可以生成endpoint

1
int  server_end_point(){
2
    // Step 1. Here we assume that the server application has
3
    //already obtained the protocol port number.
4
    unsigned short port_num = 3333;
5

6
    // Step 2. Create special object of asio::ip::address class
7
    // that specifies all IP-addresses available on the host. Note
8
    // that here we assume that server works over IPv6 protocol.
9
    asio::ip::address ip_address = asio::ip::address_v6::any();
10

11
    // Step 3.
12
    asio::ip::tcp::endpoint ep(ip_address, port_num);
13

14
    // Step 4. The endpoint is created and can be used to
15
    // specify the IP addresses and a port number on which
16
    // the server application wants to listen for incoming
17
    // connections.
18

19
    return 0;
20
}

创建socket#

创建socket分为4步，创建上下文iocontext，选择协议，生成socket，打开socket。

1
int create_tcp_socket() {
2
    // Step 1. An instance of 'io_service' class is required by
3
            // socket constructor.
4
    asio::io_context  ios;
5

6
    // Step 2. Creating an object of 'tcp' class representing
7
    // a TCP protocol with IPv4 as underlying protocol.
8
    asio::ip::tcp protocol = asio::ip::tcp::v4();
9

10
    // Step 3. Instantiating an active TCP socket object.
11
    asio::ip::tcp::socket sock(ios);
12

13
    // Used to store information about error that happens
14
    // while opening the socket.
15
    boost::system::error_code ec;
16

17
    // Step 4. Opening the socket.
18
    sock.open(protocol, ec);
19

20
    if (ec.value() != 0) {
21
        // Failed to open the socket.
22
        std::cout
23
            << "Failed to open the socket! Error code = "
24
            << ec.value() << ". Message: " << ec.message();
25
        return ec.value();
26
    }
27

28
    return 0;
29
}

上述socket只是通信的socket，如果是服务端，我们还需要生成一个acceptor的socket，用来接收新的连接。

1
int  create_acceptor_socket() {
2
    // Step 1. An instance of 'io_service' class is required by
3
        // socket constructor.
4
    asio::io_context ios;
5

6
    // Step 2. Creating an object of 'tcp' class representing
7
            // a TCP protocol with IPv6 as underlying protocol.
8
    asio::ip::tcp protocol = asio::ip::tcp::v6();
9

10
    // Step 3. Instantiating an acceptor socket object.
11
    asio::ip::tcp::acceptor acceptor(ios);
12

13
    // Used to store information about error that happens
14
    // while opening the acceptor socket.
15
    boost::system::error_code ec;
16

17
    // Step 4. Opening the acceptor socket.
18
    acceptor.open(protocol, ec);
19

20
    if (ec.value() != 0) {
21
        // Failed to open the socket.
22
        std::cout
23
            << "Failed to open the acceptor socket!"
24
            << "Error code = "
25
            << ec.value() << ". Message: " << ec.message();
26
        return ec.value();
27
    }
28

29
    return 0;
30
}

绑定acceptor#

对于acceptor类型的socket，服务器要将其绑定到指定的断点,所有连接这个端点的连接都可以被接收到。

1
int  bind_acceptor_socket() {
2

3
    // Step 1. Here we assume that the server application has
4
        // already obtained the protocol port number.
5
    unsigned short port_num = 3333;
6

7
    // Step 2. Creating an endpoint.
8
    asio::ip::tcp::endpoint ep(asio::ip::address_v4::any(),
9
        port_num);
10

11
    // Used by 'acceptor' class constructor.
12
    asio::io_context  ios;
13

14
    // Step 3. Creating and opening an acceptor socket.
15
    asio::ip::tcp::acceptor acceptor(ios, ep.protocol());
16

17
    boost::system::error_code ec;
18

19
    // Step 4. Binding the acceptor socket.
20
    acceptor.bind(ep, ec);
21

22
    // Handling errors if any.
23
    if (ec.value() != 0) {
24
        // Failed to bind the acceptor socket. Breaking
25
        // execution.
26
        std::cout << "Failed to bind the acceptor socket."
27
            << "Error code = " << ec.value() << ". Message: "
28
            << ec.message();
29

30
        return ec.value();
31
    }
32

33
    return 0;
34
}

连接指定的端点#

作为客户端可以连接服务器指定的端点进行连接

1
int  connect_to_end() {
2
    // Step 1. Assume that the client application has already
3
            // obtained the IP address and protocol port number of the
4
            // target server.
5
    std::string raw_ip_address = "127.0.0.1";
6
    unsigned short port_num = 3333;
7

8
    try {
9
        // Step 2. Creating an endpoint designating
10
        // a target server application.
11
        asio::ip::tcp::endpoint
12
            ep(asio::ip::address::from_string(raw_ip_address),
13
                port_num);
14

15
        asio::io_context ios;
16

17
        // Step 3. Creating and opening a socket.
18
        asio::ip::tcp::socket sock(ios, ep.protocol());
19

20
        // Step 4. Connecting a socket.
21
        sock.connect(ep);
22

23
        // At this point socket 'sock' is connected to
24
        // the server application and can be used
25
        // to send data to or receive data from it.
26
    }
27
    // Overloads of asio::ip::address::from_string() and
28
    // asio::ip::tcp::socket::connect() used here throw
29
    // exceptions in case of error condition.
30
    catch (system::system_error& e) {
31
        std::cout << "Error occured! Error code = " << e.code()
32
            << ". Message: " << e.what();
33

34
        return e.code().value();
35
    }
36
}

服务器接收连接#

当有客户端连接时，服务器需要接收连接

1
int accept_new_connection(){
2
    // The size of the queue containing the pending connection
3
            // requests.
4
    const int BACKLOG_SIZE = 30;
5

6
    // Step 1. Here we assume that the server application has
7
    // already obtained the protocol port number.
8
    unsigned short port_num = 3333;
9

10
    // Step 2. Creating a server endpoint.
11
    asio::ip::tcp::endpoint ep(asio::ip::address_v4::any(),
12
        port_num);
13

14
    asio::io_context  ios;
15

16
    try {
17
        // Step 3. Instantiating and opening an acceptor socket.
18
        asio::ip::tcp::acceptor acceptor(ios, ep.protocol());
19

20
        // Step 4. Binding the acceptor socket to the
21
        // server endpint.
22
        acceptor.bind(ep);
23

24
        // Step 5. Starting to listen for incoming connection
25
        // requests.
26
        acceptor.listen(BACKLOG_SIZE);
27

28
        // Step 6. Creating an active socket.
29
        asio::ip::tcp::socket sock(ios);
30

31
        // Step 7. Processing the next connection request and
32
        // connecting the active socket to the client.
33
        acceptor.accept(sock);
34

35
        // At this point 'sock' socket is connected to
36
        //the client application and can be used to send data to
37
        // or receive data from it.
38
    }
39
    catch (system::system_error& e) {
40
        std::cout << "Error occured! Error code = " << e.code()
41
            << ". Message: " << e.what();
42

43
        return e.code().value();
44
    }
45
}

关于buffer#

任何网络库都有提供buffer的数据结构，所谓buffer就是接收和发送数据时缓存数据的结构。
boost::asio提供了asio::mutable_buffer 和 asio::const_buffer这两个结构，他们是一段连续的空间，首字节存储了后续数据的长度。
asio::mutable_buffer用于写服务，asio::const_buffer用于读服务。但是这两个结构都没有被asio的api直接使用。
对于api的buffer参数，asio提出了MutableBufferSequence和ConstBufferSequence概念，他们是由多个asio::mutable_buffer和asio::const_buffer组成的。也就是说boost::asio为了节省空间，将一部分连续的空间组合起来，作为参数交给api使用。
我们可以理解为MutableBufferSequence的数据结构为std::vectorasio::mutable_buffer

每隔vector存储的都是mutable_buffer的地址，每个mutable_buffer的第一个字节表示数据的长度，后面跟着数据内容。
这么复杂的结构交给用户使用并不合适，所以asio提出了buffer()函数，该函数接收多种形式的字节流，该函数返回asio::mutable_buffers_1 o或者asio::const_buffers_1结构的对象。
如果传递给buffer()的参数是一个只读类型，则函数返回asio::const_buffers_1 类型对象。
如果传递给buffer()的参数是一个可写类型，则返回asio::mutable_buffers_1 类型对象。
asio::const_buffers_1和asio::mutable_buffers_1是asio::mutable_buffer和asio::const_buffer的适配器，提供了符合MutableBufferSequence和ConstBufferSequence概念的接口，所以他们可以作为boost::asio的api函数的参数使用。
简单概括一下，我们可以用buffer()函数生成我们要用的缓存存储数据。
比如boost的发送接口send要求的参数为ConstBufferSequence类型

1
template<typename ConstBufferSequence>
2
std::size_t send(const ConstBufferSequence & buffers);

我们需要将”Hello Word转化为该类型”

1
void use_const_buffer() {
2
    std::string buf = "hello world!";
3
    asio::const_buffer  asio_buf(buf.c_str(), buf.length());
4
    std::vector<asio::const_buffer> buffers_sequence;
5
    buffers_sequence.push_back(asio_buf);
6
}

最终buffers_sequence就是可以传递给发送接口send的类型。但是这太复杂了，可以直接用buffer函数转化为send需要的参数类型

1
void use_buffer_str() {
2
    asio::const_buffers_1 output_buf = asio::buffer("hello world");
3
}

output_buf可以直接传递给该send接口。我们也可以将数组转化为send接受的类型

1
void use_buffer_array(){
2
    const size_t  BUF_SIZE_BYTES = 20;
3
    std::unique_ptr<char[] > buf(new char[BUF_SIZE_BYTES]);
4
    auto input_buf = asio::buffer(static_cast<void*>(buf.get()), BUF_SIZE_BYTES);
5
}

对于流式操作，我们可以用streambuf，将输入输出流和streambuf绑定，可以实现流式输入和输出。

1
void use_stream_buffer() {
2
    asio::streambuf buf;
3

4
    std::ostream output(&buf);
5

6
    // Writing the message to the stream-based buffer.
7
    output << "Message1\nMessage2";
8

9
    // Now we want to read all data from a streambuf
10
    // until '\n' delimiter.
11
    // Instantiate an input stream which uses our
12
    // stream buffer.
13
    std::istream input(&buf);
14

15
    // We'll read data into this string.
16
    std::string message1;
17

18
    std::getline(input, message1);
19

20
    // Now message1 string contains 'Message1'.
21
}