The asio::ip::tcp::socket class contains another method to read data from the socket synchronously called receive(). There are three overloads of this method. One of them is equivalent to the read_some() method, as described earlier. It has exactly the same signature and provides exactly the same functionality. These methods are synonyms in a sense.

The second overload accepts one additional argument as compared to the read_some() method. Let's take a look at it:

template<
    typename MutableBufferSequence>
std::size_t receive(
    const MutableBufferSequence & buffers,
    socket_base::message_flags flags);

This additional argument is named flags. It can be used to specify a bit mask, representing flags that control the operation. Because these flags are rarely used, we won't consider them in this book. Refer to the Boost.Asio documentation to find out more about this topic.

The third overload is equivalent to the second one, but it doesn't throw exceptions in case of a failure. Instead, the error information is returned by means of an additional output argument of the boost::system::error_code type.

The asio::read() function is the simplest one out of the three. Let's take a look at the declaration of one of its overloads:

template<
    typename SyncReadStream,
    typename MutableBufferSequence>
std::size_t read(
    SyncReadStream & s,
    const MutableBufferSequence & buffers);

This function accepts two arguments. The first of them named s is a reference to an object that satisfies the requirements of the SyncReadStream concept. For a complete list of the requirements, refer to the corresponding Boost.Asio documentation section available at http://www.boost.org/doc/libs/1_58_0/doc/html/boost_asio/reference/SyncReadStream.html. The object of the asio::ip::tcp::socket class that represents a TCP socket satisfies these requirements and, therefore, can be used as the first argument of the function. The second argument named buffers represents a buffer (simple or composite) to which the data will be read from the socket.

In contrast to the socket's read_some() method, which reads some amount of data from the socket to the buffer, the asio::read() function, during a single call, reads data from the socket until the buffer passed to it as an argument is filled or an error occurs. This simplifies reading from the socket and makes the code shorter and cleaner.

This is how our readFromSocket() function from the previous sample would look like if we used the asio::read() function instead of the socket object's read_some() method to read data from the socket:

std::string readFromSocketEnhanced(asio::ip::tcp::socket& sock) {
  const unsigned char MESSAGE_SIZE = 7;
  char buf[MESSAGE_SIZE];

  asio::read(sock, asio::buffer(buf, MESSAGE_SIZE));

  return std::string(buf, MESSAGE_SIZE);
}

In the preceding sample, a call to the asio::read() function will block the thread of execution until exactly 7 bytes are read or an error occurs. The benefits of this approach over the socket's read_some() method are obvious.

The asio::read_until() function provides a way to read data from a socket until a specified pattern is encountered in the data. There are eight overloads of this function. Let's consider one of them:

template<
    typename SyncReadStream,
    typename Allocator>
std::size_t read_until(
    SyncReadStream & s,
    boost::asio::basic_streambuf< Allocator > & b,
    char delim);

This function accepts three arguments. The first of them named s is a reference to an object that satisfies the requirements of the SyncReadStream concept. For a complete list of the requirements, refer to the corresponding Boost.Asio documentation section at http://www.boost.org/doc/libs/1_58_0/doc/html/boost_asio/reference/SyncReadStream.html. The object of the asio::ip::tcp::socket class that represents a TCP socket satisfies these requirements and, therefore, can be used as the first argument of the function.

The second argument named b represents a stream-oriented extensible buffer in which the data will be read. The last argument named delim specifies a delimiter character.

The asio::read_until() function will read data from the s socket to the buffer b until it encounters a character specified by the delim argument in the read portion of the data. When the specified character is encountered, the function returns.

It's important to note that the asio::read_until() function is implemented so that it reads the data from the socket by blocks of variable sizes (internally it uses the socket's read_some() method to read the data). When the function returns, the buffer b may contain some symbols after the delimiter symbol. This may happen if the remote application sends some more data after the delimiter symbol (for example, it may send two messages in a row, each having a delimiter symbol in the end). In other words, when the asio::read_until() function returns successfully, it is guaranteed that the buffer b contains at least one delimiter symbol but may contain more. It is the developer's responsibility to parse the data in the buffer and handle the situation when it contains data after the delimiter symbol.

This is how we will implement our readFromSocket() function if we want to read all the data from a socket until a specific symbol is encountered. Let's assume the message delimiter to be a new line ASCII symbol, :

std::string readFromSocketDelim(asio::ip::tcp::socket& sock) {
  asio::streambuf buf;

  // Synchronously read data from the socket until
  // '
' symbol is encountered.  
  asio::read_until(sock, buf, '
');

  std::string message;

  // Because buffer 'buf' may contain some other data
  // after '
' symbol, we have to parse the buffer and
  // extract only symbols before the delimiter. 
  
  std::istream input_stream(&buf);
  std::getline(input_stream, message);
  return message;
}

This example is quite simple and straightforward. Because buf may contain more symbols after the delimiter symbol, we use the std::getline() function to extract the messages of interest before the delimiter symbol and put them into the message string object, which is then returned to the caller.

The asio::read_at() function provides a way to read data from a socket, starting at a particular offset. Because this function is rarely used, it is beyond the scope of this book. Refer to the corresponding Boost.Asio documentation section for more details about this function and its overloads at http://www.boost.org/doc/libs/1_58_0/doc/html/boost_asio/reference/read_at.html.

The asio::read(), asio::read_until(), and asio::read_at() functions are implemented in a similar way to how the original readFromSocket() function in our sample is implemented by means of several calls to the socket object's read_some() method in a loop until the termination condition is satisfied or an error occurs.