lokinet/llarp/router.cpp

#include "link.hpp"
#include "mem.hpp"
#include "str.hpp"
#include <llarp/link.h>
#include <llarp/router.h>

namespace llarp {
void router_iter_config(llarp_config_iterator *iter, const char *section,
                        const char *key, const char *val);
struct router_links {
  struct llarp_link *link = nullptr;
  struct router_links *next = nullptr;
};

} // namespace llarp

struct llarp_router {
  struct llarp_threadpool *tp;
  llarp::router_links links;
  llarp_crypto crypto;

  static void *operator new(size_t sz) {
    return llarp_g_mem.alloc(sz, llarp::alignment<llarp_router>());
  }

  static void operator delete(void *ptr) { llarp_g_mem.free(ptr); }

  void AddLink(struct llarp_link *link) {
    llarp::router_links *head = &links;
    while (head->next && head->link)
      head = head->next;

    if (head->link)
      head->next = new llarp::router_links{link, nullptr};
    else
      head->link = link;
  }

  void ForEachLink(std::function<void(llarp_link *)> visitor) {
    llarp::router_links *cur = &links;
    do {
      if (cur->link)
        visitor(cur->link);
      cur = cur->next;
    } while (cur);
  }

  void Close() { ForEachLink(llarp_link_stop); }
};

extern "C" {

struct llarp_router *llarp_init_router(struct llarp_threadpool *tp) {
  llarp_router *router = new llarp_router;
  router->tp = tp;
  llarp_crypto_libsodium_init(&router->crypto);
  return router;
}

int llarp_configure_router(struct llarp_router *router,
                           struct llarp_config *conf) {
  llarp_config_iterator iter;
  iter.user = router;
  iter.visit = llarp::router_iter_config;
  llarp_config_iter(conf, &iter);
  return 0;
}

void llarp_run_router(struct llarp_router *router, struct llarp_ev_loop *loop) {
  router->ForEachLink([loop](llarp_link *link) {
    llarp_ev_add_udp_listener(loop, llarp_link_udp_listener(link));
  });
}

void llarp_stop_router(struct llarp_router *router) { router->Close(); }

void llarp_free_router(struct llarp_router **router) {
  if (*router) {
    (*router)->ForEachLink([](llarp_link *link) { llarp_g_mem.free(link); });
    delete *router;
  }
  *router = nullptr;
}
}

namespace llarp {

void router_iter_config(llarp_config_iterator *iter, const char *section,
                        const char *key, const char *val) {
  llarp_router *self = static_cast<llarp_router *>(iter->user);
  if (StrEq(section, "links")) {
    if (StrEq(val, "ip")) {
      struct llarp_link *link = llarp_link_alloc();
      if (llarp_link_configure(link, key, AF_INET6))
        self->AddLink(link);
      else {
        llarp_link_free(&link);
        printf("failed to configure %s link for %s\n", val, key);
      }
    } else if (StrEq(val, "eth")) {
      /** todo: ethernet link */
    }
  }
}
} // namespace llarp