SNode.C
Loading...
Searching...
No Matches
clients.h
Go to the documentation of this file.
1/*
2 * SNode.C - A Slim Toolkit for Network Communication
3 * Copyright (C) Volker Christian <me@vchrist.at>
4 * 2020, 2021, 2022, 2023, 2024, 2025
5 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU Lesser General Public License as published
8 * by the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20/*
21 * MIT License
22 *
23 * Permission is hereby granted, free of charge, to any person obtaining a copy
24 * of this software and associated documentation files (the "Software"), to deal
25 * in the Software without restriction, including without limitation the rights
26 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
27 * copies of the Software, and to permit persons to whom the Software is
28 * furnished to do so, subject to the following conditions:
29 *
30 * The above copyright notice and this permission notice shall be included in
31 * all copies or substantial portions of the Software.
32 *
33 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
34 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
35 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
36 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
37 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
38 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
39 * THE SOFTWARE.
40 */
41
42#ifndef APPS_HTTP_MODEL_CLIENTS_H
43#define APPS_HTTP_MODEL_CLIENTS_H
44
45#define QUOTE_INCLUDE(a) STR_INCLUDE(a)
46#define STR_INCLUDE(a) #a
47
48// clang-format off
49#define CLIENT_INCLUDE QUOTE_INCLUDE(web/http/STREAM/NET/Client.h)
50
51#define EVENTSOURCE_INCLUDE QUOTE_INCLUDE(web/http/STREAM/NET/EventSource.h)
52
53// clang-format on
54
55#include CLIENT_INCLUDE // IWYU pragma: export
56#include EVENTSOURCE_INCLUDE // IWYU pragma: export
57
58#ifndef DOXYGEN_SHOULD_SKIP_THIS
59
60#include "log/Logger.h"
61#include "web/http/http_utils.h"
62
63#if (STREAM_TYPE == TLS) // tls
64#include <cstddef>
65#include <openssl/ssl.h>
66#include <openssl/x509v3.h>
67#endif
68
69#endif /* DOXYGEN_SHOULD_SKIP_THIS */
70
71static void logResponse(const std::shared_ptr<web::http::client::Request>& req, const std::shared_ptr<web::http::client::Response>& res) {
72 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName() << " HTTP response: " << req->method << " " << req->url
73 << " HTTP/" << req->httpMajor << "." << req->httpMinor << "\n"
74 << httputils::toString(req->method,
75 req->url,
76 "HTTP/" + std::to_string(req->httpMajor) + "." + std::to_string(req->httpMinor),
77 req->getQueries(),
78 req->getHeaders(),
79 req->getTrailer(),
80 req->getCookies(),
81 {})
82 << "\n"
83 << httputils::toString(res->httpVersion, res->statusCode, res->reason, res->headers, res->cookies, res->body);
84}
85
86#if (STREAM_TYPE == LEGACY) // legacy
87
88namespace apps::http::legacy {
89
90 using Client = web::http::legacy::NET::Client;
91 using MasterRequest = Client::MasterRequest;
92 using Request = Client::Request;
93 using Response = Client::Response;
94 using SocketConnection = Client::SocketConnection;
95
96 inline Client getClient() {
97 Client client(
98 "httpclient",
99 [](const std::shared_ptr<MasterRequest>& req) {
100 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName() << ": OnRequestStart";
101
102 req->httpMajor = 1;
103 req->httpMinor = 1;
104 req->url = "/";
105 req->set("Connection", "keep-alive");
106 req->setTrailer("MyTrailer",
107 "MyTrailerValue"); // The "Trailer" header field should be populated but the Trailer itself should not be
108 // send here because there is no content which is send using "Transfer-Encoding:chunked"
109 req->end(
110 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
111 logResponse(req, res);
112 },
113 [](const std::shared_ptr<Request>&, const std::string&) {
114 });
115
116 req->httpMinor = 1;
117 req->method = "GET";
118 req->url = "/sendfile/";
119 req->set("Connection", "keep-alive");
120 req->sendFile(
121 "/home/voc/projects/snodec/snode.c/CMakeLists.tt",
122 [req](int ret) {
123 if (ret == 0) {
124 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName()
125 << " HTTP: Request accepted: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
126 VLOG(1) << " /home/voc/projects/snodec/snode.c/CMakeLists.tt";
127 } else {
128 LOG(ERROR) << req->getSocketContext()->getSocketConnection()->getConnectionName()
129 << " HTTP: Request failed: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
130 PLOG(ERROR) << " /home/voc/projects/snodec/snode.c/CMakeLists.tt";
131 }
132 },
133 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
134 logResponse(req, res);
135 },
136 [](const std::shared_ptr<Request>&, const std::string&) {
137 });
138
139 req->init();
140 req->httpMinor = 1;
141 req->url = "/third";
142 req->set("Connection", "keep-alive");
143 req->setTrailer("MyTrailer",
144 "MyTrailerValue"); // The "Trailer" header field should be populated but the Trailer itself should not be
145 // send here because there is no content which is send using "Transfer-Encoding:chunked"
146 req->end(
147 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
148 logResponse(req, res);
149 },
150 [](const std::shared_ptr<Request>&, const std::string&) {
151 });
152
153#define LONG
154#ifdef LONG
155 req->url = "/";
156 req->set("Connection", "keep-alive");
157 req->end(
158 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
159 logResponse(req, res);
160 },
161 [](const std::shared_ptr<Request>&, const std::string&) {
162 });
163
164 req->httpMinor = 1;
165 req->url = "/index.html";
166 // req->set("Connection", "keep-alive");
167 req->end(
168 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
169 logResponse(req, res);
170 },
171 [](const std::shared_ptr<Request>&, const std::string&) {
172 });
173 req->url = "/";
174 req->set("Connection", "keep-alive");
175 req->end(
176 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
177 logResponse(req, res);
178 },
179 [req](const std::shared_ptr<Request>&, const std::string&) {
180 });
181 req->url = "/index.html";
182 req->set("Connection", "keep-alive");
183 req->end(
184 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
185 logResponse(req, res);
186 },
187 [req](const std::shared_ptr<Request>&, const std::string&) {
188 });
189 req->url = "/";
190 req->set("Connection", "keep-alive");
191 req->end(
192 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
193 logResponse(req, res);
194 },
195 [req](const std::shared_ptr<Request>&, const std::string&) {
196 });
197 req->url = "/index.html";
198 req->set("Connection", "keep-alive");
199 req->end(
200 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
201 logResponse(req, res);
202 },
203 [req](const std::shared_ptr<Request>&, const std::string&) {
204 });
205 req->url = "/";
206 req->set("Connection", "keep-alive");
207 req->end(
208 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
209 logResponse(req, res);
210 },
211 [req](const std::shared_ptr<Request>&, const std::string&) {
212 });
213 req->url = "/index.html";
214 req->set("Connection", "keep-alive");
215 req->end(
216 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
217 logResponse(req, res);
218 },
219 [req](const std::shared_ptr<Request>&, const std::string&) {
220 });
221 req->url = "/";
222 req->set("Connection", "keep-alive");
223 req->end(
224 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
225 logResponse(req, res);
226 },
227 [req](const std::shared_ptr<Request>&, const std::string&) {
228 });
229 req->url = "/index.html";
230 req->set("Connection", "keep-alive");
231 req->end(
232 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
233 logResponse(req, res);
234 },
235 [req](const std::shared_ptr<Request>&, const std::string&) {
236 });
237 req->url = "/";
238 req->set("Connection", "keep-alive");
239 req->end(
240 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
241 logResponse(req, res);
242 },
243 [req](const std::shared_ptr<Request>&, const std::string&) {
244 });
245 req->url = "/index.html";
246 req->set("Connection", "keep-alive");
247 req->end(
248 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
249 logResponse(req, res);
250 },
251 [req](const std::shared_ptr<Request>&, const std::string&) {
252 });
253 req->url = "/";
254 req->set("Connection", "keep-alive");
255 req->end(
256 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
257 logResponse(req, res);
258 },
259 [req](const std::shared_ptr<Request>&, const std::string&) {
260 });
261 req->url = "/index.html";
262 req->set("Connection", "keep-alive");
263 req->end(
264 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
265 logResponse(req, res);
266 },
267 [req](const std::shared_ptr<Request>&, const std::string&) {
268 });
269 req->url = "/";
270 req->set("Connection", "keep-alive");
271 req->end(
272 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
273 logResponse(req, res);
274 },
275 [req](const std::shared_ptr<Request>&, const std::string&) {
276 });
277 req->url = "/index.html";
278 req->set("Connection", "keep-alive");
279 req->end(
280 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
281 logResponse(req, res);
282 },
283 [req](const std::shared_ptr<Request>&, const std::string&) {
284 });
285 req->url = "/";
286 req->set("Connection", "keep-alive");
287 req->end(
288 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
289 logResponse(req, res);
290 },
291 [req](const std::shared_ptr<Request>&, const std::string&) {
292 });
293
294 /*
295 const std::shared_ptr<web::http::client::tools::EventSource> eventStream_1 =
296 web::http::legacy::NET::EventSource("http://localhost:8080/sse");
297 */
298 /*
299 const std::shared_ptr<web::http::client::tools::EventSource> eventStream_1 =
300 web::http::legacy::NET::EventSource("localhost", 8080, "/sse");
301 */
302 /*
303 const std::shared_ptr<web::http::client::tools::EventSource> eventStream_1 =
304 web::http::legacy::NET::EventSource("http://localhost:8080", "/sse");
305 */
306
307 const std::shared_ptr<web::http::client::tools::EventSource> eventStream_1 =
308 web::http::legacy::NET::EventSource("http://" + req->hostFieldValue, "/sse?hihi=3");
309
310 if (eventStream_1) {
311 eventStream_1->onOpen([]() {
312 VLOG(0) << "OnOpen 1";
313 });
314
315 eventStream_1->onError([]() {
316 VLOG(0) << "onError 1";
317 });
318
319 eventStream_1->onMessage([](const web::http::client::tools::EventSource::MessageEvent& message) {
320 VLOG(0) << "OnMessage 1:1: " << message.data;
321 });
322 eventStream_1->onMessage([](const web::http::client::tools::EventSource::MessageEvent& message) {
323 VLOG(0) << "OnMessage 1:2: " << message.data;
324 });
325 eventStream_1->addEventListener("myevent", [](const web::http::client::tools::EventSource::MessageEvent& message) {
326 VLOG(0) << "EventListener for 'myevent' 1:1: " << message.lastEventId << " : " << message.data;
327 });
328 eventStream_1->addEventListener("myevent", [](const web::http::client::tools::EventSource::MessageEvent& message) {
329 VLOG(0) << "EventListener for 'myevent' 1:2: " << message.lastEventId << " : " << message.data;
330 });
331
332 core::timer::Timer::singleshotTimer(
333 [eventStream_1]() {
334 eventStream_1->close();
335 },
336 5);
337 }
338
339 auto eventStream_2 = web::http::legacy::NET::EventSource("http://localhost:8080/sse");
340
341 if (eventStream_2) {
342 eventStream_2->onOpen([]() {
343 VLOG(0) << "OnOpen 2";
344 });
345
346 eventStream_2->onError([]() {
347 VLOG(0) << "onError 2";
348 });
349
350 eventStream_2->onMessage([](const web::http::client::tools::EventSource::MessageEvent& message) {
351 VLOG(0) << "OnMessage 2:1: " << message.data;
352 });
353 eventStream_2->onMessage([](const web::http::client::tools::EventSource::MessageEvent& message) {
354 VLOG(0) << "OnMessage 2:2: " << message.data;
355 });
356 eventStream_2->addEventListener("myevent", [](const web::http::client::tools::EventSource::MessageEvent& message) {
357 VLOG(0) << "EventListener for 'myevent' 2:1: " << message.lastEventId << " : " << message.data;
358 });
359 eventStream_2->addEventListener("myevent", [](const web::http::client::tools::EventSource::MessageEvent& message) {
360 VLOG(0) << "EventListener for 'myevent' 2:2: " << message.lastEventId << " : " << message.data;
361 });
362 }
363
364 /*
365 req->requestEventSource("/sse", [request = std::weak_ptr<MasterRequest>(req)]() -> std::size_t {
366 std::size_t consumed = 0;
367
368 if (!request.expired()) {
369 char message[2048];
370 consumed = request.lock()->getSocketContext()->readFromPeer(message, 2047);
371 message[consumed] = 0;
372
373 std::cout << "Message: " << message;
374 } else {
375 if (!request.expired()) {
376 logResponse(request.lock(), std::shared_ptr<web::http::client::Response>());
377 }
378 }
379
380 return consumed;
381 });
382 */
383
384 /*
385 req->httpMinor = 1;
386 req->method = "GET";
387 req->url = "/";
388 req->set("Test", "aaa");
389 req->setTrailer("MyTrailer1",
390 "MyTrailerValue1"); // Full trailer processing. Header field "Trailer" set and the Trailer itself is also
391 // sent because here content will be sent with "Transfer-Encoding:chunked"
392 req->setTrailer("MyTrailer2", "MyTrailerValue2");
393 req->setTrailer("MyTrailer3", "MyTrailerValue3");
394 req->setTrailer("MyTrailer4", "MyTrailerValue4");
395 req->setTrailer("MyTrailer5", "MyTrailerValue5");
396 req->setTrailer("MyTrailer6", "MyTrailerValue6");
397 req->query("Query1", "QueryValue1");
398 req->query("Query2", "QueryValue2");
399 req->sendFile(
400 "/home/voc/projects/snodec/snode.c/CMakeLists.txt",
401 [req](int ret) {
402 if (ret == 0) {
403 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName()
404 << " HTTP: Request accepted: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
405 VLOG(1) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
406 } else {
407 LOG(ERROR) << req->getSocketContext()->getSocketConnection()->getConnectionName()
408 << " HTTP: Request failed: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
409 PLOG(ERROR) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
410 }
411 },
412 [&req](const std::shared_ptr<Request>& reqa, const std::shared_ptr<Response>& res) {
413 logResponse(reqa, res);
414
415 req->method = "GET";
416 req->url = "/sdfsdf";
417 req->set("Connection", "close");
418 req->set("Test", "bbb");
419 req->sendFile(
420 "/home/voc/projects/snodec/snode.c/CMakeLists.txt",
421 [&req](int ret) {
422 if (ret == 0) {
423 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName()
424 << " HTTP: Request accepted: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
425 VLOG(1) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
426 } else {
427 LOG(ERROR) << req->getSocketContext()->getSocketConnection()->getConnectionName()
428 << " HTTP: Request failed: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
429 PLOG(ERROR) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
430 }
431 },
432 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
433 logResponse(req, res);
434 },
435 [req](const std::shared_ptr<Request>&, const std::string&) {
436 });
437 },
438 [req](const std::shared_ptr<Request>&, const std::string&) {
439 });
440 req->method = "GET";
441 req->url = "/";
442 // req->set("Connection", "close");
443 req->set("Test", "xxx");
444 req->end(
445 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
446 logResponse(req, res);
447 },
448 [req](const std::shared_ptr<Request>&, const std::string&) {
449 });
450 core::EventReceiver::atNextTick([&req]() {
451 req->method = "GET";
452 req->url = "/";
453 req->set("Connection", "keep-alive");
454 req->set("Test", "ddd");
455 req->sendFile(
456 "/home/voc/projects/snodec/snode.c/CMakeLists.txt",
457 [req](int ret) {
458 if (ret == 0) {
459 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName()
460 << " HTTP: Request accepted: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
461 VLOG(1) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
462 } else {
463 LOG(ERROR) << req->getSocketContext()->getSocketConnection()->getConnectionName()
464 << " HTTP: Request failed: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
465 PLOG(ERROR) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
466 }
467 },
468 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
469 logResponse(req, res);
470 },
471 [req](const std::shared_ptr<Request>&, const std::string&) {
472 });
473
474 req->method = "GET";
475 req->url = "/";
476 req->set("Connection", "keep-alive");
477 req->set("Test", "eee");
478 req->setTrailer("MyTrailer1", "MyTrailerValue1");
479 req->setTrailer("MyTrailer2", "MyTrailerValue2");
480 req->sendFile(
481 "/home/voc/projects/snodec/snode.c/CMakeLists.txt",
482 [req](int ret) {
483 if (ret == 0) {
484 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName()
485 << " HTTP: Request accepted: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
486 VLOG(1) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
487 } else {
488 LOG(ERROR) << req->getSocketContext()->getSocketConnection()->getConnectionName()
489 << " HTTP: Request failed: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
490 PLOG(ERROR) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
491 }
492 },
493 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
494 logResponse(req, res);
495 },
496 [req](const std::shared_ptr<Request>&, const std::string&) {
497 });
498 });
499 */
500#endif
501 },
502 []([[maybe_unused]] const std::shared_ptr<Request>& req) {
503 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName() << ": OnRequestEnd";
504 });
505
506 client.setOnConnect([](SocketConnection* socketConnection) { // onConnect
507 VLOG(1) << socketConnection->getConnectionName() << ": OnConnect";
508
509 VLOG(1) << "\tLocal: " << socketConnection->getLocalAddress().toString();
510 VLOG(1) << "\tPeer: " << socketConnection->getRemoteAddress().toString();
511 });
512
513 client.setOnDisconnect([](SocketConnection* socketConnection) { // onDisconnect
514 VLOG(1) << socketConnection->getConnectionName() << ": OnDisconnect";
515
516 VLOG(1) << "\tLocal: " << socketConnection->getLocalAddress().toString();
517 VLOG(1) << "\tPeer: " << socketConnection->getRemoteAddress().toString();
518 });
519
520 return client;
521 }
522
523} // namespace apps::http::legacy
524
525#endif // (STREAM_TYPE == LEGACY) // legacy
526
527#if (STREAM_TYPE == TLS) // tls
528
529namespace apps::http::tls {
530
531 using Client = web::http::tls::NET::Client;
532 using MasterRequest = Client::MasterRequest;
533 using Request = Client::Request;
534 using Response = Client::Response;
535 using SocketConnection = Client::SocketConnection;
536
537 inline Client getClient() {
538 Client client(
539 "httpclient",
540 [](const std::shared_ptr<MasterRequest>& req) {
541 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName() << ": OnRequestStart";
542
543 req->url = "/";
544 req->set("Connection", "keep-alive");
545 req->end(
546 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
547 logResponse(req, res);
548 },
549 [](const std::shared_ptr<Request>&, const std::string&) {
550 });
551 req->url = "/";
552 req->set("Connection", "keep-alive");
553 req->end(
554 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
555 logResponse(req, res);
556 },
557 [](const std::shared_ptr<Request>&, const std::string&) {
558 });
559 req->url = "/index.html";
560 req->set("Connection", "keep-alive");
561 req->end(
562 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
563 logResponse(req, res);
564 },
565 [](const std::shared_ptr<Request>&, const std::string&) {
566 });
567 req->url = "/";
568 req->set("Connection", "keep-alive");
569 req->end(
570 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
571 logResponse(req, res);
572 },
573 [](const std::shared_ptr<Request>&, const std::string&) {
574 });
575 req->url = "/index.html";
576 req->set("Connection", "keep-alive");
577 req->end(
578 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
579 logResponse(req, res);
580 },
581 [](const std::shared_ptr<Request>&, const std::string&) {
582 });
583 req->url = "/";
584 req->set("Connection", "keep-alive");
585 req->end(
586 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
587 logResponse(req, res);
588 },
589 [](const std::shared_ptr<Request>&, const std::string&) {
590 });
591 req->url = "/index.html";
592 req->set("Connection", "keep-alive");
593 req->end(
594 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
595 logResponse(req, res);
596 },
597 [](const std::shared_ptr<Request>&, const std::string&) {
598 });
599 req->url = "/";
600 req->set("Connection", "keep-alive");
601 req->end(
602 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
603 logResponse(req, res);
604 },
605 [](const std::shared_ptr<Request>&, const std::string&) {
606 });
607 req->url = "/index.html";
608 req->set("Connection", "keep-alive");
609 req->end(
610 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
611 logResponse(req, res);
612 },
613 [](const std::shared_ptr<Request>&, const std::string&) {
614 });
615 req->url = "/";
616 req->set("Connection", "keep-alive");
617 req->end(
618 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
619 logResponse(req, res);
620 },
621 [](const std::shared_ptr<Request>&, const std::string&) {
622 });
623 req->url = "/index.html";
624 req->set("Connection", "keep-alive");
625 req->end(
626 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
627 logResponse(req, res);
628 },
629 [](const std::shared_ptr<Request>&, const std::string&) {
630 });
631 req->url = "/";
632 req->set("Connection", "keep-alive");
633 req->end(
634 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
635 logResponse(req, res);
636 },
637 [](const std::shared_ptr<Request>&, const std::string&) {
638 });
639 req->url = "/index.html";
640 req->set("Connection", "keep-alive");
641 req->end(
642 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
643 logResponse(req, res);
644 },
645 [](const std::shared_ptr<Request>&, const std::string&) {
646 });
647 req->url = "/";
648 req->set("Connection", "keep-alive");
649 req->end(
650 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
651 logResponse(req, res);
652 },
653 [](const std::shared_ptr<Request>&, const std::string&) {
654 });
655 req->url = "/index.html";
656 req->set("Connection", "keep-alive");
657 req->end(
658 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
659 logResponse(req, res);
660 },
661 [](const std::shared_ptr<Request>&, const std::string&) {
662 });
663 req->url = "/";
664 req->set("Connection", "keep-alive");
665 req->end(
666 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
667 logResponse(req, res);
668 },
669 [](const std::shared_ptr<Request>&, const std::string&) {
670 });
671 req->url = "/index.html";
672 req->set("Connection", "keep-alive");
673 req->end(
674 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
675 logResponse(req, res);
676 },
677 [](const std::shared_ptr<Request>&, const std::string&) {
678 });
679 req->url = "/";
680 req->set("Connection", "close");
681 req->end(
682 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
683 logResponse(req, res);
684 },
685 [](const std::shared_ptr<Request>&, const std::string&) {
686 });
687 },
688 []([[maybe_unused]] const std::shared_ptr<Request>& req) {
689 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName() << ": OnRequestEnd";
690 });
691
692 client.setOnConnect([](SocketConnection* socketConnection) { // onConnect
693 VLOG(1) << "OnConnect " << socketConnection->getConnectionName();
694
695 VLOG(1) << "\tLocal: " << socketConnection->getLocalAddress().toString();
696 VLOG(1) << "\tPeer: " << socketConnection->getRemoteAddress().toString();
697
698 /* Enable automatic hostname checks */
699 // X509_VERIFY_PARAM* param = SSL_get0_param(socketConnection->getSSL());
700
701 // X509_VERIFY_PARAM_set_hostflags(param, X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
702 // if (!X509_VERIFY_PARAM_set1_host(param, "localhost", sizeof("localhost") - 1)) {
703 // // handle error
704 // socketConnection->close();
705 // }
706 });
707
708 client.setOnConnected([](SocketConnection* socketConnection) { // onConnected
709 VLOG(1) << socketConnection->getConnectionName() << ": OnConnected";
710 X509* server_cert = SSL_get_peer_certificate(socketConnection->getSSL());
711 if (server_cert != nullptr) {
712 long verifyErr = SSL_get_verify_result(socketConnection->getSSL());
713
714 VLOG(1) << "\tPeer certificate verifyErr = " + std::to_string(verifyErr) + ": " +
715 std::string(X509_verify_cert_error_string(verifyErr));
716
717 char* str = X509_NAME_oneline(X509_get_subject_name(server_cert), nullptr, 0);
718 VLOG(1) << "\t Subject: " + std::string(str);
719 OPENSSL_free(str);
720
721 str = X509_NAME_oneline(X509_get_issuer_name(server_cert), nullptr, 0);
722 VLOG(1) << "\t Issuer: " + std::string(str);
723 OPENSSL_free(str);
724
725 // We could do all sorts of certificate verification stuff here before deallocating the certificate.
726
727 GENERAL_NAMES* subjectAltNames =
728 static_cast<GENERAL_NAMES*>(X509_get_ext_d2i(server_cert, NID_subject_alt_name, nullptr, nullptr));
729#ifdef __GNUC__
730#pragma GCC diagnostic push
731#ifdef __has_warning
732#if __has_warning("-Wused-but-marked-unused")
733#pragma GCC diagnostic ignored "-Wused-but-marked-unused"
734#endif
735#endif
736#endif
737 int32_t altNameCount = sk_GENERAL_NAME_num(subjectAltNames);
738#ifdef __GNUC_
739#pragma GCC diagnostic pop
740#endif
741 VLOG(1) << "\t Subject alternative name count: " << altNameCount;
742 for (int32_t i = 0; i < altNameCount; ++i) {
743#ifdef __GNUC__
744#pragma GCC diagnostic push
745#ifdef __has_warning
746#if __has_warning("-Wused-but-marked-unused")
747#pragma GCC diagnostic ignored "-Wused-but-marked-unused"
748#endif
749#endif
750#endif
751 GENERAL_NAME* generalName = sk_GENERAL_NAME_value(subjectAltNames, i);
752#ifdef __GNUC_
753#pragma GCC diagnostic pop
754#endif
755 if (generalName->type == GEN_URI) {
756 std::string subjectAltName =
757 std::string(reinterpret_cast<const char*>(ASN1_STRING_get0_data(generalName->d.uniformResourceIdentifier)),
758 static_cast<std::size_t>(ASN1_STRING_length(generalName->d.uniformResourceIdentifier)));
759 VLOG(1) << "\t SAN (URI): '" + subjectAltName;
760 } else if (generalName->type == GEN_DNS) {
761 std::string subjectAltName =
762 std::string(reinterpret_cast<const char*>(ASN1_STRING_get0_data(generalName->d.dNSName)),
763 static_cast<std::size_t>(ASN1_STRING_length(generalName->d.dNSName)));
764 VLOG(1) << "\t SAN (DNS): '" + subjectAltName;
765 } else {
766 VLOG(1) << "\t SAN (Type): '" + std::to_string(generalName->type);
767 }
768 }
769#ifdef __GNUC__
770#pragma GCC diagnostic push
771#ifdef __has_warning
772#if __has_warning("-Wused-but-marked-unused")
773#pragma GCC diagnostic ignored "-Wused-but-marked-unused"
774#endif
775#endif
776#endif
777 sk_GENERAL_NAME_pop_free(subjectAltNames, GENERAL_NAME_free);
778#ifdef __GNUC_
779#pragma GCC diagnostic pop
780#endif
781 X509_free(server_cert);
782 } else {
783 VLOG(1) << "\tPeer certificate: no certificate";
784 }
785 });
786
787 client.setOnDisconnect([](SocketConnection* socketConnection) { // onDisconnect
788 VLOG(1) << socketConnection->getConnectionName() << ": OnDisconnect";
789
790 VLOG(1) << "\tLocal: " << socketConnection->getLocalAddress().toString();
791 VLOG(1) << "\tPeer: " << socketConnection->getRemoteAddress().toString();
792 });
793
794 return client;
795 }
796
797} // namespace apps::http::tls
798
799#endif // (STREAM_TYPE == TLS) // tls
800
801#endif // APPS_HTTP_MODEL_CLIENTS_H
QUOTE_INCLUDE
#define QUOTE_INCLUDE(a)
Definition clients.h:47
STR_INCLUDE
#define STR_INCLUDE(a)
Definition servers.h:48
logResponse
static void logResponse(const std::shared_ptr< web::http::client::Request > &req, const std::shared_ptr< web::http::client::Response > &res)
Definition clients.h:71
LONG
#define LONG
apps::http::legacy::getClient
Client getClient()
Definition clients.h:96
apps::http::tls::getClient
Client getClient()
Definition clients.h:537
main
int main(int argc, char *argv[])
Definition testmariadb.cpp:60