Branch data Line data Source code
1 : : // Copyright (c) 2020-2022 The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #include <chainparams.h>
6 : : #include <common/args.h>
7 : : #include <compat/compat.h>
8 : : #include <compat/endian.h>
9 : : #include <crypto/sha256.h>
10 : : #include <i2p.h>
11 : : #include <logging.h>
12 : : #include <netaddress.h>
13 : : #include <netbase.h>
14 : : #include <random.h>
15 : : #include <script/parsing.h>
16 : : #include <sync.h>
17 : : #include <tinyformat.h>
18 : : #include <util/fs.h>
19 : : #include <util/readwritefile.h>
20 : : #include <util/sock.h>
21 : : #include <util/strencodings.h>
22 : : #include <util/threadinterrupt.h>
23 : :
24 : : #include <chrono>
25 : : #include <memory>
26 : : #include <stdexcept>
27 : : #include <string>
28 : :
29 : : using util::Split;
30 : :
31 : : namespace i2p {
32 : :
33 : : /**
34 : : * Swap Standard Base64 <-> I2P Base64.
35 : : * Standard Base64 uses `+` and `/` as last two characters of its alphabet.
36 : : * I2P Base64 uses `-` and `~` respectively.
37 : : * So it is easy to detect in which one is the input and convert to the other.
38 : : * @param[in] from Input to convert.
39 : : * @return converted `from`
40 : : */
41 : 698 : static std::string SwapBase64(const std::string& from)
42 : : {
43 : 698 : std::string to;
44 [ + - ]: 698 : to.resize(from.size());
45 [ + + ]: 2056693 : for (size_t i = 0; i < from.size(); ++i) {
46 [ + + + + : 2055995 : switch (from[i]) {
+ ]
47 : : case '-':
48 [ + - ]: 1514 : to[i] = '+';
49 : 1514 : break;
50 : : case '~':
51 [ + - ]: 1762 : to[i] = '/';
52 : 1762 : break;
53 : : case '+':
54 [ + - ]: 1570 : to[i] = '-';
55 : 1570 : break;
56 : : case '/':
57 [ + - ]: 2668 : to[i] = '~';
58 : 2668 : break;
59 : : default:
60 [ + - ]: 2048481 : to[i] = from[i];
61 : 2048481 : break;
62 : : }
63 : 2055995 : }
64 : 698 : return to;
65 [ + - ]: 698 : }
66 : :
67 : : /**
68 : : * Decode an I2P-style Base64 string.
69 : : * @param[in] i2p_b64 I2P-style Base64 string.
70 : : * @return decoded `i2p_b64`
71 : : * @throw std::runtime_error if decoding fails
72 : : */
73 : 351 : static Binary DecodeI2PBase64(const std::string& i2p_b64)
74 : : {
75 : 351 : const std::string& std_b64 = SwapBase64(i2p_b64);
76 [ + - ]: 351 : auto decoded = DecodeBase64(std_b64);
77 [ + + ]: 351 : if (!decoded) {
78 [ + - + - : 107 : throw std::runtime_error(strprintf("Cannot decode Base64: \"%s\"", i2p_b64));
- + + - ]
79 : : }
80 : 244 : return std::move(*decoded);
81 : 458 : }
82 : :
83 : : /**
84 : : * Derive the .b32.i2p address of an I2P destination (binary).
85 : : * @param[in] dest I2P destination.
86 : : * @return the address that corresponds to `dest`
87 : : * @throw std::runtime_error if conversion fails
88 : : */
89 : 217 : static CNetAddr DestBinToAddr(const Binary& dest)
90 : : {
91 : 217 : CSHA256 hasher;
92 : 217 : hasher.Write(dest.data(), dest.size());
93 : 217 : unsigned char hash[CSHA256::OUTPUT_SIZE];
94 : 217 : hasher.Finalize(hash);
95 : :
96 : 217 : CNetAddr addr;
97 [ + - + - ]: 217 : const std::string addr_str = EncodeBase32(hash, false) + ".b32.i2p";
98 [ + - + - ]: 217 : if (!addr.SetSpecial(addr_str)) {
99 [ # # # # : 0 : throw std::runtime_error(strprintf("Cannot parse I2P address: \"%s\"", addr_str));
# # # # ]
100 : : }
101 : :
102 : 217 : return addr;
103 [ + - ]: 217 : }
104 : :
105 : : /**
106 : : * Derive the .b32.i2p address of an I2P destination (I2P-style Base64).
107 : : * @param[in] dest I2P destination.
108 : : * @return the address that corresponds to `dest`
109 : : * @throw std::runtime_error if conversion fails
110 : : */
111 : 57 : static CNetAddr DestB64ToAddr(const std::string& dest)
112 : : {
113 : 57 : const Binary& decoded = DecodeI2PBase64(dest);
114 [ + - ]: 57 : return DestBinToAddr(decoded);
115 : 57 : }
116 : :
117 : : namespace sam {
118 : :
119 [ + - ]: 591 : Session::Session(const fs::path& private_key_file,
120 : : const Proxy& control_host,
121 : : CThreadInterrupt* interrupt)
122 : 591 : : m_private_key_file{private_key_file},
123 [ + - ]: 591 : m_control_host{control_host},
124 : 591 : m_interrupt{interrupt},
125 : 591 : m_transient{false}
126 : : {
127 : 591 : }
128 : :
129 [ # # ]: 0 : Session::Session(const Proxy& control_host, CThreadInterrupt* interrupt)
130 [ # # ]: 0 : : m_control_host{control_host},
131 : 0 : m_interrupt{interrupt},
132 : 0 : m_transient{true}
133 : : {
134 : 0 : }
135 : :
136 : 591 : Session::~Session()
137 : : {
138 [ + - + - ]: 591 : LOCK(m_mutex);
139 [ + - ]: 591 : Disconnect();
140 : 591 : }
141 : :
142 : 591 : bool Session::Listen(Connection& conn)
143 : : {
144 : : try {
145 [ + - + - ]: 591 : LOCK(m_mutex);
146 [ + + ]: 591 : CreateIfNotCreatedAlready();
147 [ + - ]: 124 : conn.me = m_my_addr;
148 [ + + ]: 124 : conn.sock = StreamAccept();
149 : 70 : return true;
150 [ - + ]: 591 : } catch (const std::runtime_error& e) {
151 [ + - - + : 521 : LogPrintLevel(BCLog::I2P, BCLog::Level::Error, "Couldn't listen: %s\n", e.what());
+ - ]
152 [ + - ]: 521 : CheckControlSock();
153 [ # # ]: 521 : }
154 : 521 : return false;
155 : 1112 : }
156 : :
157 : 70 : bool Session::Accept(Connection& conn)
158 : : {
159 : 70 : AssertLockNotHeld(m_mutex);
160 : :
161 : 70 : std::string errmsg;
162 : 70 : bool disconnect{false};
163 : :
164 [ + + - + ]: 156 : while (!*m_interrupt) {
165 : 103 : Sock::Event occurred;
166 [ + - + - : 103 : if (!conn.sock->Wait(MAX_WAIT_FOR_IO, Sock::RECV, &occurred)) {
+ + ]
167 [ + - ]: 5 : errmsg = "wait on socket failed";
168 : 5 : break;
169 : : }
170 : :
171 [ + + ]: 98 : if (occurred == 0) {
172 : : // Timeout, no incoming connections or errors within MAX_WAIT_FOR_IO.
173 : 33 : continue;
174 : : }
175 : :
176 : 65 : std::string peer_dest;
177 : : try {
178 [ + - + + ]: 65 : peer_dest = conn.sock->RecvUntilTerminator('\n', MAX_WAIT_FOR_IO, *m_interrupt, MAX_MSG_SIZE);
179 [ - + ]: 65 : } catch (const std::runtime_error& e) {
180 [ - + ]: 8 : errmsg = e.what();
181 : : break;
182 [ - + # # ]: 8 : }
183 : :
184 [ - + ]: 57 : CNetAddr peer_addr;
185 : : try {
186 [ + + ]: 57 : peer_addr = DestB64ToAddr(peer_dest);
187 [ - + ]: 57 : } catch (const std::runtime_error& e) {
188 : : // The I2P router is expected to send the Base64 of the connecting peer,
189 : : // but it may happen that something like this is sent instead:
190 : : // STREAM STATUS RESULT=I2P_ERROR MESSAGE="Session was closed"
191 : : // In that case consider the session damaged and close it right away,
192 : : // even if the control socket is alive.
193 [ + + ]: 40 : if (peer_dest.find("RESULT=I2P_ERROR") != std::string::npos) {
194 [ + - ]: 6 : errmsg = strprintf("unexpected reply that hints the session is unusable: %s", peer_dest);
195 : 6 : disconnect = true;
196 : 6 : } else {
197 [ - + ]: 34 : errmsg = e.what();
198 : : }
199 : : break;
200 [ - + # # ]: 40 : }
201 : :
202 [ + - ]: 17 : conn.peer = CService(peer_addr, I2P_SAM31_PORT);
203 : :
204 : 17 : return true;
205 [ + + ]: 103 : }
206 : :
207 [ + + - + ]: 0 : if (*m_interrupt) {
208 [ # # # # : 0 : LogPrintLevel(BCLog::I2P, BCLog::Level::Debug, "Accept was interrupted\n");
# # ]
209 : 0 : } else {
210 [ + - + - : 53 : LogPrintLevel(BCLog::I2P, BCLog::Level::Debug, "Error accepting%s: %s\n", disconnect ? " (will close the session)" : "", errmsg);
# # ]
211 : : }
212 [ + + ]: 53 : if (disconnect) {
213 [ + - + - ]: 6 : LOCK(m_mutex);
214 [ + - ]: 6 : Disconnect();
215 : 6 : } else {
216 [ + - ]: 47 : CheckControlSock();
217 : : }
218 : 53 : return false;
219 : 224 : }
220 : :
221 : 591 : bool Session::Connect(const CService& to, Connection& conn, bool& proxy_error)
222 : : {
223 : : // Refuse connecting to arbitrary ports. We don't specify any destination port to the SAM proxy
224 : : // when connecting (SAM 3.1 does not use ports) and it forces/defaults it to I2P_SAM31_PORT.
225 [ - + ]: 591 : if (to.GetPort() != I2P_SAM31_PORT) {
226 [ # # # # : 0 : LogPrintLevel(BCLog::I2P, BCLog::Level::Debug, "Error connecting to %s, connection refused due to arbitrary port %s\n", to.ToStringAddrPort(), to.GetPort());
# # ]
227 : 0 : proxy_error = false;
228 : 0 : return false;
229 : : }
230 : :
231 : 591 : proxy_error = true;
232 : :
233 : 591 : std::string session_id;
234 : 591 : std::unique_ptr<Sock> sock;
235 [ + - ]: 591 : conn.peer = to;
236 : :
237 : : try {
238 : : {
239 [ + - + - ]: 591 : LOCK(m_mutex);
240 [ + + ]: 591 : CreateIfNotCreatedAlready();
241 [ + - ]: 88 : session_id = m_session_id;
242 [ + - ]: 88 : conn.me = m_my_addr;
243 [ + + ]: 88 : sock = Hello();
244 : 591 : }
245 : :
246 : 110 : const Reply& lookup_reply =
247 [ + - + - : 64 : SendRequestAndGetReply(*sock, strprintf("NAMING LOOKUP NAME=%s", to.ToStringAddr()));
+ + ]
248 : :
249 [ + - + + ]: 46 : const std::string& dest = lookup_reply.Get("VALUE");
250 : :
251 [ + + ]: 32 : const Reply& connect_reply = SendRequestAndGetReply(
252 [ + - ]: 32 : *sock, strprintf("STREAM CONNECT ID=%s DESTINATION=%s SILENT=false", session_id, dest),
253 : : false);
254 : :
255 [ + - + + ]: 28 : const std::string& result = connect_reply.Get("RESULT");
256 : :
257 [ + - + + ]: 24 : if (result == "OK") {
258 : 8 : conn.sock = std::move(sock);
259 : 8 : return true;
260 : : }
261 : :
262 [ - + + + ]: 16 : if (result == "INVALID_ID") {
263 [ + - - + ]: 2 : LOCK(m_mutex);
264 [ - + ]: 2 : Disconnect();
265 [ + - + - ]: 2 : throw std::runtime_error("Invalid session id");
266 : 2 : }
267 : :
268 [ - + + + : 14 : if (result == "CANT_REACH_PEER" || result == "TIMEOUT") {
+ - + + ]
269 : 3 : proxy_error = false;
270 : 3 : }
271 : :
272 [ + - + - : 14 : throw std::runtime_error(strprintf("\"%s\"", connect_reply.full));
+ - ]
273 [ - + ]: 591 : } catch (const std::runtime_error& e) {
274 [ + - + - : 583 : LogPrintLevel(BCLog::I2P, BCLog::Level::Debug, "Error connecting to %s: %s\n", to.ToStringAddrPort(), e.what());
# # # # ]
275 [ + - ]: 583 : CheckControlSock();
276 : 583 : return false;
277 [ + - # # ]: 583 : }
278 : 1174 : }
279 : :
280 : : // Private methods
281 : :
282 : 1619 : std::string Session::Reply::Get(const std::string& key) const
283 : : {
284 : 1619 : const auto& pos = keys.find(key);
285 [ + + + + ]: 1619 : if (pos == keys.end() || !pos->second.has_value()) {
286 [ + - - + : 242 : throw std::runtime_error(
+ - ]
287 [ + - ]: 242 : strprintf("Missing %s= in the reply to \"%s\": \"%s\"", key, request, full));
288 : : }
289 : 1377 : return pos->second.value();
290 : 1861 : }
291 : :
292 : 2164 : Session::Reply Session::SendRequestAndGetReply(const Sock& sock,
293 : : const std::string& request,
294 : : bool check_result_ok) const
295 : : {
296 [ + - + - : 2684 : sock.SendComplete(request + "\n", MAX_WAIT_FOR_IO, *m_interrupt);
+ + ]
297 : :
298 : 1875 : Reply reply;
299 : :
300 : : // Don't log the full "SESSION CREATE ..." because it contains our private key.
301 [ + - + - : 1875 : reply.request = request.substr(0, 14) == "SESSION CREATE" ? "SESSION CREATE ..." : request;
+ + + - +
- + - + +
+ + # # #
# ]
302 : :
303 : : // It could take a few minutes for the I2P router to reply as it is querying the I2P network
304 : : // (when doing name lookup, for example). Notice: `RecvUntilTerminator()` is checking
305 : : // `m_interrupt` more often, so we would not be stuck here for long if `m_interrupt` is
306 : : // signaled.
307 : : static constexpr auto recv_timeout = 3min;
308 : :
309 [ + - + + ]: 1875 : reply.full = sock.RecvUntilTerminator('\n', recv_timeout, *m_interrupt, MAX_MSG_SIZE);
310 : :
311 [ + - + - : 125671 : for (const auto& kv : Split(reply.full, ' ')) {
+ + ]
312 [ + - ]: 124098 : const auto& pos = std::find(kv.begin(), kv.end(), '=');
313 [ + + ]: 124098 : if (pos != kv.end()) {
314 [ + - - + : 23238 : reply.keys.emplace(std::string{kv.begin(), pos}, std::string{pos + 1, kv.end()});
+ - ]
315 : 23238 : } else {
316 [ + - - + ]: 100860 : reply.keys.emplace(std::string{kv.begin(), kv.end()}, std::nullopt);
317 : : }
318 : 124098 : }
319 : :
320 [ + + + - : 1761 : if (check_result_ok && reply.Get("RESULT") != "OK") {
+ + + - +
+ + + + +
+ + + + +
+ + + # #
- + - + -
+ - + -
+ ]
321 [ + - + - : 30 : throw std::runtime_error(
+ - ]
322 [ + - ]: 30 : strprintf("Unexpected reply to \"%s\": \"%s\"", request, reply.full));
323 : : }
324 : :
325 : 1355 : return reply;
326 [ + - ]: 2382 : }
327 : :
328 : 1382 : std::unique_ptr<Sock> Session::Hello() const
329 : : {
330 : 1382 : auto sock = m_control_host.Connect();
331 : :
332 [ + + ]: 1382 : if (!sock) {
333 [ + - + - : 120 : throw std::runtime_error(strprintf("Cannot connect to %s", m_control_host.ToString()));
+ - + - +
- ]
334 : : }
335 : :
336 [ + - + + ]: 1262 : SendRequestAndGetReply(*sock, "HELLO VERSION MIN=3.1 MAX=3.1");
337 : :
338 : 643 : return sock;
339 [ + - ]: 2121 : }
340 : :
341 : 1151 : void Session::CheckControlSock()
342 : : {
343 : 1151 : LOCK(m_mutex);
344 : :
345 : 1151 : std::string errmsg;
346 [ + + + - : 1151 : if (m_control_sock && !m_control_sock->IsConnected(errmsg)) {
+ + ]
347 [ + - - + : 167 : LogPrintLevel(BCLog::I2P, BCLog::Level::Debug, "Control socket error: %s\n", errmsg);
# # ]
348 [ + - ]: 167 : Disconnect();
349 : 167 : }
350 : 1151 : }
351 : :
352 : 359 : void Session::DestGenerate(const Sock& sock)
353 : : {
354 : : // https://geti2p.net/spec/common-structures#key-certificates
355 : : // "7" or "EdDSA_SHA512_Ed25519" - "Recent Router Identities and Destinations".
356 : : // Use "7" because i2pd <2.24.0 does not recognize the textual form.
357 : : // If SIGNATURE_TYPE is not specified, then the default one is DSA_SHA1.
358 [ + - + + ]: 359 : const Reply& reply = SendRequestAndGetReply(sock, "DEST GENERATE SIGNATURE_TYPE=7", false);
359 : :
360 [ + - + + : 360 : m_private_key = DecodeI2PBase64(reply.Get("PRIV"));
+ + ]
361 : 491 : }
362 : :
363 : 227 : void Session::GenerateAndSavePrivateKey(const Sock& sock)
364 : : {
365 : 227 : DestGenerate(sock);
366 : :
367 : : // umask is set to 0077 in common/system.cpp, which is ok.
368 [ + - + - ]: 227 : if (!WriteBinaryFile(m_private_key_file,
369 [ + - ]: 227 : std::string(m_private_key.begin(), m_private_key.end()))) {
370 [ # # # # : 0 : throw std::runtime_error(
# # ]
371 [ # # # # : 0 : strprintf("Cannot save I2P private key to %s", fs::quoted(fs::PathToString(m_private_key_file))));
# # ]
372 : : }
373 : 227 : }
374 : :
375 : 224 : Binary Session::MyDestination() const
376 : : {
377 : : // From https://geti2p.net/spec/common-structures#destination:
378 : : // "They are 387 bytes plus the certificate length specified at bytes 385-386, which may be
379 : : // non-zero"
380 : : static constexpr size_t DEST_LEN_BASE = 387;
381 : : static constexpr size_t CERT_LEN_POS = 385;
382 : :
383 : 224 : uint16_t cert_len;
384 : :
385 [ + + ]: 224 : if (m_private_key.size() < CERT_LEN_POS + sizeof(cert_len)) {
386 [ + - + - : 32 : throw std::runtime_error(strprintf("The private key is too short (%d < %d)",
+ - + - ]
387 : 16 : m_private_key.size(),
388 : 16 : CERT_LEN_POS + sizeof(cert_len)));
389 : : }
390 : :
391 : 208 : memcpy(&cert_len, &m_private_key.at(CERT_LEN_POS), sizeof(cert_len));
392 : 208 : cert_len = be16toh_internal(cert_len);
393 : :
394 : 208 : const size_t dest_len = DEST_LEN_BASE + cert_len;
395 : :
396 [ + + ]: 208 : if (dest_len > m_private_key.size()) {
397 [ + - + - : 16 : throw std::runtime_error(strprintf("Certificate length (%d) designates that the private key should "
+ - + - ]
398 : : "be %d bytes, but it is only %d bytes",
399 : : cert_len,
400 : : dest_len,
401 : 8 : m_private_key.size()));
402 : : }
403 : :
404 [ + - ]: 200 : return Binary{m_private_key.begin(), m_private_key.begin() + dest_len};
405 : 248 : }
406 : :
407 : 1182 : void Session::CreateIfNotCreatedAlready()
408 : : {
409 : 1182 : std::string errmsg;
410 [ + + + - : 1182 : if (m_control_sock && m_control_sock->IsConnected(errmsg)) {
+ + ]
411 : 12 : return;
412 : : }
413 : :
414 : 1170 : const auto session_type = m_transient ? "transient" : "persistent";
415 [ + - + - ]: 1170 : const auto session_id = GetRandHash().GetHex().substr(0, 10); // full is overkill, too verbose in the logs
416 : :
417 [ + - + - : 1170 : LogPrintLevel(BCLog::I2P, BCLog::Level::Debug, "Creating %s SAM session %s with %s\n", session_type, session_id, m_control_host.ToString());
# # # # ]
418 : :
419 [ + + ]: 1170 : auto sock = Hello();
420 : :
421 [ - + ]: 479 : if (m_transient) {
422 : : // The destination (private key) is generated upon session creation and returned
423 : : // in the reply in DESTINATION=.
424 [ # # ]: 0 : const Reply& reply = SendRequestAndGetReply(
425 : 0 : *sock,
426 [ # # ]: 0 : strprintf("SESSION CREATE STYLE=STREAM ID=%s DESTINATION=TRANSIENT SIGNATURE_TYPE=7 "
427 : : "i2cp.leaseSetEncType=4,0 inbound.quantity=1 outbound.quantity=1",
428 : : session_id));
429 : :
430 [ # # # # : 0 : m_private_key = DecodeI2PBase64(reply.Get("DESTINATION"));
# # ]
431 : 0 : } else {
432 : : // Read our persistent destination (private key) from disk or generate
433 : : // one and save it to disk. Then use it when creating the session.
434 [ + - ]: 479 : const auto& [read_ok, data] = ReadBinaryFile(m_private_key_file);
435 [ + + ]: 479 : if (read_ok) {
436 [ + - + - : 360 : m_private_key.assign(data.begin(), data.end());
+ - ]
437 : 120 : } else {
438 [ + + ]: 359 : GenerateAndSavePrivateKey(*sock);
439 : : }
440 : :
441 [ + - + - : 347 : const std::string& private_key_b64 = SwapBase64(EncodeBase64(m_private_key));
+ - ]
442 : :
443 [ + + ]: 347 : SendRequestAndGetReply(*sock,
444 [ + - + - ]: 694 : strprintf("SESSION CREATE STYLE=STREAM ID=%s DESTINATION=%s "
445 : : "i2cp.leaseSetEncType=4,0 inbound.quantity=3 outbound.quantity=3",
446 : : session_id,
447 : 347 : private_key_b64));
448 : 479 : }
449 : :
450 [ + + + - : 248 : m_my_addr = CService(DestBinToAddr(MyDestination()), I2P_SAM31_PORT);
+ - ]
451 [ + - ]: 200 : m_session_id = session_id;
452 : 200 : m_control_sock = std::move(sock);
453 : :
454 [ + - - + : 200 : LogPrintLevel(BCLog::I2P, BCLog::Level::Info, "%s SAM session %s created, my address=%s\n",
+ - + - +
- + - ]
455 : : Capitalize(session_type),
456 : : m_session_id,
457 : : m_my_addr.ToStringAddrPort());
458 [ - + ]: 1461 : }
459 : :
460 : 100 : std::unique_ptr<Sock> Session::StreamAccept()
461 : : {
462 : 100 : auto sock = Hello();
463 : :
464 [ + + ]: 100 : const Reply& reply = SendRequestAndGetReply(
465 [ + - ]: 100 : *sock, strprintf("STREAM ACCEPT ID=%s SILENT=false", m_session_id), false);
466 : :
467 [ + - + + ]: 87 : const std::string& result = reply.Get("RESULT");
468 : :
469 [ + - + + ]: 84 : if (result == "OK") {
470 : 70 : return sock;
471 : : }
472 : :
473 [ - + + + ]: 14 : if (result == "INVALID_ID") {
474 : : // If our session id is invalid, then force session re-creation on next usage.
475 [ - + ]: 2 : Disconnect();
476 : 2 : }
477 : :
478 [ + - + - : 14 : throw std::runtime_error(strprintf("\"%s\"", reply.full));
+ - + - ]
479 [ + - ]: 130 : }
480 : :
481 : 768 : void Session::Disconnect()
482 : : {
483 [ + + ]: 768 : if (m_control_sock) {
484 [ - + ]: 193 : if (m_session_id.empty()) {
485 [ # # ]: 0 : LogPrintLevel(BCLog::I2P, BCLog::Level::Info, "Destroying incomplete SAM session\n");
486 : 0 : } else {
487 [ - + ]: 193 : LogPrintLevel(BCLog::I2P, BCLog::Level::Info, "Destroying SAM session %s\n", m_session_id);
488 : : }
489 : 193 : m_control_sock.reset();
490 : 193 : }
491 : 768 : m_session_id.clear();
492 : 768 : }
493 : : } // namespace sam
494 : : } // namespace i2p
|