WIP: relay sessions almost complete

Author: dr7ana

daemon/lokinet-cntrl.cpp

@@ -19,9 +19,11 @@ namespace
         Runtime CLI subcommands:
         - list
         - refresh
-        - init
-        - status
-        - close
+        - instance
+            - init
+            - status
+            - close
+            - stop
      */
 
     struct cli_opts
@@ -153,6 +155,15 @@ namespace
                 rpc->close(index, std::move(pubkey));
         });
 
+        auto* halt_subcom = instance_subcom->add_subcommand("halt", "Immediately halt lokinet instance");
+
+        halt_subcom->callback([&]() {
+            if (not address.empty())
+                rpc->halt(omq::address{std::move(address)});
+            else
+                rpc->halt(index);
+        });
+
         // notify startup successful
         runtime_data->running = true;
         p.set_value();

daemon/utils.cpp

@@ -43,7 +43,6 @@ namespace llarp::controller
 
         nlohmann::json req;
         req["pk"] = remote;
-        req["x"] = false;
 
         if (auto it = _binds.find(src); it != _binds.end())
             _omq->request(
@@ -110,6 +109,26 @@ namespace llarp::controller
                 logcat, "Could not find connection ID to RPC bind {} for `session_close` command", src.full_address());
     }
 
+    void rpc_controller::_halt(omq::address src)
+    {
+        log::info(logcat, "Instructing lokinet instance (bind:{}) to halt", src.full_address());
+
+        if (auto it = _binds.find(src); it != _binds.end())
+        {
+            _omq->request(it->second.cid, "llarp.halt", [&](bool success, std::vector<std::string> data) {
+                if (success)
+                {
+                    auto res = nlohmann::json::parse(data[0]);
+                    log::info(logcat, "RPC call to halt instance succeeded: {}", res.dump());
+                }
+                else
+                    log::critical(logcat, "RPC call to halt instance failed!");
+            });
+        }
+        else
+            log::critical(logcat, "Could not find connection ID to RPC bind {} for `halt` command", src.full_address());
+    }
+
     bool rpc_controller::_omq_connect(const std::vector<std::string>& bind_addrs)
     {
         int i = 0;
@@ -197,4 +216,14 @@ namespace llarp::controller
         else
             log::warning(logcat, "Could not find instance with given index: {}", idx);
     }
+
+    void rpc_controller::halt(omq::address src) { return _halt(std::move(src)); }
+
+    void rpc_controller::halt(size_t idx)
+    {
+        if (auto it = _indexes.find(idx); it != _indexes.end())
+            _halt(it->second);
+        else
+            log::warning(logcat, "Could not find instance with given index: {}", idx);
+    }
 }  // namespace llarp::controller

daemon/utils.hpp

@@ -44,6 +44,7 @@ namespace llarp::controller
         void _initiate(omq::address src, std::string remote);
         void _status(omq::address src);
         void _close(omq::address src, std::string remote);
+        void _halt(omq::address src);
 
         bool _omq_connect(const std::vector<std::string>& bind_addrs);
 
@@ -54,16 +55,16 @@ namespace llarp::controller
 
         void refresh();
 
-        void initiate(size_t idx, std::string remote);
-
         void initiate(omq::address src, std::string remote);
+        void initiate(size_t idx, std::string remote);
 
         void status(omq::address src);
-
         void status(size_t idx);
 
         void close(omq::address src, std::string remote);
-
         void close(size_t idx, std::string remote);
+
+        void halt(omq::address src);
+        void halt(size_t idx);
     };
 }  // namespace llarp::controller

llarp/address/address.cpp

@@ -12,10 +12,12 @@ namespace llarp
 
         if (arg.ends_with(TLD::SNODE))
         {
+            arg.remove_suffix(TLD::SNODE.size());
             ret = NetworkAddress{arg, TLD::SNODE};
         }
         else if (arg.ends_with(TLD::LOKI))
         {
+            arg.remove_suffix(TLD::LOKI.size());
             ret = NetworkAddress{arg, TLD::LOKI};
         }
         else
@@ -31,7 +33,7 @@ namespace llarp
 
     NetworkAddress::NetworkAddress(std::string_view arg, std::string_view tld) : _tld{tld}
     {
-        if (not _pubkey.from_string(arg.substr(0, _tld.size())))
+        if (not _pubkey.from_string(oxenc::from_base32z(arg)))
             throw std::invalid_argument{"Invalid pubkey passed to NetworkAddress constructor: {}"_format(arg)};
 
         _is_client = tld == TLD::LOKI;

llarp/contact/client_contact.cpp

@@ -121,7 +121,7 @@ namespace llarp
         }
     }
 
-    session_tag ClientContact::generate_session_tag() const { return session_tag::make(protos & proto_mask); }
+    session_tag ClientContact::generate_session_tag() const { return session_tag::make(protos); }
 
     bool ClientContact::is_expired(std::chrono::milliseconds now) const
     {

llarp/contact/tag.cpp

@@ -14,7 +14,7 @@ namespace llarp
         log::trace(logcat, "new session tag generated: {}", buffer_printer{buf});
     }
 
-    session_tag session_tag::make(uint8_t protocol) { return session_tag{protocol}; }
+    session_tag session_tag::make(uint8_t protos) { return session_tag{static_cast<uint8_t>(protos & proto_mask)}; }
 
     std::tuple<bool, bool> session_tag::proto_bits() const
     {

llarp/ev/types.cpp

@@ -203,14 +203,14 @@ namespace llarp
     bool LinuxPoller::start()
     {
         auto rv = event_add(ev.get(), nullptr) == 0;
-        log::info(logcat, "Linux poller {} watching FD {}", rv ? "successfully began" : "failed to start", fd);
+        log::debug(logcat, "Linux poller {} watching FD {}", rv ? "successfully began" : "failed to start", fd);
         return rv;
     }
 
     bool LinuxPoller::stop()
     {
         auto rv = event_del(ev.get());
-        log::info(logcat, "Linux poller {} watching FD {}", rv ? "successfully stopped" : "failed to stop", fd);
+        log::debug(logcat, "Linux poller {} watching FD {}", rv ? "successfully stopped" : "failed to stop", fd);
         return rv;
     }
 }  //  namespace llarp