1 /*
2 * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10 /*
11 * This is a temporary test server for QUIC. It will eventually be replaced
12 * by s_server and removed once we have full QUIC server support.
13 */
14
15 #include <stdio.h>
16 #include <openssl/bio.h>
17 #include <openssl/ssl.h>
18 #include <openssl/err.h>
19 #include "internal/e_os.h"
20 #include "internal/sockets.h"
21 #include "internal/quic_tserver.h"
22 #include "internal/quic_stream_map.h"
23 #include "internal/time.h"
24
25 static BIO *bio_err = NULL;
26
wait_for_activity(QUIC_TSERVER * qtserv)27 static void wait_for_activity(QUIC_TSERVER *qtserv)
28 {
29 fd_set readfds, writefds;
30 fd_set *readfdsp = NULL, *writefdsp = NULL;
31 struct timeval timeout, *timeoutp = NULL;
32 int width;
33 int sock;
34 BIO *bio = ossl_quic_tserver_get0_rbio(qtserv);
35 OSSL_TIME deadline;
36
37 BIO_get_fd(bio, &sock);
38
39 if (ossl_quic_tserver_get_net_read_desired(qtserv)) {
40 readfdsp = &readfds;
41 FD_ZERO(readfdsp);
42 openssl_fdset(sock, readfdsp);
43 }
44
45 if (ossl_quic_tserver_get_net_write_desired(qtserv)) {
46 writefdsp = &writefds;
47 FD_ZERO(writefdsp);
48 openssl_fdset(sock, writefdsp);
49 }
50
51 deadline = ossl_quic_tserver_get_deadline(qtserv);
52
53 if (!ossl_time_is_infinite(deadline)) {
54 timeout = ossl_time_to_timeval(ossl_time_subtract(deadline,
55 ossl_time_now()));
56 timeoutp = &timeout;
57 }
58
59 width = sock + 1;
60
61 if (readfdsp == NULL && writefdsp == NULL && timeoutp == NULL)
62 return;
63
64 select(width, readfdsp, writefdsp, NULL, timeoutp);
65 }
66
67 /* Helper function to create a BIO connected to the server */
create_dgram_bio(int family,const char * hostname,const char * port)68 static BIO *create_dgram_bio(int family, const char *hostname, const char *port)
69 {
70 int sock = -1;
71 BIO_ADDRINFO *res;
72 const BIO_ADDRINFO *ai = NULL;
73 BIO *bio;
74
75 if (BIO_sock_init() != 1)
76 return NULL;
77
78 /*
79 * Lookup IP address info for the server.
80 */
81 if (!BIO_lookup_ex(hostname, port, BIO_LOOKUP_SERVER, family, SOCK_DGRAM,
82 0, &res))
83 return NULL;
84
85 /*
86 * Loop through all the possible addresses for the server and find one
87 * we can create and start listening on
88 */
89 for (ai = res; ai != NULL; ai = BIO_ADDRINFO_next(ai)) {
90 /* Create the UDP socket */
91 sock = BIO_socket(BIO_ADDRINFO_family(ai), SOCK_DGRAM, 0, 0);
92 if (sock == -1)
93 continue;
94
95 /* Start listening on the socket */
96 if (!BIO_listen(sock, BIO_ADDRINFO_address(ai), 0)) {
97 BIO_closesocket(sock);
98 continue;
99 }
100
101 /* Set to non-blocking mode */
102 if (!BIO_socket_nbio(sock, 1)) {
103 BIO_closesocket(sock);
104 continue;
105 }
106
107 break; /* stop searching if we found an addr */
108 }
109
110 /* Free the address information resources we allocated earlier */
111 BIO_ADDRINFO_free(res);
112
113 /* If we didn't bind any sockets, fail */
114 if (ai == NULL)
115 return NULL;
116
117 /* Create a BIO to wrap the socket */
118 bio = BIO_new(BIO_s_datagram());
119 if (bio == NULL) {
120 BIO_closesocket(sock);
121 return NULL;
122 }
123
124 /*
125 * Associate the newly created BIO with the underlying socket. By
126 * passing BIO_CLOSE here the socket will be automatically closed when
127 * the BIO is freed. Alternatively you can use BIO_NOCLOSE, in which
128 * case you must close the socket explicitly when it is no longer
129 * needed.
130 */
131 BIO_set_fd(bio, sock, BIO_CLOSE);
132
133 return bio;
134 }
135
usage(void)136 static void usage(void)
137 {
138 BIO_printf(bio_err, "quicserver [-6][-trace] hostname port certfile keyfile\n");
139 }
140
main(int argc,char * argv[])141 int main(int argc, char *argv[])
142 {
143 QUIC_TSERVER_ARGS tserver_args = {0};
144 QUIC_TSERVER *qtserv = NULL;
145 int ipv6 = 0, trace = 0;
146 int argnext = 1;
147 BIO *bio = NULL;
148 char *hostname, *port, *certfile, *keyfile;
149 int ret = EXIT_FAILURE;
150 unsigned char reqbuf[1024];
151 size_t numbytes, reqbytes = 0;
152 const char reqterm[] = {
153 '\r', '\n', '\r', '\n'
154 };
155 const char *response[] = {
156 "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n<!DOCTYPE html>\n<html>\n<body>Hello world</body>\n</html>\n",
157 "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n<!DOCTYPE html>\n<html>\n<body>Hello again</body>\n</html>\n",
158 "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n<!DOCTYPE html>\n<html>\n<body>Another response</body>\n</html>\n",
159 "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n<!DOCTYPE html>\n<html>\n<body>A message</body>\n</html>\n",
160 };
161 unsigned char alpn[] = { 8, 'h', 't', 't', 'p', '/', '1', '.', '0' };
162 int first = 1;
163 uint64_t streamid;
164 size_t respnum = 0;
165
166 bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
167 if (argc == 0 || bio_err == NULL)
168 goto end2;
169
170 while (argnext < argc) {
171 if (argv[argnext][0] != '-')
172 break;
173 if (strcmp(argv[argnext], "-6") == 0) {
174 ipv6 = 1;
175 } else if(strcmp(argv[argnext], "-trace") == 0) {
176 trace = 1;
177 } else {
178 BIO_printf(bio_err, "Unrecognised argument %s\n", argv[argnext]);
179 usage();
180 goto end2;
181 }
182 argnext++;
183 }
184
185 if (argc - argnext != 4) {
186 usage();
187 goto end2;
188 }
189 hostname = argv[argnext++];
190 port = argv[argnext++];
191 certfile = argv[argnext++];
192 keyfile = argv[argnext++];
193
194 bio = create_dgram_bio(ipv6 ? AF_INET6 : AF_INET, hostname, port);
195 if (bio == NULL || !BIO_up_ref(bio)) {
196 BIO_printf(bio_err, "Unable to create server socket\n");
197 goto end2;
198 }
199
200 tserver_args.libctx = NULL;
201 tserver_args.net_rbio = bio;
202 tserver_args.net_wbio = bio;
203 tserver_args.alpn = alpn;
204 tserver_args.alpnlen = sizeof(alpn);
205 tserver_args.ctx = NULL;
206
207 qtserv = ossl_quic_tserver_new(&tserver_args, certfile, keyfile);
208 if (qtserv == NULL) {
209 BIO_printf(bio_err, "Failed to create the QUIC_TSERVER\n");
210 goto end;
211 }
212
213 BIO_printf(bio_err, "Starting quicserver\n");
214 BIO_printf(bio_err,
215 "Note that this utility will be removed in a future OpenSSL version.\n");
216 BIO_printf(bio_err,
217 "For test purposes only. Not for use in a production environment.\n");
218
219 /* Ownership of the BIO is passed to qtserv */
220 bio = NULL;
221
222 if (trace)
223 #ifndef OPENSSL_NO_SSL_TRACE
224 ossl_quic_tserver_set_msg_callback(qtserv, SSL_trace, bio_err);
225 #else
226 BIO_printf(bio_err,
227 "Warning: -trace specified but no SSL tracing support present\n");
228 #endif
229
230 /* Wait for handshake to complete */
231 ossl_quic_tserver_tick(qtserv);
232 while(!ossl_quic_tserver_is_handshake_confirmed(qtserv)) {
233 wait_for_activity(qtserv);
234 ossl_quic_tserver_tick(qtserv);
235 if (ossl_quic_tserver_is_terminated(qtserv)) {
236 BIO_printf(bio_err, "Failed waiting for handshake completion\n");
237 ret = EXIT_FAILURE;
238 goto end;
239 }
240 }
241
242 for (;; respnum++) {
243 if (respnum >= OSSL_NELEM(response))
244 goto end;
245 /* Wait for an incoming stream */
246 do {
247 streamid = ossl_quic_tserver_pop_incoming_stream(qtserv);
248 if (streamid == UINT64_MAX)
249 wait_for_activity(qtserv);
250 ossl_quic_tserver_tick(qtserv);
251 if (ossl_quic_tserver_is_terminated(qtserv)) {
252 /* Assume we finished everything the clients wants from us */
253 ret = EXIT_SUCCESS;
254 goto end;
255 }
256 } while(streamid == UINT64_MAX);
257
258 /* Read the request */
259 do {
260 if (first)
261 first = 0;
262 else
263 wait_for_activity(qtserv);
264
265 ossl_quic_tserver_tick(qtserv);
266 if (ossl_quic_tserver_is_terminated(qtserv)) {
267 BIO_printf(bio_err, "Failed reading request\n");
268 ret = EXIT_FAILURE;
269 goto end;
270 }
271
272 if (ossl_quic_tserver_read(qtserv, streamid, reqbuf + reqbytes,
273 sizeof(reqbuf) - reqbytes,
274 &numbytes)) {
275 if (numbytes > 0)
276 fwrite(reqbuf + reqbytes, 1, numbytes, stdout);
277 reqbytes += numbytes;
278 }
279 } while (reqbytes < sizeof(reqterm)
280 || memcmp(reqbuf + reqbytes - sizeof(reqterm), reqterm,
281 sizeof(reqterm)) != 0);
282
283 if ((streamid & QUIC_STREAM_DIR_UNI) != 0) {
284 /*
285 * Incoming stream was uni-directional. Create a server initiated
286 * uni-directional stream for the response.
287 */
288 if (!ossl_quic_tserver_stream_new(qtserv, 1, &streamid)) {
289 BIO_printf(bio_err, "Failed creating response stream\n");
290 goto end;
291 }
292 }
293
294 /* Send the response */
295
296 ossl_quic_tserver_tick(qtserv);
297 if (!ossl_quic_tserver_write(qtserv, streamid,
298 (unsigned char *)response[respnum],
299 strlen(response[respnum]), &numbytes))
300 goto end;
301
302 if (!ossl_quic_tserver_conclude(qtserv, streamid))
303 goto end;
304 }
305
306 end:
307 /* Free twice because we did an up-ref */
308 BIO_free(bio);
309 end2:
310 BIO_free(bio);
311 ossl_quic_tserver_free(qtserv);
312 BIO_free(bio_err);
313 return ret;
314 }
315
