add release targets to makefile for future

purge llarp_alloc

colored logging

.gitignore

@@ -21,3 +21,7 @@ CMakeCache.txt
 
 callgrind.*
 .gdb_history
+
+*.sig
+*.signed
+*.key

CMakeLists.txt

@@ -9,6 +9,15 @@ endif(ASAN)
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 -Wall -fPIC ${DEBUG_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall -fPIC ${DEBUG_FLAGS}")
 
+if(NOT GIT_VERSION)
+  exec_program("git" ${CMAKE_CURRENT_SOURCE_DIR} ARGS "rev-parse --short HEAD" OUTPUT_VARIABLE GIT_VERSION)
+  add_definitions(-DGIT_REV="${GIT_VERSION}")
+endif()
+
+if(RELEASE_MOTTO)
+  add_definitions(-DLLARP_RELEASE_MOTTO="${RELEASE_MOTTO}")
+endif()
+
 
 set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
 
@@ -17,7 +26,6 @@ set(EXE_SRC daemon/main.cpp)
 
 set(LIBS sodium pthread stdc++fs)
 
-
 set(LIB llarp)
 set(SHARED_LIB ${LIB})
 set(STATIC_LIB ${LIB}-static)
@@ -30,16 +38,15 @@ set(LIB_SRC
   llarp/crypto_async.cpp
   llarp/crypto_libsodium.cpp
   llarp/ev.cpp
-  llarp/exit_info.c
+  llarp/exit_info.cpp
   llarp/exit_route.c
   llarp/iwp_link.cpp
   llarp/logger.cpp
   llarp/link.c
   llarp/link_intro.cpp
   llarp/link_message.cpp
-  llarp/logic.c
+  llarp/logic.cpp
   llarp/mem.cpp
-  llarp/mem_std.cpp
   llarp/net.cpp
   llarp/nodedb.cpp
   llarp/router_contact.cpp

Makefile

@@ -1,21 +1,42 @@
 
 all: debug
 
+SIGN = gpg --sign --detach
+
+TARGETS = llarpd libllarp.so libllarp-static.a
+SIGS = $(TARGETS:=.sig)
+
 clean:
 	rm -f build.ninja rules.ninja cmake_install.cmake CMakeCache.txt
 	rm -rf CMakeFiles
+	rm -f $(TARGETS)
+	rm -f *.sig
 
 debug-configure: clean
 	cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DASAN=true
 
+release-configure: clean
+	cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DRELEASE_MOTTO="$(shell cat motto.txt)"
+
 configure: clean
-	cmake -GNinja -DCMAKE_BUILD_TYPE=Release
+	cmake -GNinja -DCMAKE_BUILD_TYPE=Debug
 
-compile: configure
+build: configure
 	ninja
 
 debug: debug-configure
 	ninja
 
+release-compile: release-configure
+	ninja
+	strip $(TARGETS)
+
+$(TARGETS): release-compile
+
+%.sig: $(TARGETS)
+	$(SIGN) $*
+
+release: $(SIGS)
+
 format:
 	clang-format -i $$(find daemon llarp include | grep -E '\.[h,c](pp)?$$')

include/llarp.hpp

@@ -16,7 +16,6 @@ namespace llarp
 
     int num_nethreads = 1;
     std::vector< std::thread > netio_threads;
-    llarp_alloc mem;
     llarp_crypto crypto;
     llarp_router *router     = nullptr;
     llarp_threadpool *worker = nullptr;

include/llarp/logger.hpp

@@ -1,7 +1,8 @@
 #ifndef LLARP_LOGGER_HPP
 #define LLARP_LOGGER_HPP
 
-#include <chrono>
+#include <ctime>
+#include <iomanip>
 #include <iostream>
 #include <sstream>
 
@@ -15,7 +16,16 @@ namespace llarp
     eLogError
   };
 
-  extern LogLevel loglevel;
+  struct Logger
+  {
+    LogLevel minlevel = eLogDebug;
+    std::ostream& out = std::cout;
+  };
+
+  extern Logger _glog;
+
+  void
+  SetLogLevel(LogLevel lvl);
 
   /** internal */
   template < typename TArg >
@@ -38,30 +48,35 @@ namespace llarp
   void
   Log(LogLevel lvl, const char* tag, TArgs&&... args)
   {
-    if(loglevel > lvl)
+    if(_glog.minlevel > lvl)
       return;
 
     std::stringstream ss;
     switch(lvl)
     {
       case eLogDebug:
+        ss << (char)27 << "[0m";
         ss << "[DBG] ";
         break;
       case eLogInfo:
+        ss << (char)27 << "[1m";
         ss << "[NFO] ";
         break;
       case eLogWarn:
+        ss << (char)27 << "[1;33m";
         ss << "[WRN] ";
         break;
       case eLogError:
+        ss << (char)27 << "[1;31m";
         ss << "[ERR] ";
         break;
     }
-    auto now = std::chrono::steady_clock::now().time_since_epoch();
-    ss << std::chrono::duration_cast< std::chrono::milliseconds >(now).count()
-       << " " << tag << "\t";
+    auto t   = std::time(nullptr);
+    auto now = std::localtime(&t);
+    ss << std::put_time(now, "%F %T") << " " << tag << "\t";
     LogAppend(ss, std::forward< TArgs >(args)...);
-    std::cout << ss.str() << std::endl;
+    ss << (char)27 << "[0;0m";
+    _glog.out << ss.str() << std::endl;
   }
 
   template < typename... TArgs >

include/llarp/logic.h

@@ -10,7 +10,7 @@ extern "C" {
 struct llarp_logic;
 
 struct llarp_logic*
-llarp_init_logic(struct llarp_alloc* mem);
+llarp_init_logic();
 
 void
 llarp_free_logic(struct llarp_logic** logic);

include/llarp/mem.h

@@ -1,34 +1,13 @@
 #ifndef LLARP_MEM_H_
 #define LLARP_MEM_H_
-#ifdef NO_JEMALLOC
-#include <stdlib.h>
-#else
-#include <jemalloc/jemalloc.h>
-#endif
 #include <stdbool.h>
 #include <stdint.h>
+#include <stdlib.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-struct llarp_alloc
-{
-  void *impl;
-  void *(*alloc)(struct llarp_alloc *mem, size_t sz, size_t align);
-  void (*free)(struct llarp_alloc *mem, void *ptr);
-};
-
-void
-llarp_mem_stdlib(struct llarp_alloc *mem);
-void
-llarp_mem_jemalloc(struct llarp_alloc *mem);
-void
-llarp_mem_dmalloc(struct llarp_alloc *mem);
-
-void
-llarp_mem_slab(struct llarp_alloc *mem, uint32_t *buf, size_t sz);
-
 /** constant time memcmp */
 bool
 llarp_eq(const void *a, const void *b, size_t sz);

include/llarp/nodedb.h

@@ -10,7 +10,7 @@ struct llarp_nodedb;
 
 /** create an empty nodedb */
 struct llarp_nodedb *
-llarp_nodedb_new(struct llarp_alloc *mem, struct llarp_crypto *crypto);
+llarp_nodedb_new(struct llarp_crypto *crypto);
 
 /** free a nodedb and all loaded rc */
 void

include/llarp/router.h

@@ -18,7 +18,7 @@ llarp_findOrCreateIdentity(struct llarp_crypto *crypto, const char *path,
                            byte_t *secretkey);
 
 struct llarp_router *
-llarp_init_router(struct llarp_alloc *mem, struct llarp_threadpool *worker,
+llarp_init_router(struct llarp_threadpool *worker,
                   struct llarp_ev_loop *netloop, struct llarp_logic *logic);
 void
 llarp_free_router(struct llarp_router **router);

include/llarp/version.h

@@ -25,4 +25,7 @@
 #endif
 #define LLARP_VERSION "llarpd" LLARP_VERSION_NUM
 
+#ifndef LLARP_RELEASE_MOTTO
+#define LLARP_RELEASE_MOTTO "(dev build)"
+#endif
 #endif

llarp/context.cpp

@@ -7,6 +7,7 @@ namespace llarp
 {
   Context::Context(std::ostream &stdout) : out(stdout)
   {
+    llarp::Info(__FILE__, LLARP_VERSION, " ", LLARP_RELEASE_MOTTO);
   }
 
   Context::~Context()
@@ -22,13 +23,14 @@ namespace llarp
   bool
   Context::ReloadConfig()
   {
-    llarp::Info(__FILE__, LLARP_VERSION, " loading config at ", configfile);
+    llarp::Info(__FILE__, "loading config at ", configfile);
     if(!llarp_load_config(config, configfile.c_str()))
     {
       llarp_config_iterator iter;
       iter.user  = this;
       iter.visit = &iter_config;
       llarp_config_iter(config, &iter);
+      llarp::Info(__FILE__, "config loaded");
       return true;
     }
     llarp_free_config(&config);
@@ -70,10 +72,10 @@ namespace llarp
   int
   Context::Run()
   {
-    llarp_mem_stdlib(&mem);
+    llarp::Info(__FILE__, "starting up");
     llarp_ev_loop_alloc(&mainloop);
     llarp_crypto_libsodium_init(&crypto);
-    nodedb = llarp_nodedb_new(&mem, &crypto);
+    nodedb = llarp_nodedb_new(&crypto);
     if(nodedb_dir[0])
     {
       nodedb_dir[sizeof(nodedb_dir) - 1] = 0;
@@ -83,9 +85,9 @@ namespace llarp
         if(!worker)
           worker = llarp_init_threadpool(2, "llarp-worker");
         // ensure netio thread
-        logic = llarp_init_logic(&mem);
+        logic = llarp_init_logic();
 
-        router = llarp_init_router(&mem, worker, mainloop, logic);
+        router = llarp_init_router(worker, mainloop, logic);
 
         if(llarp_configure_router(router, config))
         {
@@ -98,7 +100,7 @@ namespace llarp
             pthread_setname_np(netio_threads.back().native_handle(),
                                "llarp-netio");
           }
-          llarp::Info(__FILE__, "running");
+          llarp::Info(__FILE__, "Ready");
           llarp_logic_mainloop(logic);
           return 0;
         }

llarp/ev_epoll.hpp

@@ -96,7 +96,7 @@ struct llarp_epoll_loop : public llarp_ev_loop
           {
             if(ev->read(readbuf, sizeof(readbuf)) == -1)
             {
-              llarp::Info(__FILE__, "close ev");
+              llarp::Debug(__FILE__, "close ev");
               close_ev(ev);
               delete ev;
             }
@@ -146,7 +146,7 @@ struct llarp_epoll_loop : public llarp_ev_loop
       }
     }
     llarp::Addr a(*addr);
-    llarp::Info(__FILE__, "bind to ", a.to_string());
+    llarp::Debug(__FILE__, "bind to ", a.to_string());
     if(bind(fd, addr, slen) == -1)
     {
       perror("bind()");

llarp/exit_info.cpp

@@ -3,29 +3,19 @@
 #include <llarp/exit_info.h>
 #include <llarp/mem.h>
 #include <llarp/string.h>
-
-struct llarp_xi_list_node
-{
-  struct llarp_xi data;
-  struct llarp_xi_list_node *next;
-};
+#include <list>
 
 struct llarp_xi_list
 {
-  struct llarp_alloc *mem;
-  struct llarp_xi_list_node *root;
+  std::list< llarp_xi > list;
 };
 
+extern "C" {
+
 struct llarp_xi_list *
-llarp_xi_list_new(struct llarp_alloc *mem)
+llarp_xi_list_new()
 {
-  struct llarp_xi_list *l = mem->alloc(mem, sizeof(struct llarp_xi_list), 8);
-  if(l)
-  {
-    l->mem  = mem;
-    l->root = NULL;
-  }
-  return l;
+  return new llarp_xi_list;
 }
 
 void
@@ -33,22 +23,15 @@ llarp_xi_list_free(struct llarp_xi_list *l)
 {
   if(l)
   {
-    struct llarp_alloc *mem            = l->mem;
-    struct llarp_xi_list_node *current = l->root;
-    while(current)
-    {
-      struct llarp_xi_list_node *tmp = current->next;
-      mem->free(mem, current);
-      current = tmp;
-    }
-    mem->free(mem, l);
+    l->list.clear();
+    delete l;
   }
 }
 
 static bool
 llarp_xi_iter_bencode(struct llarp_xi_list_iter *iter, struct llarp_xi *xi)
 {
-  return llarp_xi_bencode(xi, iter->user);
+  return llarp_xi_bencode(xi, static_cast< llarp_buffer_t * >(iter->user));
 }
 
 bool
@@ -56,8 +39,7 @@ llarp_xi_list_bencode(struct llarp_xi_list *l, llarp_buffer_t *buff)
 {
   if(!bencode_start_list(buff))
     return false;
-  struct llarp_xi_list_iter xi_itr = {.user  = buff,
-                                      .visit = &llarp_xi_iter_bencode};
+  struct llarp_xi_list_iter xi_itr = {buff, nullptr, &llarp_xi_iter_bencode};
   llarp_xi_list_iterate(l, &xi_itr);
   return bencode_end(buff);
 }
@@ -65,15 +47,10 @@ llarp_xi_list_bencode(struct llarp_xi_list *l, llarp_buffer_t *buff)
 void
 llarp_xi_list_iterate(struct llarp_xi_list *l, struct llarp_xi_list_iter *iter)
 {
-  struct llarp_xi_list_node *current = l->root;
-  iter->list                         = l;
-  while(current)
-  {
-    if(!iter->visit(iter, &current->data))
+  iter->list = l;
+  for(auto &item : l->list)
+    if(!iter->visit(iter, &item))
       return;
-
-    current = current->next;
-  }
 }
 
 bool
@@ -121,7 +98,7 @@ llarp_xi_decode_dict(struct dict_reader *r, llarp_buffer_t *key)
   if(!key)
     return true;
 
-  struct llarp_xi *xi = r->user;
+  llarp_xi *xi = static_cast< llarp_xi * >(r->user);
   llarp_buffer_t strbuf;
   uint64_t v;
   char tmp[128] = {0};
@@ -170,31 +147,15 @@ llarp_xi_decode_dict(struct dict_reader *r, llarp_buffer_t *key)
 bool
 llarp_xi_bdecode(struct llarp_xi *xi, llarp_buffer_t *buf)
 {
-  struct dict_reader r = {.user = xi, .on_key = &llarp_xi_decode_dict};
+  struct dict_reader r = {buf, xi, &llarp_xi_decode_dict};
   return bdecode_read_dict(buf, &r);
 }
 
 void
 llarp_xi_list_pushback(struct llarp_xi_list *l, struct llarp_xi *xi)
 {
-  struct llarp_xi_list_node *cur = l->root;
-  if(cur)
-  {
-    // go to the end of the list
-    while(cur->next)
-      cur = cur->next;
-
-    cur->next = l->mem->alloc(l->mem, sizeof(struct llarp_xi_list_node), 16);
-    cur       = cur->next;
-  }
-  else
-  {
-    l->root = l->mem->alloc(l->mem, sizeof(struct llarp_xi_list_node), 16);
-    cur     = l->root;
-  }
-
-  llarp_xi_copy(&cur->data, xi);
-  cur->next = 0;
+  l->list.emplace_back();
+  llarp_xi_copy(&l->list.back(), xi);
 }
 
 void
@@ -209,21 +170,15 @@ llarp_xi_list_decode_item(struct list_reader *r, bool more)
   if(!more)
     return true;
 
-  struct llarp_xi_list *l = r->user;
-  struct llarp_xi xi;
-  if(!llarp_xi_bdecode(&xi, r->buffer))
-    return false;
-
-  llarp_xi_list_pushback(l, &xi);
-  return true;
+  llarp_xi_list *l = static_cast< llarp_xi_list * >(r->user);
+  l->list.emplace_back();
+  return llarp_xi_bdecode(&l->list.back(), r->buffer);
 }
 
 bool
 llarp_xi_list_bdecode(struct llarp_xi_list *l, llarp_buffer_t *buff)
 {
-  struct list_reader r = {
-      .user    = l,
-      .on_item = &llarp_xi_list_decode_item,
-  };
+  list_reader r = {buff, l, &llarp_xi_list_decode_item};
   return bdecode_read_list(buff, &r);
 }
+}

llarp/iwp_link.cpp

@@ -1198,8 +1198,8 @@ namespace iwp
           auto itr = m_sessions.find(addr);
           if(itr != m_sessions.end())
           {
-            llarp::Info(__FILE__, "session with ", addr.to_string(),
-                        " is stale, removing");
+            llarp::Debug(__FILE__, "session with ", addr.to_string(),
+                         " is stale, removing");
             session *s = static_cast< session * >(itr->second.impl);
             m_sessions.erase(addr);
             if(s->keepalive_timer_id)
@@ -1221,7 +1221,7 @@ namespace iwp
     bool
     ensure_privkey()
     {
-      llarp::Info(__FILE__, "ensure transport private key at ", keyfile);
+      llarp::Debug(__FILE__, "ensure transport private key at ", keyfile);
       std::error_code ec;
       if(!fs::exists(keyfile, ec))
       {
@@ -1456,7 +1456,7 @@ namespace iwp
     link->netloop      = netloop;
     link->udp.recvfrom = &server::handle_recvfrom;
     link->udp.user     = link;
-    llarp::Info(__FILE__, "bind IWP link to ", link->addr.to_string());
+    llarp::Debug(__FILE__, "bind IWP link to ", link->addr.to_string());
     return llarp_ev_add_udp(link->netloop, &link->udp, link->addr) != -1;
   }
 

llarp/logger.cpp

@@ -2,5 +2,11 @@
 
 namespace llarp
 {
-  LogLevel loglevel = eLogDebug;
+  Logger _glog;
+
+  void
+  SetLogLevel(LogLevel lvl)
+  {
+    _glog.minlevel = lvl;
+  }
 }

llarp/logic.cpp

@@ -3,18 +3,18 @@
 
 struct llarp_logic
 {
-  struct llarp_alloc* mem;
   struct llarp_threadpool* thread;
   struct llarp_timer_context* timer;
 };
 
+extern "C" {
+
 struct llarp_logic*
-llarp_init_logic(struct llarp_alloc* mem)
+llarp_init_logic()
 {
-  struct llarp_logic* logic = mem->alloc(mem, sizeof(struct llarp_logic), 8);
+  llarp_logic* logic = new llarp_logic;
   if(logic)
   {
-    logic->mem    = mem;
     logic->thread = llarp_init_threadpool(1, "llarp-logic");
     logic->timer  = llarp_init_timer();
   }
@@ -26,11 +26,10 @@ llarp_free_logic(struct llarp_logic** logic)
 {
   if(*logic)
   {
-    struct llarp_alloc* mem = (*logic)->mem;
     llarp_free_threadpool(&(*logic)->thread);
     llarp_free_timer(&(*logic)->timer);
-    mem->free(mem, *logic);
-    *logic = NULL;
+    delete *logic;
+    *logic = nullptr;
   }
 }
 
@@ -71,3 +70,4 @@ llarp_logic_remove_call(struct llarp_logic* logic, uint32_t id)
 {
   llarp_timer_remove_job(logic->timer, id);
 }
+}

llarp/mem.hpp

@@ -6,27 +6,6 @@
 
 namespace llarp
 {
-  template < typename T >
-  static constexpr size_t
-  alignment()
-  {
-    size_t idx = 0;
-    size_t sz  = sizeof(T);
-    while(sz)
-    {
-      ++idx;
-      sz >>= 1;
-    }
-    return 1 << idx;
-  }
-
-  template < typename T >
-  static T *
-  Alloc(llarp_alloc *mem)
-  {
-    return static_cast< T * >(mem->alloc(mem, sizeof(T), alignment< T >()));
-  }
-
   void
   Zero(void *ptr, size_t sz);
 

llarp/nodedb.cpp

@@ -106,7 +106,7 @@ struct llarp_nodedb
 extern "C" {
 
 struct llarp_nodedb *
-llarp_nodedb_new(struct llarp_alloc *mem, struct llarp_crypto *crypto)
+llarp_nodedb_new(struct llarp_crypto *crypto)
 {
   return new llarp_nodedb(crypto);
 }

llarp/router.cpp

@@ -20,8 +20,7 @@ namespace llarp
                      const char *key, const char *val);
 }  // namespace llarp
 
-llarp_router::llarp_router(struct llarp_alloc *m)
-    : ready(false), mem(m), inbound_msg_handler(this)
+llarp_router::llarp_router() : ready(false), inbound_msg_handler(this)
 {
   llarp_rc_clear(&rc);
 }
@@ -81,7 +80,7 @@ llarp_router::try_connect(fs::path rcfile)
   {
     if(llarp_rc_verify_sig(&crypto, &remote))
     {
-      llarp::Info(__FILE__, "verified signature");
+      llarp::Debug(__FILE__, "verified signature");
       if(!llarp_router_try_connect(this, &remote))
       {
         llarp::Warn(__FILE__, "session already made");
@@ -118,7 +117,7 @@ llarp_router::Ready()
 bool
 llarp_router::SaveRC()
 {
-  llarp::Info(__FILE__, "verify RC signature");
+  llarp::Debug(__FILE__, "verify RC signature");
   if(!llarp_rc_verify_sig(&crypto, &rc))
   {
     llarp::Error(__FILE__, "RC has bad signature not saving");
@@ -134,11 +133,11 @@ llarp_router::SaveRC()
     if(f.is_open())
     {
       f.write((char *)buf.base, buf.cur - buf.base);
-      llarp::Info(__FILE__, "RC saved to ", our_rc_file);
+      llarp::Info(__FILE__, "our RC saved to ", our_rc_file.c_str());
       return true;
     }
   }
-  llarp::Error(__FILE__, "did not save RC to ", our_rc_file);
+  llarp::Error(__FILE__, "did not save RC to ", our_rc_file.c_str());
   return false;
 }
 
@@ -219,7 +218,7 @@ llarp_router::Run()
   const char *us =
       llarp::HexEncode< llarp::pubkey, decltype(tmp) >(ourPubkey, tmp);
 
-  llarp::Info(__FILE__, "we are ", us);
+  llarp::Debug(__FILE__, "our router has public key ", us);
 
   // start links
   for(auto link : links)
@@ -228,7 +227,7 @@ llarp_router::Run()
     if(result == -1)
       llarp::Warn(__FILE__, "Link ", link->name(), " failed to start");
     else
-      llarp::Info(__FILE__, "Link ", link->name(), " started");
+      llarp::Debug(__FILE__, "Link ", link->name(), " started");
   }
 
   for(const auto &itr : connect)
@@ -262,10 +261,10 @@ llarp_router::iter_try_connect(llarp_router_link_iter *iter,
 extern "C" {
 
 struct llarp_router *
-llarp_init_router(struct llarp_alloc *mem, struct llarp_threadpool *tp,
-                  struct llarp_ev_loop *netloop, struct llarp_logic *logic)
+llarp_init_router(struct llarp_threadpool *tp, struct llarp_ev_loop *netloop,
+                  struct llarp_logic *logic)
 {
-  llarp_router *router = new llarp_router(mem);
+  llarp_router *router = new llarp_router();
   if(router)
   {
     router->netloop = netloop;

llarp/router.hpp

@@ -47,7 +47,6 @@ struct llarp_router
   llarp_logic *logic;
   llarp_crypto crypto;
   llarp_path_context *paths;
-  llarp_alloc *mem;
   llarp_seckey_t identity;
 
   llarp::InboundMessageHandler inbound_msg_handler;
@@ -56,7 +55,7 @@ struct llarp_router
 
   std::map< llarp::pubkey, std::vector< llarp::Message > > pendingMessages;
 
-  llarp_router(llarp_alloc *mem);
+  llarp_router();
   ~llarp_router();
 
   bool

motto.txt

@@ -0,0 +1 @@
+demo or die