ceph/src/boost/libs/asio/test/ssl/stream.cpp

   1 //
   2 // stream.cpp
   3 // ~~~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9 //
  10
  11 // Disable autolinking for unit tests.
  12 #if !defined(BOOST_ALL_NO_LIB)
  13 #define BOOST_ALL_NO_LIB 1
  14 #endif // !defined(BOOST_ALL_NO_LIB)
  15
  16 // Test that header file is self-contained.
  17 #include <boost/asio/ssl/stream.hpp>
  18
  19 #include <boost/asio.hpp>
  20 #include <boost/asio/ssl.hpp>
  21 #include "../archetypes/async_result.hpp"
  22 #include "../unit_test.hpp"
  23
  24 //------------------------------------------------------------------------------
  25
  26 // ssl_stream_compile test
  27 // ~~~~~~~~~~~~~~~~~~~~~~~
  28 // The following test checks that all public member functions on the class
  29 // ssl::stream::socket compile and link correctly. Runtime failures are ignored.
  30
  31 namespace ssl_stream_compile {
  32
  33 bool verify_callback(bool, boost::asio::ssl::verify_context&)
  34 {
  35   return false;
  36 }
  37
  38 void handshake_handler(const boost::system::error_code&)
  39 {
  40 }
  41
  42 void buffered_handshake_handler(const boost::system::error_code&, std::size_t)
  43 {
  44 }
  45
  46 void shutdown_handler(const boost::system::error_code&)
  47 {
  48 }
  49
  50 void write_some_handler(const boost::system::error_code&, std::size_t)
  51 {
  52 }
  53
  54 void read_some_handler(const boost::system::error_code&, std::size_t)
  55 {
  56 }
  57
  58 void test()
  59 {
  60   using namespace boost::asio;
  61   namespace ip = boost::asio::ip;
  62
  63   try
  64   {
  65     io_context ioc;
  66     char mutable_char_buffer[128] = "";
  67     const char const_char_buffer[128] = "";
  68     boost::asio::ssl::context context(boost::asio::ssl::context::sslv23);
  69     archetypes::lazy_handler lazy;
  70     boost::system::error_code ec;
  71
  72     // ssl::stream constructors.
  73
  74     ssl::stream<ip::tcp::socket> stream1(ioc, context);
  75     ip::tcp::socket socket1(ioc, ip::tcp::v4());
  76     ssl::stream<ip::tcp::socket&> stream2(socket1, context);
  77
  78     // basic_io_object functions.
  79
  80     ssl::stream<ip::tcp::socket>::executor_type ex = stream1.get_executor();
  81     (void)ex;
  82
  83 #if !defined(BOOST_ASIO_NO_DEPRECATED)
  84     io_context& ioc_ref = stream1.get_io_context();
  85     (void)ioc_ref;
  86
  87     io_context& ioc_ref2 = stream1.get_io_service();
  88     (void)ioc_ref2;
  89 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
  90
  91     // ssl::stream functions.
  92
  93     SSL* ssl1 = stream1.native_handle();
  94     (void)ssl1;
  95
  96     ssl::stream<ip::tcp::socket>::lowest_layer_type& lowest_layer
  97       = stream1.lowest_layer();
  98     (void)lowest_layer;
  99
 100     const ssl::stream<ip::tcp::socket>& stream3 = stream1;
 101     const ssl::stream<ip::tcp::socket>::lowest_layer_type& lowest_layer2
 102       = stream3.lowest_layer();
 103     (void)lowest_layer2;
 104
 105     stream1.set_verify_mode(ssl::verify_none);
 106     stream1.set_verify_mode(ssl::verify_none, ec);
 107
 108     stream1.set_verify_depth(1);
 109     stream1.set_verify_depth(1, ec);
 110
 111     stream1.set_verify_callback(verify_callback);
 112     stream1.set_verify_callback(verify_callback, ec);
 113
 114     stream1.handshake(ssl::stream_base::client);
 115     stream1.handshake(ssl::stream_base::server);
 116     stream1.handshake(ssl::stream_base::client, ec);
 117     stream1.handshake(ssl::stream_base::server, ec);
 118
 119     stream1.handshake(ssl::stream_base::client, buffer(mutable_char_buffer));
 120     stream1.handshake(ssl::stream_base::server, buffer(mutable_char_buffer));
 121     stream1.handshake(ssl::stream_base::client, buffer(const_char_buffer));
 122     stream1.handshake(ssl::stream_base::server, buffer(const_char_buffer));
 123     stream1.handshake(ssl::stream_base::client,
 124         buffer(mutable_char_buffer), ec);
 125     stream1.handshake(ssl::stream_base::server,
 126         buffer(mutable_char_buffer), ec);
 127     stream1.handshake(ssl::stream_base::client,
 128         buffer(const_char_buffer), ec);
 129     stream1.handshake(ssl::stream_base::server,
 130         buffer(const_char_buffer), ec);
 131
 132     stream1.async_handshake(ssl::stream_base::client, handshake_handler);
 133     stream1.async_handshake(ssl::stream_base::server, handshake_handler);
 134     int i1 = stream1.async_handshake(ssl::stream_base::client, lazy);
 135     (void)i1;
 136     int i2 = stream1.async_handshake(ssl::stream_base::server, lazy);
 137     (void)i2;
 138
 139     stream1.async_handshake(ssl::stream_base::client,
 140         buffer(mutable_char_buffer), buffered_handshake_handler);
 141     stream1.async_handshake(ssl::stream_base::server,
 142         buffer(mutable_char_buffer), buffered_handshake_handler);
 143     stream1.async_handshake(ssl::stream_base::client,
 144         buffer(const_char_buffer), buffered_handshake_handler);
 145     stream1.async_handshake(ssl::stream_base::server,
 146         buffer(const_char_buffer), buffered_handshake_handler);
 147     int i3 = stream1.async_handshake(ssl::stream_base::client,
 148         buffer(mutable_char_buffer), lazy);
 149     (void)i3;
 150     int i4 = stream1.async_handshake(ssl::stream_base::server,
 151         buffer(mutable_char_buffer), lazy);
 152     (void)i4;
 153     int i5 = stream1.async_handshake(ssl::stream_base::client,
 154         buffer(const_char_buffer), lazy);
 155     (void)i5;
 156     int i6 = stream1.async_handshake(ssl::stream_base::server,
 157         buffer(const_char_buffer), lazy);
 158     (void)i6;
 159
 160     stream1.shutdown();
 161     stream1.shutdown(ec);
 162
 163     stream1.async_shutdown(shutdown_handler);
 164     int i7 = stream1.async_shutdown(lazy);
 165     (void)i7;
 166
 167     stream1.write_some(buffer(mutable_char_buffer));
 168     stream1.write_some(buffer(const_char_buffer));
 169     stream1.write_some(buffer(mutable_char_buffer), ec);
 170     stream1.write_some(buffer(const_char_buffer), ec);
 171
 172     stream1.async_write_some(buffer(mutable_char_buffer), write_some_handler);
 173     stream1.async_write_some(buffer(const_char_buffer), write_some_handler);
 174     int i8 = stream1.async_write_some(buffer(mutable_char_buffer), lazy);
 175     (void)i8;
 176     int i9 = stream1.async_write_some(buffer(const_char_buffer), lazy);
 177     (void)i9;
 178
 179     stream1.read_some(buffer(mutable_char_buffer));
 180     stream1.read_some(buffer(mutable_char_buffer), ec);
 181
 182     stream1.async_read_some(buffer(mutable_char_buffer), read_some_handler);
 183     int i10 = stream1.async_read_some(buffer(mutable_char_buffer), lazy);
 184     (void)i10;
 185   }
 186   catch (std::exception&)
 187   {
 188   }
 189 }
 190
 191 } // namespace ssl_stream_compile
 192
 193 //------------------------------------------------------------------------------
 194
 195 BOOST_ASIO_TEST_SUITE
 196 (
 197   "ssl/stream",
 198   BOOST_ASIO_TEST_CASE(ssl_stream_compile::test)
 199 )