From f69454ec9879a0b0a424f743ca144d1123ef7e99 Mon Sep 17 00:00:00 2001
From: Adam Ierymenko <adam.ierymenko@gmail.com>
Date: Thu, 24 Sep 2015 16:21:36 -0700
Subject: (1) Make ZT_ naming convention consistent (get rid of ZT1_), (2) Make
 local interface a full sockaddr_storage instead of an int identifier, which
 turns out to be better for multi-homing and other uses.

---
 include/ZeroTierOne.h | 247 ++++++++++++++++++++++++++------------------------
 1 file changed, 127 insertions(+), 120 deletions(-)

(limited to 'include')

diff --git a/include/ZeroTierOne.h b/include/ZeroTierOne.h
index fd0b0d24..e8a19e33 100644
--- a/include/ZeroTierOne.h
+++ b/include/ZeroTierOne.h
@@ -26,8 +26,8 @@
  */
 
 /*
- * This defines the external C API for ZeroTier One, the core network
- * virtualization engine.
+ * This defines the external C API for ZeroTier's core network virtualization
+ * engine.
  */
 
 #ifndef ZT_ZEROTIERONE_H
@@ -56,9 +56,9 @@ extern "C" {
 /****************************************************************************/
 
 /**
- * Default port for the ZeroTier service
+ * Default UDP port for devices running a ZeroTier endpoint
  */
-#define ZT1_DEFAULT_PORT 9993
+#define ZT_DEFAULT_PORT 9993
 
 /**
  * Maximum MTU for ZeroTier virtual networks
@@ -83,37 +83,42 @@ extern "C" {
  * We use 2800, which leaves some room for other payload in other types of
  * messages such as multicast propagation or future support for bridging.
  */
-#define ZT1_MAX_MTU 2800
+#define ZT_MAX_MTU 2800
 
 /**
  * Maximum length of network short name
  */
-#define ZT1_MAX_NETWORK_SHORT_NAME_LENGTH 255
+#define ZT_MAX_NETWORK_SHORT_NAME_LENGTH 255
 
 /**
  * Maximum number of statically assigned IP addresses per network endpoint using ZT address management (not DHCP)
  */
-#define ZT1_MAX_ZT_ASSIGNED_ADDRESSES 16
+#define ZT_MAX_ZT_ASSIGNED_ADDRESSES 16
 
 /**
  * Maximum number of multicast group subscriptions per network
  */
-#define ZT1_MAX_NETWORK_MULTICAST_SUBSCRIPTIONS 4096
+#define ZT_MAX_NETWORK_MULTICAST_SUBSCRIPTIONS 4096
 
 /**
  * Maximum number of direct network paths to a given peer
  */
-#define ZT1_MAX_PEER_NETWORK_PATHS 4
+#define ZT_MAX_PEER_NETWORK_PATHS 4
 
 /**
  * Feature flag: ZeroTier One was built to be thread-safe -- concurrent processXXX() calls are okay
  */
-#define ZT1_FEATURE_FLAG_THREAD_SAFE 0x00000001
+#define ZT_FEATURE_FLAG_THREAD_SAFE 0x00000001
 
 /**
  * Feature flag: FIPS compliant build (not available yet, but reserved for future use if we ever do this)
  */
-#define ZT1_FEATURE_FLAG_FIPS 0x00000002
+#define ZT_FEATURE_FLAG_FIPS 0x00000002
+
+/**
+ * A null/empty sockaddr (all zero) to signify an unspecified socket address
+ */
+extern const struct sockaddr_storage ZT_SOCKADDR_NULL;
 
 /****************************************************************************/
 /* Structures and other types                                               */
@@ -122,53 +127,53 @@ extern "C" {
 /**
  * Function return code: OK (0) or error results
  *
- * Use ZT1_ResultCode_isFatal() to check for a fatal error. If a fatal error
+ * Use ZT_ResultCode_isFatal() to check for a fatal error. If a fatal error
  * occurs, the node should be considered to not be working correctly. These
  * indicate serious problems like an inaccessible data store or a compile
  * problem.
  */
-enum ZT1_ResultCode
+enum ZT_ResultCode
 {
 	/**
 	 * Operation completed normally
 	 */
-	ZT1_RESULT_OK = 0,
+	ZT_RESULT_OK = 0,
 
 	// Fatal errors (>0, <1000)
 
 	/**
 	 * Ran out of memory
 	 */
-	ZT1_RESULT_FATAL_ERROR_OUT_OF_MEMORY = 1,
+	ZT_RESULT_FATAL_ERROR_OUT_OF_MEMORY = 1,
 
 	/**
 	 * Data store is not writable or has failed
 	 */
-	ZT1_RESULT_FATAL_ERROR_DATA_STORE_FAILED = 2,
+	ZT_RESULT_FATAL_ERROR_DATA_STORE_FAILED = 2,
 
 	/**
 	 * Internal error (e.g. unexpected exception indicating bug or build problem)
 	 */
-	ZT1_RESULT_FATAL_ERROR_INTERNAL = 3,
+	ZT_RESULT_FATAL_ERROR_INTERNAL = 3,
 
 	// Non-fatal errors (>1000)
 
 	/**
 	 * Network ID not valid
 	 */
-	ZT1_RESULT_ERROR_NETWORK_NOT_FOUND = 1000
+	ZT_RESULT_ERROR_NETWORK_NOT_FOUND = 1000
 };
 
 /**
  * @param x Result code
  * @return True if result code indicates a fatal error
  */
-#define ZT1_ResultCode_isFatal(x) ((((int)(x)) > 0)&&(((int)(x)) < 1000))
+#define ZT_ResultCode_isFatal(x) ((((int)(x)) > 0)&&(((int)(x)) < 1000))
 
 /**
  * Status codes sent to status update callback when things happen
  */
-enum ZT1_Event
+enum ZT_Event
 {
 	/**
 	 * Node has been initialized
@@ -178,21 +183,21 @@ enum ZT1_Event
 	 *
 	 * Meta-data: none
 	 */
-	ZT1_EVENT_UP = 0,
+	ZT_EVENT_UP = 0,
 
 	/**
 	 * Node is offline -- network does not seem to be reachable by any available strategy
 	 *
 	 * Meta-data: none
 	 */
-	ZT1_EVENT_OFFLINE = 1,
+	ZT_EVENT_OFFLINE = 1,
 
 	/**
 	 * Node is online -- at least one upstream node appears reachable
 	 *
 	 * Meta-data: none
 	 */
-	ZT1_EVENT_ONLINE = 2,
+	ZT_EVENT_ONLINE = 2,
 
 	/**
 	 * Node is shutting down
@@ -203,7 +208,7 @@ enum ZT1_Event
 	 *
 	 * Meta-data: none
 	 */
-	ZT1_EVENT_DOWN = 3,
+	ZT_EVENT_DOWN = 3,
 
 	/**
 	 * Your identity has collided with another node's ZeroTier address
@@ -235,7 +240,7 @@ enum ZT1_Event
 	 *
 	 * Meta-data: none
 	 */
-	ZT1_EVENT_FATAL_ERROR_IDENTITY_COLLISION = 4,
+	ZT_EVENT_FATAL_ERROR_IDENTITY_COLLISION = 4,
 
 	/**
 	 * A more recent version was observed on the network
@@ -246,21 +251,21 @@ enum ZT1_Event
 	 *
 	 * Meta-data: unsigned int[3], more recent version number
 	 */
-	ZT1_EVENT_SAW_MORE_RECENT_VERSION = 5,
+	ZT_EVENT_SAW_MORE_RECENT_VERSION = 5,
 
 	/**
 	 * A packet failed authentication
 	 *
 	 * Meta-data: struct sockaddr_storage containing origin address of packet
 	 */
-	ZT1_EVENT_AUTHENTICATION_FAILURE = 6,
+	ZT_EVENT_AUTHENTICATION_FAILURE = 6,
 
 	/**
 	 * A received packet was not valid
 	 *
 	 * Meta-data: struct sockaddr_storage containing origin address of packet
 	 */
-	ZT1_EVENT_INVALID_PACKET = 7,
+	ZT_EVENT_INVALID_PACKET = 7,
 
 	/**
 	 * Trace (debugging) message
@@ -269,7 +274,7 @@ enum ZT1_Event
 	 *
 	 * Meta-data: C string, TRACE message
 	 */
-	ZT1_EVENT_TRACE = 8
+	ZT_EVENT_TRACE = 8
 };
 
 /**
@@ -300,58 +305,58 @@ typedef struct
 	 * True if some kind of connectivity appears available
 	 */
 	int online;
-} ZT1_NodeStatus;
+} ZT_NodeStatus;
 
 /**
  * Virtual network status codes
  */
-enum ZT1_VirtualNetworkStatus
+enum ZT_VirtualNetworkStatus
 {
 	/**
 	 * Waiting for network configuration (also means revision == 0)
 	 */
-	ZT1_NETWORK_STATUS_REQUESTING_CONFIGURATION = 0,
+	ZT_NETWORK_STATUS_REQUESTING_CONFIGURATION = 0,
 
 	/**
 	 * Configuration received and we are authorized
 	 */
-	ZT1_NETWORK_STATUS_OK = 1,
+	ZT_NETWORK_STATUS_OK = 1,
 
 	/**
 	 * Netconf master told us 'nope'
 	 */
-	ZT1_NETWORK_STATUS_ACCESS_DENIED = 2,
+	ZT_NETWORK_STATUS_ACCESS_DENIED = 2,
 
 	/**
 	 * Netconf master exists, but this virtual network does not
 	 */
-	ZT1_NETWORK_STATUS_NOT_FOUND = 3,
+	ZT_NETWORK_STATUS_NOT_FOUND = 3,
 
 	/**
 	 * Initialization of network failed or other internal error
 	 */
-	ZT1_NETWORK_STATUS_PORT_ERROR = 4,
+	ZT_NETWORK_STATUS_PORT_ERROR = 4,
 
 	/**
 	 * ZeroTier One version too old
 	 */
-	ZT1_NETWORK_STATUS_CLIENT_TOO_OLD = 5
+	ZT_NETWORK_STATUS_CLIENT_TOO_OLD = 5
 };
 
 /**
  * Virtual network type codes
  */
-enum ZT1_VirtualNetworkType
+enum ZT_VirtualNetworkType
 {
 	/**
 	 * Private networks are authorized via certificates of membership
 	 */
-	ZT1_NETWORK_TYPE_PRIVATE = 0,
+	ZT_NETWORK_TYPE_PRIVATE = 0,
 
 	/**
 	 * Public networks have no access control -- they'll always be AUTHORIZED
 	 */
-	ZT1_NETWORK_TYPE_PUBLIC = 1
+	ZT_NETWORK_TYPE_PUBLIC = 1
 };
 
 /**
@@ -368,32 +373,32 @@ typedef struct
 	 * Additional distinguishing information (usually zero)
 	 */
 	unsigned long adi;
-} ZT1_MulticastGroup;
+} ZT_MulticastGroup;
 
 /**
  * Virtual network configuration update type
  */
-enum ZT1_VirtualNetworkConfigOperation
+enum ZT_VirtualNetworkConfigOperation
 {
 	/**
 	 * Network is coming up (either for the first time or after service restart)
 	 */
-	ZT1_VIRTUAL_NETWORK_CONFIG_OPERATION_UP = 1,
+	ZT_VIRTUAL_NETWORK_CONFIG_OPERATION_UP = 1,
 
 	/**
 	 * Network configuration has been updated
 	 */
-	ZT1_VIRTUAL_NETWORK_CONFIG_OPERATION_CONFIG_UPDATE = 2,
+	ZT_VIRTUAL_NETWORK_CONFIG_OPERATION_CONFIG_UPDATE = 2,
 
 	/**
 	 * Network is going down (not permanently)
 	 */
-	ZT1_VIRTUAL_NETWORK_CONFIG_OPERATION_DOWN = 3,
+	ZT_VIRTUAL_NETWORK_CONFIG_OPERATION_DOWN = 3,
 
 	/**
 	 * Network is going down permanently (leave/delete)
 	 */
-	ZT1_VIRTUAL_NETWORK_CONFIG_OPERATION_DESTROY = 4
+	ZT_VIRTUAL_NETWORK_CONFIG_OPERATION_DESTROY = 4
 };
 
 /**
@@ -414,17 +419,17 @@ typedef struct
 	/**
 	 * Network name (from network configuration master)
 	 */
-	char name[ZT1_MAX_NETWORK_SHORT_NAME_LENGTH + 1];
+	char name[ZT_MAX_NETWORK_SHORT_NAME_LENGTH + 1];
 
 	/**
 	 * Network configuration request status
 	 */
-	enum ZT1_VirtualNetworkStatus status;
+	enum ZT_VirtualNetworkStatus status;
 
 	/**
 	 * Network type
 	 */
-	enum ZT1_VirtualNetworkType type;
+	enum ZT_VirtualNetworkType type;
 
 	/**
 	 * Maximum interface MTU
@@ -478,7 +483,7 @@ typedef struct
 	/**
 	 * Multicast group subscriptions
 	 */
-	ZT1_MulticastGroup multicastSubscriptions[ZT1_MAX_NETWORK_MULTICAST_SUBSCRIPTIONS];
+	ZT_MulticastGroup multicastSubscriptions[ZT_MAX_NETWORK_MULTICAST_SUBSCRIPTIONS];
 
 	/**
 	 * Number of assigned addresses
@@ -495,17 +500,17 @@ typedef struct
 	 * This is only used for ZeroTier-managed address assignments sent by the
 	 * virtual network's configuration master.
 	 */
-	struct sockaddr_storage assignedAddresses[ZT1_MAX_ZT_ASSIGNED_ADDRESSES];
-} ZT1_VirtualNetworkConfig;
+	struct sockaddr_storage assignedAddresses[ZT_MAX_ZT_ASSIGNED_ADDRESSES];
+} ZT_VirtualNetworkConfig;
 
 /**
  * A list of networks
  */
 typedef struct
 {
-	ZT1_VirtualNetworkConfig *networks;
+	ZT_VirtualNetworkConfig *networks;
 	unsigned long networkCount;
-} ZT1_VirtualNetworkList;
+} ZT_VirtualNetworkList;
 
 /**
  * Physical network path to a peer
@@ -541,15 +546,15 @@ typedef struct
 	 * Is path preferred?
 	 */
 	int preferred;
-} ZT1_PeerPhysicalPath;
+} ZT_PeerPhysicalPath;
 
 /**
  * What trust hierarchy role does this peer have?
  */
-enum ZT1_PeerRole {
-	ZT1_PEER_ROLE_LEAF = 0,     // ordinary node
-	ZT1_PEER_ROLE_RELAY = 1,    // relay node
-	ZT1_PEER_ROLE_ROOT = 2      // root server
+enum ZT_PeerRole {
+	ZT_PEER_ROLE_LEAF = 0,     // ordinary node
+	ZT_PEER_ROLE_RELAY = 1,    // relay node
+	ZT_PEER_ROLE_ROOT = 2      // root server
 };
 
 /**
@@ -595,7 +600,7 @@ typedef struct
 	/**
 	 * What trust hierarchy role does this device have?
 	 */
-	enum ZT1_PeerRole role;
+	enum ZT_PeerRole role;
 
 	/**
 	 * Number of paths (size of paths[])
@@ -605,31 +610,31 @@ typedef struct
 	/**
 	 * Known network paths to peer
 	 */
-	ZT1_PeerPhysicalPath paths[ZT1_MAX_PEER_NETWORK_PATHS];
-} ZT1_Peer;
+	ZT_PeerPhysicalPath paths[ZT_MAX_PEER_NETWORK_PATHS];
+} ZT_Peer;
 
 /**
  * List of peers
  */
 typedef struct
 {
-	ZT1_Peer *peers;
+	ZT_Peer *peers;
 	unsigned long peerCount;
-} ZT1_PeerList;
+} ZT_PeerList;
 
 /**
  * Local interface trust levels
  */
 typedef enum {
-	ZT1_LOCAL_INTERFACE_ADDRESS_TRUST_NORMAL = 0,
-	ZT1_LOCAL_INTERFACE_ADDRESS_TRUST_PRIVACY = 1,
-	ZT1_LOCAL_INTERFACE_ADDRESS_TRUST_ULTIMATE = 2
-} ZT1_LocalInterfaceAddressTrust;
+	ZT_LOCAL_INTERFACE_ADDRESS_TRUST_NORMAL = 0,
+	ZT_LOCAL_INTERFACE_ADDRESS_TRUST_PRIVACY = 1,
+	ZT_LOCAL_INTERFACE_ADDRESS_TRUST_ULTIMATE = 2
+} ZT_LocalInterfaceAddressTrust;
 
 /**
  * An instance of a ZeroTier One node (opaque)
  */
-typedef void ZT1_Node;
+typedef void ZT_Node;
 
 /****************************************************************************/
 /* Callbacks used by Node API                                               */
@@ -656,12 +661,12 @@ typedef void ZT1_Node;
  * on failure, and this results in the network being placed into the
  * PORT_ERROR state.
  */
-typedef int (*ZT1_VirtualNetworkConfigFunction)(
-	ZT1_Node *,
+typedef int (*ZT_VirtualNetworkConfigFunction)(
+	ZT_Node *,
 	void *,
 	uint64_t,
-	enum ZT1_VirtualNetworkConfigOperation,
-	const ZT1_VirtualNetworkConfig *);
+	enum ZT_VirtualNetworkConfigOperation,
+	const ZT_VirtualNetworkConfig *);
 
 /**
  * Function to send a frame out to a virtual network port
@@ -670,8 +675,8 @@ typedef int (*ZT1_VirtualNetworkConfigFunction)(
  * (5) destination MAC, (6) ethertype, (7) VLAN ID, (8) frame data,
  * (9) frame length.
  */
-typedef void (*ZT1_VirtualNetworkFrameFunction)(
-	ZT1_Node *,
+typedef void (*ZT_VirtualNetworkFrameFunction)(
+	ZT_Node *,
 	void *,
 	uint64_t,
 	uint64_t,
@@ -688,12 +693,12 @@ typedef void (*ZT1_VirtualNetworkFrameFunction)(
  * and on certain non-fatal errors and events of interest. The final void
  * parameter points to event meta-data. The type of event meta-data (and
  * whether it is present at all) is event type dependent. See the comments
- * in the definition of ZT1_Event.
+ * in the definition of ZT_Event.
  */
-typedef void (*ZT1_EventCallback)(
-	ZT1_Node *,
+typedef void (*ZT_EventCallback)(
+	ZT_Node *,
 	void *,
-	enum ZT1_Event,
+	enum ZT_Event,
 	const void *);
 
 /**
@@ -716,8 +721,8 @@ typedef void (*ZT1_EventCallback)(
  * read. The caller may call the function multiple times to read the whole
  * object.
  */
-typedef long (*ZT1_DataStoreGetFunction)(
-	ZT1_Node *,
+typedef long (*ZT_DataStoreGetFunction)(
+	ZT_Node *,
 	void *,
 	const char *,
 	void *,
@@ -741,8 +746,8 @@ typedef long (*ZT1_DataStoreGetFunction)(
  * If the data pointer is null, this must be interpreted as a delete
  * operation.
  */
-typedef int (*ZT1_DataStorePutFunction)(
-	ZT1_Node *,
+typedef int (*ZT_DataStorePutFunction)(
+	ZT_Node *,
 	void *,
 	const char *,
 	const void *,
@@ -755,23 +760,25 @@ typedef int (*ZT1_DataStorePutFunction)(
  * Parameters:
  *  (1) Node
  *  (2) User pointer
- *  (3) Local interface ID, -1==unspcified/random
+ *  (3) Local interface address
  *  (4) Remote address
  *  (5) Packet data
  *  (6) Packet length
  *
- * If you have only one local interface it is fine to ignore the local
- * interface ID field. This is used to support different local interface
- * endpoints and differentiation between them.
+ * If there is only one local interface it is safe to ignore the local
+ * interface address. Otherwise if running with multiple interfaces, the
+ * correct local interface should be chosen by address unless NULL. If
+ * the ss_family field is zero (NULL address), a random or preferred
+ * default interface should be used.
  *
  * The function must return zero on success and may return any error code
  * on failure. Note that success does not (of course) guarantee packet
  * delivery. It only means that the packet appears to have been sent.
  */
-typedef int (*ZT1_WirePacketSendFunction)(
-	ZT1_Node *,                      /* Node */
+typedef int (*ZT_WirePacketSendFunction)(
+	ZT_Node *,                      /* Node */
 	void *,                          /* User ptr */
-	int,                             /* Local interface ID, -1 for unspecified/random */
+	const struct sockaddr_storage *, /* Local address */
 	const struct sockaddr_storage *, /* Remote address */
 	const void *,                    /* Packet data */
 	unsigned int);                   /* Packet length */
@@ -796,16 +803,16 @@ typedef int (*ZT1_WirePacketSendFunction)(
  * @param overrideRootTopology Alternative root server topology or NULL for default (mostly for test/debug use)
  * @return OK (0) or error code if a fatal error condition has occurred
  */
-enum ZT1_ResultCode ZT1_Node_new(
-	ZT1_Node **node,
+enum ZT_ResultCode ZT_Node_new(
+	ZT_Node **node,
 	void *uptr,
 	uint64_t now,
-	ZT1_DataStoreGetFunction dataStoreGetFunction,
-	ZT1_DataStorePutFunction dataStorePutFunction,
-	ZT1_WirePacketSendFunction wirePacketSendFunction,
-	ZT1_VirtualNetworkFrameFunction virtualNetworkFrameFunction,
-	ZT1_VirtualNetworkConfigFunction virtualNetworkConfigFunction,
-	ZT1_EventCallback eventCallback,
+	ZT_DataStoreGetFunction dataStoreGetFunction,
+	ZT_DataStorePutFunction dataStorePutFunction,
+	ZT_WirePacketSendFunction wirePacketSendFunction,
+	ZT_VirtualNetworkFrameFunction virtualNetworkFrameFunction,
+	ZT_VirtualNetworkConfigFunction virtualNetworkConfigFunction,
+	ZT_EventCallback eventCallback,
 	const char *overrideRootTopology);
 
 /**
@@ -816,24 +823,24 @@ enum ZT1_ResultCode ZT1_Node_new(
  *
  * @param node Node to delete
  */
-void ZT1_Node_delete(ZT1_Node *node);
+void ZT_Node_delete(ZT_Node *node);
 
 /**
  * Process a packet received from the physical wire
  *
  * @param node Node instance
  * @param now Current clock in milliseconds
- * @param localInterfaceId Local interface ID on which packet was received (use 0 if only one interface or unsure)
+ * @param localAddress Local address, or point to ZT_SOCKADDR_NULL if unspecified
  * @param remoteAddress Origin of packet
  * @param packetData Packet data
  * @param packetLength Packet length
  * @param nextBackgroundTaskDeadline Value/result: set to deadline for next call to processBackgroundTasks()
  * @return OK (0) or error code if a fatal error condition has occurred
  */
-enum ZT1_ResultCode ZT1_Node_processWirePacket(
-	ZT1_Node *node,
+enum ZT_ResultCode ZT_Node_processWirePacket(
+	ZT_Node *node,
 	uint64_t now,
-	const int localInterfaceId,
+	const struct sockaddr_storage *localAddress,
 	const struct sockaddr_storage *remoteAddress,
 	const void *packetData,
 	unsigned int packetLength,
@@ -854,8 +861,8 @@ enum ZT1_ResultCode ZT1_Node_processWirePacket(
  * @param nextBackgroundTaskDeadline Value/result: set to deadline for next call to processBackgroundTasks()
  * @return OK (0) or error code if a fatal error condition has occurred
  */
-enum ZT1_ResultCode ZT1_Node_processVirtualNetworkFrame(
-	ZT1_Node *node,
+enum ZT_ResultCode ZT_Node_processVirtualNetworkFrame(
+	ZT_Node *node,
 	uint64_t now,
 	uint64_t nwid,
 	uint64_t sourceMac,
@@ -874,7 +881,7 @@ enum ZT1_ResultCode ZT1_Node_processVirtualNetworkFrame(
  * @param nextBackgroundTaskDeadline Value/result: set to deadline for next call to processBackgroundTasks()
  * @return OK (0) or error code if a fatal error condition has occurred
  */
-enum ZT1_ResultCode ZT1_Node_processBackgroundTasks(ZT1_Node *node,uint64_t now,volatile uint64_t *nextBackgroundTaskDeadline);
+enum ZT_ResultCode ZT_Node_processBackgroundTasks(ZT_Node *node,uint64_t now,volatile uint64_t *nextBackgroundTaskDeadline);
 
 /**
  * Join a network
@@ -889,7 +896,7 @@ enum ZT1_ResultCode ZT1_Node_processBackgroundTasks(ZT1_Node *node,uint64_t now,
  * @param nwid 64-bit ZeroTier network ID
  * @return OK (0) or error code if a fatal error condition has occurred
  */
-enum ZT1_ResultCode ZT1_Node_join(ZT1_Node *node,uint64_t nwid);
+enum ZT_ResultCode ZT_Node_join(ZT_Node *node,uint64_t nwid);
 
 /**
  * Leave a network
@@ -902,7 +909,7 @@ enum ZT1_ResultCode ZT1_Node_join(ZT1_Node *node,uint64_t nwid);
  * @param nwid 64-bit network ID
  * @return OK (0) or error code if a fatal error condition has occurred
  */
-enum ZT1_ResultCode ZT1_Node_leave(ZT1_Node *node,uint64_t nwid);
+enum ZT_ResultCode ZT_Node_leave(ZT_Node *node,uint64_t nwid);
 
 /**
  * Subscribe to an Ethernet multicast group
@@ -929,7 +936,7 @@ enum ZT1_ResultCode ZT1_Node_leave(ZT1_Node *node,uint64_t nwid);
  * @param multicastAdi Multicast ADI (least significant 32 bits only, use 0 if not needed)
  * @return OK (0) or error code if a fatal error condition has occurred
  */
-enum ZT1_ResultCode ZT1_Node_multicastSubscribe(ZT1_Node *node,uint64_t nwid,uint64_t multicastGroup,unsigned long multicastAdi);
+enum ZT_ResultCode ZT_Node_multicastSubscribe(ZT_Node *node,uint64_t nwid,uint64_t multicastGroup,unsigned long multicastAdi);
 
 /**
  * Unsubscribe from an Ethernet multicast group (or all groups)
@@ -945,7 +952,7 @@ enum ZT1_ResultCode ZT1_Node_multicastSubscribe(ZT1_Node *node,uint64_t nwid,uin
  * @param multicastAdi Multicast ADI (least significant 32 bits only, use 0 if not needed)
  * @return OK (0) or error code if a fatal error condition has occurred
  */
-enum ZT1_ResultCode ZT1_Node_multicastUnsubscribe(ZT1_Node *node,uint64_t nwid,uint64_t multicastGroup,unsigned long multicastAdi);
+enum ZT_ResultCode ZT_Node_multicastUnsubscribe(ZT_Node *node,uint64_t nwid,uint64_t multicastGroup,unsigned long multicastAdi);
 
 /**
  * Get this node's 40-bit ZeroTier address
@@ -953,7 +960,7 @@ enum ZT1_ResultCode ZT1_Node_multicastUnsubscribe(ZT1_Node *node,uint64_t nwid,u
  * @param node Node instance
  * @return ZeroTier address (least significant 40 bits of 64-bit int)
  */
-uint64_t ZT1_Node_address(ZT1_Node *node);
+uint64_t ZT_Node_address(ZT_Node *node);
 
 /**
  * Get the status of this node
@@ -961,7 +968,7 @@ uint64_t ZT1_Node_address(ZT1_Node *node);
  * @param node Node instance
  * @param status Buffer to fill with current node status
  */
-void ZT1_Node_status(ZT1_Node *node,ZT1_NodeStatus *status);
+void ZT_Node_status(ZT_Node *node,ZT_NodeStatus *status);
 
 /**
  * Get a list of known peer nodes
@@ -972,7 +979,7 @@ void ZT1_Node_status(ZT1_Node *node,ZT1_NodeStatus *status);
  * @param node Node instance
  * @return List of known peers or NULL on failure
  */
-ZT1_PeerList *ZT1_Node_peers(ZT1_Node *node);
+ZT_PeerList *ZT_Node_peers(ZT_Node *node);
 
 /**
  * Get the status of a virtual network
@@ -984,7 +991,7 @@ ZT1_PeerList *ZT1_Node_peers(ZT1_Node *node);
  * @param nwid 64-bit network ID
  * @return Network configuration or NULL if we are not a member of this network
  */
-ZT1_VirtualNetworkConfig *ZT1_Node_networkConfig(ZT1_Node *node,uint64_t nwid);
+ZT_VirtualNetworkConfig *ZT_Node_networkConfig(ZT_Node *node,uint64_t nwid);
 
 /**
  * Enumerate and get status of all networks
@@ -992,7 +999,7 @@ ZT1_VirtualNetworkConfig *ZT1_Node_networkConfig(ZT1_Node *node,uint64_t nwid);
  * @param node Node instance
  * @return List of networks or NULL on failure
  */
-ZT1_VirtualNetworkList *ZT1_Node_networks(ZT1_Node *node);
+ZT_VirtualNetworkList *ZT_Node_networks(ZT_Node *node);
 
 /**
  * Free a query result buffer
@@ -1002,7 +1009,7 @@ ZT1_VirtualNetworkList *ZT1_Node_networks(ZT1_Node *node);
  * @param node Node instance
  * @param qr Query result buffer
  */
-void ZT1_Node_freeQueryResult(ZT1_Node *node,void *qr);
+void ZT_Node_freeQueryResult(ZT_Node *node,void *qr);
 
 /**
  * Add a local interface address
@@ -1030,12 +1037,12 @@ void ZT1_Node_freeQueryResult(ZT1_Node *node,void *qr);
  * @param trust How much do you trust the local network under this interface?
  * @return Boolean: non-zero if address was accepted and added
  */
-int ZT1_Node_addLocalInterfaceAddress(ZT1_Node *node,const struct sockaddr_storage *addr,int metric,ZT1_LocalInterfaceAddressTrust trust);
+int ZT_Node_addLocalInterfaceAddress(ZT_Node *node,const struct sockaddr_storage *addr,int metric,ZT_LocalInterfaceAddressTrust trust);
 
 /**
  * Clear local interface addresses
  */
-void ZT1_Node_clearLocalInterfaceAddresses(ZT1_Node *node);
+void ZT_Node_clearLocalInterfaceAddresses(ZT_Node *node);
 
 /**
  * Set a network configuration master instance for this node
@@ -1052,7 +1059,7 @@ void ZT1_Node_clearLocalInterfaceAddresses(ZT1_Node *node);
  * @param networkConfigMasterInstance Instance of NetworkConfigMaster C++ class or NULL to disable
  * @return OK (0) or error code if a fatal error condition has occurred
  */
-void ZT1_Node_setNetconfMaster(ZT1_Node *node,void *networkConfigMasterInstance);
+void ZT_Node_setNetconfMaster(ZT_Node *node,void *networkConfigMasterInstance);
 
 /**
  * Get ZeroTier One version
@@ -1062,7 +1069,7 @@ void ZT1_Node_setNetconfMaster(ZT1_Node *node,void *networkConfigMasterInstance)
  * @param revision Result: revision
  * @param featureFlags: Result: feature flag bitmap
  */
-void ZT1_version(int *major,int *minor,int *revision,unsigned long *featureFlags);
+void ZT_version(int *major,int *minor,int *revision,unsigned long *featureFlags);
 
 #ifdef __cplusplus
 }
-- 
cgit v1.2.3


From 5076c49210542243075556aa1ab74f33d4d50ba3 Mon Sep 17 00:00:00 2001
From: Adam Ierymenko <adam.ierymenko@gmail.com>
Date: Thu, 1 Oct 2015 15:40:54 -0700
Subject: Peer serialization and related changes.

---
 include/ZeroTierOne.h            |   4 +-
 node/CertificateOfMembership.hpp |  72 -----------------------
 node/Identity.hpp                |   2 -
 node/InetAddress.hpp             |  46 +++++++++++++++
 node/Path.hpp                    |   8 +--
 node/Peer.hpp                    | 121 +++++++++++++++++++++++++++++++++++++++
 node/RemotePath.hpp              |  46 ++++++++++++---
 service/OneService.cpp           |   5 +-
 8 files changed, 214 insertions(+), 90 deletions(-)

(limited to 'include')

diff --git a/include/ZeroTierOne.h b/include/ZeroTierOne.h
index e8a19e33..8eacc993 100644
--- a/include/ZeroTierOne.h
+++ b/include/ZeroTierOne.h
@@ -627,8 +627,8 @@ typedef struct
  */
 typedef enum {
 	ZT_LOCAL_INTERFACE_ADDRESS_TRUST_NORMAL = 0,
-	ZT_LOCAL_INTERFACE_ADDRESS_TRUST_PRIVACY = 1,
-	ZT_LOCAL_INTERFACE_ADDRESS_TRUST_ULTIMATE = 2
+	ZT_LOCAL_INTERFACE_ADDRESS_TRUST_PRIVACY = 10,
+	ZT_LOCAL_INTERFACE_ADDRESS_TRUST_ULTIMATE = 20
 } ZT_LocalInterfaceAddressTrust;
 
 /**
diff --git a/node/CertificateOfMembership.hpp b/node/CertificateOfMembership.hpp
index 9a03374d..81e00fbb 100644
--- a/node/CertificateOfMembership.hpp
+++ b/node/CertificateOfMembership.hpp
@@ -315,78 +315,6 @@ public:
 	 */
 	inline const Address &signedBy() const throw() { return _signedBy; }
 
-	/**
-	 * Serialize to std::string or compatible class
-	 *
-	 * @param b String or other class supporting push_back() and append() like std::string
-	 */
-	template<typename T>
-	inline void serialize2(T &b) const
-	{
-		uint64_t tmp[3];
-		char tmp2[ZT_ADDRESS_LENGTH];
-		b.push_back((char)COM_UINT64_ED25519);
-		b.push_back((char)((_qualifiers.size() >> 8) & 0xff));
-		b.push_back((char)(_qualifiers.size() & 0xff));
-		for(std::vector<_Qualifier>::const_iterator q(_qualifiers.begin());q!=_qualifiers.end();++q) {
-			tmp[0] = Utils::hton(q->id);
-			tmp[1] = Utils::hton(q->value);
-			tmp[2] = Utils::hton(q->maxDelta);
-			b.append(reinterpret_cast<const char *>(reinterpret_cast<void *>(tmp)),sizeof(tmp));
-		}
-		_signedBy.copyTo(tmp2,ZT_ADDRESS_LENGTH);
-		b.append(tmp2,ZT_ADDRESS_LENGTH);
-		if (_signedBy)
-			b.append((const char *)_signature.data,_signature.size());
-	}
-
-	/**
-	 * Deserialize from std::string::iterator or compatible iterator or char* pointer
-	 *
-	 * @param p Iterator
-	 * @param end End of buffer
-	 */
-	template<typename T>
-	inline void deserialize2(T &p,const T &end)
-	{
-		uint64_t tmp[3];
-		char tmp2[ZT_ADDRESS_LENGTH];
-		unsigned int qcount;
-
-		_qualifiers.clear();
-		_signedBy.zero();
-
-		if (p == end) throw std::out_of_range("incomplete certificate of membership");
-		if (*(p++) != (char)COM_UINT64_ED25519) throw std::invalid_argument("unknown certificate of membership type");
-
-		if (p == end) throw std::out_of_range("incomplete certificate of membership");
-		qcount = (unsigned int)*(p++) << 8;
-		if (p == end) throw std::out_of_range("incomplete certificate of membership");
-		qcount |= (unsigned int)*(p++);
-
-		for(unsigned int i=0;i<qcount;++i) {
-			char *p2 = reinterpret_cast<char *>(reinterpret_cast<void *>(tmp));
-			for(unsigned int j=0;j<sizeof(tmp);++j) {
-				if (p == end) throw std::out_of_range("incomplete certificate of membership");
-				*(p2++) = *(p++);
-			}
-			_qualifiers.push_back(_Qualifier(Utils::ntoh(tmp[0]),Utils::ntoh(tmp[1]),Utils::ntoh(tmp[2])));
-		}
-
-		for(unsigned int j=0;j<ZT_ADDRESS_LENGTH;++j) {
-			if (p == end) throw std::out_of_range("incomplete certificate of membership");
-			tmp2[j] = *(p++);
-		}
-		_signedBy.setTo(tmp2,ZT_ADDRESS_LENGTH);
-
-		if (_signedBy) {
-			for(unsigned int j=0;j<_signature.size();++j) {
-				if (p == end) throw std::out_of_range("incomplete certificate of membership");
-				_signature.data[j] = (unsigned char)*(p++);
-			}
-		}
-	}
-
 	template<unsigned int C>
 	inline void serialize(Buffer<C> &b) const
 	{
diff --git a/node/Identity.hpp b/node/Identity.hpp
index cc72632e..18e67eb6 100644
--- a/node/Identity.hpp
+++ b/node/Identity.hpp
@@ -220,7 +220,6 @@ public:
 	 */
 	template<unsigned int C>
 	inline void serialize(Buffer<C> &b,bool includePrivate = false) const
-		throw(std::out_of_range)
 	{
 		_address.appendTo(b);
 		b.append((unsigned char)IDENTITY_TYPE_C25519);
@@ -245,7 +244,6 @@ public:
 	 */
 	template<unsigned int C>
 	inline unsigned int deserialize(const Buffer<C> &b,unsigned int startAt = 0)
-		throw(std::out_of_range,std::invalid_argument)
 	{
 		delete _privateKey;
 		_privateKey = (C25519::Private *)0;
diff --git a/node/InetAddress.hpp b/node/InetAddress.hpp
index 3c05d83b..c376a032 100644
--- a/node/InetAddress.hpp
+++ b/node/InetAddress.hpp
@@ -38,6 +38,7 @@
 #include "../include/ZeroTierOne.h"
 #include "Utils.hpp"
 #include "MAC.hpp"
+#include "Buffer.hpp"
 
 namespace ZeroTier {
 
@@ -362,6 +363,51 @@ struct InetAddress : public sockaddr_storage
 	 */
 	inline operator bool() const throw() { return (ss_family != 0); }
 
+	template<unsigned int C>
+	inline void serialize(Buffer<C> &b) const
+	{
+		// Format is the same as in VERB_HELLO in Packet.hpp
+		switch(ss_family) {
+			case AF_INET:
+				b.append((uint8_t)0x04);
+				b.append(&(reinterpret_cast<const struct sockaddr_in *>(this)->sin_addr.s_addr),4);
+				b.append((uint16_t)port()); // just in case sin_port != uint16_t
+				return;
+			case AF_INET6:
+				b.append((uint8_t)0x06);
+				b.append(reinterpret_cast<const struct sockaddr_in6 *>(this)->sin6_addr.s6_addr,16);
+				b.append((uint16_t)port()); // just in case sin_port != uint16_t
+				return;
+			default:
+				b.append((uint8_t)0);
+				return;
+		}
+	}
+
+	template<unsigned int C>
+	inline unsigned int deserialize(const Buffer<C> &b,unsigned int startAt = 0)
+	{
+		unsigned int p = startAt;
+		memset(this,0,sizeof(InetAddress));
+		switch(b[p++]) {
+			case 0:
+				return 1;
+			case 0x04:
+				ss_family = AF_INET;
+				memcpy(&(reinterpret_cast<struct sockaddr_in *>(this)->sin_addr.s_addr),b.field(p,4),4); p += 4;
+				reinterpret_cast<struct sockaddr_in *>(this)->sin_port = Utils::hton(b.template at<uint16_t>(p)); p += 2;
+				break;
+			case 0x06:
+				ss_family = AF_INET6;
+				memcpy(reinterpret_cast<struct sockaddr_in6 *>(this)->sin6_addr.s6_addr,b.field(p,16),16); p += 16;
+				reinterpret_cast<struct sockaddr_in *>(this)->sin_port = Utils::hton(b.template at<uint16_t>(p)); p += 2;
+				break;
+			default:
+				throw std::invalid_argument("invalid serialized InetAddress");
+		}
+		return (p - startAt);
+	}
+
 	bool operator==(const InetAddress &a) const throw();
 	bool operator<(const InetAddress &a) const throw();
 	inline bool operator!=(const InetAddress &a) const throw() { return !(*this == a); }
diff --git a/node/Path.hpp b/node/Path.hpp
index 8d662ff7..6a69e071 100644
--- a/node/Path.hpp
+++ b/node/Path.hpp
@@ -59,11 +59,11 @@ public:
 	 *
 	 * These values MUST match ZT_LocalInterfaceAddressTrust in ZeroTierOne.h
 	 */
-	enum Trust
+	enum Trust // NOTE: max 255
 	{
 		TRUST_NORMAL = 0,
-		TRUST_PRIVACY = 1,
-		TRUST_ULTIMATE = 2
+		TRUST_PRIVACY = 10,
+		TRUST_ULTIMATE = 20
 	};
 
 	Path() :
@@ -155,7 +155,7 @@ public:
 		return false;
 	}
 
-private:
+protected:
 	InetAddress _addr;
 	InetAddress::IpScope _ipScope; // memoize this since it's a computed value checked often
 	Trust _trust;
diff --git a/node/Peer.hpp b/node/Peer.hpp
index 568de0d5..482c0a82 100644
--- a/node/Peer.hpp
+++ b/node/Peer.hpp
@@ -445,6 +445,127 @@ public:
 		else return std::pair<InetAddress,InetAddress>();
 	}
 
+	template<unsigned int C>
+	inline void serialize(Buffer<C> &b) const
+	{
+		Mutex::Lock _l(_lock);
+
+		const unsigned int lengthAt = b.size();
+		b.addSize(4); // space for uint32_t field length
+
+		b.append((uint32_t)1); // version of serialized Peer data
+
+		_id.serialize(b,false);
+
+		b.append((uint64_t)_lastUsed);
+		b.append((uint64_t)_lastReceive);
+		b.append((uint64_t)_lastUnicastFrame);
+		b.append((uint64_t)_lastMulticastFrame);
+		b.append((uint64_t)_lastAnnouncedTo);
+		b.append((uint64_t)_lastPathConfirmationSent);
+		b.append((uint64_t)_lastDirectPathPush);
+		b.append((uint64_t)_lastPathSort);
+		b.append((uint16_t)_vProto);
+		b.append((uint16_t)_vMajor);
+		b.append((uint16_t)_vMinor);
+		b.append((uint16_t)_vRevision);
+		b.append((uint32_t)_latency);
+
+		b.append((uint32_t)_numPaths);
+		for(unsigned int i=0;i<_numPaths;++i)
+			_paths[i].serialize(b);
+
+		b.append((uint32_t)_networkComs.size());
+		{
+			uint64_t *k = (uint64_t *)0;
+			_NetworkCom *v = (_NetworkCom *)0;
+			Hashtable<uint64_t,_NetworkCom>::Iterator i(const_cast<Peer *>(this)->_networkComs);
+			while (i.next(k,v)) {
+				b.append((uint64_t)*k);
+				b.append((uint64_t)v->ts);
+				v->com.serialize(b);
+			}
+		}
+
+		b.append((uint32_t)_lastPushedComs.size());
+		{
+			uint64_t *k = (uint64_t *)0;
+			uint64_t *v = (uint64_t *)0;
+			Hashtable<uint64_t,uint64_t>::Iterator i(const_cast<Peer *>(this)->_lastPushedComs);
+			while (i.next(k,v)) {
+				b.append((uint64_t)*k);
+				b.append((uint64_t)*v);
+			}
+		}
+
+		b.setAt(lengthAt,(uint32_t)((b.size() - 4) - lengthAt)); // set size, not including size field itself
+	}
+
+	/**
+	 * Create a new Peer from a serialized instance
+	 *
+	 * @param myIdentity This node's identity
+	 * @param b Buffer containing serialized Peer data
+	 * @param p Pointer to current position in buffer, will be updated in place as buffer is read (value/result)
+	 * @return New instance of Peer or NULL if serialized data was corrupt or otherwise invalid (may also throw an exception via Buffer)
+	 */
+	template<unsigned int C>
+	static inline SharedPtr<Peer> deserializeNew(const Identity &myIdentity,const Buffer<C> &b,unsigned int &p)
+	{
+		const uint32_t recSize = b.template at<uint32_t>(p); p += 4;
+		if ((p + recSize) > b.size())
+			return SharedPtr<Peer>(); // size invalid
+		if (b.template at<uint32_t>(p) != 1)
+			return SharedPtr<Peer>(); // version mismatch
+		p += 4;
+
+		Identity npid;
+		p += npid.deserialize(b,p);
+		if (!npid)
+			return SharedPtr<Peer>();
+
+		SharedPtr<Peer> np(new Peer(myIdentity,npid));
+
+		np->_lastUsed = b.template at<uint64_t>(p); p += 8;
+		np->_lastReceive = b.template at<uint64_t>(p); p += 8;
+		np->_lastUnicastFrame = b.template at<uint64_t>(p); p += 8;
+		np->_lastMulticastFrame = b.template at<uint64_t>(p); p += 8;
+		np->_lastAnnouncedTo = b.template at<uint64_t>(p); p += 8;
+		np->_lastPathConfirmationSent = b.template at<uint64_t>(p); p += 8;
+		np->_lastDirectPathPush = b.template at<uint64_t>(p); p += 8;
+		np->_lastPathSort = b.template at<uint64_t>(p); p += 8;
+		np->_vProto = b.template at<uint16_t>(p); p += 2;
+		np->_vMajor = b.template at<uint16_t>(p); p += 2;
+		np->_vMinor = b.template at<uint16_t>(p); p += 2;
+		np->_vRevision = b.template at<uint16_t>(p); p += 2;
+		np->_latency = b.template at<uint32_t>(p); p += 4;
+
+		const unsigned int numPaths = b.template at<uint32_t>(p); p += 2;
+		for(unsigned int i=0;i<numPaths;++i) {
+			if (i < ZT_MAX_PEER_NETWORK_PATHS) {
+				p += np->_paths[np->_numPaths++].deserialize(b,p);
+			} else {
+				// Skip any paths beyond max, but still read stream
+				RemotePath foo;
+				p += foo.deserialize(b,p);
+			}
+		}
+
+		const unsigned int numNetworkComs = b.template at<uint32_t>(p); p += 4;
+		for(unsigned int i=0;i<numNetworkComs;++i) {
+			_NetworkCom &c = np->_networkComs[b.template at<uint64_t>(p)]; p += 8;
+			c.ts = b.template at<uint64_t>(p); p += 8;
+			p += c.com.deserialize(b,p);
+		}
+
+		const unsigned int numLastPushed = b.template at<uint32_t>(p); p += 4;
+		for(unsigned int i=0;i<numLastPushed;++i) {
+			const uint64_t nwid = b.template at<uint64_t>(p); p += 8;
+			const uint64_t ts = b.template at<uint64_t>(p); p += 8;
+			np->_lastPushedComs.set(nwid,ts);
+		}
+	}
+
 private:
 	void _sortPaths(const uint64_t now);
 	RemotePath *_getBestPath(const uint64_t now);
diff --git a/node/RemotePath.hpp b/node/RemotePath.hpp
index 0034242e..9a8a3ff8 100644
--- a/node/RemotePath.hpp
+++ b/node/RemotePath.hpp
@@ -39,6 +39,8 @@
 #include "AntiRecursion.hpp"
 #include "RuntimeEnvironment.hpp"
 
+#define ZT_REMOTEPATH_FLAG_FIXED 0x0001
+
 namespace ZeroTier {
 
 /**
@@ -54,14 +56,14 @@ public:
 		_lastSend(0),
 		_lastReceived(0),
 		_localAddress(),
-		_fixed(false) {}
+		_flags(0) {}
 
 	RemotePath(const InetAddress &localAddress,const InetAddress &addr,bool fixed) :
 		Path(addr,0,TRUST_NORMAL),
 		_lastSend(0),
 		_lastReceived(0),
 		_localAddress(localAddress),
-		_fixed(fixed) {}
+		_flags(fixed ? ZT_REMOTEPATH_FLAG_FIXED : 0) {}
 
 	inline const InetAddress &localAddress() const throw() { return _localAddress; }
 
@@ -71,7 +73,7 @@ public:
 	/**
 	 * @return Is this a fixed path?
 	 */
-	inline bool fixed() const throw() { return _fixed; }
+	inline bool fixed() const throw() { return ((_flags & ZT_REMOTEPATH_FLAG_FIXED) != 0); }
 
 	/**
 	 * @param f New value of fixed flag
@@ -79,7 +81,9 @@ public:
 	inline void setFixed(const bool f)
 		throw()
 	{
-		_fixed = f;
+		if (f)
+			_flags |= ZT_REMOTEPATH_FLAG_FIXED;
+		else _flags &= ~ZT_REMOTEPATH_FLAG_FIXED;
 	}
 
 	/**
@@ -113,7 +117,7 @@ public:
 	inline bool active(uint64_t now) const
 		throw()
 	{
-		return ( (_fixed) || ((now - _lastReceived) < ZT_PEER_ACTIVITY_TIMEOUT) );
+		return ( ((_flags & ZT_REMOTEPATH_FLAG_FIXED) != 0) || ((now - _lastReceived) < ZT_PEER_ACTIVITY_TIMEOUT) );
 	}
 
 	/**
@@ -135,11 +139,39 @@ public:
 		return false;
 	}
 
-private:
+	template<unsigned int C>
+	inline void serialize(Buffer<C> &b) const
+	{
+		b.append((uint8_t)1); // version
+		_addr.serialize(b);
+		b.append((uint8_t)_trust);
+		b.append((uint64_t)_lastSend);
+		b.append((uint64_t)_lastReceived);
+		_localAddress.serialize(b);
+		b.append((uint16_t)_flags);
+	}
+
+	template<unsigned int C>
+	inline unsigned int deserialize(const Buffer<C> &b,unsigned int startAt = 0)
+	{
+		unsigned int p = startAt;
+		if (b[p++] != 1)
+			throw std::invalid_argument("invalid serialized RemotePath");
+		p += _addr.deserialize(b,p);
+		_ipScope = _addr.ipScope();
+		_trust = (Path::Trust)b[p++];
+		_lastSend = b.template at<uint64_t>(p); p += 8;
+		_lastReceived = b.template at<uint64_t>(p); p += 8;
+		p += _localAddress.deserialize(b,p);
+		_flags = b.template at<uint16_t>(p); p += 4;
+		return (startAt - p);
+	}
+
+protected:
 	uint64_t _lastSend;
 	uint64_t _lastReceived;
 	InetAddress _localAddress;
-	bool _fixed;
+	uint16_t _flags;
 };
 
 } // namespace ZeroTier
diff --git a/service/OneService.cpp b/service/OneService.cpp
index 7b3c4ff6..4b374cd7 100644
--- a/service/OneService.cpp
+++ b/service/OneService.cpp
@@ -489,13 +489,12 @@ public:
 		OSUtils::writeFile((_homePath + ZT_PATH_SEPARATOR_S + "zerotier-one.port").c_str(),std::string(portstr));
 
 #ifdef ZT_USE_MINIUPNPC
-		// Bind a random secondary port for use with uPnP, since some NAT routers
+		// Bind a secondary port for use with uPnP, since some NAT routers
 		// (cough Ubiquity Edge cough) barf up a lung if you do both conventional
 		// NAT-t and uPnP from behind the same port. I think this is a bug, but
 		// everyone else's router bugs are our problem. :P
 		for(int k=0;k<512;++k) {
-			unsigned int upnport = 40000 + (((port + 1) * (k + 1)) % 25500);
-
+			const unsigned int upnport = 40000 + (((port + 1) * (k + 1)) % 25500);
 			_v4UpnpLocalAddress = InetAddress(0,upnport);
 			_v4UpnpUdpSocket = _phy.udpBind((const struct sockaddr *)&_v4UpnpLocalAddress,reinterpret_cast<void *>(&_v4UpnpLocalAddress),131072);
 			if (_v4UpnpUdpSocket) {
-- 
cgit v1.2.3


From d3f29d09e8eb7fdbbbed682b383da73bc44928d6 Mon Sep 17 00:00:00 2001
From: Adam Ierymenko <adam.ierymenko@gmail.com>
Date: Tue, 6 Oct 2015 14:42:51 -0700
Subject: Plumbing through circuit test stuff.

---
 include/ZeroTierOne.h   | 271 ++++++++++++++++++++++++++++++++++++++++++++++++
 node/IncomingPacket.cpp |   7 +-
 node/Node.cpp           |  52 ++++++++++
 node/Node.hpp           |  12 +++
 node/Packet.hpp         |  38 -------
 5 files changed, 339 insertions(+), 41 deletions(-)

(limited to 'include')

diff --git a/include/ZeroTierOne.h b/include/ZeroTierOne.h
index 8eacc993..43c8fc0b 100644
--- a/include/ZeroTierOne.h
+++ b/include/ZeroTierOne.h
@@ -115,6 +115,19 @@ extern "C" {
  */
 #define ZT_FEATURE_FLAG_FIPS 0x00000002
 
+/**
+ * Maximum number of hops in a ZeroTier circuit test
+ *
+ * This is more or less the max that can be fit in a given packet (with
+ * fragmentation) and only one address per hop.
+ */
+#define ZT_CIRCUIT_TEST_MAX_HOPS 512
+
+/**
+ * Maximum number of addresses per hop in a circuit test
+ */
+#define ZT_CIRCUIT_TEST_MAX_HOP_BREADTH 256
+
 /**
  * A null/empty sockaddr (all zero) to signify an unspecified socket address
  */
@@ -631,6 +644,231 @@ typedef enum {
 	ZT_LOCAL_INTERFACE_ADDRESS_TRUST_ULTIMATE = 20
 } ZT_LocalInterfaceAddressTrust;
 
+/**
+ * Vendor ID
+ */
+typedef enum {
+	ZT_VENDOR_UNSPECIFIED = 0,
+	ZT_VENDOR_ZEROTIER = 1
+} ZT_Vendor;
+
+/**
+ * Platform type
+ */
+typedef enum {
+	ZT_PLATFORM_UNSPECIFIED = 0,
+	ZT_PLATFORM_LINUX = 1,
+	ZT_PLATFORM_WINDOWS = 2,
+	ZT_PLATFORM_MACOS = 3,
+	ZT_PLATFORM_ANDROID = 4,
+	ZT_PLATFORM_IOS = 5,
+	ZT_PLATFORM_SOLARIS_SMARTOS = 6,
+	ZT_PLATFORM_FREEBSD = 7,
+	ZT_PLATFORM_NETBSD = 8,
+	ZT_PLATFORM_OPENBSD = 9,
+	ZT_PLATFORM_RISCOS = 10,
+	ZT_PLATFORM_VXWORKS = 11,
+	ZT_PLATFORM_FREERTOS = 12,
+	ZT_PLATFORM_SYSBIOS = 13,
+	ZT_PLATFORM_HURD = 14
+} ZT_Platform;
+
+/**
+ * Architecture type
+ */
+typedef enum {
+	ZT_ARCHITECTURE_UNSPECIFIED = 0,
+	ZT_ARCHITECTURE_X86 = 1,
+	ZT_ARCHITECTURE_X64 = 2,
+	ZT_ARCHITECTURE_ARM32 = 3,
+	ZT_ARCHITECTURE_ARM64 = 4,
+	ZT_ARCHITECTURE_MIPS32 = 5,
+	ZT_ARCHITECTURE_MIPS64 = 6,
+	ZT_ARCHITECTURE_POWER32 = 7,
+	ZT_ARCHITECTURE_POWER64 = 8
+} ZT_Architecture;
+
+/**
+ * ZeroTier circuit test configuration and path
+ */
+typedef struct {
+	/**
+	 * Test ID -- an arbitrary 64-bit identifier
+	 */
+	uint64_t testId;
+
+	/**
+	 * Timestamp -- sent with test and echoed back by each reporter
+	 */
+	uint64_t timestamp;
+
+	/**
+	 * Originator credential: network ID
+	 *
+	 * If this is nonzero, a network ID will be set for this test and
+	 * the originator must be its primary network controller. This is
+	 * currently the only authorization method available, so it must
+	 * be set to run a test.
+	 */
+	uint64_t credentialNetworkId;
+
+	/**
+	 * Hops in circuit test (a.k.a. FIFO for graph traversal)
+	 */
+	struct {
+		/**
+		 * Hop flags (currently unused, must be zero)
+		 */
+		unsigned int flags;
+
+		/**
+		 * Number of addresses in this hop (max: ZT_CIRCUIT_TEST_MAX_HOP_BREADTH)
+		 */
+		unsigned int breadth;
+
+		/**
+		 * 40-bit ZeroTier addresses (most significant 24 bits ignored)
+		 */
+		uint64_t addresses[ZT_CIRCUIT_TEST_MAX_HOP_BREADTH];
+	} hops[ZT_CIRCUIT_TEST_MAX_HOPS];
+
+	/**
+	 * Number of hops (max: ZT_CIRCUIT_TEST_MAX_HOPS)
+	 */
+	unsigned int hopCount;
+
+	/**
+	 * If non-zero, circuit test will report back at every hop
+	 */
+	int reportAtEveryHop;
+
+	/**
+	 * An arbitrary user-settable pointer
+	 */
+	void *ptr;
+
+	/**
+	 * Pointer for internal use -- initialize to zero and do not modify
+	 */
+	void *_internalPtr;
+} ZT_CircuitTest;
+
+/**
+ * Circuit test result report
+ */
+typedef struct {
+	/**
+	 * 64-bit test ID
+	 */
+	uint64_t testId;
+
+	/**
+	 * Timestamp from original test (echoed back at each hop)
+	 */
+	uint64_t timestamp;
+
+	/**
+	 * Timestamp on remote device
+	 */
+	uint64_t remoteTimestamp;
+
+	/**
+	 * 64-bit packet ID of packet received by the reporting device
+	 */
+	uint64_t sourcePacketId;
+
+	/**
+	 * Flags (currently unused, will be zero)
+	 */
+	uint64_t flags;
+
+	/**
+	 * ZeroTier protocol-level hop count of packet received by reporting device (>0 indicates relayed)
+	 */
+	unsigned int sourcePacketHopCount;
+
+	/**
+	 * Error code (currently unused, will be zero)
+	 */
+	unsigned int errorCode;
+
+	/**
+	 * Remote device vendor ID
+	 */
+	ZT_Vendor vendor;
+
+	/**
+	 * Remote device protocol compliance version
+	 */
+	unsigned int protocolVersion;
+
+	/**
+	 * Software major version
+	 */
+	unsigned int majorVersion;
+
+	/**
+	 * Software minor version
+	 */
+	unsigned int minorVersion;
+
+	/**
+	 * Software revision
+	 */
+	unsigned int revision;
+
+	/**
+	 * Platform / OS
+	 */
+	ZT_Platform platform;
+
+	/**
+	 * System architecture
+	 */
+	ZT_Architecture architecture;
+
+	/**
+	 * Local device address on which packet was received by reporting device
+	 *
+	 * This may have ss_family equal to zero (null address) if unspecified.
+	 */
+	struct sockaddr_storage receivedOnLocalAddress;
+
+	/**
+	 * Remote address from which reporter received the test packet
+	 *
+	 * This may have ss_family set to zero (null address) if unspecified.
+	 */
+	struct sockaddr_storage receivedFromAddress;
+
+	/**
+	 * Next hops to which packets are being or will be sent by the reporter
+	 *
+	 * In addition to reporting back, the reporter may send the test on if
+	 * there are more recipients in the FIFO. If it does this, it can report
+	 * back the address(es) that make up the next hop and the physical address
+	 * for each if it has one. The physical address being null/unspecified
+	 * typically indicates that no direct path exists and the next packet
+	 * will be relayed.
+	 */
+	struct {
+		/**
+		 * 40-bit ZeroTier address
+		 */
+		uint64_t address;
+
+		/**
+		 * Physical address or null address (ss_family == 0) if unspecified or unknown
+		 */
+		struct sockaddr_storage physicalAddress;
+	} nextHops[ZT_CIRCUIT_TEST_MAX_HOP_BREADTH];
+
+	/**
+	 * Number of next hops reported in nextHops[]
+	 */
+	unsigned int nextHopCount;
+} ZT_CircuitTestReport;
+
 /**
  * An instance of a ZeroTier One node (opaque)
  */
@@ -1061,6 +1299,39 @@ void ZT_Node_clearLocalInterfaceAddresses(ZT_Node *node);
  */
 void ZT_Node_setNetconfMaster(ZT_Node *node,void *networkConfigMasterInstance);
 
+/**
+ * Initiate a VL1 circuit test
+ *
+ * This sends an initial VERB_CIRCUIT_TEST and reports results back to the
+ * supplied callback until circuitTestEnd() is called. The supplied
+ * ZT_CircuitTest structure should be initially zeroed and then filled
+ * in with settings and hops.
+ *
+ * It is the caller's responsibility to call circuitTestEnd() and then
+ * to dispose of the test structure. Otherwise this node will listen
+ * for results forever.
+ *
+ * @param node Node instance
+ * @param test Test configuration
+ * @param reportCallback Function to call each time a report is received
+ * @return OK or error if, for example, test is too big for a packet or support isn't compiled in
+ */
+ZT_ResultCode ZT_Node_circuitTestBegin(ZT_Node *node,ZT_CircuitTest *test,void (*reportCallback)(ZT_Node *,ZT_CircuitTest *,const ZT_CircuitTestReport *));
+
+/**
+ * Stop listening for results to a given circuit test
+ *
+ * This does not free the 'test' structure. The caller may do that
+ * after calling this method to unregister it.
+ *
+ * Any reports that are received for a given test ID after it is
+ * terminated are ignored.
+ *
+ * @param node Node instance
+ * @param test Test configuration to unregister
+ */
+void ZT_Node_circuitTestEnd(ZT_Node *node,ZT_CircuitTest *test);
+
 /**
  * Get ZeroTier One version
  *
diff --git a/node/IncomingPacket.cpp b/node/IncomingPacket.cpp
index 49a5981b..c8e4cf5f 100644
--- a/node/IncomingPacket.cpp
+++ b/node/IncomingPacket.cpp
@@ -30,6 +30,7 @@
 #include <stdlib.h>
 
 #include "../version.h"
+#include "../include/ZeroTierOne.h"
 
 #include "Constants.hpp"
 #include "Defaults.hpp"
@@ -1033,13 +1034,13 @@ bool IncomingPacket::_doCIRCUIT_TEST(const RuntimeEnvironment *RR,const SharedPt
 			outp.append((uint64_t)timestamp);
 			outp.append((uint64_t)testId);
 			outp.append((uint64_t)now);
-			outp.append((uint8_t)0); // vendor ID, currently unused
+			outp.append((uint8_t)ZT_VENDOR_ZEROTIER);
 			outp.append((uint8_t)ZT_PROTO_VERSION);
 			outp.append((uint8_t)ZEROTIER_ONE_VERSION_MAJOR);
 			outp.append((uint8_t)ZEROTIER_ONE_VERSION_MINOR);
 			outp.append((uint16_t)ZEROTIER_ONE_VERSION_REVISION);
-			outp.append((uint16_t)CIRCUIT_TEST_REPORT_PLATFORM_UNSPECIFIED);
-			outp.append((uint16_t)CIRCUIT_TEST_REPORT_ARCH_UNSPECIFIED);
+			outp.append((uint16_t)ZT_PLATFORM_UNSPECIFIED);
+			outp.append((uint16_t)ZT_ARCHITECTURE_UNSPECIFIED);
 			outp.append((uint16_t)0); // error code, currently unused
 			outp.append((uint64_t)0); // flags, currently unused
 			outp.append((uint64_t)packetId());
diff --git a/node/Node.cpp b/node/Node.cpp
index 6dc83d4e..cd20972b 100644
--- a/node/Node.cpp
+++ b/node/Node.cpp
@@ -464,6 +464,28 @@ void Node::setNetconfMaster(void *networkControllerInstance)
 	RR->localNetworkController = reinterpret_cast<NetworkController *>(networkControllerInstance);
 }
 
+ZT_ResultCode Node::circuitTestBegin(ZT_CircuitTest *test,void (*reportCallback)(ZT_Node *,ZT_CircuitTest *,const ZT_CircuitTestReport *))
+{
+	{
+		test->_internalPtr = reinterpret_cast<void *>(reportCallback);
+		Mutex::Lock _l(_circuitTests_m);
+		if (std::find(_circuitTests.begin(),_circuitTests.end(),test) == _circuitTests.end())
+			_circuitTests.push_back(test);
+	}
+	return ZT_RESULT_OK;
+}
+
+void Node::circuitTestEnd(ZT_CircuitTest *test)
+{
+	Mutex::Lock _l(_circuitTests_m);
+	for(;;) {
+		std::vector< ZT_CircuitTest * >::iterator ct(std::find(_circuitTests.begin(),_circuitTests.end(),test));
+		if (ct == _circuitTests.end())
+			break;
+		else _circuitTests.erase(ct);
+	}
+}
+
 /****************************************************************************/
 /* Node methods used only within node/                                      */
 /****************************************************************************/
@@ -533,6 +555,20 @@ uint64_t Node::prng()
 	return _prngStream[p];
 }
 
+void Node::postCircuitTestReport(const ZT_CircuitTestReport *report)
+{
+	std::vector< ZT_CircuitTest * > toNotify;
+	{
+		Mutex::Lock _l(_circuitTests_m);
+		for(std::vector< ZT_CircuitTest * >::iterator i(_circuitTests.begin());i!=_circuitTests.end();++i) {
+			if ((*i)->testId == report->testId)
+				toNotify.push_back(*i);
+		}
+	}
+	for(std::vector< ZT_CircuitTest * >::iterator i(toNotify.begin());i!=toNotify.end();++i)
+		(reinterpret_cast<void (*)(ZT_Node *,ZT_CircuitTest *,const ZT_CircuitTestReport *)>((*i)->_internalPtr))(reinterpret_cast<ZT_Node *>(this),*i,report);
+}
+
 } // namespace ZeroTier
 
 /****************************************************************************/
@@ -721,6 +757,22 @@ void ZT_Node_setNetconfMaster(ZT_Node *node,void *networkControllerInstance)
 	} catch ( ... ) {}
 }
 
+ZT_ResultCode ZT_Node_circuitTestBegin(ZT_Node *node,ZT_CircuitTest *test,void (*reportCallback)(ZT_Node *,ZT_CircuitTest *,const ZT_CircuitTestReport *))
+{
+	try {
+		return reinterpret_cast<ZeroTier::Node *>(node)->circuitTestBegin(test,reportCallback);
+	} catch ( ... ) {
+		return ZT_RESULT_FATAL_ERROR_INTERNAL;
+	}
+}
+
+void ZT_Node_circuitTestEnd(ZT_Node *node,ZT_CircuitTest *test)
+{
+	try {
+		reinterpret_cast<ZeroTier::Node *>(node)->circuitTestEnd(test);
+	} catch ( ... ) {}
+}
+
 int ZT_Node_addLocalInterfaceAddress(ZT_Node *node,const struct sockaddr_storage *addr,int metric,ZT_LocalInterfaceAddressTrust trust)
 {
 	try {
diff --git a/node/Node.hpp b/node/Node.hpp
index 0f659f47..20c54471 100644
--- a/node/Node.hpp
+++ b/node/Node.hpp
@@ -109,6 +109,8 @@ public:
 	int addLocalInterfaceAddress(const struct sockaddr_storage *addr,int metric,ZT_LocalInterfaceAddressTrust trust);
 	void clearLocalInterfaceAddresses();
 	void setNetconfMaster(void *networkControllerInstance);
+	ZT_ResultCode circuitTestBegin(ZT_CircuitTest *test,void (*reportCallback)(ZT_Node *,ZT_CircuitTest *,const ZT_CircuitTestReport *));
+	void circuitTestEnd(ZT_CircuitTest *test);
 
 	// Internal functions ------------------------------------------------------
 
@@ -238,6 +240,13 @@ public:
 	 */
 	uint64_t prng();
 
+	/**
+	 * Post a circuit test report to any listeners for a given test ID
+	 *
+	 * @param report Report (includes test ID)
+	 */
+	void postCircuitTestReport(const ZT_CircuitTestReport *report);
+
 private:
 	inline SharedPtr<Network> _network(uint64_t nwid) const
 	{
@@ -264,6 +273,9 @@ private:
 	std::vector< std::pair< uint64_t, SharedPtr<Network> > > _networks;
 	Mutex _networks_m;
 
+	std::vector< ZT_CircuitTest * > _circuitTests;
+	Mutex _circuitTests_m;
+
 	std::vector<Path> _directPaths;
 	Mutex _directPaths_m;
 
diff --git a/node/Packet.hpp b/node/Packet.hpp
index eaffb922..409762c7 100644
--- a/node/Packet.hpp
+++ b/node/Packet.hpp
@@ -1020,44 +1020,6 @@ public:
 		VERB_CIRCUIT_TEST_REPORT = 18
 	};
 
-	/**
-	 * Platforms reported in circuit tests
-	 */
-	enum CircuitTestReportPlatform
-	{
-		CIRCUIT_TEST_REPORT_PLATFORM_UNSPECIFIED = 0,
-		CIRCUIT_TEST_REPORT_PLATFORM_LINUX = 1,
-		CIRCUIT_TEST_REPORT_PLATFORM_WINDOWS = 2,
-		CIRCUIT_TEST_REPORT_PLATFORM_MACOS = 3,
-		CIRCUIT_TEST_REPORT_PLATFORM_ANDROID = 4,
-		CIRCUIT_TEST_REPORT_PLATFORM_IOS = 5,
-		CIRCUIT_TEST_REPORT_PLATFORM_SOLARIS_SMARTOS = 6,
-		CIRCUIT_TEST_REPORT_PLATFORM_FREEBSD = 7,
-		CIRCUIT_TEST_REPORT_PLATFORM_NETBSD = 8,
-		CIRCUIT_TEST_REPORT_PLATFORM_OPENBSD = 9,
-		CIRCUIT_TEST_REPORT_PLATFORM_RISCOS = 10,
-		CIRCUIT_TEST_REPORT_PLATFORM_VXWORKS = 11,
-		CIRCUIT_TEST_REPORT_PLATFORM_FREERTOS = 12,
-		CIRCUIT_TEST_REPORT_PLATFORM_SYSBIOS = 13,
-		CIRCUIT_TEST_REPORT_PLATFORM_HURD = 14
-	};
-
-	/**
-	 * Architectures reported in circuit tests
-	 */
-	enum CircuitTestReportArchitecture
-	{
-		CIRCUIT_TEST_REPORT_ARCH_UNSPECIFIED = 0,
-		CIRCUIT_TEST_REPORT_ARCH_X86 = 1,
-		CIRCUIT_TEST_REPORT_ARCH_X64 = 2,
-		CIRCUIT_TEST_REPORT_ARCH_ARM32 = 3,
-		CIRCUIT_TEST_REPORT_ARCH_ARM64 = 4,
-		CIRCUIT_TEST_REPORT_ARCH_MIPS32 = 5,
-		CIRCUIT_TEST_REPORT_ARCH_MIPS64 = 6,
-		CIRCUIT_TEST_REPORT_ARCH_POWER32 = 7,
-		CIRCUIT_TEST_REPORT_ARCH_POWER64 = 8
-	};
-
 	/**
 	 * Error codes for VERB_ERROR
 	 */
-- 
cgit v1.2.3


From 477feee8a3fbc84d00c2939b5fc8a9bbf19af2ca Mon Sep 17 00:00:00 2001
From: Adam Ierymenko <adam.ierymenko@gmail.com>
Date: Tue, 6 Oct 2015 17:55:57 -0700
Subject: Some work on CIRCUIT_TEST, and a significant speedup to Poly1305.

---
 include/ZeroTierOne.h |   7 +-
 node/Poly1305.cpp     | 279 +++++++++++++++++++++++++++++++++++++++++++++++++-
 selftest.cpp          |  16 +++
 3 files changed, 296 insertions(+), 6 deletions(-)

(limited to 'include')

diff --git a/include/ZeroTierOne.h b/include/ZeroTierOne.h
index 43c8fc0b..341bb767 100644
--- a/include/ZeroTierOne.h
+++ b/include/ZeroTierOne.h
@@ -757,6 +757,11 @@ typedef struct {
  * Circuit test result report
  */
 typedef struct {
+	/**
+	 * Sender of report
+	 */
+	uint64_t address;
+
 	/**
 	 * 64-bit test ID
 	 */
@@ -839,7 +844,7 @@ typedef struct {
 	 *
 	 * This may have ss_family set to zero (null address) if unspecified.
 	 */
-	struct sockaddr_storage receivedFromAddress;
+	struct sockaddr_storage receivedFromRemoteAddress;
 
 	/**
 	 * Next hops to which packets are being or will be sent by the reporter
diff --git a/node/Poly1305.cpp b/node/Poly1305.cpp
index 230b2eff..77b32a80 100644
--- a/node/Poly1305.cpp
+++ b/node/Poly1305.cpp
@@ -7,14 +7,18 @@ Public domain.
 #include "Constants.hpp"
 #include "Poly1305.hpp"
 
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
 #ifdef __WINDOWS__
 #pragma warning(disable: 4146)
 #endif
 
 namespace ZeroTier {
 
-//////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
+#if 0
 
 static inline void add(unsigned int h[17],const unsigned int c[17])
 {
@@ -113,13 +117,278 @@ static inline int crypto_onetimeauth(unsigned char *out,const unsigned char *in,
   return 0;
 }
 
-//////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
 void Poly1305::compute(void *auth,const void *data,unsigned int len,const void *key)
 	throw()
 {
 	crypto_onetimeauth((unsigned char *)auth,(const unsigned char *)data,len,(const unsigned char *)key);
 }
 
+#endif
+
+namespace {
+
+typedef struct poly1305_context {
+  size_t aligner;
+  unsigned char opaque[136];
+} poly1305_context;
+
+/*
+  poly1305 implementation using 32 bit * 32 bit = 64 bit multiplication and 64 bit addition
+*/
+
+#define poly1305_block_size 16
+
+/* 17 + sizeof(size_t) + 14*sizeof(unsigned long) */
+typedef struct poly1305_state_internal_t {
+  unsigned long r[5];
+  unsigned long h[5];
+  unsigned long pad[4];
+  size_t leftover;
+  unsigned char buffer[poly1305_block_size];
+  unsigned char final;
+} poly1305_state_internal_t;
+
+/* interpret four 8 bit unsigned integers as a 32 bit unsigned integer in little endian */
+static unsigned long
+U8TO32(const unsigned char *p) {
+  return
+    (((unsigned long)(p[0] & 0xff)      ) |
+       ((unsigned long)(p[1] & 0xff) <<  8) |
+         ((unsigned long)(p[2] & 0xff) << 16) |
+         ((unsigned long)(p[3] & 0xff) << 24));
+}
+
+/* store a 32 bit unsigned integer as four 8 bit unsigned integers in little endian */
+static void
+U32TO8(unsigned char *p, unsigned long v) {
+  p[0] = (v      ) & 0xff;
+  p[1] = (v >>  8) & 0xff;
+  p[2] = (v >> 16) & 0xff;
+  p[3] = (v >> 24) & 0xff;
+}
+
+static inline void
+poly1305_init(poly1305_context *ctx, const unsigned char key[32]) {
+  poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;
+
+  /* r &= 0xffffffc0ffffffc0ffffffc0fffffff */
+  st->r[0] = (U8TO32(&key[ 0])     ) & 0x3ffffff;
+  st->r[1] = (U8TO32(&key[ 3]) >> 2) & 0x3ffff03;
+  st->r[2] = (U8TO32(&key[ 6]) >> 4) & 0x3ffc0ff;
+  st->r[3] = (U8TO32(&key[ 9]) >> 6) & 0x3f03fff;
+  st->r[4] = (U8TO32(&key[12]) >> 8) & 0x00fffff;
+
+  /* h = 0 */
+  st->h[0] = 0;
+  st->h[1] = 0;
+  st->h[2] = 0;
+  st->h[3] = 0;
+  st->h[4] = 0;
+
+  /* save pad for later */
+  st->pad[0] = U8TO32(&key[16]);
+  st->pad[1] = U8TO32(&key[20]);
+  st->pad[2] = U8TO32(&key[24]);
+  st->pad[3] = U8TO32(&key[28]);
+
+  st->leftover = 0;
+  st->final = 0;
+}
+
+static inline void
+poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, size_t bytes) {
+  const unsigned long hibit = (st->final) ? 0 : (1 << 24); /* 1 << 128 */
+  unsigned long r0,r1,r2,r3,r4;
+  unsigned long s1,s2,s3,s4;
+  unsigned long h0,h1,h2,h3,h4;
+  unsigned long long d0,d1,d2,d3,d4;
+  unsigned long c;
+
+  r0 = st->r[0];
+  r1 = st->r[1];
+  r2 = st->r[2];
+  r3 = st->r[3];
+  r4 = st->r[4];
+
+  s1 = r1 * 5;
+  s2 = r2 * 5;
+  s3 = r3 * 5;
+  s4 = r4 * 5;
+
+  h0 = st->h[0];
+  h1 = st->h[1];
+  h2 = st->h[2];
+  h3 = st->h[3];
+  h4 = st->h[4];
+
+  while (bytes >= poly1305_block_size) {
+    /* h += m[i] */
+    h0 += (U8TO32(m+ 0)     ) & 0x3ffffff;
+    h1 += (U8TO32(m+ 3) >> 2) & 0x3ffffff;
+    h2 += (U8TO32(m+ 6) >> 4) & 0x3ffffff;
+    h3 += (U8TO32(m+ 9) >> 6) & 0x3ffffff;
+    h4 += (U8TO32(m+12) >> 8) | hibit;
+
+    /* h *= r */
+    d0 = ((unsigned long long)h0 * r0) + ((unsigned long long)h1 * s4) + ((unsigned long long)h2 * s3) + ((unsigned long long)h3 * s2) + ((unsigned long long)h4 * s1);
+    d1 = ((unsigned long long)h0 * r1) + ((unsigned long long)h1 * r0) + ((unsigned long long)h2 * s4) + ((unsigned long long)h3 * s3) + ((unsigned long long)h4 * s2);
+    d2 = ((unsigned long long)h0 * r2) + ((unsigned long long)h1 * r1) + ((unsigned long long)h2 * r0) + ((unsigned long long)h3 * s4) + ((unsigned long long)h4 * s3);
+    d3 = ((unsigned long long)h0 * r3) + ((unsigned long long)h1 * r2) + ((unsigned long long)h2 * r1) + ((unsigned long long)h3 * r0) + ((unsigned long long)h4 * s4);
+    d4 = ((unsigned long long)h0 * r4) + ((unsigned long long)h1 * r3) + ((unsigned long long)h2 * r2) + ((unsigned long long)h3 * r1) + ((unsigned long long)h4 * r0);
+
+    /* (partial) h %= p */
+                  c = (unsigned long)(d0 >> 26); h0 = (unsigned long)d0 & 0x3ffffff;
+    d1 += c;      c = (unsigned long)(d1 >> 26); h1 = (unsigned long)d1 & 0x3ffffff;
+    d2 += c;      c = (unsigned long)(d2 >> 26); h2 = (unsigned long)d2 & 0x3ffffff;
+    d3 += c;      c = (unsigned long)(d3 >> 26); h3 = (unsigned long)d3 & 0x3ffffff;
+    d4 += c;      c = (unsigned long)(d4 >> 26); h4 = (unsigned long)d4 & 0x3ffffff;
+    h0 += c * 5;  c =                (h0 >> 26); h0 =                h0 & 0x3ffffff;
+    h1 += c;
+
+    m += poly1305_block_size;
+    bytes -= poly1305_block_size;
+  }
+
+  st->h[0] = h0;
+  st->h[1] = h1;
+  st->h[2] = h2;
+  st->h[3] = h3;
+  st->h[4] = h4;
+}
+
+static inline void
+poly1305_update(poly1305_context *ctx, const unsigned char *m, size_t bytes) {
+  poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;
+  size_t i;
+
+  /* handle leftover */
+  if (st->leftover) {
+    size_t want = (poly1305_block_size - st->leftover);
+    if (want > bytes)
+      want = bytes;
+    for (i = 0; i < want; i++)
+      st->buffer[st->leftover + i] = m[i];
+    bytes -= want;
+    m += want;
+    st->leftover += want;
+    if (st->leftover < poly1305_block_size)
+      return;
+    poly1305_blocks(st, st->buffer, poly1305_block_size);
+    st->leftover = 0;
+  }
+
+  /* process full blocks */
+  if (bytes >= poly1305_block_size) {
+    size_t want = (bytes & ~(poly1305_block_size - 1));
+    poly1305_blocks(st, m, want);
+    m += want;
+    bytes -= want;
+  }
+
+  /* store leftover */
+  if (bytes) {
+    for (i = 0; i < bytes; i++)
+      st->buffer[st->leftover + i] = m[i];
+    st->leftover += bytes;
+  }
+}
+
+static inline void
+poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) {
+  poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;
+  unsigned long h0,h1,h2,h3,h4,c;
+  unsigned long g0,g1,g2,g3,g4;
+  unsigned long long f;
+  unsigned long mask;
+
+  /* process the remaining block */
+  if (st->leftover) {
+    size_t i = st->leftover;
+    st->buffer[i++] = 1;
+    for (; i < poly1305_block_size; i++)
+      st->buffer[i] = 0;
+    st->final = 1;
+    poly1305_blocks(st, st->buffer, poly1305_block_size);
+  }
+
+  /* fully carry h */
+  h0 = st->h[0];
+  h1 = st->h[1];
+  h2 = st->h[2];
+  h3 = st->h[3];
+  h4 = st->h[4];
+
+               c = h1 >> 26; h1 = h1 & 0x3ffffff;
+  h2 +=     c; c = h2 >> 26; h2 = h2 & 0x3ffffff;
+  h3 +=     c; c = h3 >> 26; h3 = h3 & 0x3ffffff;
+  h4 +=     c; c = h4 >> 26; h4 = h4 & 0x3ffffff;
+  h0 += c * 5; c = h0 >> 26; h0 = h0 & 0x3ffffff;
+  h1 +=     c;
+
+  /* compute h + -p */
+  g0 = h0 + 5; c = g0 >> 26; g0 &= 0x3ffffff;
+  g1 = h1 + c; c = g1 >> 26; g1 &= 0x3ffffff;
+  g2 = h2 + c; c = g2 >> 26; g2 &= 0x3ffffff;
+  g3 = h3 + c; c = g3 >> 26; g3 &= 0x3ffffff;
+  g4 = h4 + c - (1 << 26);
+
+  /* select h if h < p, or h + -p if h >= p */
+  mask = (g4 >> ((sizeof(unsigned long) * 8) - 1)) - 1;
+  g0 &= mask;
+  g1 &= mask;
+  g2 &= mask;
+  g3 &= mask;
+  g4 &= mask;
+  mask = ~mask;
+  h0 = (h0 & mask) | g0;
+  h1 = (h1 & mask) | g1;
+  h2 = (h2 & mask) | g2;
+  h3 = (h3 & mask) | g3;
+  h4 = (h4 & mask) | g4;
+
+  /* h = h % (2^128) */
+  h0 = ((h0      ) | (h1 << 26)) & 0xffffffff;
+  h1 = ((h1 >>  6) | (h2 << 20)) & 0xffffffff;
+  h2 = ((h2 >> 12) | (h3 << 14)) & 0xffffffff;
+  h3 = ((h3 >> 18) | (h4 <<  8)) & 0xffffffff;
+
+  /* mac = (h + pad) % (2^128) */
+  f = (unsigned long long)h0 + st->pad[0]            ; h0 = (unsigned long)f;
+  f = (unsigned long long)h1 + st->pad[1] + (f >> 32); h1 = (unsigned long)f;
+  f = (unsigned long long)h2 + st->pad[2] + (f >> 32); h2 = (unsigned long)f;
+  f = (unsigned long long)h3 + st->pad[3] + (f >> 32); h3 = (unsigned long)f;
+
+  U32TO8(mac +  0, h0);
+  U32TO8(mac +  4, h1);
+  U32TO8(mac +  8, h2);
+  U32TO8(mac + 12, h3);
+
+  /* zero out the state */
+  st->h[0] = 0;
+  st->h[1] = 0;
+  st->h[2] = 0;
+  st->h[3] = 0;
+  st->h[4] = 0;
+  st->r[0] = 0;
+  st->r[1] = 0;
+  st->r[2] = 0;
+  st->r[3] = 0;
+  st->r[4] = 0;
+  st->pad[0] = 0;
+  st->pad[1] = 0;
+  st->pad[2] = 0;
+  st->pad[3] = 0;
+}
+
+} // anonymous namespace
+
+void Poly1305::compute(void *auth,const void *data,unsigned int len,const void *key)
+  throw()
+{
+  poly1305_context ctx;
+  poly1305_init(&ctx,reinterpret_cast<const unsigned char *>(key));
+  poly1305_update(&ctx,reinterpret_cast<const unsigned char *>(data),(size_t)len);
+  poly1305_finish(&ctx,reinterpret_cast<unsigned char *>(auth));
+}
+
 } // namespace ZeroTier
diff --git a/selftest.cpp b/selftest.cpp
index b899ee5a..e938cf4d 100644
--- a/selftest.cpp
+++ b/selftest.cpp
@@ -269,6 +269,22 @@ static int testCrypto()
 	}
 	std::cout << "PASS" << std::endl;
 
+	std::cout << "[crypto] Benchmarking Poly1305... "; std::cout.flush();
+	{
+		unsigned char *bb = (unsigned char *)::malloc(1234567);
+		for(unsigned int i=0;i<1234567;++i)
+			bb[i] = (unsigned char)i;
+		double bytes = 0.0;
+		uint64_t start = OSUtils::now();
+		for(unsigned int i=0;i<200;++i) {
+			Poly1305::compute(buf1,bb,1234567,poly1305TV0Key);
+			bytes += 1234567.0;
+		}
+		uint64_t end = OSUtils::now();
+		std::cout << ((bytes / 1048576.0) / ((double)(end - start) / 1000.0)) << " MiB/second" << std::endl;
+		::free((void *)bb);
+	}
+
 	std::cout << "[crypto] Testing C25519 and Ed25519 against test vectors... "; std::cout.flush();
 	for(int k=0;k<ZT_NUM_C25519_TEST_VECTORS;++k) {
 		C25519::Pair p1,p2;
-- 
cgit v1.2.3