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