LCOV - code coverage report
Current view: top level - src - i2p.cpp (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 1 235 0.4 %
Date: 2023-10-05 12:38:51 Functions: 1 27 3.7 %
Branches: 0 541 0.0 %

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

Generated by: LCOV version 1.14