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