1 // Copyright (c) 2025 Huawei Device Co., Ltd.
2 // Licensed under the Apache License, Version 2.0 (the "License");
3 // you may not use this file except in compliance with the License.
4 // You may obtain a copy of the License at
5 //
6 // http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13
14 #![cfg(all(feature = "async", feature = "tokio_base", feature = "__tls"))]
15
16 mod common;
17
18 use std::convert::Infallible;
19
20 use ylong_http::response::status::StatusCode;
21 use ylong_http_client::async_impl::{Body, Client, Request};
22 use ylong_http_client::{CertVerifier, ServerCerts};
23
24 use crate::common::init_test_work_runtime;
25
server_fn( _req: hyper::Request<hyper::Body>, ) -> Result<hyper::Response<hyper::Body>, Infallible>26 async fn server_fn(
27 _req: hyper::Request<hyper::Body>,
28 ) -> Result<hyper::Response<hyper::Body>, Infallible> {
29 let response = hyper::Response::builder()
30 .status(hyper::StatusCode::OK)
31 .body(hyper::Body::empty())
32 .expect("build hyper response failed");
33 Ok(response)
34 }
35
36 #[test]
37 #[cfg(feature = "http1_1")]
sdv_client_request_http1_verify_true()38 fn sdv_client_request_http1_verify_true() {
39 struct Verifier;
40 impl CertVerifier for Verifier {
41 fn verify(&self, _certs: &ServerCerts) -> bool {
42 true
43 }
44 }
45
46 define_service_handle!(HTTPS;);
47
48 let rt = init_test_work_runtime(4);
49
50 let mut handles_vec = vec![];
51 start_server!(
52 HTTPS;
53 ServerNum: 1,
54 Runtime: rt,
55 Handles: handles_vec,
56 ServeFnName: server_fn,
57 );
58 let handle = handles_vec.pop().expect("No more handles !");
59
60 let client = Client::builder()
61 .cert_verifier(Verifier)
62 .build()
63 .expect("Build Client failed.");
64
65 let request = Request::builder()
66 .url(format!("{}:{}", "127.0.0.1", handle.port).as_str())
67 .version("HTTP/1.1")
68 .method("GET")
69 .body(Body::empty())
70 .expect("Client build Request failed.");
71
72 rt.block_on(async move {
73 let response = client.request(request).await.unwrap();
74 assert_eq!(response.status(), StatusCode::OK);
75 });
76 }
77
78 #[test]
79 #[cfg(feature = "http2")]
sdv_client_request_http2_verify_true()80 fn sdv_client_request_http2_verify_true() {
81 struct Verifier;
82 impl CertVerifier for Verifier {
83 fn verify(&self, _certs: &ServerCerts) -> bool {
84 true
85 }
86 }
87
88 define_service_handle!(HTTPS;);
89
90 let rt = init_test_work_runtime(4);
91
92 let key_path = std::path::PathBuf::from("tests/file/key.pem");
93 let cert_path = std::path::PathBuf::from("tests/file/cert.pem");
94
95 let (tx, rx) = std::sync::mpsc::channel();
96 let server_handle = rt.spawn(async move {
97 let handle = {
98 let mut port = 10000;
99 let listener = loop {
100 let addr = std::net::SocketAddr::from(([127, 0, 0, 1], port));
101 match tokio::net::TcpListener::bind(addr).await {
102 Ok(listener) => break listener,
103 Err(_) => {
104 port += 1;
105 if port == u16::MAX {
106 port = 10000;
107 }
108 continue;
109 }
110 }
111 };
112 let port = listener.local_addr().unwrap().port();
113
114 tokio::spawn(async move {
115 let mut acceptor =
116 openssl::ssl::SslAcceptor::mozilla_intermediate(openssl::ssl::SslMethod::tls())
117 .expect("SslAcceptorBuilder error");
118 acceptor
119 .set_session_id_context(b"test")
120 .expect("Set session id error");
121 acceptor
122 .set_private_key_file(key_path, openssl::ssl::SslFiletype::PEM)
123 .expect("Set private key error");
124 acceptor
125 .set_certificate_chain_file(cert_path)
126 .expect("Set cert error");
127 acceptor.set_alpn_protos(b"\x02h2").unwrap();
128 acceptor.set_alpn_select_callback(|_, client| {
129 openssl::ssl::select_next_proto(b"\x02h2", client)
130 .ok_or(openssl::ssl::AlpnError::NOACK)
131 });
132
133 let acceptor = acceptor.build();
134
135 let (stream, _) = listener.accept().await.expect("TCP listener accept error");
136 let ssl = openssl::ssl::Ssl::new(acceptor.context()).expect("Ssl Error");
137 let mut stream =
138 tokio_openssl::SslStream::new(ssl, stream).expect("SslStream Error");
139 core::pin::Pin::new(&mut stream).accept().await.unwrap();
140
141 hyper::server::conn::Http::new()
142 .serve_connection(stream, hyper::service::service_fn(server_fn))
143 .await
144 });
145
146 TlsHandle { port }
147 };
148 tx.send(handle)
149 .expect("Failed to send the handle to the test thread.");
150 });
151 rt.block_on(server_handle)
152 .expect("Runtime start server coroutine failed");
153 let handle = rx
154 .recv()
155 .expect("Handle send channel (Server-Half) be closed unexpectedly");
156
157 let client = Client::builder()
158 .http2_prior_knowledge()
159 .cert_verifier(Verifier)
160 .build()
161 .expect("Build Client failed.");
162
163 let request = Request::builder()
164 .url(format!("{}:{}", "127.0.0.1", handle.port).as_str())
165 .version("HTTP/2.0")
166 .method("GET")
167 .body(Body::empty())
168 .expect("Client build Request failed.");
169
170 rt.block_on(async move {
171 let response = client.request(request).await.unwrap();
172 assert_eq!(response.status(), StatusCode::OK);
173 });
174 }
175
176 #[test]
177 #[cfg(feature = "http1_1")]
sdv_client_request_http1_verify_false()178 fn sdv_client_request_http1_verify_false() {
179 struct Verifier;
180 impl CertVerifier for Verifier {
181 fn verify(&self, _certs: &ServerCerts) -> bool {
182 false
183 }
184 }
185
186 define_service_handle!(HTTPS;);
187
188 let rt = init_test_work_runtime(4);
189
190 let mut handles_vec = vec![];
191 start_server!(
192 HTTPS;
193 ServerNum: 1,
194 Runtime: rt,
195 Handles: handles_vec,
196 ServeFnName: server_fn,
197 );
198 let handle = handles_vec.pop().expect("No more handles !");
199
200 let client = Client::builder()
201 .cert_verifier(Verifier)
202 .build()
203 .expect("Build Client failed.");
204
205 let request = Request::builder()
206 .url(format!("{}:{}", "127.0.0.1", handle.port).as_str())
207 .version("HTTP/1.1")
208 .method("GET")
209 .body(Body::empty())
210 .expect("Client build Request failed.");
211
212 rt.block_on(async move {
213 let response = client.request(request).await;
214 assert!(response.is_err());
215 });
216 }
217
218 #[test]
219 #[cfg(feature = "http1_1")]
sdv_client_request_http1_verify_true_invalid_cert()220 fn sdv_client_request_http1_verify_true_invalid_cert() {
221 struct Verifier;
222 impl CertVerifier for Verifier {
223 fn verify(&self, _certs: &ServerCerts) -> bool {
224 true
225 }
226 }
227
228 define_service_handle!(HTTPS;);
229
230 let rt = init_test_work_runtime(4);
231
232 let key_path = std::path::PathBuf::from("tests/file/invalid_key.pem");
233 let cert_path = std::path::PathBuf::from("tests/file/invalid_cert.pem");
234
235 let (tx, rx) = std::sync::mpsc::channel();
236 let server_handle = rt.spawn(async move {
237 let handle = start_http_server!(
238 HTTPS ;
239 server_fn ,
240 key_path ,
241 cert_path
242 );
243 tx.send(handle)
244 .expect("Failed to send the handle to the test thread.");
245 });
246 rt.block_on(server_handle)
247 .expect("Runtime start server coroutine failed");
248 let handle = rx
249 .recv()
250 .expect("Handle send channel (Server-Half) be closed unexpectedly");
251
252 let client = Client::builder()
253 .cert_verifier(Verifier)
254 .build()
255 .expect("Build Client failed.");
256
257 let request = Request::builder()
258 .url(format!("{}:{}", "127.0.0.1", handle.port).as_str())
259 .version("HTTP/1.1")
260 .method("GET")
261 .body(Body::empty())
262 .expect("Client build Request failed.");
263
264 rt.block_on(async move {
265 let response = client.request(request).await.unwrap();
266 assert_eq!(response.status(), StatusCode::OK);
267 });
268 }
269