sarp -> llarp

daemon/main.c

@@ -1,30 +1,28 @@
-#include <sarp.h>
-#include <sarp/mem.h>
-#include <sarp/ev.h>
+#include <llarp.h>
 #include <stdio.h>
 
-struct sarp_router * router;
-struct sarp_config * gconfig;
-struct sarp_ev_loop * mainloop;
+struct llarp_router * router;
+struct llarp_config * gconfig;
+struct llarp_ev_loop * mainloop;
 
 int main(int argc, char * argv[])
 {
   const char * conffname = "daemon.ini";
   if (argc > 1)
     conffname = argv[1];
-  sarp_mem_jemalloc();
-  sarp_new_config(&gconfig);
-  sarp_ev_loop_alloc(&mainloop);
-  printf("%s loaded\n", SARP_VERSION);
-  if(!sarp_load_config(gconfig, conffname))
+  llarp_mem_jemalloc();
+  llarp_new_config(&gconfig);
+  llarp_ev_loop_alloc(&mainloop);
+  printf("%s loaded\n", LLARP_VERSION);
+  if(!llarp_load_config(gconfig, conffname))
   {
     printf("Loaded config %s\n", conffname);
-    sarp_init_router(&router);
-    if(!sarp_configure_router(router, gconfig))
+    llarp_init_router(&router);
+    if(!llarp_configure_router(router, gconfig))
     {
       printf("Running\n");
-      sarp_run_router(router, mainloop);
-      sarp_ev_loop_run(mainloop);
+      llarp_run_router(router, mainloop);
+      llarp_ev_loop_run(mainloop);
     }
     else
       printf("Failed to configure router\n");
@@ -33,11 +31,11 @@ int main(int argc, char * argv[])
     printf("Failed to load config %s\n", conffname);
   
   printf("Shutting down.");
-  sarp_free_router(&router);
+  llarp_free_router(&router);
   printf(".");
-  sarp_free_config(&gconfig);
+  llarp_free_config(&gconfig);
   printf(".");
-  sarp_ev_loop_free(&mainloop);
+  llarp_ev_loop_free(&mainloop);
   printf(".\n");
   return 0;
 }

include/llarp.h

@@ -0,0 +1,7 @@
+#ifndef LLARP_H_
+#define LLARP_H_
+#include <llarp/router.h>
+#include <llarp/version.h>
+#include <llarp/mem.h>
+#include <llarp/ev.h>
+#endif

include/llarp/address_info.h

@@ -0,0 +1,29 @@
+#ifndef LLARP_AI_H
+#define LLARP_AI_H
+#include <llarp/crypto.h>
+#include <llarp/net.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  struct llarp_address_info
+  {
+    uint16_t rank;
+    llarp_pubkey_t enc_key;
+    char * dialect;
+    struct in6_addr ip;
+    uint16_t port;
+  };
+
+  bool llarp_address_info_bencode(struct llarp_address_info * ai, llarp_buffer_t * buff);
+  bool llarp_address_info_bdecode(struct llarp_address_info * ai, llarp_buffer_t  buff);
+  
+  struct llarp_address_info_list;
+  
+#ifdef __cplusplus
+}
+#endif
+  
+#endif

include/llarp/buffer.h

@@ -0,0 +1,20 @@
+#ifndef LLARP_BUFFER_H_
+#define LLARP_BUFFER_H_
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <stdlib.h>
+
+  typedef struct llarp_buffer_t {
+    char * base;
+    size_t sz;
+    char * cur;
+  } llarp_buffer_t;
+
+  size_t llarp_buffer_size_left(llarp_buffer_t * buff);
+  
+#ifdef __cplusplus
+}
+#endif
+  
+#endif

include/llarp/config.h

@@ -0,0 +1,30 @@
+#ifndef LLARP_CONFIG_H_
+#define LLARP_CONFIG_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  struct llarp_config;
+
+  void llarp_new_config(struct llarp_config ** conf);
+  void llarp_free_config(struct llarp_config **  conf);
+
+  /** @brief return -1 on fail otherwiwse 0 */
+  int llarp_load_config(struct llarp_config * conf, const char * fname);
+
+  struct llarp_config_iterator
+  {
+    void * user;
+    /** set by sarp_config_iter */
+    struct llarp_config * conf;
+    /** visit (self, section, key, value) */
+    void (*visit)(struct llarp_config_iterator *, const char *, const char *, const char *);
+  };
+  
+  void llarp_config_iter(struct llarp_config * conf, struct llarp_config_iterator * iter);
+  
+#ifdef __cplusplus
+}
+#endif
+#endif

include/llarp/crypto.h

@@ -0,0 +1,45 @@
+#ifndef LLARP_CRYPTO_H_
+#define LLARP_CRYPTO_H_
+#include <llarp/buffer.h>
+#include <stdint.h>
+#include <stdbool.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PUBKEYSIZE 32
+#define SECKEYSIZE 32
+#define NOUNCESIZE 24
+#define SHAREDKEYSIZE 32
+#define HASHSIZE 64
+#define HMACSECSIZE 32
+#define SIGSIZE 64
+#define TUNNOUNCESIZE 32
+
+  typedef uint8_t llarp_pubkey_t[PUBKEYSIZE];
+  typedef uint8_t llarp_seckey_t[SECKEYSIZE];
+  typedef uint8_t llarp_nounce_t[NOUNCESIZE];
+  typedef uint8_t llarp_sharedkey_t[SHAREDKEYSIZE];
+  typedef uint8_t llarp_hash_t[HASHSIZE];
+  typedef uint8_t llarp_hmacsec_t[HMACSECSIZE];
+  typedef uint8_t llarp_sig_t[SIGSIZE];
+  typedef uint8_t llarp_tunnel_nounce_t[TUNNOUNCESIZE];
+
+  struct llarp_crypto
+  {
+    bool (*xchacha20)(llarp_buffer_t, llarp_sharedkey_t, llarp_nounce_t);
+    bool (*dh_client)(llarp_sharedkey_t *, llarp_pubkey_t, llarp_tunnel_nounce_t, llarp_seckey_t);
+    bool (*dh_server)(llarp_sharedkey_t *, llarp_pubkey_t, llarp_tunnel_nounce_t, llarp_seckey_t);
+    bool (*hash)(llarp_hash_t *, llarp_buffer_t);
+    bool (*hmac)(llarp_hash_t *, llarp_buffer_t, llarp_hmacsec_t);
+    bool (*sign)(llarp_sig_t *, llarp_seckey_t, llarp_buffer_t);
+    bool (*verify)(llarp_pubkey_t, llarp_buffer_t, llarp_sig_t);
+  };
+
+  void llarp_crypto_libsodium_init(struct llarp_crypto * c);
+
+#ifdef __cplusplus
+}
+#endif
+  
+#endif

include/llarp/ev.h

@@ -0,0 +1,36 @@
+#ifndef LLARP_EV_H
+#define LLARP_EV_H
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <sys/socket.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  struct llarp_ev_loop;
+
+  void llarp_ev_loop_alloc(struct llarp_ev_loop ** ev);
+  void llarp_ev_loop_free(struct llarp_ev_loop ** ev);
+
+  int llarp_ev_loop_run(struct llarp_ev_loop * ev);
+
+  struct llarp_udp_listener
+  {
+    char * host;
+    uint16_t port;
+    void * user;
+    void * impl;
+    void (*recvfrom)(struct llarp_udp_listener *, const struct sockaddr *,  char *, ssize_t);
+    void (*closed)(struct llarp_udp_listener *);
+  };
+  
+  int llarp_ev_add_udp_listener(struct llarp_ev_loop * ev, struct llarp_udp_listener * listener);
+
+  int llarp_ev_close_udp_listener(struct llarp_udp_listener * listener);
+  
+#ifdef __cplusplus
+}
+#endif
+#endif

include/llarp/exit_info.h

@@ -1,18 +1,18 @@
-#ifndef SARP_XI_H
-#define SARP_XI_H
-#include <sarp/net.h>
+#ifndef LLARP_XI_H
+#define LLARP_XI_H
+#include <llarp/net.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
   
-  struct sarp_exit_info
+  struct llarp_exit_info
   {
     in6_addr address;
     in6_addr netmask;
   };
 
-  struct sarp_exit_info_list;
+  struct llarp_exit_info_list;
   
 #ifdef __cplusplus
 }

include/llarp/link.h

@@ -0,0 +1,27 @@
+#ifndef LLARP_LINK_H_
+#define LLARP_LINK_H_
+#include <llarp/config.h>
+#include <llarp/mem.h>
+#include <llarp/router.h>
+#include <llarp/ev.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  struct llarp_inet_link;
+
+  void llarp_inet_link_alloc(struct llarp_inet_link ** link, struct llarp_alloc * mem);
+  void llarp_inet_link_free(struct llarp_inet_link ** link);
+
+  void llarp_inet_link_configure(struct llarp_inet_link * link, struct llarp_config * conf);
+
+  void llarp_inet_link_start(struct llarp_inet_link * link, struct llarp_router * router);
+
+  void llarp_inet_link_stop(struct llarp_inet_link * link);
+  
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/llarp/mem.h

@@ -1,5 +1,5 @@
-#ifndef SARP_MEM_H_
-#define SARP_MEM_H_
+#ifndef LLARP_MEM_H_
+#define LLARP_MEM_H_
 
 #ifdef __cplusplus
 extern "C" {
@@ -7,7 +7,7 @@ extern "C" {
 
 #include <stdlib.h>
 
-  struct sarp_alloc
+  struct llarp_alloc
   {
     void * (*malloc)(size_t sz);
     void * (*realloc)(void * ptr, size_t sz);
@@ -16,11 +16,11 @@ extern "C" {
   };
   
   /** global memory allocator */
-  extern struct sarp_alloc sarp_g_mem;
+  extern struct llarp_alloc llarp_g_mem;
   
-  void sarp_mem_jemalloc();
-  void sarp_mem_std();
-  void sarp_mem_dmalloc();
+  void llarp_mem_jemalloc();
+  void llarp_mem_std();
+  void llarp_mem_dmalloc();
 
 #ifdef __cplusplus
 }

include/llarp/router.h

@@ -0,0 +1,24 @@
+#ifndef LLARP_ROUTER_H_
+#define LLARP_ROUTER_H_
+#include <llarp/config.h>
+#include <llarp/ev.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  struct llarp_router;
+
+  void llarp_init_router(struct llarp_router ** router);
+  void llarp_free_router(struct llarp_router ** router);
+
+  int llarp_configure_router(struct llarp_router * router, struct llarp_config * conf);
+  
+  void llarp_run_router(struct llarp_router * router, struct llarp_ev_loop * loop);
+  void llarp_stop_router(struct llarp_router * router);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/llarp/router_contact.h

@@ -0,0 +1,29 @@
+#ifndef LLARP_RC_H
+#define LLARP_RC_H
+#include <llarp/address_info.h>
+#include <llarp/exit_info.h>
+#include <llarp/crypto.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+  
+  struct llarp_router_contact
+  {
+    llarp_buffer_t raw;
+    struct llarp_address_info_list * addreses;
+    llarp_pubkey_t pubkey;
+    struct llarp_exit_info_list * exits;
+    llarp_sig_t signature;
+  };
+
+  bool llarp_rc_bdecode(struct llarp_router_contact * rc, llarp_buffer_t buf);
+  bool llarp_rc_bencode(struct llarp_router_contact * rc, llarp_buffer_t * buf);
+  void llarp_rc_free(struct llarp_router_contact ** rc);
+  bool llarp_rc_verify_sig(struct llarp_rotuer_contact * rc);
+
+  
+  
+#ifdef __cplusplus
+}
+#endif
+#endif

include/llarp/service_info.h

@@ -0,0 +1,24 @@
+#ifndef LLARP_SI_H
+#define LLARP_SI_H
+#include <llarp/crypto.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  struct llarp_service_info
+  {
+    llarp_buffer_t name;
+    llarp_pubkey_t signingkey;
+    llarp_buffer_t vanity;
+  };
+
+  void llarp_service_info_hash(struct llarp_service_info * si, llarp_hash_t * h);
+  bool llarp_service_info_bencode(struct llarp_serivce_info * si, llarp_buffer_t * buff);
+  bool llarp_service_info_bdecode(struct llarp_serivce_info * si, llarp_buffer_t  buff);
+  void llarp_service_info_free(struct llarp_service_info ** si);
+  
+#ifdef __cplusplus
+}
+#endif
+#endif

include/llarp/time.h

@@ -0,0 +1,14 @@
+#ifndef LLARP_TIME_H
+#define LLARP_TIME_H
+#include <stdint.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  uint64_t llarp_time_now_ms();
+  uint64_t llarp_time_now_sec();
+  
+#ifdef __cplusplus
+}
+#endif
+#endif

include/llarp/version.h

@@ -0,0 +1,25 @@
+#ifndef LLARP_VERSION_H
+#define LLARP_VERSION_H
+
+#ifndef LLARP_VERSION_MAJ
+#define LLARP_VERSION_MAJ "0"
+#endif
+
+#ifndef LLARP_VERSION_MIN
+#define LLARP_VERSION_MIN "0"
+#endif
+
+#ifndef LLARP_VERSION_PATCH
+#define LLARP_VERSION_PATCH "0"
+#endif
+
+#ifndef LLARP_VERSION_NUM
+#ifdef GIT_REV
+#define LLARP_VERSION_NUM "-"LLARP_VERSION_MAJ"."LLARP_VERSION_MIN"."LLARP_VERSION_PATCH"-"GIT_REV
+#else
+#define LLARP_VERSION_NUM "-"LLARP_VERSION_MAJ"."LLARP_VERSION_MIN"."LLARP_VERSION_PATCH
+#endif
+#endif
+#define LLARP_VERSION "llarpd"LLARP_VERSION_NUM
+
+#endif

include/sarp.h

@@ -1,5 +0,0 @@
-#ifndef SARP_H_
-#define SARP_H_
-#include <sarp/router.h>
-#include <sarp/version.h>
-#endif

include/sarp/address_info.h

@@ -1,29 +0,0 @@
-#ifndef SARP_AI_H
-#define SARP_AI_H
-#include <sarp/crypto.h>
-#include <sarp/net.h>
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-  struct sarp_address_info
-  {
-    uint16_t rank;
-    sarp_pubkey_t enc_key;
-    char * dialect;
-    struct in6_addr ip;
-    uint16_t port;
-  };
-
-  bool sarp_address_info_bencode(struct sarp_address_info * ai, sarp_buffer_t * buff);
-  bool sarp_address_info_bdecode(struct sarp_address_info * ai, sarp_buffer_t  buff);
-  
-  struct sarp_address_info_list;
-  
-#ifdef __cplusplus
-}
-#endif
-  
-#endif

include/sarp/buffer.h

@@ -1,20 +0,0 @@
-#ifndef SARP_BUFFER_H_
-#define SARP_BUFFER_H_
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <stdlib.h>
-
-  typedef struct sarp_buffer_t {
-    char * base;
-    size_t sz;
-    char * cur;
-  } sarp_buffer_t;
-
-  size_t sarp_buffer_size_left(sarp_buffer_t * buff);
-  
-#ifdef __cplusplus
-}
-#endif
-  
-#endif

include/sarp/config.h

@@ -1,30 +0,0 @@
-#ifndef SARP_CONFIG_H_
-#define SARP_CONFIG_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct sarp_config;
-
-void sarp_new_config(struct sarp_config ** conf);
-void sarp_free_config(struct sarp_config **  conf);
-
-  /** @brief return -1 on fail otherwiwse 0 */
-int sarp_load_config(struct sarp_config * conf, const char * fname);
-
-struct sarp_config_iterator
-{
-  void * user;
-  /** set by sarp_config_iter */
-  struct sarp_config * conf;
-  /** visit (self, section, key, value) */
-  void (*visit)(struct sarp_config_iterator *, const char *, const char *, const char *);
-};
-  
-void sarp_config_iter(struct sarp_config * conf, struct sarp_config_iterator * iter);
-  
-#ifdef __cplusplus
-}
-#endif
-#endif

include/sarp/crypto.h

@@ -1,45 +0,0 @@
-#ifndef SARP_CRYPTO_H_
-#define SARP_CRYPTO_H_
-#include <sarp/buffer.h>
-#include <stdint.h>
-#include <stdbool.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define PUBKEYSIZE 32
-#define SECKEYSIZE 32
-#define NOUNCESIZE 24
-#define SHAREDKEYSIZE 32
-#define HASHSIZE 64
-#define HMACSECSIZE 32
-#define SIGSIZE 64
-#define TUNNOUNCESIZE 32
-
-  typedef uint8_t sarp_pubkey_t[PUBKEYSIZE];
-  typedef uint8_t sarp_seckey_t[SECKEYSIZE];
-  typedef uint8_t sarp_nounce_t[NOUNCESIZE];
-  typedef uint8_t sarp_sharedkey_t[SHAREDKEYSIZE];
-  typedef uint8_t sarp_hash_t[HASHSIZE];
-  typedef uint8_t sarp_hmacsec_t[HMACSECSIZE];
-  typedef uint8_t sarp_sig_t[SIGSIZE];
-  typedef uint8_t sarp_tunnel_nounce_t[TUNNOUNCESIZE];
-
-  struct sarp_crypto
-  {
-    bool (*xchacha20)(sarp_buffer_t, sarp_sharedkey_t, sarp_nounce_t);
-    bool (*dh_client)(sarp_sharedkey_t *, sarp_pubkey_t, sarp_tunnel_nounce_t, sarp_seckey_t);
-    bool (*dh_server)(sarp_sharedkey_t *, sarp_pubkey_t, sarp_tunnel_nounce_t, sarp_seckey_t);
-    bool (*hash)(sarp_hash_t *, sarp_buffer_t);
-    bool (*hmac)(sarp_hash_t *, sarp_buffer_t, sarp_hmacsec_t);
-    bool (*sign)(sarp_sig_t *, sarp_seckey_t, sarp_buffer_t);
-    bool (*verify)(sarp_pubkey_t, sarp_buffer_t, sarp_sig_t);
-  };
-
-  void sarp_crypto_libsodium_init(struct sarp_crypto * c);
-
-#ifdef __cplusplus
-}
-#endif
-  
-#endif

include/sarp/ev.h

@@ -1,36 +0,0 @@
-#ifndef SARP_EV_H
-#define SARP_EV_H
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <sys/socket.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-  struct sarp_ev_loop;
-
-  void sarp_ev_loop_alloc(struct sarp_ev_loop ** ev);
-  void sarp_ev_loop_free(struct sarp_ev_loop ** ev);
-
-  int sarp_ev_loop_run(struct sarp_ev_loop * ev);
-
-  struct sarp_udp_listener
-  {
-    char * host;
-    uint16_t port;
-    void * user;
-    void * impl;
-    void (*recvfrom)(struct sarp_udp_listener *, const struct sockaddr *,  char *, ssize_t);
-    void (*closed)(struct sarp_udp_listener *);
-  };
-  
-  int sarp_ev_add_udp_listener(struct sarp_ev_loop * ev, struct sarp_udp_listener * listener);
-
-  int sarp_ev_close_udp_listener(struct sarp_udp_listener * listener);
-  
-#ifdef __cplusplus
-}
-#endif
-#endif

include/sarp/link.h

@@ -1,27 +0,0 @@
-#ifndef SARP_LINK_H_
-#define SARP_LINK_H_
-#include <sarp/config.h>
-#include <sarp/mem.h>
-#include <sarp/router.h>
-#include <sarp/ev.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-  struct sarp_inet_link;
-
-  void sarp_inet_link_alloc(struct sarp_inet_link ** link, struct sarp_alloc * mem);
-  void sarp_inet_link_free(struct sarp_inet_link ** link);
-
-  void sarp_inet_link_configure(struct sarp_inet_link * link, struct sarp_config * conf);
-
-  void sarp_inet_link_start(struct sarp_inet_link * link, struct sarp_router * router);
-
-  void sarp_inet_link_stop(struct sarp_inet_link * link);
-  
-#ifdef __cplusplus
-}
-#endif
-
-#endif

include/sarp/router.h

@@ -1,24 +0,0 @@
-#ifndef SARP_ROUTER_H_
-#define SARP_ROUTER_H_
-#include <sarp/config.h>
-#include <sarp/ev.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-  struct sarp_router;
-
-  void sarp_init_router(struct sarp_router ** router);
-  void sarp_free_router(struct sarp_router ** router);
-
-  int sarp_configure_router(struct sarp_router * router, struct sarp_config * conf);
-  
-  void sarp_run_router(struct sarp_router * router, struct sarp_ev_loop * loop);
-  void sarp_stop_router(struct sarp_router * router);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

include/sarp/router_contact.h

@@ -1,29 +0,0 @@
-#ifndef SARP_RC_H
-#define SARP_RC_H
-#include <sarp/address_info.h>
-#include <sarp/exit_info.h>
-#include <sarp/crypto.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-  
-  struct sarp_router_contact
-  {
-    sarp_buffer_t raw;
-    struct sarp_address_info_list * addreses;
-    sarp_pubkey_t pubkey;
-    struct sarp_exit_info_list * exits;
-    sarp_sig_t signature;
-  };
-
-  bool sarp_rc_bdecode(struct sarp_router_contact * rc, sarp_buffer_t buf);
-  bool sarp_rc_bencode(struct sarp_router_contact * rc, sarp_buffer_t * buf);
-  void sarp_rc_free(struct sarp_router_contact ** rc);
-  bool sarp_rc_verify_sig(struct sarp_rotuer_contact * rc);
-
-  
-  
-#ifdef __cplusplus
-}
-#endif
-#endif

include/sarp/service_info.h

@@ -1,24 +0,0 @@
-#ifndef SARP_SI_H
-#define SARP_SI_H
-#include <sarp/crypto.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-  struct sarp_service_info
-  {
-    sarp_buffer_t name;
-    sarp_pubkey_t signingkey;
-    sarp_buffer_t vanity;
-  };
-
-  void sarp_service_info_hash(struct sarp_service_info * si, sarp_hash_t * h);
-  bool sarp_service_info_bencode(struct sarp_serivce_info * si, sarp_buffer_t * buff);
-  bool sarp_service_info_bdecode(struct sarp_serivce_info * si, sarp_buffer_t  buff);
-  void sarp_service_info_free(struct sarp_service_info ** si);
-  
-#ifdef __cplusplus
-}
-#endif
-#endif

include/sarp/time.h

@@ -1,14 +0,0 @@
-#ifndef SARP_TIME_H
-#define SARP_TIME_H
-#include <stdint.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-  uint64_t sarp_time_now_ms();
-  uint64_t sarp_time_now_sec();
-  
-#ifdef __cplusplus
-}
-#endif
-#endif

include/sarp/version.h

@@ -1,25 +0,0 @@
-#ifndef SARP_VERSION_H
-#define SARP_VERSION_H
-
-#ifndef SARP_VERSION_MAJ
-#define SARP_VERSION_MAJ "0"
-#endif
-
-#ifndef SARP_VERSION_MIN
-#define SARP_VERSION_MIN "0"
-#endif
-
-#ifndef SARP_VERSION_PATCH
-#define SARP_VERSION_PATCH "0"
-#endif
-
-#ifndef SARP_VERSION_NUM
-#ifdef GIT_REV
-#define SARP_VERSION_NUM "-"SARP_VERSION_MAJ"."SARP_VERSION_MIN"."SARP_VERSION_PATCH"-"GIT_REV
-#else
-#define SARP_VERSION_NUM "-"SARP_VERSION_MAJ"."SARP_VERSION_MIN"."SARP_VERSION_PATCH
-#endif
-#endif
-#define SARP_VERSION "llarpd"SARP_VERSION_NUM
-
-#endif

llarp/address_info.c

@@ -1,11 +1,11 @@
-#include <sarp/address_info.h>
+#include <llarp/address_info.h>
 #include <stdio.h>
 #include <string.h>
 
-bool sarp_address_info_bencode(struct sarp_address_info * ai, sarp_buffer_t * buff)
+bool llarp_address_info_bencode(struct llarp_address_info * ai, llarp_buffer_t * buff)
 {
   char * ptr = buff->cur;
-  size_t sz = sarp_buffer_size_left(buff);
+  size_t sz = llarp_buffer_size_left(buff);
   char * end = ptr + sz;
   int r = 0;
   r = snprintf(ptr, (end - ptr), "d1:ci%de1:e32:", ai->rank);

llarp/buffer.cpp

@@ -1,8 +1,8 @@
-#include <sarp/buffer.h>
+#include <llarp/buffer.h>
 
 extern "C" {
 
-  size_t sarp_buffer_size_left(sarp_buffer_t * buff)
+  size_t llarp_buffer_size_left(llarp_buffer_t * buff)
   {
     std::ptrdiff_t diff = buff->cur - buff->base;
     if(diff < 0)

llarp/config.cpp

@@ -1,9 +1,9 @@
-#include <sarp/config.h>
-#include <sarp/mem.h>
+#include <llarp/config.h>
+#include <llarp/mem.h>
 #include "config.hpp"
 #include "ini.hpp"
 
-namespace sarp
+namespace llarp
 {
 
   template<typename Config, typename Section>
@@ -40,29 +40,29 @@ extern "C" {
 
 
   
-  void sarp_new_config(struct sarp_config ** conf)
+  void llarp_new_config(struct llarp_config ** conf)
   {
-    sarp_config * c = static_cast<sarp_config *>(sarp_g_mem.malloc(sizeof(sarp_config)));
+    llarp_config * c = static_cast<llarp_config *>(llarp_g_mem.malloc(sizeof(llarp_config)));
     *conf = c;
   }
 
-  void sarp_free_config(struct sarp_config ** conf)
+  void llarp_free_config(struct llarp_config ** conf)
   {
     if(*conf)
-      sarp_g_mem.free(*conf);
+      llarp_g_mem.free(*conf);
     *conf = nullptr;
   }
 
-  int sarp_load_config(struct sarp_config * conf, const char * fname)
+  int llarp_load_config(struct llarp_config * conf, const char * fname)
   {
     if(!conf->impl.Load(fname)) return -1;
     return 0;
   }
 
-  void sarp_config_iter(struct sarp_config * conf, struct sarp_config_iterator * iter)
+  void llarp_config_iter(struct llarp_config * conf, struct llarp_config_iterator * iter)
   {
     iter->conf = conf;
-    std::map<std::string, sarp::Config::section_t&> sections = {
+    std::map<std::string, llarp::Config::section_t&> sections = {
       {"router", conf->impl.router},
       {"network", conf->impl.network},
       {"links", conf->impl.links},

llarp/config.hpp

@@ -1,11 +1,11 @@
-#ifndef LIBSARP_CONFIG_HPP
-#define LIBSARP_CONFIG_HPP
+#ifndef LIBLLARP_CONFIG_HPP
+#define LIBLLARP_CONFIG_HPP
 #include <map>
 #include <string>
 
-#include <sarp/config.h>
+#include <llarp/config.h>
 
-namespace sarp
+namespace llarp
 {
   struct Config
   {
@@ -23,9 +23,9 @@ namespace sarp
 
 
 extern "C" {
-  struct sarp_config
+  struct llarp_config
   {
-    sarp::Config impl;
+    llarp::Config impl;
   };
 }
 

llarp/crypto_libsodium.cpp

@@ -1,36 +1,36 @@
-#include <sarp/crypto.h>
+#include <llarp/crypto.h>
 #include <sodium/crypto_stream_xchacha20.h>
 #include <sodium/crypto_generichash.h>
 #include <sodium/crypto_scalarmult.h>
 #include <sodium/crypto_sign.h>
 
-namespace sarp
+namespace llarp
 {
   namespace sodium
   {
-    bool xchacha20(sarp_buffer_t buff, sarp_sharedkey_t k, sarp_nounce_t n)
+    bool xchacha20(llarp_buffer_t buff, llarp_sharedkey_t k, llarp_nounce_t n)
     {
       uint8_t * base = (uint8_t*)buff.base;
       return crypto_stream_xchacha20_xor(base, base, buff.sz, n, k) == 0;
     }
 
-    bool dh(sarp_sharedkey_t * shared, uint8_t * client_pk, uint8_t * server_pk, uint8_t * remote_key, uint8_t * local_key)
+    bool dh(llarp_sharedkey_t * shared, uint8_t * client_pk, uint8_t * server_pk, uint8_t * remote_key, uint8_t * local_key)
     {
       uint8_t * out = *shared;
       const size_t outsz = SHAREDKEYSIZE;
       crypto_generichash_state h;
       if(crypto_scalarmult(out, local_key, remote_key) == -1) return false;
       crypto_generichash_init(&h, NULL, 0U, outsz);
-      crypto_generichash_update(&h, client_pk, sizeof(sarp_pubkey_t));
-      crypto_generichash_update(&h, server_pk, sizeof(sarp_pubkey_t));
+      crypto_generichash_update(&h, client_pk, sizeof(llarp_pubkey_t));
+      crypto_generichash_update(&h, server_pk, sizeof(llarp_pubkey_t));
       crypto_generichash_update(&h, out, crypto_scalarmult_BYTES);
       crypto_generichash_final(&h, out, outsz);
       return true;
     }
 
-    bool dh_client(sarp_sharedkey_t * shared, sarp_pubkey_t pk, sarp_tunnel_nounce_t n, sarp_seckey_t sk)
+    bool dh_client(llarp_sharedkey_t * shared, llarp_pubkey_t pk, llarp_tunnel_nounce_t n, llarp_seckey_t sk)
     {
-      sarp_pubkey_t local_pk;
+      llarp_pubkey_t local_pk;
       crypto_scalarmult_base(local_pk, sk);
       if(dh(shared, local_pk, pk, pk, sk))
       {
@@ -39,9 +39,9 @@ namespace sarp
       return false;
     }
 
-    bool dh_server(sarp_sharedkey_t * shared, sarp_pubkey_t pk, sarp_tunnel_nounce_t n, sarp_seckey_t sk)
+    bool dh_server(llarp_sharedkey_t * shared, llarp_pubkey_t pk, llarp_tunnel_nounce_t n, llarp_seckey_t sk)
     {
-      sarp_pubkey_t local_pk;
+      llarp_pubkey_t local_pk;
       crypto_scalarmult_base(local_pk, sk);
       if(dh(shared, pk, local_pk, pk, sk))
       {
@@ -50,25 +50,25 @@ namespace sarp
       return false;
     }
 
-    bool hash(sarp_hash_t * result, sarp_buffer_t buff)
+    bool hash(llarp_hash_t * result, llarp_buffer_t buff)
     {
       const uint8_t * base = (const uint8_t *) buff.base;
       return crypto_generichash(*result, HASHSIZE, base, buff.sz, nullptr, 0) != -1;
     }
 
-    bool hmac(sarp_hash_t * result, sarp_buffer_t buff, sarp_seckey_t secret)
+    bool hmac(llarp_hash_t * result, llarp_buffer_t buff, llarp_seckey_t secret)
     {
       const uint8_t * base = (const uint8_t *) buff.base;
-      return crypto_generichash(*result, sizeof(sarp_hash_t), base, buff.sz, secret, HMACSECSIZE) != -1;
+      return crypto_generichash(*result, sizeof(llarp_hash_t), base, buff.sz, secret, HMACSECSIZE) != -1;
     }
 
-    bool sign(sarp_sig_t * result, sarp_seckey_t secret, sarp_buffer_t buff)
+    bool sign(llarp_sig_t * result, llarp_seckey_t secret, llarp_buffer_t buff)
     {
       const uint8_t * base = (const uint8_t *) buff.base;
       return crypto_sign_detached(*result, nullptr, base, buff.sz, secret) != -1;
     }
 
-    bool verify(sarp_pubkey_t pub, sarp_buffer_t buff, sarp_sig_t sig)
+    bool verify(llarp_pubkey_t pub, llarp_buffer_t buff, llarp_sig_t sig)
     {
       const uint8_t * base = (const uint8_t *) buff.base;
       return crypto_sign_verify_detached(sig, base, buff.sz, pub) != -1;
@@ -77,14 +77,14 @@ namespace sarp
 }
 
 extern "C" {
-  void sarp_crypto_libsodium_init(struct sarp_crypto * c)
+  void llarp_crypto_libsodium_init(struct llarp_crypto * c)
   {
-    c->xchacha20 = sarp::sodium::xchacha20;
-    c->dh_client = sarp::sodium::dh_client;
-    c->dh_server = sarp::sodium::dh_server;
-    c->hash = sarp::sodium::hash;
-    c->hmac = sarp::sodium::hmac;
-    c->sign = sarp::sodium::sign;
-    c->verify = sarp::sodium::verify;
+    c->xchacha20 = llarp::sodium::xchacha20;
+    c->dh_client = llarp::sodium::dh_client;
+    c->dh_server = llarp::sodium::dh_server;
+    c->hash = llarp::sodium::hash;
+    c->hmac = llarp::sodium::hmac;
+    c->sign = llarp::sodium::sign;
+    c->verify = llarp::sodium::verify;
   }
 }

llarp/ev.cpp

@@ -1,20 +1,20 @@
-#include <sarp/ev.h>
-#include <sarp/mem.h>
+#include <llarp/ev.h>
+#include <llarp/mem.h>
 #include <uv.h>
 
-struct sarp_ev_loop
+struct llarp_ev_loop
 {
   uv_loop_t _loop;
 
   uv_loop_t * loop() { return &_loop; }
 };
 
-namespace sarp
+namespace llarp
 {
   struct udp_listener
   {
     uv_udp_t _handle;
-    struct sarp_udp_listener * listener;
+    struct llarp_udp_listener * listener;
     
     void recvfrom(const struct sockaddr * addr, char * buff, ssize_t sz)
     {
@@ -35,7 +35,7 @@ namespace sarp
 
   static void udp_alloc_cb(uv_handle_t * h, size_t sz, uv_buf_t * buf)
   {
-    buf->base = static_cast<char *>(sarp_g_mem.malloc(sz));
+    buf->base = static_cast<char *>(llarp_g_mem.malloc(sz));
     buf->len = sz;
   }
 
@@ -43,49 +43,49 @@ namespace sarp
   {
     udp_listener * l = static_cast<udp_listener *>(handle->data);
     l->recvfrom(addr, buf->base, nread);
-    sarp_g_mem.free(buf->base);
+    llarp_g_mem.free(buf->base);
   }
 
   static void udp_close_cb(uv_handle_t * handle)
   {
     udp_listener * l = static_cast<udp_listener *>(handle->data);
     l->closed();
-    sarp_g_mem.free(l);
+    llarp_g_mem.free(l);
   }
 }
 
 
 extern "C" {
-  void sarp_ev_loop_alloc(struct sarp_ev_loop ** ev)
+  void llarp_ev_loop_alloc(struct llarp_ev_loop ** ev)
   {
-    *ev = static_cast<sarp_ev_loop*>(sarp_g_mem.malloc(sizeof(struct sarp_ev_loop)));
+    *ev = static_cast<llarp_ev_loop*>(llarp_g_mem.malloc(sizeof(struct llarp_ev_loop)));
     if (*ev)
     {
       uv_loop_init((*ev)->loop());
     }
   }
   
-  void sarp_ev_loop_free(struct sarp_ev_loop ** ev)
+  void llarp_ev_loop_free(struct llarp_ev_loop ** ev)
   {
     if(*ev)
     {
       uv_loop_close((*ev)->loop());
-      sarp_g_mem.free(*ev);
+      llarp_g_mem.free(*ev);
     }
     *ev = nullptr;
   }
 
-  int sarp_ev_loop_run(struct sarp_ev_loop * ev)
+  int llarp_ev_loop_run(struct llarp_ev_loop * ev)
   {
     return uv_run(ev->loop(), UV_RUN_DEFAULT);
   }
  
-  int sarp_ev_add_udp_listener(struct sarp_ev_loop * ev, struct sarp_udp_listener * listener)
+  int llarp_ev_add_udp_listener(struct llarp_ev_loop * ev, struct llarp_udp_listener * listener)
   {
     sockaddr_in6 addr;
     uv_ip6_addr(listener->host, listener->port, &addr);
     int ret = 0;
-    sarp::udp_listener * l = static_cast<sarp::udp_listener *>(sarp_g_mem.malloc(sizeof(sarp::udp_listener)));
+    llarp::udp_listener * l = static_cast<llarp::udp_listener *>(llarp_g_mem.malloc(sizeof(llarp::udp_listener)));
     listener->impl = l;
     l->udp()->data = l;
     l->listener = listener;
@@ -96,24 +96,24 @@ extern "C" {
       ret = uv_udp_bind(l->udp(), (const sockaddr *)&addr, 0);
       if (ret == 0)
       {
-        ret = uv_udp_recv_start(l->udp(), sarp::udp_alloc_cb, sarp::udp_recv_cb);
+        ret = uv_udp_recv_start(l->udp(), llarp::udp_alloc_cb, llarp::udp_recv_cb);
       }
     }
     return ret;
   }
 
-  int sarp_ev_close_udp_listener(struct sarp_udp_listener * listener)
+  int llarp_ev_close_udp_listener(struct llarp_udp_listener * listener)
   {
     int ret = -1;
     if(listener)
     {
-      sarp::udp_listener * l = static_cast<sarp::udp_listener*>(listener->impl);
+      llarp::udp_listener * l = static_cast<llarp::udp_listener*>(listener->impl);
       if(l)
       {
         if(!uv_udp_recv_stop(l->udp()))
         {
           l->closed();
-          sarp_g_mem.free(l);
+          llarp_g_mem.free(l);
           ret = 0;
         }
       }

llarp/link.cpp

@@ -1,16 +1,16 @@
 #include "link.hpp"
 #include <cstring>
-#include <sarp/time.h>
+#include <llarp/time.h>
 
 bool operator < (const sockaddr_in6 addr0, const sockaddr_in6 addr1)
 {
   return memcmp(addr0.sin6_addr.s6_addr, addr1.sin6_addr.s6_addr, sizeof(addr0.sin6_addr)) && addr0.sin6_port < addr1.sin6_port;
 }
 
-namespace sarp
+namespace llarp
 {
 
-  static void link_recv_from(struct sarp_udp_listener * l, const struct sockaddr * src, char * buff, ssize_t sz)
+  static void link_recv_from(struct llarp_udp_listener * l, const struct sockaddr * src, char * buff, ssize_t sz)
   {
     if(src && src->sa_family == AF_INET6)
     {
@@ -26,7 +26,7 @@ namespace sarp
     }
   }
   
-  Link::Link(sarp_crypto * crypto) : _crypto(crypto)
+  Link::Link(llarp_crypto * crypto) : _crypto(crypto)
   {
     _listener.user = this;
     _listener.recvfrom = link_recv_from;
@@ -36,7 +36,7 @@ namespace sarp
   {
   }
   
-  PeerSession::PeerSession(sarp_crypto * crypto, sockaddr_in6 remote) :
+  PeerSession::PeerSession(llarp_crypto * crypto, sockaddr_in6 remote) :
     lastRX(0),
     remoteAddr(remote),
     _crypto(crypto),
@@ -48,6 +48,6 @@ namespace sarp
 
   void PeerSession::RecvFrom(const char * buff, ssize_t sz)
   {
-    lastRX = sarp_time_now_ms();
+    lastRX = llarp_time_now_ms();
   }
 }

llarp/link.hpp

@@ -1,26 +1,26 @@
-#ifndef LIBSARP_LINK_HPP
-#define LIBSARP_LINK_HPP
+#ifndef LLARP_LINK_HPP
+#define LLARP_LINK_HPP
 #include <netinet/in.h>
-#include <sarp/crypto.h>
+#include <llarp/crypto.h>
 #include <cstdint>
 #include <map>
 #include <memory>
 
-#include <sarp/ev.h>
+#include <llarp/ev.h>
 
-namespace sarp
+namespace llarp
 {
   struct Link;
   
   struct PeerSession
   {
     sockaddr_in6 remoteAddr;
-    sarp_pubkey_t remotePubkey;
-    sarp_sharedkey_t sessionKey;
+    llarp_pubkey_t remotePubkey;
+    llarp_sharedkey_t sessionKey;
 
     uint64_t lastRX;
 
-    sarp_crypto * _crypto;
+    llarp_crypto * _crypto;
     
     enum State
     {
@@ -38,10 +38,10 @@ namespace sarp
     State state;
 
     /** inbound session */
-    PeerSession(sarp_crypto * crypto, sockaddr_in6 remote);
+    PeerSession(llarp_crypto * crypto, sockaddr_in6 remote);
 
     /** outbound session */
-    PeerSession(sarp_crypto * crypto, sockaddr_in6 remote, sarp_pubkey_t remotePubkey);
+    PeerSession(llarp_crypto * crypto, sockaddr_in6 remote, llarp_pubkey_t remotePubkey);
 
     PeerSession & operator=(const PeerSession & other);
     
@@ -58,17 +58,17 @@ namespace sarp
     typedef std::map<sockaddr_in6, PeerSession_ptr> Sessions;
  
     Sessions sessions;
-    sarp_seckey_t transportSecKey;
-    sarp_pubkey_t transportPubKey;
+    llarp_seckey_t transportSecKey;
+    llarp_pubkey_t transportPubKey;
 
-    sarp_crypto * _crypto;
+    llarp_crypto * _crypto;
 
-    Link(sarp_crypto * crypto);
+    Link(llarp_crypto * crypto);
     ~Link();
     
-    sarp_udp_listener _listener;
+    llarp_udp_listener _listener;
 
-    sarp_udp_listener * Listener() { return &_listener; }
+    llarp_udp_listener * Listener() { return &_listener; }
     
   };
 }

llarp/mem.cpp

@@ -1,7 +1,7 @@
-#include <sarp/mem.h>
+#include <llarp/mem.h>
 
 extern "C" {
-  struct sarp_alloc sarp_g_mem = {
+  struct llarp_alloc llarp_g_mem = {
     .malloc = nullptr,
     .realloc = nullptr,
     .calloc = nullptr,

llarp/mem_jemalloc.cpp

@@ -1,7 +1,7 @@
-#include <sarp/mem.h>
+#include <llarp/mem.h>
 #include <jemalloc/jemalloc.h>
 
-namespace sarp
+namespace llarp
 {
   static void * jem_malloc(size_t sz)
   {
@@ -25,11 +25,11 @@ namespace sarp
 }
 
 extern "C" {
-  void sarp_mem_jemalloc()
+  void llarp_mem_jemalloc()
   {
-    sarp_g_mem.malloc = sarp::jem_malloc;
-    sarp_g_mem.free = sarp::jem_free;
-    sarp_g_mem.calloc = sarp::jem_calloc;
-    sarp_g_mem.realloc = sarp::jem_realloc;
+    llarp_g_mem.malloc = llarp::jem_malloc;
+    llarp_g_mem.free = llarp::jem_free;
+    llarp_g_mem.calloc = llarp::jem_calloc;
+    llarp_g_mem.realloc = llarp::jem_realloc;
   }
 }

llarp/mem_std.cpp

@@ -1,6 +1,6 @@
-#include <sarp/mem.h>
+#include <llarp/mem.h>
 
-namespace sarp
+namespace llarp
 {
   void * std_malloc(size_t sz)
   {
@@ -31,11 +31,11 @@ namespace sarp
 }
 
 extern "C" {
-  void sarp_mem_std()
+  void llarp_mem_std()
   {
-    sarp_g_mem.malloc = sarp::std_malloc;
-    sarp_g_mem.free = sarp::std_free;
-    sarp_g_mem.calloc = sarp::std_calloc;
-    sarp_g_mem.realloc = sarp::std_realloc;
+    llarp_g_mem.malloc = llarp::std_malloc;
+    llarp_g_mem.free = llarp::std_free;
+    llarp_g_mem.calloc = llarp::std_calloc;
+    llarp_g_mem.realloc = llarp::std_realloc;
   }
 }

llarp/router.cpp

@@ -1,25 +1,25 @@
-#include <sarp/router.h>
-#include <sarp/link.h>
+#include <llarp/router.h>
+#include <llarp/link.h>
 #include "link.hpp"
 #include <list>
 #include "str.hpp"
 
-namespace sarp
+namespace llarp
 {
-  void router_iter_config(sarp_config_iterator * iter, const char * section, const char * key, const char * val);
+  void router_iter_config(llarp_config_iterator * iter, const char * section, const char * key, const char * val);
 
   
   struct Router
   {
     std::list<Link *> Links;
-    sarp_crypto * crypto;
+    llarp_crypto * crypto;
     void Close()
     {
       if(Links.size())
       {
         for(auto & itr : Links)
         {
-          sarp_ev_close_udp_listener(itr->Listener());
+          llarp_ev_close_udp_listener(itr->Listener());
         }
         Links.clear();
       }
@@ -37,55 +37,55 @@ namespace sarp
 
 extern "C" {
 
-  struct sarp_router
+  struct llarp_router
   {
-    sarp::Router impl;
-    sarp_crypto crypto;
+    llarp::Router impl;
+    llarp_crypto crypto;
   };
   
-  void sarp_init_router(struct sarp_router ** router)
+  void llarp_init_router(struct llarp_router ** router)
   {
-    *router = static_cast<sarp_router *>(sarp_g_mem.malloc(sizeof(sarp_router)));
+    *router = static_cast<llarp_router *>(llarp_g_mem.malloc(sizeof(llarp_router)));
     if(*router)
     {
-      sarp_crypto_libsodium_init(&(*router)->crypto);
+      llarp_crypto_libsodium_init(&(*router)->crypto);
     }
   }
 
-  int sarp_configure_router(struct sarp_router * router, struct sarp_config * conf)
+  int llarp_configure_router(struct llarp_router * router, struct llarp_config * conf)
   {
-    sarp_config_iterator iter;
+    llarp_config_iterator iter;
     iter.user = router;
-    iter.visit = sarp::router_iter_config;
-    sarp_config_iter(conf, &iter);
+    iter.visit = llarp::router_iter_config;
+    llarp_config_iter(conf, &iter);
     return router->impl.Configured() ? 0 : -1;
   }
 
-  void sarp_run_router(struct sarp_router * router, struct sarp_ev_loop * loop)
+  void llarp_run_router(struct llarp_router * router, struct llarp_ev_loop * loop)
   {
     if(router->impl.Links.size())
       for(auto & iter : router->impl.Links)
-        sarp_ev_add_udp_listener(loop, iter->Listener());
+        llarp_ev_add_udp_listener(loop, iter->Listener());
   }
 
-  void sarp_free_router(struct sarp_router ** router)
+  void llarp_free_router(struct llarp_router ** router)
   {
     if(*router)
     {
-      sarp_router * r = *router;
+      llarp_router * r = *router;
       r->impl.Close();
-      sarp_g_mem.free(*router);
+      llarp_g_mem.free(*router);
     }
     *router = nullptr;
   }
 }
 
-namespace sarp
+namespace llarp
 {
   
-  void router_iter_config(sarp_config_iterator * iter, const char * section, const char * key, const char * val)
+  void router_iter_config(llarp_config_iterator * iter, const char * section, const char * key, const char * val)
   {
-    sarp_router * self = static_cast<sarp_router *>(iter->user);
+    llarp_router * self = static_cast<llarp_router *>(iter->user);
     if (streq(section, "links"))
     {
       if(streq(val, "ip"))

llarp/str.hpp

@@ -1,8 +1,8 @@
-#ifndef LIBSARP_STR_HPP
-#define LIBSARP_STR_HPP
+#ifndef LIBLLARP_STR_HPP
+#define LIBLLARP_STR_HPP
 #include <cstring>
 
-namespace sarp
+namespace llarp
 {
   static bool streq(const char * s1, const char * s2)
   {

llarp/time.cpp

@@ -1,25 +1,25 @@
-#include <sarp/time.h>
+#include <llarp/time.h>
 #include <chrono>
 
-namespace sarp
+namespace llarp
 {
   typedef std::chrono::steady_clock clock_t;
 
   template<typename Res>
   static uint64_t time_since_epoch()
   {
-    return std::chrono::duration_cast<Res>(sarp::clock_t::now().time_since_epoch()).count();
+    return std::chrono::duration_cast<Res>(llarp::clock_t::now().time_since_epoch()).count();
   }
 }
 
 extern "C" {
-  uint64_t sarp_time_now_ms()
+  uint64_t llarp_time_now_ms()
   {
-    return sarp::time_since_epoch<std::chrono::milliseconds>();
+    return llarp::time_since_epoch<std::chrono::milliseconds>();
   }
   
-  uint64_t sarp_time_now_sec()
+  uint64_t llarp_time_now_sec()
   {
-    return sarp::time_since_epoch<std::chrono::seconds>();
+    return llarp::time_since_epoch<std::chrono::seconds>();
   }
 }