| #ifndef _UBUS_CXX_HPP |
| #define _UBUS_CXX_HPP |
| |
| #include <libubus.h> |
| #include <cassert> |
| #include <memory> |
| #include <mutex> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #ifndef NDEBUG |
| #include <iostream> |
| #endif |
| |
| namespace ubus { |
| |
| static constexpr int call_timeout = 500; |
| |
| using msg_ptr = std::shared_ptr<const blob_attr>; |
| |
| using strings = std::vector<std::string>; |
| |
| inline auto concat(strings dest) |
| { |
| return dest; |
| } |
| |
| template <class... Strings> |
| inline auto concat(strings dest, strings src, Strings... more) |
| { |
| dest.reserve(dest.size() + src.size()); |
| dest.insert(std::end(dest), std::make_move_iterator(std::begin(src)), |
| std::make_move_iterator(std::end(src))); |
| return concat(std::move(dest), std::move(more)...); |
| } |
| |
| template <class S, class... Strings> |
| inline auto concat(strings dest, S src, Strings... more) |
| { |
| dest.emplace_back(std::move(src)); |
| return concat(std::move(dest), std::move(more)...); |
| } |
| |
| class iterator { |
| private: |
| const strings& keys; |
| |
| const size_t n = 0; |
| |
| size_t i = 0; |
| |
| const blob_attr* pos = nullptr; |
| |
| std::unique_ptr<iterator> cur{}; |
| |
| iterator* parent = nullptr; |
| |
| size_t rem = 0; |
| |
| [[nodiscard]] inline auto matches() const -> bool |
| { |
| return (keys[i].empty() || blobmsg_name(cur->pos) == keys[i]); |
| } |
| |
| explicit iterator(iterator* par) |
| : keys{par->keys}, n{par->n}, pos{par->pos}, cur{this}, parent{par} |
| { |
| if (pos != nullptr) { |
| rem = blobmsg_data_len(pos); |
| pos = static_cast<blob_attr*>(blobmsg_data(pos)); |
| } |
| } |
| |
| public: |
| explicit iterator(const blob_attr* msg, const strings& key_filter = {""}) |
| : keys{key_filter}, n{keys.size() - 1}, pos{msg}, cur{this} |
| { |
| if (pos != nullptr) { |
| rem = blobmsg_data_len(pos); |
| pos = static_cast<blob_attr*>(blobmsg_data(pos)); |
| |
| if (rem == 0) { |
| pos = nullptr; |
| } |
| else if (i != n || !matches()) { |
| ++*this; |
| } |
| } |
| } |
| |
| inline iterator(iterator&&) noexcept = default; |
| |
| inline iterator(const iterator&) = delete; |
| |
| inline auto operator=(const iterator&) -> iterator& = delete; |
| |
| inline auto operator=(iterator &&) -> iterator& = delete; |
| |
| inline auto operator*() |
| { |
| return cur->pos; |
| } |
| |
| inline auto operator!=(const iterator& rhs) |
| { |
| return (cur->rem != rhs.cur->rem || cur->pos != rhs.cur->pos); |
| } |
| |
| auto operator++() -> iterator&; |
| |
| inline ~iterator() |
| { |
| if (cur.get() == this) { |
| static_cast<void>(cur.release()); |
| } |
| } |
| }; |
| |
| class message { |
| private: |
| const msg_ptr msg{}; // initialized by callback. |
| |
| const strings keys{}; |
| |
| public: |
| inline explicit message(msg_ptr message_ptr, strings key_filter = {""}) |
| : msg{std::move(message_ptr)}, keys{std::move(key_filter)} |
| {} |
| |
| inline message(message&&) = default; |
| |
| inline message(const message&) = delete; |
| |
| inline auto operator=(message &&) -> message& = delete; |
| |
| inline auto operator=(const message&) -> message& = delete; |
| |
| [[nodiscard]] inline auto begin() const -> iterator |
| { |
| return iterator{msg.get(), keys}; |
| } |
| |
| [[nodiscard]] inline auto end() const -> iterator |
| { |
| return iterator{nullptr, keys}; |
| } |
| |
| inline explicit operator bool() const |
| { |
| return begin() != end(); |
| } |
| |
| template <class... Strings> |
| auto filter(Strings... key_filter) |
| { |
| strings both{}; |
| if (keys.size() != 1 || !keys[0].empty()) { |
| both = keys; |
| } |
| both = concat(std::move(both), std::move(key_filter)...); |
| return std::move(message{msg, std::move(both)}); |
| } |
| |
| inline ~message() = default; |
| }; |
| |
| class lock_shared_resources { |
| private: |
| static std::mutex inuse; |
| |
| public: |
| inline lock_shared_resources() |
| { |
| inuse.lock(); |
| } |
| |
| inline lock_shared_resources(lock_shared_resources&&) noexcept = default; |
| |
| inline lock_shared_resources(const lock_shared_resources&) = delete; |
| |
| inline auto operator=(const lock_shared_resources&) -> auto& = delete; |
| |
| inline auto operator=(lock_shared_resources &&) -> auto&& = delete; |
| |
| // NOLINTNEXTLINE(readability-convert-member-functions-to-static) |
| inline auto get_context() -> ubus_context* // is member to enforce inuse. |
| { |
| static auto ubus_freeing = [](ubus_context* ctx) { ubus_free(ctx); }; |
| static std::unique_ptr<ubus_context, decltype(ubus_freeing)> lazy_ctx{ubus_connect(nullptr), |
| ubus_freeing}; |
| |
| if (!lazy_ctx) { // it could be available on a later call: |
| |
| lazy_ctx.reset(ubus_connect(nullptr)); |
| |
| if (!lazy_ctx) { |
| throw std::runtime_error("ubus error: cannot connect context"); |
| } |
| } |
| |
| return lazy_ctx.get(); |
| } |
| |
| // NOLINTNEXTLINE(readability-convert-member-functions-to-static) |
| inline auto get_blob_buf() -> blob_buf* // is member to enforce inuse. |
| { |
| static blob_buf buf; |
| |
| static auto blob_buf_freeing = [](blob_buf* b) { blob_buf_free(b); }; |
| static std::unique_ptr<blob_buf, decltype(blob_buf_freeing)> |
| created_to_free_on_the_end_of_life{&buf, blob_buf_freeing}; |
| |
| blob_buf_init(&buf, 0); |
| |
| return &buf; |
| } |
| |
| inline ~lock_shared_resources() |
| { |
| inuse.unlock(); |
| } |
| }; |
| |
| template <class F> |
| auto call(const char* path, const char* method, F set_arguments, int timeout = call_timeout) |
| -> message; |
| |
| inline auto call(const char* path, const char* method, int timeout = call_timeout) -> message |
| { |
| return call( |
| path, method, [](blob_buf* /*buf*/) { return 0; }, timeout); |
| } |
| |
| inline auto call(const char* path, int timeout = call_timeout) -> message |
| { |
| return call(path, "", timeout); |
| } |
| |
| // ------------------------- implementation: ---------------------------------- |
| |
| std::mutex lock_shared_resources::inuse; |
| |
| inline auto iterator::operator++() -> iterator& |
| { |
| for (;;) { |
| #ifndef NDEBUG |
| std::cout << std::string(i, '>') << " look for " << keys[i] << " at "; |
| std::cout << blobmsg_name(cur->pos) << std::endl; |
| #endif |
| |
| auto id = blob_id(cur->pos); |
| if ((id == BLOBMSG_TYPE_TABLE || id == BLOBMSG_TYPE_ARRAY) && i < n && matches() && |
| blobmsg_data_len(cur->pos) > 0) |
| { // immmerge: |
| ++i; |
| |
| auto* tmp = cur.release(); |
| |
| struct new_iterator : public iterator // use private constructor: |
| { |
| explicit new_iterator(iterator* par) : iterator{par} {} |
| }; |
| cur = std::make_unique<new_iterator>(tmp); |
| } |
| else { |
| while (true) { |
| cur->rem -= blob_pad_len(cur->pos); |
| cur->pos = blob_next(cur->pos); |
| auto len = blob_pad_len(cur->pos); |
| |
| if (cur->rem > 0 && len <= cur->rem && len >= sizeof(blob_attr)) { |
| break; |
| } |
| |
| // emerge: |
| auto* tmp = cur->parent; |
| |
| if (tmp == nullptr) { |
| cur->pos = nullptr; |
| return *cur; |
| } |
| |
| cur.reset(tmp); |
| |
| --i; |
| } |
| } |
| if (i == n && matches()) { |
| return *cur; |
| } |
| } |
| } |
| |
| template <class F> |
| inline auto call(const char* path, const char* method, F set_arguments, int timeout) -> message |
| { |
| auto shared = lock_shared_resources{}; |
| |
| auto* ctx = shared.get_context(); |
| |
| uint32_t id = 0; |
| int err = ubus_lookup_id(ctx, path, &id); |
| |
| if (err == 0) { // call |
| ubus_request request{}; |
| |
| auto* buf = shared.get_blob_buf(); |
| err = set_arguments(buf); |
| if (err == 0) { |
| err = ubus_invoke_async(ctx, id, method, buf->head, &request); |
| } |
| |
| if (err == 0) { |
| msg_ptr message_ptr; |
| |
| /* Cannot capture message_ptr, the lambda would be another type. |
| * Pass a location where to save the message as priv pointer when |
| * invoking and get it back here: |
| */ |
| request.priv = &message_ptr; |
| |
| request.data_cb = [](ubus_request* req, int /*type*/, blob_attr* msg) { |
| if (req == nullptr || msg == nullptr) { |
| return; |
| } |
| |
| auto* saved = static_cast<msg_ptr*>(req->priv); |
| if (saved == nullptr || *saved) { |
| return; |
| } |
| |
| saved->reset(blob_memdup(msg), free); |
| if (!*saved) { |
| throw std::bad_alloc(); |
| } |
| }; |
| |
| err = ubus_complete_request(ctx, &request, timeout); |
| |
| if (err == 0) { |
| return message{message_ptr}; |
| } |
| } |
| } |
| |
| std::string errmsg = "ubus::call error: cannot invoke"; |
| errmsg += " (" + std::to_string(err) + ") " + path + " " + method; |
| throw std::runtime_error(errmsg); |
| } |
| |
| } // namespace ubus |
| |
| #endif |