1 //
2 // stream.cpp
3 // ~~~~~~~~~~
4 //
5 // Copyright (c) 2003-2020 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
verify_callback(bool,boost::asio::ssl::verify_context &)33 bool verify_callback(bool, boost::asio::ssl::verify_context&)
34 {
35 return false;
36 }
37
handshake_handler(const boost::system::error_code &)38 void handshake_handler(const boost::system::error_code&)
39 {
40 }
41
buffered_handshake_handler(const boost::system::error_code &,std::size_t)42 void buffered_handshake_handler(const boost::system::error_code&, std::size_t)
43 {
44 }
45
shutdown_handler(const boost::system::error_code &)46 void shutdown_handler(const boost::system::error_code&)
47 {
48 }
49
write_some_handler(const boost::system::error_code &,std::size_t)50 void write_some_handler(const boost::system::error_code&, std::size_t)
51 {
52 }
53
read_some_handler(const boost::system::error_code &,std::size_t)54 void read_some_handler(const boost::system::error_code&, std::size_t)
55 {
56 }
57
test()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 #if defined(BOOST_ASIO_HAS_MOVE)
79 ssl::stream<ip::tcp::socket> stream3
80 = ssl::stream<ip::tcp::socket>(ioc, context);
81 ssl::stream<ip::tcp::socket> stream4(std::move(stream3));
82 #endif // defined(BOOST_ASIO_HAS_MOVE)
83
84 // basic_io_object functions.
85
86 ssl::stream<ip::tcp::socket>::executor_type ex = stream1.get_executor();
87 (void)ex;
88
89 // ssl::stream functions.
90
91 SSL* ssl1 = stream1.native_handle();
92 (void)ssl1;
93
94 ssl::stream<ip::tcp::socket>::lowest_layer_type& lowest_layer
95 = stream1.lowest_layer();
96 (void)lowest_layer;
97
98 const ssl::stream<ip::tcp::socket>& stream5 = stream1;
99 const ssl::stream<ip::tcp::socket>::lowest_layer_type& lowest_layer2
100 = stream5.lowest_layer();
101 (void)lowest_layer2;
102
103 stream1.set_verify_mode(ssl::verify_none);
104 stream1.set_verify_mode(ssl::verify_none, ec);
105
106 stream1.set_verify_depth(1);
107 stream1.set_verify_depth(1, ec);
108
109 stream1.set_verify_callback(verify_callback);
110 stream1.set_verify_callback(verify_callback, ec);
111
112 stream1.handshake(ssl::stream_base::client);
113 stream1.handshake(ssl::stream_base::server);
114 stream1.handshake(ssl::stream_base::client, ec);
115 stream1.handshake(ssl::stream_base::server, ec);
116
117 stream1.handshake(ssl::stream_base::client, buffer(mutable_char_buffer));
118 stream1.handshake(ssl::stream_base::server, buffer(mutable_char_buffer));
119 stream1.handshake(ssl::stream_base::client, buffer(const_char_buffer));
120 stream1.handshake(ssl::stream_base::server, buffer(const_char_buffer));
121 stream1.handshake(ssl::stream_base::client,
122 buffer(mutable_char_buffer), ec);
123 stream1.handshake(ssl::stream_base::server,
124 buffer(mutable_char_buffer), ec);
125 stream1.handshake(ssl::stream_base::client,
126 buffer(const_char_buffer), ec);
127 stream1.handshake(ssl::stream_base::server,
128 buffer(const_char_buffer), ec);
129
130 stream1.async_handshake(ssl::stream_base::client, handshake_handler);
131 stream1.async_handshake(ssl::stream_base::server, handshake_handler);
132 int i1 = stream1.async_handshake(ssl::stream_base::client, lazy);
133 (void)i1;
134 int i2 = stream1.async_handshake(ssl::stream_base::server, lazy);
135 (void)i2;
136
137 stream1.async_handshake(ssl::stream_base::client,
138 buffer(mutable_char_buffer), buffered_handshake_handler);
139 stream1.async_handshake(ssl::stream_base::server,
140 buffer(mutable_char_buffer), buffered_handshake_handler);
141 stream1.async_handshake(ssl::stream_base::client,
142 buffer(const_char_buffer), buffered_handshake_handler);
143 stream1.async_handshake(ssl::stream_base::server,
144 buffer(const_char_buffer), buffered_handshake_handler);
145 int i3 = stream1.async_handshake(ssl::stream_base::client,
146 buffer(mutable_char_buffer), lazy);
147 (void)i3;
148 int i4 = stream1.async_handshake(ssl::stream_base::server,
149 buffer(mutable_char_buffer), lazy);
150 (void)i4;
151 int i5 = stream1.async_handshake(ssl::stream_base::client,
152 buffer(const_char_buffer), lazy);
153 (void)i5;
154 int i6 = stream1.async_handshake(ssl::stream_base::server,
155 buffer(const_char_buffer), lazy);
156 (void)i6;
157
158 stream1.shutdown();
159 stream1.shutdown(ec);
160
161 stream1.async_shutdown(shutdown_handler);
162 int i7 = stream1.async_shutdown(lazy);
163 (void)i7;
164
165 stream1.write_some(buffer(mutable_char_buffer));
166 stream1.write_some(buffer(const_char_buffer));
167 stream1.write_some(buffer(mutable_char_buffer), ec);
168 stream1.write_some(buffer(const_char_buffer), ec);
169
170 stream1.async_write_some(buffer(mutable_char_buffer), write_some_handler);
171 stream1.async_write_some(buffer(const_char_buffer), write_some_handler);
172 int i8 = stream1.async_write_some(buffer(mutable_char_buffer), lazy);
173 (void)i8;
174 int i9 = stream1.async_write_some(buffer(const_char_buffer), lazy);
175 (void)i9;
176
177 stream1.read_some(buffer(mutable_char_buffer));
178 stream1.read_some(buffer(mutable_char_buffer), ec);
179
180 stream1.async_read_some(buffer(mutable_char_buffer), read_some_handler);
181 int i10 = stream1.async_read_some(buffer(mutable_char_buffer), lazy);
182 (void)i10;
183 }
184 catch (std::exception&)
185 {
186 }
187 }
188
189 } // namespace ssl_stream_compile
190
191 //------------------------------------------------------------------------------
192
193 BOOST_ASIO_TEST_SUITE
194 (
195 "ssl/stream",
196 BOOST_ASIO_TEST_CASE(ssl_stream_compile::test)
197 )
198