Release v2.0.0-beta1

Author: miloszlagan

README.md

@@ -0,0 +1,24 @@
+![Husarnet logo](images/logo.svg)
+
+# Husarnet for Arduino ESP32
+
+Husarnet is a low latency, lightweight, privacy preserving P2P VPN. If you want
+to know more go to the [Husarnet's webpage](https://husarnet.com/) or directly
+to the [documentation page](https://docs.husarnet.com/).
+
+This repository only contains library code for the Arduino IDE. If you want
+to use Husarnet with the PlatformIO IDE, go to the [husarnet-esp32-platformio](https://github.com/husarnet/husarnet-esp32-platformio).
+
+Due to the way precompiled libraries work in Arduino the static library for each
+target must be placed in a seperate directory. Due to this `libhusarnet.a` is
+duplicated few times in different folders.
+
+## Installation and usage
+
+Coming soon...
+
+## Examples
+
+You'll find full examples in our [examples](examples) directory.
+
+Start with a [simple-webserver](examples/simple-webserver) for a fairly minimal example.

examples/simple-webserver/simple-webserver.ino

@@ -0,0 +1,60 @@
+#include <Arduino.h>
+#include <WiFi.h>
+#include <WebServer.h>
+#include <husarnet.h>
+
+// WiFi credentials
+#define WIFI_SSID = "wifi-network";
+#define WIFI_PASS = "wifi-password";
+
+// Husarnet credentials
+#define HOSTNAME = "esp32-arduino-webserver";
+#define JOIN_CODE = "xxxxxxxxxxxxxxxxxxxx";
+
+HusarnetClient husarnet;
+WebServer server(80);
+
+void handleRoot() {
+  server.send(200, "text/plain", "Hello Husarnet!");
+}
+
+void setup() {
+  Serial.begin(115200);
+
+  // Connect to the WiFi network
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(WIFI_SSID, WIFI_PASS);
+  
+  Serial.println("Connecting to WiFi");
+  if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    Serial.printf("WiFi connection failure (err: %d)\n", WiFi.status());
+    delay(5000);
+    ESP.restart();
+  }
+
+  Serial.print("Local IP: ");
+  Serial.println(WiFi.localIP());
+
+  // Join the Husarnet network
+  husarnet.join(HOSTNAME, JOIN_CODE);
+
+  while(!husarnet.isJoined()) {
+    Serial.println("Waiting for Husarnet network...");
+    delay(1000);
+  }
+  Serial.println("Husarnet network joined");
+
+  Serial.print("Husarnet IP: ");
+  Serial.println(husarnet.getIpAddress().c_str());
+
+  // Start the web server
+  server.on("/", handleRoot);
+  server.begin();
+  Serial.println("HTTP server started");
+}
+
+void loop() {
+  // Handle incoming connections
+  server.handleClient();
+  delay(2);
+}

images/logo.svg

@@ -0,0 +1,10 @@
+name=Husarnet ESP32
+version=2.0.0-beta1
+author=Husarnet
+maintainer=Milosz Lagan, [email protected]
+sentence=Connect your devices using secure P2P network layer for robots and IoT.
+paragraph=Look at docs.husarnet.com for information how to configure your project!
+category=Communication
+url=https://husarnet.com/
+includes=husarnet.h
+precompiled=true

library.properties

@@ -0,0 +1,10 @@
+#pragma once
+
+// User-facing API is defined in the
+// "husarnet/port/esp32/user_interface.h" header
+// in the included Husarnet submodule.
+#include "husarnet/ports/esp32/user_interface.h"
+
+#if defined(ARDUINO) && !defined(ARDUINO_ARCH_ESP32)
+  #error "This library only supports boards from the ESP32 family."
+#endif

src/esp32/libhusarnet.a

@@ -0,0 +1,27 @@
+// Copyright (c) 2024 Husarnet sp. z o.o.
+// Authors: listed in project_root/README.md
+// License: specified in project_root/LICENSE.txt
+#pragma once
+#include <string>
+
+#include <husarnet/husarnet_manager.h>
+
+#include "husarnet/identity.h"
+
+#include "httplib.h"
+#include "nlohmann/json.hpp"
+
+class DashboardApiProxy {
+ private:
+  HusarnetManager* manager;
+
+ public:
+  DashboardApiProxy(HusarnetManager* manager) : manager(manager)
+  {
+  }
+
+  void signAndForward(
+      const httplib::Request& req,
+      httplib::Response& res,
+      const std::string& path);
+};

src/esp32c2/libhusarnet.a

@@ -0,0 +1,58 @@
+// Copyright (c) 2024 Husarnet sp. z o.o.
+// Authors: listed in project_root/README.md
+// License: specified in project_root/LICENSE.txt
+#pragma once
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+#include <string>
+
+#include "husarnet/api_server/dashboard_api_proxy.h"
+
+#include "httplib.h"
+#include "nlohmann/json.hpp"
+
+class HusarnetManager;
+
+namespace httplib {
+  struct Request;
+  struct Response;
+}  // namespace httplib
+
+class ApiServer {
+ private:
+  HusarnetManager* manager;
+  DashboardApiProxy* proxy;
+  std::mutex mutex;
+  std::condition_variable cv;
+
+  void returnSuccess(
+      const httplib::Request& req,
+      httplib::Response& res,
+      nlohmann::json result);
+  void returnSuccess(const httplib::Request& req, httplib::Response& res);
+
+  void returnInvalidQuery(
+      const httplib::Request& req,
+      httplib::Response& res,
+      std::string errorString);
+  void returnError(
+      const httplib::Request& req,
+      httplib::Response& res,
+      std::string errorString);
+
+  bool validateSecret(const httplib::Request& req, httplib::Response& res);
+
+  nlohmann::json getStandardReply();
+
+  bool requireParams(
+      const httplib::Request& req,
+      httplib::Response& res,
+      std::list<std::string> paramNames);
+
+ public:
+  ApiServer(HusarnetManager* manager, DashboardApiProxy* proxy);
+
+  void runThread();
+  void waitStarted();
+};

src/esp32c3/libhusarnet.a

@@ -0,0 +1,36 @@
+// Copyright (c) 2024 Husarnet sp. z o.o.
+// Authors: listed in project_root/README.md
+// License: specified in project_root/LICENSE.txt
+#pragma once
+#include <string>
+
+#include "husarnet/device_id.h"
+#include "husarnet/husarnet_manager.h"
+#include "husarnet/layer_interfaces.h"
+#include "husarnet/string_view.h"
+
+class ConfigStorage;
+class HusarnetManager;
+class PeerContainer;
+
+class CompressionLayer : public BidirectionalLayer {
+ private:
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+  HusarnetManager* manager;
+#pragma clang diagnostic pop
+
+  ConfigStorage& config;
+  PeerContainer* peerContainer;
+
+  std::string compressionBuffer;
+  std::string cleartextBuffer;
+
+  bool shouldProceed(DeviceId source);
+
+ public:
+  CompressionLayer(HusarnetManager* manager);
+
+  void onUpperLayerData(DeviceId peerId, string_view data);
+  void onLowerLayerData(DeviceId peerId, string_view data);
+};

src/esp32c5/libhusarnet.a

@@ -0,0 +1,135 @@
+// Copyright (c) 2024 Husarnet sp. z o.o.
+// Authors: listed in project_root/README.md
+// License: specified in project_root/LICENSE.txt
+#pragma once
+#include <functional>
+#include <list>
+#include <stdexcept>
+#include <string>
+
+#include "husarnet/config_storage.h"
+#include "husarnet/ipaddress.h"
+
+#include "enum.h"
+#include "nlohmann/json.hpp"
+
+using namespace nlohmann;  // json
+
+// Remember to add sane defaults in husarnet_config.h
+// Keep the naming consistent, i.e use only enable* format, and *not* *enable or
+// disable*
+BETTER_ENUM(
+    InternalSetting,
+    int,
+    websetupSecret = 1  // string
+)
+BETTER_ENUM(
+    UserSetting,
+    int,
+    dashboardFqdn = 1,            // string
+    enableWhitelist = 2,          // bool
+    interfaceName = 3,            // string
+    daemonApiPort = 4,            // int
+    enableCompression = 5,        // bool
+    enableUdpTunneling = 6,       // bool
+    enableTcpTunneling = 7,       // bool
+    enableUdp = 8,                // bool
+    enableMulticast = 9,          // bool
+    overrideBaseAddress = 10,     // inet
+    overrideSourcePort = 11,      // int
+    extraAdvertisedAddress = 12,  // inet
+    joinCode = 13,                // string, this will never be persisted
+    hostname = 14,                // string, this will never be persisted
+    enableHooks = 15,             // bool
+    logVerbosity = 16,            // int
+    enableNotifications = 17,     // bool, orphaned
+    daemonApiAddress = 18,        // ip
+    daemonApiInterface = 19       // string
+)
+
+const std::string trueValue = "true";
+const std::string falseValue =
+    "false";  // This is not strictly checked. It's here just to provide a known
+              // placeholder
+
+class HusarnetManager;
+
+class ConfigStorage {
+  HusarnetManager* manager;
+  std::function<std::string()> readFunc;
+  std::function<void(std::string)> writeFunc;
+  std::map<UserSetting, std::string> userDefaults;
+  std::map<UserSetting, std::string> userOverrides;
+  std::map<InternalSetting, std::string> internalDefaults;
+
+  json currentData;
+
+  bool shouldSaveImmediately = true;
+  bool hostCacheInvalidated = true;
+
+  std::string serialize();
+  void deserialize(std::string blob);
+
+  void save();
+
+ public:
+  ConfigStorage(
+      HusarnetManager* manager,
+      std::function<std::string()> readFunc,
+      std::function<void(std::string)> writeFunc,
+      std::map<UserSetting, std::string> userDefaults,
+      std::map<UserSetting, std::string> userOverrides,
+      std::map<InternalSetting, std::string> internalDefaults);
+
+  ConfigStorage(ConfigStorage&) = delete;
+
+  void updateHostsInSystem();
+
+  json getCurrentData() const;
+
+  void groupChanges(std::function<void()> f);
+
+  void hostTableAdd(std::string hostname, IpAddress address);
+  void hostTableRm(std::string hostname);
+  std::map<std::string, IpAddress> getHostTable() const;
+  void hostTableClear();
+
+  void whitelistAdd(IpAddress address);
+  void whitelistRm(IpAddress address);
+  bool isOnWhitelist(IpAddress address) const;
+  std::list<IpAddress> getWhitelist() const;
+  void whitelistClear();
+
+  void setInternalSetting(InternalSetting setting, std::string value);
+  void setInternalSetting(InternalSetting setting, const char* value);
+  void setInternalSetting(InternalSetting setting, bool value);
+  void setInternalSetting(InternalSetting setting, int value);
+  void clearInternalSetting(InternalSetting setting);
+
+  std::string getInternalSetting(InternalSetting setting) const;
+  bool getInternalSettingBool(InternalSetting setting) const;
+  int getInternalSettingInt(InternalSetting setting) const;
+
+  bool isInternalSettingEmpty(InternalSetting setting) const;
+
+  void setUserSetting(UserSetting setting, std::string value);
+  void setUserSetting(UserSetting setting, const char* value);
+  void setUserSetting(UserSetting setting, bool value);
+  void setUserSetting(UserSetting setting, int value);
+  void setUserSetting(UserSetting setting, InetAddress inet);
+  void clearUserSetting(UserSetting setting);
+
+  bool isUserSettingOverriden(UserSetting setting) const;
+  std::string getPersistentUserSetting(UserSetting setting) const;
+  void persistUserSettingOverride(UserSetting setting);
+
+  std::string getUserSetting(UserSetting setting) const;
+  bool getUserSettingBool(UserSetting setting) const;
+  int getUserSettingInt(UserSetting setting) const;
+  InetAddress getUserSettingInet(UserSetting setting) const;
+  IpAddress getUserSettingIp(UserSetting setting) const;
+
+  std::map<std::string, std::string> getUserSettings() const;
+
+  void printSettings() const;
+};