### Daytime.1 - A synchronous TCP daytime client

This tutorial program shows how to use asio to implement a client application with TCP.

We start by including the necessary header files.

    #include <array>
    #include <iostream>
    #include <asio.hpp>

The purpose of this application is to access a daytime service, so we need the user to specify the server.

    using asio::ip::tcp;

    int main(int argc, char* argv[])
    {
      try
      {
        if (argc != 2)
        {
          std::cerr << "Usage: client <host>" << std::endl;
          return 1;
        }

All programs that use asio need to have at least one I/O execution context, such as an io_context object.

        asio::io_context io_context;

We need to turn the server name that was specified as a parameter to the application, into a TCP endpoint. To do this we use an ip::tcp::resolver object.

        tcp::resolver resolver(io_context);

A resolver takes a host name and service name and turns them into a list of endpoints. We perform a resolve call using the name of the server, specified in `argv[1]`, and the name of the service, in this case `"daytime"`.

The list of endpoints is returned using an object of type ip::tcp::resolver::results_type. This object is a range, with begin() and end() member functions that may be used for iterating over the results.

        tcp::resolver::results_type endpoints =
          resolver.resolve(argv[1], "daytime");

Now we create and connect the socket. The list of endpoints obtained above may contain both IPv4 and IPv6 endpoints, so we need to try each of them until we find one that works. This keeps the client program independent of a specific IP version. The asio::connect() function does this for us automatically.

        tcp::socket socket(io_context);
        asio::connect(socket, endpoints);

The connection is open. All we need to do now is read the response from the daytime service.

We use a `std::array` to hold the received data. The asio::buffer() function automatically determines the size of the array to help prevent buffer overruns. Instead of a `std::array`, we could have used a `char []` or `std::vector`.

        for (;;)
        {
          std::array<char, 128> buf;
          std::error_code error;

          size_t len = socket.read_some(asio::buffer(buf), error);

When the server closes the connection, the ip::tcp::socket::read_some() function will exit with the asio::error::eof error, which is how we know to exit the loop.

          if (error == asio::error::eof)
            break; // Connection closed cleanly by peer.
          else if (error)
            throw std::system_error(error); // Some other error.

          std::cout.write(buf.data(), len);
        }

Finally, handle any exceptions that may have been thrown.

      }
      catch (std::exception& e)
      {
        std::cerr << e.what() << std::endl;
      }

See the full source listing

Return to the tutorial index

Next: Daytime.2 - A synchronous TCP daytime server