treewide: avoid 'static sstring' in favor of 'constexpr string_view'

I had problems with fuzzer+address sanitizer `-fsanitize=fuzzer,address`. It worked fine with `SEASTAR_SSTRING` undefined. Enabling `SEASTAR_ASAN_ENABLED` didn't help.

What I gathered is that it was static sstring destructors being called at exit.

IIUC, there is no reason to use `sstring` for static constants, except to avoid copies like in `tls.cc`.
Luckily, it doesn't seem like the `_blobs` map stores any keys that are external to `tls.cc` itself,
which means it should be safe to use `std::string_view` instead.

*   Replaced `extern sstring magic_key_suffix` in the websocket header with `constexpr std::string_view` in the `.cc` file.
*   Replaced `static const sstring` in `tls.cc` with `constexpr std::string_view`.
*   Replaced the `sstring` key in the `credentials_builder::_blobs` map with `std::string_view`.

The Seastar memory allocator + ASAN is quite a complex interaction I can't entirely grasp.
The issue might be deeper and the solution should be different, but this patch seems good to me anyway.

Fixes the following issue:

```
munmap_chunk(): invalid pointer
==350803== ERROR: libFuzzer: deadly signal
    #0 0x560609c161aa in __sanitizer_print_stack_trace (iobuf_fuzz_test+0x1df1aa)
    #1 0x560609b0fc50 in fuzzer::PrintStackTrace() (iobuf_fuzz_test+0xd8c50)
    scylladb#2 0x560609aea8b6 in fuzzer::Fuzzer::CrashCallback() (.part.0) (iobuf_fuzz_test+0xb38b6)
    scylladb#3 0x560609aea97a in fuzzer::Fuzzer::StaticCrashSignalCallback() (iobuf_fuzz_test+0xb397a)
    scylladb#4 0x7f96d4c4146f  (/lib/libc.so.6+0x4146f)
    scylladb#5 0x7f96d4c99cdb in __pthread_kill_implementation (/lib/libc.so.6+0x99cdb)
    scylladb#6 0x7f96d4c413c5 in gsignal (/lib/libc.so.6+0x413c5)
    scylladb#7 0x7f96d4c28939 in abort (/lib/libc.so.6+0x28939)
    scylladb#8 0x7f96d4c299a2 in __libc_message_impl.cold (/lib/libc.so.6+0x299a2)
    scylladb#9 0x7f96d4ca44e6 in malloc_printerr (/lib/libc.so.6+0xa44e6)
    scylladb#10 0x7f96d4ca471b in munmap_chunk (/lib/libc.so.6+0xa471b)
    scylladb#11 0x7f96d4ca91df in cfree@GLIBC_2.2.5 (/lib/libc.so.6+0xa91df)
    scylladb#12 0x7f96d5d5cba7 in seastar::memory::cpu_pages::do_foreign_free(void*) (libseastar.so+0x35cba7)
    scylladb#13 0x7f96d5d5a901 in seastar::basic_sstring<char, unsigned int, 15u, true>::~basic_sstring() (libseastar.so+0x35a901)
    scylladb#14 0x7f96d4c436a8 in __cxa_finalize (/lib/libc.so.6+0x436a8)
    scylladb#15 0x7f96d5cf2516 in __do_global_dtors_aux (libseastar.so+0x2f2516)
```

```
(lldb) rbreak seastar::basic_sstring<.*>::~basic_sstring
(lldb) r
[...]
* thread #1, name = 'iobuf_fuzz_test', stop reason = breakpoint 1.1
    frame #0: 0x00007ffff775a870 libseastar.so`seastar::basic_sstring<char, unsigned int, 15u, true>::~basic_sstring()
libseastar.so`seastar::basic_sstring<char, unsigned int, 15u, true>::~basic_sstring:
->  0x7ffff775a870 <+0>: pushq  %rbp
    0x7ffff775a871 <+1>: movq   %rsp, %rbp
    0x7ffff775a874 <+4>: pushq  %r14
    0x7ffff775a876 <+6>: pushq  %rbx
(lldb) bt
* thread #1, name = 'iobuf_fuzz_test', stop reason = breakpoint 1.1
  * frame #0: 0x00007ffff775a870 libseastar.so`seastar::basic_sstring<char, unsigned int, 15u, true>::~basic_sstring()
    frame #1: 0x00007ffff68436a9 libc.so.6`__cxa_finalize + 361
    frame scylladb#2: 0x00007ffff76f2517 libseastar.so`__do_global_dtors_aux + 39
    frame scylladb#3: 0x00007ffff7fc60f2 ld-linux-x86-64.so.2`_dl_call_fini + 82
    frame scylladb#4: 0x00007ffff7fc946e ld-linux-x86-64.so.2`_dl_fini + 494
    frame scylladb#5: 0x00007ffff6843bf1 libc.so.6`__run_exit_handlers + 433
    frame scylladb#6: 0x00007ffff6843cb0 libc.so.6`exit + 32
    frame scylladb#7: 0x0000555555598567 iobuf_fuzz_test`fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) + 12311
    frame scylladb#8: 0x00005555555d79f3 iobuf_fuzz_test`main + 35
    frame scylladb#9: 0x00007ffff682a47e libc.so.6`__libc_start_call_main + 126
    frame scylladb#10: 0x00007ffff682a539 libc.so.6`__libc_start_main@@GLIBC_2.34 + 137
    frame scylladb#11: 0x0000555555581e25 iobuf_fuzz_test`_start + 37
(lldb) register read rdi
     rdi = 0x00007ffff7a57558  libseastar.so`seastar::experimental::websocket::magic_key_suffix
```

Closes scylladb#3159

Author: crackcomm

include/seastar/net/tls.hh

@@ -350,7 +350,7 @@ namespace tls {
     private:
         friend class reloadable_credentials_base;
 
-        std::multimap<sstring, std::any> _blobs;
+        std::multimap<std::string_view, std::any> _blobs;
         client_auth _client_auth = client_auth::NONE;
         session_resume_mode _session_resume_mode = session_resume_mode::NONE;
         sstring _priority;

include/seastar/websocket/common.hh

@@ -30,8 +30,6 @@
 
 namespace seastar::experimental::websocket {
 
-extern sstring magic_key_suffix;
-
 using handler_t = std::function<future<>(input_stream<char>&, output_stream<char>&)>;
 
 class server;

src/net/tls.cc

@@ -69,6 +69,8 @@ module seastar;
 
 namespace seastar {
 
+using namespace std::string_view_literals;
+
 class net::get_impl {
 public:
     static std::unique_ptr<connected_socket_impl> get(connected_socket s) {
@@ -627,12 +629,12 @@ void tls::server_credentials::set_alpn_protocols(const std::vector<sstring>& pro
     _impl->set_alpn_protocols(protocols);
 }
 
-static const sstring dh_level_key = "dh_level";
-static const sstring x509_trust_key = "x509_trust";
-static const sstring x509_crl_key = "x509_crl";
-static const sstring x509_key_key = "x509_key";
-static const sstring pkcs12_key = "pkcs12";
-static const sstring system_trust = "system_trust";
+constexpr auto dh_level_key = "dh_level"sv;
+constexpr auto x509_trust_key = "x509_trust"sv;
+constexpr auto x509_crl_key = "x509_crl"sv;
+constexpr auto x509_key_key = "x509_key"sv;
+constexpr auto pkcs12_key = "pkcs12"sv;
+constexpr auto system_trust = "system_trust"sv;
 
 using buffer_type = std::basic_string<tls::blob::value_type, tls::blob::traits_type, std::allocator<tls::blob::value_type>>;
 
@@ -744,7 +746,7 @@ void tls::credentials_builder::set_alpn_protocols(const std::vector<sstring>& pr
 
 template<typename Blobs, typename Visitor>
 static void visit_blobs(Blobs& blobs, Visitor&& visitor) {
-    auto visit = [&](const sstring& key, auto* vt) {
+    auto visit = [&](const std::string_view& key, auto* vt) {
         auto tr = blobs.equal_range(key);
         for (auto& p : boost::make_iterator_range(tr.first, tr.second)) {
             auto* v = std::any_cast<std::decay_t<decltype(*vt)>>(&p.second);
@@ -760,17 +762,17 @@ static void visit_blobs(Blobs& blobs, Visitor&& visitor) {
 void tls::credentials_builder::apply_to(certificate_credentials& creds) const {
     // Could potentially be templated down, but why bother...
     visit_blobs(_blobs, make_visitor(
-        [&](const sstring& key, const x509_simple& info) {
+        [&](const std::string_view& key, const x509_simple& info) {
             if (key == x509_trust_key) {
                 creds.set_x509_trust(info.data, info.format);
             } else if (key == x509_crl_key) {
                 creds.set_x509_crl(info.data, info.format);
             }
         },
-        [&](const sstring&, const x509_key& info) {
+        [&](const std::string_view&, const x509_key& info) {
             creds.set_x509_key(info.cert, info.key, info.format);
         },
-        [&](const sstring&, const pkcs12_simple& info) {
+        [&](const std::string_view&, const pkcs12_simple& info) {
             creds.set_simple_pkcs12(info.data, info.format, info.password);
         }
     ));
@@ -842,14 +844,14 @@ class tls::reloadable_credentials_base {
         future<> init() {
             std::vector<future<>> futures;
             visit_blobs(_blobs, make_visitor(
-                [&](const sstring&, const x509_simple& info) {
+                [&](const std::string_view&, const x509_simple& info) {
                     _all_files.emplace(info.file.filename);
                 },
-                [&](const sstring&, const x509_key& info) {
+                [&](const std::string_view&, const x509_key& info) {
                     _all_files.emplace(info.cert_file.filename);
                     _all_files.emplace(info.key_file.filename);
                 },
-                [&](const sstring&, const pkcs12_simple& info) {
+                [&](const std::string_view&, const pkcs12_simple& info) {
                     _all_files.emplace(info.file.filename);
                 }
             ));
@@ -942,14 +944,14 @@ class tls::reloadable_credentials_base {
                 ++num_changed;
             };
             visit_blobs(_blobs, make_visitor(
-                [&](const sstring&, x509_simple& info) {
+                [&](const std::string_view&, x509_simple& info) {
                     maybe_reload(info.file.filename, info.data);
                 },
-                [&](const sstring&, x509_key& info) {
+                [&](const std::string_view&, x509_key& info) {
                     maybe_reload(info.cert_file.filename, info.cert);
                     maybe_reload(info.key_file.filename, info.key);
                 },
-                [&](const sstring&, pkcs12_simple& info) {
+                [&](const std::string_view&, pkcs12_simple& info) {
                     maybe_reload(info.file.filename, info.data);
                 }
             ));

src/websocket/common.cc

@@ -29,7 +29,6 @@
 
 namespace seastar::experimental::websocket {
 
-sstring magic_key_suffix = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 logger websocket_logger("websocket");
 
 future<> connection::handle_ping() {

src/websocket/server.cc

@@ -28,12 +28,15 @@
 
 namespace seastar::experimental::websocket {
 
-static sstring http_upgrade_reply_template =
+using namespace std::string_view_literals;
+
+constexpr auto magic_key_suffix = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"sv;
+constexpr auto http_upgrade_reply_template =
     "HTTP/1.1 101 Switching Protocols\r\n"
     "Upgrade: websocket\r\n"
     "Connection: Upgrade\r\n"
     "Sec-WebSocket-Version: 13\r\n"
-    "Sec-WebSocket-Accept: ";
+    "Sec-WebSocket-Accept: "sv;
 
 void server::listen(socket_address addr, listen_options lo) {
     _listeners.push_back(seastar::listen(addr, lo));
@@ -135,14 +138,14 @@ future<> server_connection::read_http_upgrade_request() {
     sstring sec_key = req->get_header("Sec-Websocket-Key");
     sstring sec_version = req->get_header("Sec-Websocket-Version");
 
-    sstring sha1_input = sec_key + magic_key_suffix;
+    auto sha1_input = fmt::format("{}{}", sec_key, magic_key_suffix);
 
     websocket_logger.debug("Sec-Websocket-Key: {}, Sec-Websocket-Version: {}", sec_key, sec_version);
 
     std::string sha1_output = sha1_base64(sha1_input);
     websocket_logger.debug("SHA1 output: {} of size {}", sha1_output, sha1_output.size());
 
-    co_await _write_buf.write(http_upgrade_reply_template);
+    co_await _write_buf.write(http_upgrade_reply_template.data(), http_upgrade_reply_template.size());
     co_await _write_buf.write(sha1_output);
     if (!_subprotocol.empty()) {
         co_await _write_buf.write("\r\nSec-WebSocket-Protocol: ", 26);