From 6267c678882ddbb6ab9a70127ab6ceac35891e45 Mon Sep 17 00:00:00 2001 From: Adam Ierymenko Date: Thu, 12 Dec 2019 16:15:49 -0800 Subject: [PATCH] A bunch of cleanup and refactoring toward 2.x --- node/AES.cpp | 12 +- node/AES.hpp | 34 +-- node/Address.hpp | 62 +++--- node/AtomicCounter.hpp | 12 +- node/C25519.cpp | 88 ++++---- node/C25519.hpp | 4 +- node/Capability.hpp | 24 +-- node/CertificateOfMembership.hpp | 30 +-- node/CertificateOfOwnership.hpp | 38 ++-- node/Constants.hpp | 22 +- node/Credential.cpp | 2 +- node/Dictionary.hpp | 44 ++-- node/ECC384.cpp | 34 +-- node/Endpoint.hpp | 181 ++++++++++++++++ node/EphemeralKey.hpp | 16 +- node/Hashtable.hpp | 62 +++--- node/Identity.hpp | 44 ++-- node/IncomingPacket.cpp | 34 +-- node/IncomingPacket.hpp | 8 +- node/InetAddress.hpp | 155 +++++++++----- node/Locator.hpp | 348 ++----------------------------- node/MAC.hpp | 60 +++--- node/Membership.hpp | 20 +- node/Meter.hpp | 6 +- node/MulticastGroup.hpp | 26 +-- node/Mutex.hpp | 36 ++-- node/Network.hpp | 54 ++--- node/NetworkConfig.hpp | 26 +-- node/Node.cpp | 6 +- node/Node.hpp | 50 ++--- node/Packet.hpp | 84 ++++---- node/Path.hpp | 46 ++-- node/Peer.hpp | 60 +++--- node/Poly1305.cpp | 22 +- node/Revocation.hpp | 20 +- node/RingBuffer.hpp | 34 +-- node/RuntimeEnvironment.hpp | 4 +- node/SHA512.cpp | 10 +- node/SHA512.hpp | 12 +- node/Salsa20.hpp | 6 +- node/ScopedPtr.hpp | 22 +- node/SelfAwareness.cpp | 4 +- node/SelfAwareness.hpp | 14 +- node/SharedPtr.hpp | 40 ++-- node/Str.hpp | 78 +++---- node/Switch.hpp | 10 +- node/Tag.hpp | 50 ++--- node/Topology.hpp | 40 ++-- node/Trace.hpp | 14 +- node/Utils.hpp | 88 ++++---- 50 files changed, 1066 insertions(+), 1130 deletions(-) create mode 100644 node/Endpoint.hpp diff --git a/node/AES.cpp b/node/AES.cpp index c4477d00f..a7b4e781f 100644 --- a/node/AES.cpp +++ b/node/AES.cpp @@ -25,7 +25,7 @@ namespace ZeroTier { #ifdef ZT_NO_TYPE_PUNNING -static ZT_ALWAYS_INLINE uint32_t readuint32_t(const void *in) +static inline uint32_t readuint32_t(const void *in) { uint32_t v = ((const uint8_t *)in)[0]; v <<= 8; @@ -36,7 +36,7 @@ static ZT_ALWAYS_INLINE uint32_t readuint32_t(const void *in) v |= ((const uint8_t *)in)[3]; return v; } -static ZT_ALWAYS_INLINE void writeuint32_t(void *out,const uint32_t v) +static inline void writeuint32_t(void *out,const uint32_t v) { ((uint8_t *)out)[0] = (uint8_t)(v >> 24); ((uint8_t *)out)[1] = (uint8_t)(v >> 16); @@ -183,7 +183,7 @@ typedef unsigned __int128 uint128_t; typedef unsigned uint128_t __attribute__((mode(TI))); #endif -static ZT_ALWAYS_INLINE void s_bmul64(const uint64_t x,const uint64_t y,uint64_t &r_high,uint64_t &r_low) +static inline void s_bmul64(const uint64_t x,const uint64_t y,uint64_t &r_high,uint64_t &r_low) { static uint128_t m1 = (uint128_t)0x2108421084210842ULL << 64 | 0x1084210842108421ULL; static uint128_t m2 = (uint128_t)0x4210842108421084ULL << 64 | 0x2108421084210842ULL; @@ -214,7 +214,7 @@ static ZT_ALWAYS_INLINE void s_bmul64(const uint64_t x,const uint64_t y,uint64_t r_low = (uint64_t)r; } -static ZT_ALWAYS_INLINE void s_gfmul(const uint64_t h_high,const uint64_t h_low,uint64_t &y0, uint64_t &y1) +static inline void s_gfmul(const uint64_t h_high,const uint64_t h_low,uint64_t &y0, uint64_t &y1) { uint64_t z2_low,z2_high,z0_low,z0_high,z1a_low,z1a_high; uint64_t y_high = Utils::ntoh(y0); @@ -236,7 +236,7 @@ static ZT_ALWAYS_INLINE void s_gfmul(const uint64_t h_high,const uint64_t h_low, #else -static ZT_ALWAYS_INLINE void s_bmul32(uint32_t x,uint32_t y,uint32_t &r_high,uint32_t &r_low) +static inline void s_bmul32(uint32_t x,uint32_t y,uint32_t &r_high,uint32_t &r_low) { const uint32_t m1 = (uint32_t)0x11111111; const uint32_t m2 = (uint32_t)0x22222222; @@ -263,7 +263,7 @@ static ZT_ALWAYS_INLINE void s_bmul32(uint32_t x,uint32_t y,uint32_t &r_high,uin r_low = (uint32_t)z; } -static ZT_ALWAYS_INLINE void s_gfmul(const uint64_t h_high,const uint64_t h_low,uint64_t &y0,uint64_t &y1) +static inline void s_gfmul(const uint64_t h_high,const uint64_t h_low,uint64_t &y0,uint64_t &y1) { uint32_t h_high_h = (uint32_t)(h_high >> 32); uint32_t h_high_l = (uint32_t)h_high; diff --git a/node/AES.hpp b/node/AES.hpp index 15f8077c9..d8392bcb0 100644 --- a/node/AES.hpp +++ b/node/AES.hpp @@ -47,14 +47,14 @@ public: */ static const bool HW_ACCEL; - ZT_ALWAYS_INLINE AES() {} - ZT_ALWAYS_INLINE AES(const uint8_t key[32]) { this->init(key); } - ZT_ALWAYS_INLINE ~AES() { Utils::burn(&_k,sizeof(_k)); } + inline AES() {} + inline AES(const uint8_t key[32]) { this->init(key); } + inline ~AES() { Utils::burn(&_k,sizeof(_k)); } /** * Set (or re-set) this AES256 cipher's key */ - ZT_ALWAYS_INLINE void init(const uint8_t key[32]) + inline void init(const uint8_t key[32]) { #ifdef ZT_AES_AESNI if (likely(HW_ACCEL)) { @@ -72,7 +72,7 @@ public: * @param in Input block * @param out Output block (can be same as input) */ - ZT_ALWAYS_INLINE void encrypt(const uint8_t in[16],uint8_t out[16]) const + inline void encrypt(const uint8_t in[16],uint8_t out[16]) const { #ifdef ZT_AES_AESNI if (likely(HW_ACCEL)) { @@ -92,7 +92,7 @@ public: * @param len Length of input * @param out 128-bit authorization tag from GMAC */ - ZT_ALWAYS_INLINE void gmac(const uint8_t iv[12],const void *in,const unsigned int len,uint8_t out[16]) const + inline void gmac(const uint8_t iv[12],const void *in,const unsigned int len,uint8_t out[16]) const { #ifdef ZT_AES_AESNI if (likely(HW_ACCEL)) { @@ -116,7 +116,7 @@ public: * @param len Length of input * @param out Output plaintext or ciphertext */ - ZT_ALWAYS_INLINE void ctr(const uint8_t iv[16],const void *in,unsigned int len,void *out) const + inline void ctr(const uint8_t iv[16],const void *in,unsigned int len,void *out) const { #ifdef ZT_AES_AESNI if (likely(HW_ACCEL)) { @@ -187,7 +187,7 @@ public: * @param out Output buffer to receive ciphertext * @param tag Output buffer to receive 64-bit authentication tag */ - static ZT_ALWAYS_INLINE void gmacSivEncrypt(const AES &k1,const AES &k2,const AES &k3,const AES &k4,const uint8_t iv[8],const uint8_t pc,const void *in,const unsigned int len,void *out,uint8_t tag[8]) + static inline void gmacSivEncrypt(const AES &k1,const AES &k2,const AES &k3,const AES &k4,const uint8_t iv[8],const uint8_t pc,const void *in,const unsigned int len,void *out,uint8_t tag[8]) { #ifdef __GNUC__ uint8_t __attribute__ ((aligned (16))) miv[12]; @@ -246,7 +246,7 @@ public: * @param tag Authentication tag supplied with message * @return True if authentication tags match and message appears authentic */ - static ZT_ALWAYS_INLINE bool gmacSivDecrypt(const AES &k1,const AES &k2,const AES &k3,const AES &k4,const uint8_t iv[8],const uint8_t pc,const void *in,const unsigned int len,void *out,const uint8_t tag[8]) + static inline bool gmacSivDecrypt(const AES &k1,const AES &k2,const AES &k3,const AES &k4,const uint8_t iv[8],const uint8_t pc,const void *in,const unsigned int len,void *out,const uint8_t tag[8]) { #ifdef __GNUC__ uint8_t __attribute__ ((aligned (16))) miv[12]; @@ -307,7 +307,7 @@ public: * @param k3 CTR IV keyed hash key * @param k4 AES-CTR key */ - static ZT_ALWAYS_INLINE void initGmacCtrKeys(const uint8_t masterKey[32],AES &k1,AES &k2,AES &k3,AES &k4) + static inline void initGmacCtrKeys(const uint8_t masterKey[32],AES &k1,AES &k2,AES &k3,AES &k4) { uint8_t k[32]; KBKDFHMACSHA384(masterKey,ZT_PROTO_KBKDF_LABEL_KEY_USE_AES_GMAC_SIV_K1,0,0,k); @@ -435,7 +435,7 @@ private: #endif /*********************************************************************/ #ifdef ZT_AES_AESNI /********************************************************/ - static ZT_ALWAYS_INLINE __m128i _init256_1_aesni(__m128i a,__m128i b) + static inline __m128i _init256_1_aesni(__m128i a,__m128i b) { __m128i x,y; b = _mm_shuffle_epi32(b,0xff); @@ -448,7 +448,7 @@ private: x = _mm_xor_si128(x,b); return x; } - static ZT_ALWAYS_INLINE __m128i _init256_2_aesni(__m128i a,__m128i b) + static inline __m128i _init256_2_aesni(__m128i a,__m128i b) { __m128i x,y,z; y = _mm_aeskeygenassist_si128(a,0x00); @@ -462,7 +462,7 @@ private: x = _mm_xor_si128(x,z); return x; } - ZT_ALWAYS_INLINE void _init_aesni(const uint8_t key[32]) + inline void _init_aesni(const uint8_t key[32]) { __m128i t1,t2; _k.ni.k[0] = t1 = _mm_loadu_si128((const __m128i *)key); @@ -508,7 +508,7 @@ private: _k.ni.hhhh = _mm_shuffle_epi8(hhhh,shuf); } - ZT_ALWAYS_INLINE void _encrypt_aesni(const void *in,void *out) const + inline void _encrypt_aesni(const void *in,void *out) const { __m128i tmp; tmp = _mm_loadu_si128((const __m128i *)in); @@ -529,7 +529,7 @@ private: _mm_storeu_si128((__m128i *)out,_mm_aesenclast_si128(tmp,_k.ni.k[14])); } - static ZT_ALWAYS_INLINE __m128i _mult_block_aesni(__m128i shuf,__m128i h,__m128i y) + static inline __m128i _mult_block_aesni(__m128i shuf,__m128i h,__m128i y) { y = _mm_shuffle_epi8(y,shuf); __m128i t1 = _mm_clmulepi64_si128(h,y,0x00); @@ -569,9 +569,9 @@ private: t4 = _mm_xor_si128(t4,t5); return _mm_shuffle_epi8(t4,shuf); } - static ZT_ALWAYS_INLINE __m128i _ghash_aesni(__m128i shuf,__m128i h,__m128i y,__m128i x) { return _mult_block_aesni(shuf,h,_mm_xor_si128(y,x)); } + static inline __m128i _ghash_aesni(__m128i shuf,__m128i h,__m128i y,__m128i x) { return _mult_block_aesni(shuf,h,_mm_xor_si128(y,x)); } - ZT_ALWAYS_INLINE void _gmac_aesni(const uint8_t iv[12],const uint8_t *in,const unsigned int len,uint8_t out[16]) const + inline void _gmac_aesni(const uint8_t iv[12],const uint8_t *in,const unsigned int len,uint8_t out[16]) const { const __m128i *const ab = (const __m128i *)in; const unsigned int blocks = len / 16; diff --git a/node/Address.hpp b/node/Address.hpp index 3cafe0925..ec7ce2040 100644 --- a/node/Address.hpp +++ b/node/Address.hpp @@ -33,24 +33,24 @@ namespace ZeroTier { class Address { public: - ZT_ALWAYS_INLINE Address() : _a(0) {} - ZT_ALWAYS_INLINE Address(const Address &a) : _a(a._a) {} - ZT_ALWAYS_INLINE Address(uint64_t a) : _a(a & 0xffffffffffULL) {} + inline Address() : _a(0) {} + inline Address(const Address &a) : _a(a._a) {} + inline Address(uint64_t a) : _a(a & 0xffffffffffULL) {} /** * @param bits Raw address -- 5 bytes, big-endian byte order * @param len Length of array */ - ZT_ALWAYS_INLINE Address(const void *bits,unsigned int len) { setTo(bits,len); } + inline Address(const void *bits,unsigned int len) { setTo(bits,len); } - ZT_ALWAYS_INLINE Address &operator=(const Address &a) { _a = a._a; return *this; } - ZT_ALWAYS_INLINE Address &operator=(const uint64_t a) { _a = (a & 0xffffffffffULL); return *this; } + inline Address &operator=(const Address &a) { _a = a._a; return *this; } + inline Address &operator=(const uint64_t a) { _a = (a & 0xffffffffffULL); return *this; } /** * @param bits Raw address -- 5 bytes, big-endian byte order * @param len Length of array */ - ZT_ALWAYS_INLINE void setTo(const void *bits,const unsigned int len) + inline void setTo(const void *bits,const unsigned int len) { if (len < ZT_ADDRESS_LENGTH) { _a = 0; @@ -69,7 +69,7 @@ public: * @param bits Buffer to hold 5-byte address in big-endian byte order * @param len Length of array */ - ZT_ALWAYS_INLINE void copyTo(void *const bits,const unsigned int len) const + inline void copyTo(void *const bits,const unsigned int len) const { if (len < ZT_ADDRESS_LENGTH) return; @@ -87,7 +87,7 @@ public: * @param b Buffer to append to */ template - ZT_ALWAYS_INLINE void appendTo(Buffer &b) const + inline void appendTo(Buffer &b) const { unsigned char *p = (unsigned char *)b.appendField(ZT_ADDRESS_LENGTH); *(p++) = (unsigned char)((_a >> 32) & 0xff); @@ -100,22 +100,22 @@ public: /** * @return Integer containing address (0 to 2^40) */ - ZT_ALWAYS_INLINE uint64_t toInt() const { return _a; } + inline uint64_t toInt() const { return _a; } /** * @return Hash code for use with Hashtable */ - ZT_ALWAYS_INLINE unsigned long hashCode() const { return (unsigned long)_a; } + inline unsigned long hashCode() const { return (unsigned long)_a; } /** * @return Hexadecimal string */ - ZT_ALWAYS_INLINE char *toString(char buf[11]) const { return Utils::hex10(_a,buf); } + inline char *toString(char buf[11]) const { return Utils::hex10(_a,buf); } /** * @return True if this address is not zero */ - ZT_ALWAYS_INLINE operator bool() const { return (_a != 0); } + inline operator bool() const { return (_a != 0); } /** * Check if this address is reserved @@ -126,33 +126,33 @@ public: * * @return True if address is reserved and may not be used */ - ZT_ALWAYS_INLINE bool isReserved() const { return ((!_a)||((_a >> 32) == ZT_ADDRESS_RESERVED_PREFIX)); } + inline bool isReserved() const { return ((!_a)||((_a >> 32) == ZT_ADDRESS_RESERVED_PREFIX)); } /** * @param i Value from 0 to 4 (inclusive) * @return Byte at said position (address interpreted in big-endian order) */ - ZT_ALWAYS_INLINE uint8_t operator[](unsigned int i) const { return (uint8_t)(_a >> (32 - (i * 8))); } + inline uint8_t operator[](unsigned int i) const { return (uint8_t)(_a >> (32 - (i * 8))); } - ZT_ALWAYS_INLINE operator unsigned int() const { return (unsigned int)_a; } - ZT_ALWAYS_INLINE operator unsigned long() const { return (unsigned long)_a; } - ZT_ALWAYS_INLINE operator unsigned long long() const { return (unsigned long long)_a; } + inline operator unsigned int() const { return (unsigned int)_a; } + inline operator unsigned long() const { return (unsigned long)_a; } + inline operator unsigned long long() const { return (unsigned long long)_a; } - ZT_ALWAYS_INLINE void zero() { _a = 0; } + inline void zero() { _a = 0; } - ZT_ALWAYS_INLINE bool operator==(const uint64_t &a) const { return (_a == (a & 0xffffffffffULL)); } - ZT_ALWAYS_INLINE bool operator!=(const uint64_t &a) const { return (_a != (a & 0xffffffffffULL)); } - ZT_ALWAYS_INLINE bool operator>(const uint64_t &a) const { return (_a > (a & 0xffffffffffULL)); } - ZT_ALWAYS_INLINE bool operator<(const uint64_t &a) const { return (_a < (a & 0xffffffffffULL)); } - ZT_ALWAYS_INLINE bool operator>=(const uint64_t &a) const { return (_a >= (a & 0xffffffffffULL)); } - ZT_ALWAYS_INLINE bool operator<=(const uint64_t &a) const { return (_a <= (a & 0xffffffffffULL)); } + inline bool operator==(const uint64_t &a) const { return (_a == (a & 0xffffffffffULL)); } + inline bool operator!=(const uint64_t &a) const { return (_a != (a & 0xffffffffffULL)); } + inline bool operator>(const uint64_t &a) const { return (_a > (a & 0xffffffffffULL)); } + inline bool operator<(const uint64_t &a) const { return (_a < (a & 0xffffffffffULL)); } + inline bool operator>=(const uint64_t &a) const { return (_a >= (a & 0xffffffffffULL)); } + inline bool operator<=(const uint64_t &a) const { return (_a <= (a & 0xffffffffffULL)); } - ZT_ALWAYS_INLINE bool operator==(const Address &a) const { return (_a == a._a); } - ZT_ALWAYS_INLINE bool operator!=(const Address &a) const { return (_a != a._a); } - ZT_ALWAYS_INLINE bool operator>(const Address &a) const { return (_a > a._a); } - ZT_ALWAYS_INLINE bool operator<(const Address &a) const { return (_a < a._a); } - ZT_ALWAYS_INLINE bool operator>=(const Address &a) const { return (_a >= a._a); } - ZT_ALWAYS_INLINE bool operator<=(const Address &a) const { return (_a <= a._a); } + inline bool operator==(const Address &a) const { return (_a == a._a); } + inline bool operator!=(const Address &a) const { return (_a != a._a); } + inline bool operator>(const Address &a) const { return (_a > a._a); } + inline bool operator<(const Address &a) const { return (_a < a._a); } + inline bool operator>=(const Address &a) const { return (_a >= a._a); } + inline bool operator<=(const Address &a) const { return (_a <= a._a); } private: uint64_t _a; diff --git a/node/AtomicCounter.hpp b/node/AtomicCounter.hpp index 4e6b95315..b5131ccb5 100644 --- a/node/AtomicCounter.hpp +++ b/node/AtomicCounter.hpp @@ -28,9 +28,9 @@ namespace ZeroTier { class AtomicCounter { public: - ZT_ALWAYS_INLINE AtomicCounter() { _v = 0; } + inline AtomicCounter() { _v = 0; } - ZT_ALWAYS_INLINE int load() const + inline int load() const { #ifdef __GNUC__ return __sync_or_and_fetch(const_cast(&_v),0); @@ -39,7 +39,7 @@ public: #endif } - ZT_ALWAYS_INLINE int operator++() + inline int operator++() { #ifdef __GNUC__ return __sync_add_and_fetch(&_v,1); @@ -48,7 +48,7 @@ public: #endif } - ZT_ALWAYS_INLINE int operator--() + inline int operator--() { #ifdef __GNUC__ return __sync_sub_and_fetch(&_v,1); @@ -58,8 +58,8 @@ public: } private: - ZT_ALWAYS_INLINE AtomicCounter(const AtomicCounter &) {} - ZT_ALWAYS_INLINE const AtomicCounter &operator=(const AtomicCounter &) { return *this; } + inline AtomicCounter(const AtomicCounter &) {} + inline const AtomicCounter &operator=(const AtomicCounter &) { return *this; } #ifdef __GNUC__ int _v; diff --git a/node/C25519.cpp b/node/C25519.cpp index f14875b7a..aa9fa66c5 100644 --- a/node/C25519.cpp +++ b/node/C25519.cpp @@ -41,7 +41,7 @@ typedef uint8_t u8; typedef int32_t s32; typedef int64_t limb; -static ZT_ALWAYS_INLINE void fsum(limb *output, const limb *in) { +static inline void fsum(limb *output, const limb *in) { unsigned i; for (i = 0; i < 10; i += 2) { output[0+i] = output[0+i] + in[0+i]; @@ -49,21 +49,21 @@ static ZT_ALWAYS_INLINE void fsum(limb *output, const limb *in) { } } -static ZT_ALWAYS_INLINE void fdifference(limb *output, const limb *in) { +static inline void fdifference(limb *output, const limb *in) { unsigned i; for (i = 0; i < 10; ++i) { output[i] = in[i] - output[i]; } } -static ZT_ALWAYS_INLINE void fscalar_product(limb *output, const limb *in, const limb scalar) { +static inline void fscalar_product(limb *output, const limb *in, const limb scalar) { unsigned i; for (i = 0; i < 10; ++i) { output[i] = in[i] * scalar; } } -static ZT_ALWAYS_INLINE void fproduct(limb *output, const limb *in2, const limb *in) { +static inline void fproduct(limb *output, const limb *in2, const limb *in) { output[0] = ((limb) ((s32) in2[0])) * ((s32) in[0]); output[1] = ((limb) ((s32) in2[0])) * ((s32) in[1]) + ((limb) ((s32) in2[1])) * ((s32) in[0]); @@ -166,7 +166,7 @@ static ZT_ALWAYS_INLINE void fproduct(limb *output, const limb *in2, const limb output[18] = 2 * ((limb) ((s32) in2[9])) * ((s32) in[9]); } -static ZT_ALWAYS_INLINE void freduce_degree(limb *output) { +static inline void freduce_degree(limb *output) { output[8] += output[18] << 4; output[8] += output[18] << 1; output[8] += output[18]; @@ -200,7 +200,7 @@ static ZT_ALWAYS_INLINE void freduce_degree(limb *output) { #error "This code only works on a two's complement system" #endif -static ZT_ALWAYS_INLINE limb div_by_2_26(const limb v) +static inline limb div_by_2_26(const limb v) { /* High word of v; no shift needed. */ const uint32_t highword = (uint32_t) (((uint64_t) v) >> 32); @@ -212,7 +212,7 @@ static ZT_ALWAYS_INLINE limb div_by_2_26(const limb v) return (v + roundoff) >> 26; } -static ZT_ALWAYS_INLINE limb div_by_2_25(const limb v) +static inline limb div_by_2_25(const limb v) { /* High word of v; no shift needed*/ const uint32_t highword = (uint32_t) (((uint64_t) v) >> 32); @@ -224,7 +224,7 @@ static ZT_ALWAYS_INLINE limb div_by_2_25(const limb v) return (v + roundoff) >> 25; } -static ZT_ALWAYS_INLINE void freduce_coefficients(limb *output) { +static inline void freduce_coefficients(limb *output) { unsigned i; output[10] = 0; @@ -277,7 +277,7 @@ static inline void fmul(limb *output, const limb *in, const limb *in2) { memcpy(output, t, sizeof(limb) * 10); } -static ZT_ALWAYS_INLINE void fsquare_inner(limb *output, const limb *in) { +static inline void fsquare_inner(limb *output, const limb *in) { output[0] = ((limb) ((s32) in[0])) * ((s32) in[0]); output[1] = 2 * ((limb) ((s32) in[0])) * ((s32) in[1]); output[2] = 2 * (((limb) ((s32) in[1])) * ((s32) in[1]) + @@ -347,7 +347,7 @@ static inline void fsquare(limb *output, const limb *in) { memcpy(output, t, sizeof(limb) * 10); } -static ZT_ALWAYS_INLINE void fexpand(limb *output, const u8 *input) { +static inline void fexpand(limb *output, const u8 *input) { #define F(n,start,shift,mask) \ output[n] = ((((limb) input[start + 0]) | \ ((limb) input[start + 1]) << 8 | \ @@ -370,7 +370,7 @@ static ZT_ALWAYS_INLINE void fexpand(limb *output, const u8 *input) { #error "This code only works when >> does sign-extension on negative numbers" #endif -static ZT_ALWAYS_INLINE s32 s32_eq(s32 a, s32 b) { +static inline s32 s32_eq(s32 a, s32 b) { a = ~(a ^ b); a &= a << 16; a &= a << 8; @@ -380,7 +380,7 @@ static ZT_ALWAYS_INLINE s32 s32_eq(s32 a, s32 b) { return a >> 31; } -static ZT_ALWAYS_INLINE s32 s32_gte(s32 a, s32 b) { +static inline s32 s32_gte(s32 a, s32 b) { a -= b; /* a >= 0 iff a >= b. */ return ~(a >> 31); @@ -560,7 +560,7 @@ static inline void fmonty(limb *x2, limb *z2, /* output 2Q */ /* |z2|i| < 2^26 */ } -static ZT_ALWAYS_INLINE void swap_conditional(limb a[19], limb b[19], limb iswap) { +static inline void swap_conditional(limb a[19], limb b[19], limb iswap) { unsigned i; const s32 swap = (s32) -iswap; @@ -701,7 +701,7 @@ static inline void crypto_scalarmult(u8 *mypublic, const u8 *secret, const u8 *b } static const unsigned char base[32] = {9}; -static ZT_ALWAYS_INLINE void crypto_scalarmult_base(unsigned char *q,const unsigned char *n) { crypto_scalarmult(q,n,base); } +static inline void crypto_scalarmult_base(unsigned char *q,const unsigned char *n) { crypto_scalarmult(q,n,base); } ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// @@ -759,7 +759,7 @@ typedef struct static inline void fe25519_sub(fe25519 *r, const fe25519 *x, const fe25519 *y); -static ZT_ALWAYS_INLINE crypto_uint32 equal(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */ +static inline crypto_uint32 equal(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */ { crypto_uint32 x = a ^ b; /* 0: yes; 1..65535: no */ x -= 1; /* 4294967295: yes; 0..65534: no */ @@ -767,7 +767,7 @@ static ZT_ALWAYS_INLINE crypto_uint32 equal(crypto_uint32 a,crypto_uint32 b) /* return x; } -static ZT_ALWAYS_INLINE crypto_uint32 ge(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */ +static inline crypto_uint32 ge(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */ { unsigned int x = a; x -= (unsigned int) b; /* 0..65535: yes; 4294901761..4294967295: no */ @@ -776,10 +776,10 @@ static ZT_ALWAYS_INLINE crypto_uint32 ge(crypto_uint32 a,crypto_uint32 b) /* 16- return x; } -static ZT_ALWAYS_INLINE crypto_uint32 times19(crypto_uint32 a) { return (a << 4) + (a << 1) + a; } -static ZT_ALWAYS_INLINE crypto_uint32 times38(crypto_uint32 a) { return (a << 5) + (a << 2) + (a << 1); } +static inline crypto_uint32 times19(crypto_uint32 a) { return (a << 4) + (a << 1) + a; } +static inline crypto_uint32 times38(crypto_uint32 a) { return (a << 5) + (a << 2) + (a << 1); } -static ZT_ALWAYS_INLINE void reduce_add_sub(fe25519 *r) +static inline void reduce_add_sub(fe25519 *r) { int i,rep; for(rep=0;rep<4;rep++) @@ -797,7 +797,7 @@ static ZT_ALWAYS_INLINE void reduce_add_sub(fe25519 *r) } } -static ZT_ALWAYS_INLINE void reduce_mul(fe25519 *r) +static inline void reduce_mul(fe25519 *r) { int i,rep; for(rep=0;rep<2;rep++) @@ -815,7 +815,7 @@ static ZT_ALWAYS_INLINE void reduce_mul(fe25519 *r) } } -static ZT_ALWAYS_INLINE void fe25519_freeze(fe25519 *r) +static inline void fe25519_freeze(fe25519 *r) { int i; crypto_uint32 mm = equal(r->v[31],127); @@ -831,14 +831,14 @@ static ZT_ALWAYS_INLINE void fe25519_freeze(fe25519 *r) r->v[0] -= mm&237; } -static ZT_ALWAYS_INLINE void fe25519_unpack(fe25519 *r, const unsigned char x[32]) +static inline void fe25519_unpack(fe25519 *r, const unsigned char x[32]) { int i; for(i=0;i<32;i++) r->v[i] = x[i]; r->v[31] &= 127; } -static ZT_ALWAYS_INLINE void fe25519_pack(unsigned char r[32], const fe25519 *x) +static inline void fe25519_pack(unsigned char r[32], const fe25519 *x) { int i; fe25519 y = *x; @@ -859,7 +859,7 @@ static inline int fe25519_iseq_vartime(const fe25519 *x, const fe25519 *y) return 1; } -static ZT_ALWAYS_INLINE void fe25519_cmov(fe25519 *r, const fe25519 *x, unsigned char b) +static inline void fe25519_cmov(fe25519 *r, const fe25519 *x, unsigned char b) { int i; crypto_uint32 mask = b; @@ -867,27 +867,27 @@ static ZT_ALWAYS_INLINE void fe25519_cmov(fe25519 *r, const fe25519 *x, unsigned for(i=0;i<32;i++) r->v[i] ^= mask & (x->v[i] ^ r->v[i]); } -static ZT_ALWAYS_INLINE unsigned char fe25519_getparity(const fe25519 *x) +static inline unsigned char fe25519_getparity(const fe25519 *x) { fe25519 t = *x; fe25519_freeze(&t); return t.v[0] & 1; } -static ZT_ALWAYS_INLINE void fe25519_setone(fe25519 *r) +static inline void fe25519_setone(fe25519 *r) { int i; r->v[0] = 1; for(i=1;i<32;i++) r->v[i]=0; } -static ZT_ALWAYS_INLINE void fe25519_setzero(fe25519 *r) +static inline void fe25519_setzero(fe25519 *r) { int i; for(i=0;i<32;i++) r->v[i]=0; } -static ZT_ALWAYS_INLINE void fe25519_neg(fe25519 *r, const fe25519 *x) +static inline void fe25519_neg(fe25519 *r, const fe25519 *x) { fe25519 t; int i; @@ -896,14 +896,14 @@ static ZT_ALWAYS_INLINE void fe25519_neg(fe25519 *r, const fe25519 *x) fe25519_sub(r, r, &t); } -static ZT_ALWAYS_INLINE void fe25519_add(fe25519 *r, const fe25519 *x, const fe25519 *y) +static inline void fe25519_add(fe25519 *r, const fe25519 *x, const fe25519 *y) { int i; for(i=0;i<32;i++) r->v[i] = x->v[i] + y->v[i]; reduce_add_sub(r); } -static ZT_ALWAYS_INLINE void fe25519_sub(fe25519 *r, const fe25519 *x, const fe25519 *y) +static inline void fe25519_sub(fe25519 *r, const fe25519 *x, const fe25519 *y) { int i; crypto_uint32 t[32]; @@ -914,7 +914,7 @@ static ZT_ALWAYS_INLINE void fe25519_sub(fe25519 *r, const fe25519 *x, const fe2 reduce_add_sub(r); } -static ZT_ALWAYS_INLINE void fe25519_mul(fe25519 *r, const fe25519 *x, const fe25519 *y) +static inline void fe25519_mul(fe25519 *r, const fe25519 *x, const fe25519 *y) { int i,j; crypto_uint32 t[63]; @@ -931,7 +931,7 @@ static ZT_ALWAYS_INLINE void fe25519_mul(fe25519 *r, const fe25519 *x, const fe2 reduce_mul(r); } -static ZT_ALWAYS_INLINE void fe25519_square(fe25519 *r, const fe25519 *x) { fe25519_mul(r, x, x); } +static inline void fe25519_square(fe25519 *r, const fe25519 *x) { fe25519_mul(r, x, x); } static inline void fe25519_invert(fe25519 *r, const fe25519 *x) { @@ -1057,7 +1057,7 @@ static inline void fe25519_pow2523(fe25519 *r, const fe25519 *x) static const crypto_uint32 m[32] = {0xED, 0xD3, 0xF5, 0x5C, 0x1A, 0x63, 0x12, 0x58, 0xD6, 0x9C, 0xF7, 0xA2, 0xDE, 0xF9, 0xDE, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10}; static const crypto_uint32 mu[33] = {0x1B, 0x13, 0x2C, 0x0A, 0xA3, 0xE5, 0x9C, 0xED, 0xA7, 0x29, 0x63, 0x08, 0x5D, 0x21, 0x06, 0x21, 0xEB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F}; -static ZT_ALWAYS_INLINE crypto_uint32 lt(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */ +static inline crypto_uint32 lt(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */ { unsigned int x = a; x -= (unsigned int) b; /* 0..65535: no; 4294901761..4294967295: yes */ @@ -1065,7 +1065,7 @@ static ZT_ALWAYS_INLINE crypto_uint32 lt(crypto_uint32 a,crypto_uint32 b) /* 16- return x; } -static ZT_ALWAYS_INLINE void reduce_add_sub(sc25519 *r) +static inline void reduce_add_sub(sc25519 *r) { crypto_uint32 pb = 0; crypto_uint32 b; @@ -1144,7 +1144,7 @@ static inline void sc25519_from64bytes(sc25519 *r, const unsigned char x[64]) barrett_reduce(r, t); } -static ZT_ALWAYS_INLINE void sc25519_to32bytes(unsigned char r[32], const sc25519 *x) +static inline void sc25519_to32bytes(unsigned char r[32], const sc25519 *x) { int i; for(i=0;i<32;i++) r[i] = x->v[i]; @@ -1181,7 +1181,7 @@ static inline void sc25519_mul(sc25519 *r, const sc25519 *x, const sc25519 *y) barrett_reduce(r, t); } -static ZT_ALWAYS_INLINE void sc25519_window3(signed char r[85], const sc25519 *s) +static inline void sc25519_window3(signed char r[85], const sc25519 *s) { char carry; int i; @@ -1218,7 +1218,7 @@ static ZT_ALWAYS_INLINE void sc25519_window3(signed char r[85], const sc25519 *s r[84] += carry; } -static ZT_ALWAYS_INLINE void sc25519_2interleave2(unsigned char r[127], const sc25519 *s1, const sc25519 *s2) +static inline void sc25519_2interleave2(unsigned char r[127], const sc25519 *s1, const sc25519 *s2) { int i; for(i=0;i<31;i++) @@ -2107,21 +2107,21 @@ static const ge25519_aff ge25519_base_multiples_affine[425] = { {{0x69, 0x3e, 0x47, 0x97, 0x2c, 0xaf, 0x52, 0x7c, 0x78, 0x83, 0xad, 0x1b, 0x39, 0x82, 0x2f, 0x02, 0x6f, 0x47, 0xdb, 0x2a, 0xb0, 0xe1, 0x91, 0x99, 0x55, 0xb8, 0x99, 0x3a, 0xa0, 0x44, 0x11, 0x51}}} }; -static ZT_ALWAYS_INLINE void p1p1_to_p2(ge25519_p2 *r, const ge25519_p1p1 *p) +static inline void p1p1_to_p2(ge25519_p2 *r, const ge25519_p1p1 *p) { fe25519_mul(&r->x, &p->x, &p->t); fe25519_mul(&r->y, &p->y, &p->z); fe25519_mul(&r->z, &p->z, &p->t); } -static ZT_ALWAYS_INLINE void p1p1_to_p2_2(ge25519_p3 *r, const ge25519_p1p1 *p) +static inline void p1p1_to_p2_2(ge25519_p3 *r, const ge25519_p1p1 *p) { fe25519_mul(&r->x, &p->x, &p->t); fe25519_mul(&r->y, &p->y, &p->z); fe25519_mul(&r->z, &p->z, &p->t); } -static ZT_ALWAYS_INLINE void p1p1_to_p3(ge25519_p3 *r, const ge25519_p1p1 *p) +static inline void p1p1_to_p3(ge25519_p3 *r, const ge25519_p1p1 *p) { p1p1_to_p2_2(r, p); fe25519_mul(&r->t, &p->x, &p->y); @@ -2190,13 +2190,13 @@ static inline void dbl_p1p1(ge25519_p1p1 *r, const ge25519_p2 *p) } /* Constant-time version of: if(b) r = p */ -static ZT_ALWAYS_INLINE void cmov_aff(ge25519_aff *r, const ge25519_aff *p, unsigned char b) +static inline void cmov_aff(ge25519_aff *r, const ge25519_aff *p, unsigned char b) { fe25519_cmov(&r->x, &p->x, b); fe25519_cmov(&r->y, &p->y, b); } -static ZT_ALWAYS_INLINE unsigned char equal(signed char b,signed char c) +static inline unsigned char equal(signed char b,signed char c) { unsigned char ub = b; unsigned char uc = c; @@ -2207,7 +2207,7 @@ static ZT_ALWAYS_INLINE unsigned char equal(signed char b,signed char c) return (unsigned char)y; } -static ZT_ALWAYS_INLINE unsigned char negative(signed char b) +static inline unsigned char negative(signed char b) { unsigned long long x = b; /* 18446744073709551361..18446744073709551615: yes; 0..255: no */ x >>= 63; /* 1: yes; 0: no */ @@ -2356,7 +2356,7 @@ static inline void ge25519_scalarmult_base(ge25519_p3 *r, const sc25519 *s) } } -static ZT_ALWAYS_INLINE void get_hram(unsigned char *hram, const unsigned char *sm, const unsigned char *pk, unsigned char *playground, unsigned long long smlen) +static inline void get_hram(unsigned char *hram, const unsigned char *sm, const unsigned char *pk, unsigned char *playground, unsigned long long smlen) { unsigned long long i; diff --git a/node/C25519.hpp b/node/C25519.hpp index 94b62c321..b73e0ec11 100644 --- a/node/C25519.hpp +++ b/node/C25519.hpp @@ -32,7 +32,7 @@ public: /** * Generate a C25519 elliptic curve key pair */ - static ZT_ALWAYS_INLINE void generate(uint8_t pub[ZT_C25519_PUBLIC_KEY_LEN],uint8_t priv[ZT_C25519_PRIVATE_KEY_LEN]) + static inline void generate(uint8_t pub[ZT_C25519_PUBLIC_KEY_LEN],uint8_t priv[ZT_C25519_PRIVATE_KEY_LEN]) { Utils::getSecureRandom(priv,ZT_C25519_PRIVATE_KEY_LEN); _calcPubDH(pub,priv); @@ -53,7 +53,7 @@ public: * @tparam F Type of 'cond' */ template - static ZT_ALWAYS_INLINE void generateSatisfying(F cond,uint8_t pub[ZT_C25519_PUBLIC_KEY_LEN],uint8_t priv[ZT_C25519_PRIVATE_KEY_LEN]) + static inline void generateSatisfying(F cond,uint8_t pub[ZT_C25519_PUBLIC_KEY_LEN],uint8_t priv[ZT_C25519_PRIVATE_KEY_LEN]) { Utils::getSecureRandom(priv,ZT_C25519_PRIVATE_KEY_LEN); _calcPubED(pub,priv); // do Ed25519 key -- bytes 32-63 of pub and priv diff --git a/node/Capability.hpp b/node/Capability.hpp index 902869e8d..167b575c2 100644 --- a/node/Capability.hpp +++ b/node/Capability.hpp @@ -61,7 +61,7 @@ class Capability : public Credential public: static inline Credential::Type credentialType() { return Credential::CREDENTIAL_TYPE_CAPABILITY; } - ZT_ALWAYS_INLINE Capability() : + inline Capability() : _nwid(0), _ts(0), _id(0), @@ -80,7 +80,7 @@ public: * @param rules Network flow rules for this capability * @param ruleCount Number of flow rules */ - ZT_ALWAYS_INLINE Capability(uint32_t id,uint64_t nwid,int64_t ts,unsigned int mccl,const ZT_VirtualNetworkRule *rules,unsigned int ruleCount) : + inline Capability(uint32_t id,uint64_t nwid,int64_t ts,unsigned int mccl,const ZT_VirtualNetworkRule *rules,unsigned int ruleCount) : _nwid(nwid), _ts(ts), _id(id), @@ -94,32 +94,32 @@ public: /** * @return Rules -- see ruleCount() for size of array */ - ZT_ALWAYS_INLINE const ZT_VirtualNetworkRule *rules() const { return _rules; } + inline const ZT_VirtualNetworkRule *rules() const { return _rules; } /** * @return Number of rules in rules() */ - ZT_ALWAYS_INLINE unsigned int ruleCount() const { return _ruleCount; } + inline unsigned int ruleCount() const { return _ruleCount; } /** * @return ID and evaluation order of this capability in network */ - ZT_ALWAYS_INLINE uint32_t id() const { return _id; } + inline uint32_t id() const { return _id; } /** * @return Network ID for which this capability was issued */ - ZT_ALWAYS_INLINE uint64_t networkId() const { return _nwid; } + inline uint64_t networkId() const { return _nwid; } /** * @return Timestamp */ - ZT_ALWAYS_INLINE int64_t timestamp() const { return _ts; } + inline int64_t timestamp() const { return _ts; } /** * @return Last 'to' address in chain of custody */ - ZT_ALWAYS_INLINE Address issuedTo() const + inline Address issuedTo() const { Address i2; for(unsigned int i=0;i static inline void serializeRules(Buffer &b,const ZT_VirtualNetworkRule *rules,unsigned int ruleCount) @@ -460,10 +460,10 @@ public: } // Provides natural sort order by ID - ZT_ALWAYS_INLINE bool operator<(const Capability &c) const { return (_id < c._id); } + inline bool operator<(const Capability &c) const { return (_id < c._id); } - ZT_ALWAYS_INLINE bool operator==(const Capability &c) const { return (memcmp(this,&c,sizeof(Capability)) == 0); } - ZT_ALWAYS_INLINE bool operator!=(const Capability &c) const { return (memcmp(this,&c,sizeof(Capability)) != 0); } + inline bool operator==(const Capability &c) const { return (memcmp(this,&c,sizeof(Capability)) == 0); } + inline bool operator!=(const Capability &c) const { return (memcmp(this,&c,sizeof(Capability)) != 0); } private: uint64_t _nwid; diff --git a/node/CertificateOfMembership.hpp b/node/CertificateOfMembership.hpp index ba21afd46..81308a216 100644 --- a/node/CertificateOfMembership.hpp +++ b/node/CertificateOfMembership.hpp @@ -69,7 +69,7 @@ class CertificateOfMembership : public Credential friend class Credential; public: - static ZT_ALWAYS_INLINE Credential::Type credentialType() { return Credential::CREDENTIAL_TYPE_COM; } + static inline Credential::Type credentialType() { return Credential::CREDENTIAL_TYPE_COM; } /** * Reserved qualifier IDs @@ -101,7 +101,7 @@ public: /** * Create an empty certificate of membership */ - ZT_ALWAYS_INLINE CertificateOfMembership() : + inline CertificateOfMembership() : _qualifierCount(0), _signatureLength(0) {} @@ -113,7 +113,7 @@ public: * @param nwid Network ID * @param issuedTo Certificate recipient */ - ZT_ALWAYS_INLINE CertificateOfMembership(uint64_t timestamp,uint64_t timestampMaxDelta,uint64_t nwid,const Address &issuedTo) + inline CertificateOfMembership(uint64_t timestamp,uint64_t timestampMaxDelta,uint64_t nwid,const Address &issuedTo) { _qualifiers[0].id = COM_RESERVED_ID_TIMESTAMP; _qualifiers[0].value = timestamp; @@ -135,22 +135,22 @@ public: * @param startAt Position to start in buffer */ template - ZT_ALWAYS_INLINE CertificateOfMembership(const Buffer &b,unsigned int startAt = 0) { deserialize(b,startAt); } + inline CertificateOfMembership(const Buffer &b,unsigned int startAt = 0) { deserialize(b,startAt); } /** * @return True if there's something here */ - ZT_ALWAYS_INLINE operator bool() const { return (_qualifierCount != 0); } + inline operator bool() const { return (_qualifierCount != 0); } /** * @return Credential ID, always 0 for COMs */ - ZT_ALWAYS_INLINE uint32_t id() const { return 0; } + inline uint32_t id() const { return 0; } /** * @return Timestamp for this cert and maximum delta for timestamp */ - ZT_ALWAYS_INLINE int64_t timestamp() const + inline int64_t timestamp() const { for(unsigned int i=0;i<_qualifierCount;++i) { if (_qualifiers[i].id == COM_RESERVED_ID_TIMESTAMP) @@ -162,7 +162,7 @@ public: /** * @return Address to which this cert was issued */ - ZT_ALWAYS_INLINE Address issuedTo() const + inline Address issuedTo() const { for(unsigned int i=0;i<_qualifierCount;++i) { if (_qualifiers[i].id == COM_RESERVED_ID_ISSUED_TO) @@ -174,7 +174,7 @@ public: /** * @return Network ID for which this cert was issued */ - ZT_ALWAYS_INLINE uint64_t networkId() const + inline uint64_t networkId() const { for(unsigned int i=0;i<_qualifierCount;++i) { if (_qualifiers[i].id == COM_RESERVED_ID_NETWORK_ID) @@ -211,7 +211,7 @@ public: } } - ZT_ALWAYS_INLINE void setQualifier(ReservedId id,uint64_t value,uint64_t maxDelta) { setQualifier((uint64_t)id,value,maxDelta); } + inline void setQualifier(ReservedId id,uint64_t value,uint64_t maxDelta) { setQualifier((uint64_t)id,value,maxDelta); } /** * Compare two certificates for parameter agreement @@ -294,17 +294,17 @@ public: * @param RR Runtime environment for looking up peers * @param tPtr Thread pointer to be handed through to any callbacks called as a result of this call */ - ZT_ALWAYS_INLINE Credential::VerifyResult verify(const RuntimeEnvironment *RR,void *tPtr) const { return _verify(RR,tPtr,*this); } + inline Credential::VerifyResult verify(const RuntimeEnvironment *RR,void *tPtr) const { return _verify(RR,tPtr,*this); } /** * @return True if signed */ - ZT_ALWAYS_INLINE bool isSigned() const { return (_signedBy); } + inline bool isSigned() const { return (_signedBy); } /** * @return Address that signed this certificate or null address if none */ - ZT_ALWAYS_INLINE const Address &signedBy() const { return _signedBy; } + inline const Address &signedBy() const { return _signedBy; } template inline void serialize(Buffer &b) const @@ -369,7 +369,7 @@ public: return (p - startAt); } - ZT_ALWAYS_INLINE bool operator==(const CertificateOfMembership &c) const + inline bool operator==(const CertificateOfMembership &c) const { if (_signedBy != c._signedBy) return false; @@ -385,7 +385,7 @@ public: } return (memcmp(_signature,c._signature,_signatureLength) == 0); } - ZT_ALWAYS_INLINE bool operator!=(const CertificateOfMembership &c) const { return (!(*this == c)); } + inline bool operator!=(const CertificateOfMembership &c) const { return (!(*this == c)); } private: struct _Qualifier diff --git a/node/CertificateOfOwnership.hpp b/node/CertificateOfOwnership.hpp index a77ebaae2..7bdcf9eed 100644 --- a/node/CertificateOfOwnership.hpp +++ b/node/CertificateOfOwnership.hpp @@ -46,7 +46,7 @@ class CertificateOfOwnership : public Credential friend class Credential; public: - static ZT_ALWAYS_INLINE Credential::Type credentialType() { return Credential::CREDENTIAL_TYPE_COO; } + static inline Credential::Type credentialType() { return Credential::CREDENTIAL_TYPE_COO; } enum Thing { @@ -56,12 +56,12 @@ public: THING_IPV6_ADDRESS = 3 }; - ZT_ALWAYS_INLINE CertificateOfOwnership() + inline CertificateOfOwnership() { memset(reinterpret_cast(this),0,sizeof(CertificateOfOwnership)); } - ZT_ALWAYS_INLINE CertificateOfOwnership(const uint64_t nwid,const int64_t ts,const Address &issuedTo,const uint32_t id) + inline CertificateOfOwnership(const uint64_t nwid,const int64_t ts,const Address &issuedTo,const uint32_t id) { memset(reinterpret_cast(this),0,sizeof(CertificateOfOwnership)); _networkId = nwid; @@ -70,19 +70,19 @@ public: _issuedTo = issuedTo; } - ZT_ALWAYS_INLINE uint64_t networkId() const { return _networkId; } - ZT_ALWAYS_INLINE int64_t timestamp() const { return _ts; } - ZT_ALWAYS_INLINE uint32_t id() const { return _id; } - ZT_ALWAYS_INLINE const Address &issuedTo() const { return _issuedTo; } - ZT_ALWAYS_INLINE const Address &signer() const { return _signedBy; } - ZT_ALWAYS_INLINE const uint8_t *signature() const { return _signature; } - ZT_ALWAYS_INLINE unsigned int signatureLength() const { return _signatureLength; } + inline uint64_t networkId() const { return _networkId; } + inline int64_t timestamp() const { return _ts; } + inline uint32_t id() const { return _id; } + inline const Address &issuedTo() const { return _issuedTo; } + inline const Address &signer() const { return _signedBy; } + inline const uint8_t *signature() const { return _signature; } + inline unsigned int signatureLength() const { return _signatureLength; } - ZT_ALWAYS_INLINE unsigned int thingCount() const { return (unsigned int)_thingCount; } - ZT_ALWAYS_INLINE Thing thingType(const unsigned int i) const { return (Thing)_thingTypes[i]; } - ZT_ALWAYS_INLINE const uint8_t *thingValue(const unsigned int i) const { return _thingValues[i]; } + inline unsigned int thingCount() const { return (unsigned int)_thingCount; } + inline Thing thingType(const unsigned int i) const { return (Thing)_thingTypes[i]; } + inline const uint8_t *thingValue(const unsigned int i) const { return _thingValues[i]; } - ZT_ALWAYS_INLINE bool owns(const InetAddress &ip) const + inline bool owns(const InetAddress &ip) const { if (ip.ss_family == AF_INET) return this->_owns(THING_IPV4_ADDRESS,&(reinterpret_cast(&ip)->sin_addr.s_addr),4); @@ -91,7 +91,7 @@ public: return false; } - ZT_ALWAYS_INLINE bool owns(const MAC &mac) const + inline bool owns(const MAC &mac) const { uint8_t tmp[6]; mac.copyTo(tmp,6); @@ -136,7 +136,7 @@ public: return false; } - ZT_ALWAYS_INLINE Credential::VerifyResult verify(const RuntimeEnvironment *RR,void *tPtr) const { return _verify(RR,tPtr,*this); } + inline Credential::VerifyResult verify(const RuntimeEnvironment *RR,void *tPtr) const { return _verify(RR,tPtr,*this); } template inline void serialize(Buffer &b,const bool forSign = false) const @@ -206,10 +206,10 @@ public: } // Provides natural sort order by ID - ZT_ALWAYS_INLINE bool operator<(const CertificateOfOwnership &coo) const { return (_id < coo._id); } + inline bool operator<(const CertificateOfOwnership &coo) const { return (_id < coo._id); } - ZT_ALWAYS_INLINE bool operator==(const CertificateOfOwnership &coo) const { return (memcmp(this,&coo,sizeof(CertificateOfOwnership)) == 0); } - ZT_ALWAYS_INLINE bool operator!=(const CertificateOfOwnership &coo) const { return (memcmp(this,&coo,sizeof(CertificateOfOwnership)) != 0); } + inline bool operator==(const CertificateOfOwnership &coo) const { return (memcmp(this,&coo,sizeof(CertificateOfOwnership)) == 0); } + inline bool operator!=(const CertificateOfOwnership &coo) const { return (memcmp(this,&coo,sizeof(CertificateOfOwnership)) != 0); } private: inline bool _owns(const Thing &t,const void *v,unsigned int l) const diff --git a/node/Constants.hpp b/node/Constants.hpp index d6da00f01..730937ab3 100644 --- a/node/Constants.hpp +++ b/node/Constants.hpp @@ -138,16 +138,22 @@ #endif #if (defined(__GNUC__) && (__GNUC__ >= 3)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__) -#define ZT_ALWAYS_INLINE inline __attribute__((always_inline)) +// #define inline __attribute__((always_inline)) +#ifndef restrict +#define restrict __restrict__ +#endif #ifndef likely #define likely(x) __builtin_expect((x),1) #endif #ifndef unlikely #define unlikely(x) __builtin_expect((x),0) #endif -#else +#else /* not GCC-like */ +#ifndef restrict +#define restrict +#endif #ifndef likely -#define ZT_ALWAYS_INLINE inline +#define inline inline #define likely(x) (x) #endif #ifndef unlikely @@ -197,6 +203,16 @@ */ #define ZT_ADDRESS_RESERVED_PREFIX 0xff +/** + * Maximum DNS or URL name size for an Endpoint + */ +#define ZT_ENDPOINT_MAX_NAME_SIZE 256 + +/** + * Size of an identity hash (SHA384) + */ +#define ZT_IDENTITY_HASH_SIZE 48 + /** * Secure DNS name for ZeroTier's default root * diff --git a/node/Credential.cpp b/node/Credential.cpp index d53b62f00..5e5ebe9bf 100644 --- a/node/Credential.cpp +++ b/node/Credential.cpp @@ -26,7 +26,7 @@ namespace ZeroTier { template -static ZT_ALWAYS_INLINE Credential::VerifyResult _credVerify(const RuntimeEnvironment *const RR,void *tPtr,CRED credential) +static inline Credential::VerifyResult _credVerify(const RuntimeEnvironment *const RR,void *tPtr,CRED credential) { const Address signedBy(credential.signer()); const uint64_t networkId = credential.networkId(); diff --git a/node/Dictionary.hpp b/node/Dictionary.hpp index 1614ccb74..599e5cfde 100644 --- a/node/Dictionary.hpp +++ b/node/Dictionary.hpp @@ -49,9 +49,9 @@ template class Dictionary { public: - ZT_ALWAYS_INLINE Dictionary() { memset(_d,0,sizeof(_d)); } - ZT_ALWAYS_INLINE Dictionary(const char *s) { this->load(s); } - ZT_ALWAYS_INLINE Dictionary(const char *s,unsigned int len) + inline Dictionary() { memset(_d,0,sizeof(_d)); } + inline Dictionary(const char *s) { this->load(s); } + inline Dictionary(const char *s,unsigned int len) { for(unsigned int i=0;i - ZT_ALWAYS_INLINE bool get(const char *key,Buffer &dest) const + inline bool get(const char *key,Buffer &dest) const { const int r = this->get(key,const_cast(reinterpret_cast(dest.data())),BC); if (r >= 0) { @@ -236,7 +236,7 @@ public: * @param dfl Default value if not found in dictionary * @return Boolean value of key or 'dfl' if not found */ - ZT_ALWAYS_INLINE bool getB(const char *key,bool dfl = false) const + inline bool getB(const char *key,bool dfl = false) const { char tmp[4]; if (this->get(key,tmp,sizeof(tmp)) >= 0) @@ -251,7 +251,7 @@ public: * @param dfl Default value or 0 if unspecified * @return Decoded hex UInt value or 'dfl' if not found */ - ZT_ALWAYS_INLINE uint64_t getUI(const char *key,uint64_t dfl = 0) const + inline uint64_t getUI(const char *key,uint64_t dfl = 0) const { char tmp[128]; if (this->get(key,tmp,sizeof(tmp)) >= 1) @@ -266,7 +266,7 @@ public: * @param dfl Default value or 0 if unspecified * @return Decoded hex UInt value or 'dfl' if not found */ - ZT_ALWAYS_INLINE int64_t getI(const char *key,int64_t dfl = 0) const + inline int64_t getI(const char *key,int64_t dfl = 0) const { char tmp[128]; if (this->get(key,tmp,sizeof(tmp)) >= 1) @@ -366,7 +366,7 @@ public: /** * Add a boolean as a '1' or a '0' */ - ZT_ALWAYS_INLINE bool add(const char *key,bool value) + inline bool add(const char *key,bool value) { return this->add(key,(value) ? "1" : "0",1); } @@ -374,7 +374,7 @@ public: /** * Add a 64-bit integer (unsigned) as a hex value */ - ZT_ALWAYS_INLINE bool add(const char *key,uint64_t value) + inline bool add(const char *key,uint64_t value) { char tmp[32]; return this->add(key,Utils::hex(value,tmp),-1); @@ -383,7 +383,7 @@ public: /** * Add a 64-bit integer (unsigned) as a hex value */ - ZT_ALWAYS_INLINE bool add(const char *key,int64_t value) + inline bool add(const char *key,int64_t value) { char tmp[32]; if (value >= 0) { @@ -397,7 +397,7 @@ public: /** * Add a 64-bit integer (unsigned) as a hex value */ - ZT_ALWAYS_INLINE bool add(const char *key,const Address &a) + inline bool add(const char *key,const Address &a) { char tmp[32]; return this->add(key,Utils::hex(a.toInt(),tmp),-1); @@ -409,7 +409,7 @@ public: * @tparam BC Buffer capacity (usually inferred) */ template - ZT_ALWAYS_INLINE bool add(const char *key,const Buffer &value) + inline bool add(const char *key,const Buffer &value) { return this->add(key,(const char *)value.data(),(int)value.size()); } @@ -418,7 +418,7 @@ public: * @param key Key to check * @return True if key is present */ - ZT_ALWAYS_INLINE bool contains(const char *key) const + inline bool contains(const char *key) const { char tmp[2]; return (this->get(key,tmp,2) >= 0); @@ -427,10 +427,10 @@ public: /** * @return Value of C template parameter */ - ZT_ALWAYS_INLINE unsigned int capacity() const { return C; } + inline unsigned int capacity() const { return C; } - ZT_ALWAYS_INLINE const char *data() const { return _d; } - ZT_ALWAYS_INLINE char *unsafeData() { return _d; } + inline const char *data() const { return _d; } + inline char *unsafeData() { return _d; } private: char _d[C]; diff --git a/node/ECC384.cpp b/node/ECC384.cpp index fa96eeadb..2395fb517 100644 --- a/node/ECC384.cpp +++ b/node/ECC384.cpp @@ -61,13 +61,13 @@ static EccPoint curve_G = CONCAT(Curve_G_, ECC_CURVE); static uint64_t curve_n[NUM_ECC_DIGITS] = CONCAT(Curve_N_, ECC_CURVE); // Use ZeroTier's secure PRNG -static ZT_ALWAYS_INLINE int getRandomNumber(uint64_t *p_vli) +static inline int getRandomNumber(uint64_t *p_vli) { Utils::getSecureRandom(p_vli,ECC_BYTES); return 1; } -static ZT_ALWAYS_INLINE void vli_clear(uint64_t *p_vli) +static inline void vli_clear(uint64_t *p_vli) { uint i; for(i=0; i= 0; --i) @@ -376,7 +376,7 @@ static inline void vli_square(uint64_t *p_result, uint64_t *p_left) /* Computes p_result = (p_left + p_right) % p_mod. Assumes that p_left < p_mod and p_right < p_mod, p_result != p_mod. */ -static ZT_ALWAYS_INLINE void vli_modAdd(uint64_t *p_result, uint64_t *p_left, uint64_t *p_right, uint64_t *p_mod) +static inline void vli_modAdd(uint64_t *p_result, uint64_t *p_left, uint64_t *p_right, uint64_t *p_mod) { uint64_t l_carry = vli_add(p_result, p_left, p_right); if(l_carry || vli_cmp(p_result, p_mod) >= 0) @@ -387,7 +387,7 @@ static ZT_ALWAYS_INLINE void vli_modAdd(uint64_t *p_result, uint64_t *p_left, ui /* Computes p_result = (p_left - p_right) % p_mod. Assumes that p_left < p_mod and p_right < p_mod, p_result != p_mod. */ -static ZT_ALWAYS_INLINE void vli_modSub(uint64_t *p_result, uint64_t *p_left, uint64_t *p_right, uint64_t *p_mod) +static inline void vli_modSub(uint64_t *p_result, uint64_t *p_left, uint64_t *p_right, uint64_t *p_mod) { uint64_t l_borrow = vli_sub(p_result, p_left, p_right); if(l_borrow) @@ -465,7 +465,7 @@ static inline void vli_mmod_fast(uint64_t *p_result, uint64_t *p_product) //#endif /* Computes p_result = (p_left * p_right) % curve_p. */ -static ZT_ALWAYS_INLINE void vli_modMult_fast(uint64_t *p_result, uint64_t *p_left, uint64_t *p_right) +static inline void vli_modMult_fast(uint64_t *p_result, uint64_t *p_left, uint64_t *p_right) { uint64_t l_product[2 * NUM_ECC_DIGITS]; vli_mult(l_product, p_left, p_right); @@ -473,7 +473,7 @@ static ZT_ALWAYS_INLINE void vli_modMult_fast(uint64_t *p_result, uint64_t *p_le } /* Computes p_result = p_left^2 % curve_p. */ -static ZT_ALWAYS_INLINE void vli_modSquare_fast(uint64_t *p_result, uint64_t *p_left) +static inline void vli_modSquare_fast(uint64_t *p_result, uint64_t *p_left) { uint64_t l_product[2 * NUM_ECC_DIGITS]; vli_square(l_product, p_left); @@ -577,7 +577,7 @@ static inline void vli_modInv(uint64_t *p_result, uint64_t *p_input, uint64_t *p /* ------ Point operations ------ */ /* Returns 1 if p_point is the point at infinity, 0 otherwise. */ -static ZT_ALWAYS_INLINE int EccPoint_isZero(EccPoint *p_point) +static inline int EccPoint_isZero(EccPoint *p_point) { return (vli_isZero(p_point->x) && vli_isZero(p_point->y)); } @@ -636,7 +636,7 @@ static inline void EccPoint_double_jacobian(uint64_t *X1, uint64_t *Y1, uint64_t } /* Modify (x1, y1) => (x1 * z^2, y1 * z^3) */ -static ZT_ALWAYS_INLINE void apply_z(uint64_t *X1, uint64_t *Y1, uint64_t *Z) +static inline void apply_z(uint64_t *X1, uint64_t *Y1, uint64_t *Z) { uint64_t t1[NUM_ECC_DIGITS]; @@ -773,7 +773,7 @@ static inline void EccPoint_mult(EccPoint *p_result, EccPoint *p_point, uint64_t vli_set(p_result->y, Ry[0]); } -static ZT_ALWAYS_INLINE void ecc_bytes2native(uint64_t p_native[NUM_ECC_DIGITS], const uint8_t p_bytes[ECC_BYTES]) +static inline void ecc_bytes2native(uint64_t p_native[NUM_ECC_DIGITS], const uint8_t p_bytes[ECC_BYTES]) { unsigned i; for(i=0; i b ? a : b); } diff --git a/node/Endpoint.hpp b/node/Endpoint.hpp new file mode 100644 index 000000000..1f01c805a --- /dev/null +++ b/node/Endpoint.hpp @@ -0,0 +1,181 @@ +/* + * Copyright (c)2019 ZeroTier, Inc. + * + * Use of this software is governed by the Business Source License included + * in the LICENSE.TXT file in the project's root directory. + * + * Change Date: 2023-01-01 + * + * On the date above, in accordance with the Business Source License, use + * of this software will be governed by version 2.0 of the Apache License. + */ +/****/ + +#ifndef ZT_ENDPOINT_HPP +#define ZT_ENDPOINT_HPP + +#include +#include +#include +#include + +#include "Constants.hpp" +#include "InetAddress.hpp" +#include "Address.hpp" +#include "Utils.hpp" + +#define ZT_ENDPOINT_MARSHAL_SIZE_MAX (ZT_ENDPOINT_MAX_NAME_SIZE+4) + +namespace ZeroTier { + +/** + * Endpoint variant specifying some form of network endpoint + */ +class Endpoint +{ +public: + enum Type + { + NIL = 0, // NIL value + SOCKADDR = 1, // InetAddress + DNSNAME = 2, // DNS name and port that resolves to InetAddress + ZEROTIER = 3, // ZeroTier Address (for relaying and meshy behavior) + URL = 4 // URL for http/https/ws/etc. (not implemented yet) + }; + + inline Endpoint() { memset(reinterpret_cast(this),0,sizeof(Endpoint)); } + + inline Endpoint(const InetAddress &sa) : _t(SOCKADDR) { _v.sa = sa; } + inline Endpoint(const Address &zt,const uint8_t identityHash[ZT_IDENTITY_HASH_SIZE]) : _t(ZEROTIER) { _v.zt.a = zt.toInt(); memcpy(_v.zt.idh,identityHash,ZT_IDENTITY_HASH_SIZE); } + inline Endpoint(const char *name,const int port) : _t(DNSNAME) { Utils::scopy(_v.dns.name,sizeof(_v.dns.name),name); _v.dns.port = port; } + inline Endpoint(const char *url) : _t(URL) { Utils::scopy(_v.url,sizeof(_v.url),url); } + + inline const InetAddress *sockaddr() const { return (_t == SOCKADDR) ? reinterpret_cast(&_v.sa) : nullptr; } + inline const char *dnsName() const { return (_t == DNSNAME) ? _v.dns.name : nullptr; } + inline const int dnsPort() const { return (_t == DNSNAME) ? _v.dns.port : -1; } + inline Address ztAddress() const { return (_t == ZEROTIER) ? Address(_v.zt.a) : Address(); } + inline const uint8_t *ztIdentityHash() const { return (_t == ZEROTIER) ? _v.zt.idh : nullptr; } + inline const char *url() const { return (_t == URL) ? _v.url : nullptr; } + + inline Type type() const { return _t; } + + inline unsigned int marshal(uint8_t data[ZT_ENDPOINT_MARSHAL_SIZE_MAX]) + { + unsigned int p; + switch(_t) { + case SOCKADDR: + data[0] = (uint8_t)SOCKADDR; + return 1 + reinterpret_cast(&_v.sa)->marshal(data+1); + case DNSNAME: + data[0] = (uint8_t)DNSNAME; + p = 1; + for (;;) { + if ((data[p] = (uint8_t)_v.dns.name[p-1]) == 0) + break; + ++p; + if (p == (ZT_ENDPOINT_MAX_NAME_SIZE+1)) + return 0; + } + data[p++] = (uint8_t)((_v.dns.port >> 8) & 0xff); + data[p++] = (uint8_t)(_v.dns.port & 0xff); + return p; + case ZEROTIER: + data[0] = (uint8_t)ZEROTIER; + data[1] = (uint8_t)((_v.zt.a >> 32) & 0xff); + data[2] = (uint8_t)((_v.zt.a >> 24) & 0xff); + data[3] = (uint8_t)((_v.zt.a >> 16) & 0xff); + data[4] = (uint8_t)((_v.zt.a >> 8) & 0xff); + data[5] = (uint8_t)(_v.zt.a & 0xff); + memcpy(data + 6,_v.zt.idh,ZT_IDENTITY_HASH_SIZE); + return (ZT_IDENTITY_HASH_SIZE + 6); + case URL: + data[0] = (uint8_t)URL; + p = 1; + for (;;) { + if ((data[p] = (uint8_t)_v.url[p-1]) == 0) + break; + ++p; + if (p == (ZT_ENDPOINT_MAX_NAME_SIZE+1)) + return 0; + } + return p; + default: + data[0] = (uint8_t)NIL; + return 1; + } + } + + inline bool unmarshal(const uint8_t *restrict data,const unsigned int len) + { + if (len == 0) + return false; + unsigned int p; + switch((Type)data[0]) { + case NIL: + _t = NIL; + return true; + case SOCKADDR: + _t = SOCKADDR; + return reinterpret_cast(&_v.sa)->unmarshal(data+1,len-1); + case DNSNAME: + if (len < 4) + return false; + _t = DNSNAME; + p = 1; + for (;;) { + if ((_v.dns.name[p-1] = (char)data[p]) == 0) + break; + ++p; + if ((p >= (ZT_ENDPOINT_MAX_NAME_SIZE+1))||(p >= (len-2))) + return; + } + _v.dns.port = ((int)data[p++]) << 8; + _v.dns.port |= (int)data[p++]; + return true; + case ZEROTIER: + if (len != (ZT_IDENTITY_HASH_SIZE + 6)) + return false; + _t = ZEROTIER; + _v.zt.a = ((uint64_t)data[1]) << 32; + _v.zt.a |= ((uint64_t)data[2]) << 24; + _v.zt.a |= ((uint64_t)data[3]) << 16; + _v.zt.a |= ((uint64_t)data[4]) << 8; + _v.zt.a |= (uint64_t)data[5]; + memcpy(_v.zt.idh,data + 6,ZT_IDENTITY_HASH_SIZE); + return true; + case URL: + if (len < 2) + return false; + _t = URL; + p = 1; + for (;;) { + if ((_v.url[p-1] = (char)data[p]) == 0) + break; + ++p; + if ((p >= (ZT_ENDPOINT_MAX_NAME_SIZE+1))||(p >= len)) + return; + } + return true; + } + return false; + } + +private: + Type _t; + union { + struct sockaddr_storage sa; + struct { + char name[ZT_ENDPOINT_MAX_NAME_SIZE]; + int port; + } dns; + struct { + uint64_t a; + uint8_t idh[ZT_IDENTITY_HASH_SIZE]; + } zt; + char url[ZT_ENDPOINT_MAX_NAME_SIZE]; + } _v; +}; + +} // namespace ZeroTier + +#endif diff --git a/node/EphemeralKey.hpp b/node/EphemeralKey.hpp index 0eda407eb..613b9a142 100644 --- a/node/EphemeralKey.hpp +++ b/node/EphemeralKey.hpp @@ -46,9 +46,9 @@ public: C25519ECC384 = 1 }; - ZT_ALWAYS_INLINE EphemeralKey() : _priv(nullptr),_type(NONE) {} + inline EphemeralKey() : _priv(nullptr),_type(NONE) {} - ZT_ALWAYS_INLINE ~EphemeralKey() + inline ~EphemeralKey() { if (_priv) { Utils::burn(_priv,ZT_EPHEMERAL_KEY_TYPE_1_PRIVATE_SIZE); @@ -56,10 +56,10 @@ public: } } - ZT_ALWAYS_INLINE Type type() const { return (Type)_type; } - ZT_ALWAYS_INLINE bool hasPrivate() const { return (_priv != nullptr); } + inline Type type() const { return (Type)_type; } + inline bool hasPrivate() const { return (_priv != nullptr); } - ZT_ALWAYS_INLINE void generate() + inline void generate() { if (!_priv) _priv = new uint8_t[ZT_EPHEMERAL_KEY_TYPE_1_PRIVATE_SIZE]; @@ -68,7 +68,7 @@ public: _type = C25519ECC384; } - ZT_ALWAYS_INLINE bool agree(const EphemeralKey &theirs,uint8_t key[ZT_PEER_SECRET_KEY_LENGTH]) const + inline bool agree(const EphemeralKey &theirs,uint8_t key[ZT_PEER_SECRET_KEY_LENGTH]) const { if ((_priv)&&(_type == 1)) { uint8_t rawkey[128],h[48]; @@ -82,7 +82,7 @@ public: } template - ZT_ALWAYS_INLINE void serialize(Buffer &b) const + inline void serialize(Buffer &b) const { b.append(_type); if (_type == C25519ECC384) @@ -90,7 +90,7 @@ public: } template - ZT_ALWAYS_INLINE unsigned int deserialize(const Buffer &b,unsigned int startAt = 0) + inline unsigned int deserialize(const Buffer &b,unsigned int startAt = 0) { unsigned int p = startAt; delete [] _priv; diff --git a/node/Hashtable.hpp b/node/Hashtable.hpp index 00b788b3f..60344ae09 100644 --- a/node/Hashtable.hpp +++ b/node/Hashtable.hpp @@ -33,10 +33,10 @@ class Hashtable private: struct _Bucket { - ZT_ALWAYS_INLINE _Bucket(const K &k,const V &v) : k(k),v(v) {} - ZT_ALWAYS_INLINE _Bucket(const K &k) : k(k),v() {} - ZT_ALWAYS_INLINE _Bucket(const _Bucket &b) : k(b.k),v(b.v) {} - ZT_ALWAYS_INLINE _Bucket &operator=(const _Bucket &b) { k = b.k; v = b.v; return *this; } + inline _Bucket(const K &k,const V &v) : k(k),v(v) {} + inline _Bucket(const K &k) : k(k),v() {} + inline _Bucket(const _Bucket &b) : k(b.k),v(b.v) {} + inline _Bucket &operator=(const _Bucket &b) { k = b.k; v = b.v; return *this; } _Bucket *next; // must be set manually for each _Bucket const K k; V v; @@ -56,7 +56,7 @@ public: /** * @param ht Hash table to iterate over */ - ZT_ALWAYS_INLINE Iterator(Hashtable &ht) : + inline Iterator(Hashtable &ht) : _idx(0), _ht(&ht), _b(ht._t[0]) @@ -68,7 +68,7 @@ public: * @param vptr Pointer to set to point to next value * @return True if kptr and vptr are set, false if no more entries */ - ZT_ALWAYS_INLINE bool next(K *&kptr,V *&vptr) + inline bool next(K *&kptr,V *&vptr) { for(;;) { if (_b) { @@ -94,7 +94,7 @@ public: /** * @param bc Initial capacity in buckets (default: 32, must be nonzero) */ - ZT_ALWAYS_INLINE Hashtable(unsigned long bc = 32) : + inline Hashtable(unsigned long bc = 32) : _t(reinterpret_cast<_Bucket **>(::malloc(sizeof(_Bucket *) * bc))), _bc(bc), _s(0) @@ -105,7 +105,7 @@ public: _t[i] = (_Bucket *)0; } - ZT_ALWAYS_INLINE Hashtable(const Hashtable &ht) : + inline Hashtable(const Hashtable &ht) : _t(reinterpret_cast<_Bucket **>(::malloc(sizeof(_Bucket *) * ht._bc))), _bc(ht._bc), _s(ht._s) @@ -125,13 +125,13 @@ public: } } - ZT_ALWAYS_INLINE ~Hashtable() + inline ~Hashtable() { this->clear(); ::free(_t); } - ZT_ALWAYS_INLINE Hashtable &operator=(const Hashtable &ht) + inline Hashtable &operator=(const Hashtable &ht) { this->clear(); if (ht._s) { @@ -149,7 +149,7 @@ public: /** * Erase all entries */ - ZT_ALWAYS_INLINE void clear() + inline void clear() { if (_s) { for(unsigned long i=0;i<_bc;++i) { @@ -168,7 +168,7 @@ public: /** * @return Vector of all keys */ - ZT_ALWAYS_INLINE typename std::vector keys() const + inline typename std::vector keys() const { typename std::vector k; if (_s) { @@ -191,7 +191,7 @@ public: * @tparam Type of V (generally inferred) */ template - ZT_ALWAYS_INLINE void appendKeys(C &v) const + inline void appendKeys(C &v) const { if (_s) { for(unsigned long i=0;i<_bc;++i) { @@ -207,7 +207,7 @@ public: /** * @return Vector of all entries (pairs of K,V) */ - ZT_ALWAYS_INLINE typename std::vector< std::pair > entries() const + inline typename std::vector< std::pair > entries() const { typename std::vector< std::pair > k; if (_s) { @@ -227,7 +227,7 @@ public: * @param k Key * @return Pointer to value or NULL if not found */ - ZT_ALWAYS_INLINE V *get(const K k) + inline V *get(const K k) { _Bucket *b = _t[_hc(k) % _bc]; while (b) { @@ -237,14 +237,14 @@ public: } return (V *)0; } - ZT_ALWAYS_INLINE const V *get(const K k) const { return const_cast(this)->get(k); } + inline const V *get(const K k) const { return const_cast(this)->get(k); } /** * @param k Key * @param v Value to fill with result * @return True if value was found and set (if false, v is not modified) */ - ZT_ALWAYS_INLINE bool get(const K &k,V &v) const + inline bool get(const K &k,V &v) const { _Bucket *b = _t[_hc(k) % _bc]; while (b) { @@ -261,7 +261,7 @@ public: * @param k Key to check * @return True if key is present */ - ZT_ALWAYS_INLINE bool contains(const K &k) const + inline bool contains(const K &k) const { _Bucket *b = _t[_hc(k) % _bc]; while (b) { @@ -276,7 +276,7 @@ public: * @param k Key * @return True if value was present */ - ZT_ALWAYS_INLINE bool erase(const K &k) + inline bool erase(const K &k) { const unsigned long bidx = _hc(k) % _bc; _Bucket *lastb = (_Bucket *)0; @@ -301,7 +301,7 @@ public: * @param v Value * @return Reference to value in table */ - ZT_ALWAYS_INLINE V &set(const K &k,const V &v) + inline V &set(const K &k,const V &v) { const unsigned long h = _hc(k); unsigned long bidx = h % _bc; @@ -331,7 +331,7 @@ public: * @param k Key * @return Value, possibly newly created */ - ZT_ALWAYS_INLINE V &operator[](const K k) + inline V &operator[](const K k) { const unsigned long h = _hc(k); unsigned long bidx = h % _bc; @@ -358,25 +358,25 @@ public: /** * @return Number of entries */ - ZT_ALWAYS_INLINE unsigned long size() const { return _s; } + inline unsigned long size() const { return _s; } /** * @return True if table is empty */ - ZT_ALWAYS_INLINE bool empty() const { return (_s == 0); } + inline bool empty() const { return (_s == 0); } private: template - static ZT_ALWAYS_INLINE unsigned long _hc(const O &obj) { return (unsigned long)obj.hashCode(); } + static inline unsigned long _hc(const O &obj) { return (unsigned long)obj.hashCode(); } - static ZT_ALWAYS_INLINE unsigned long _hc(const uint64_t i) { return (unsigned long)(i ^ (i >> 32)); } - static ZT_ALWAYS_INLINE unsigned long _hc(const uint32_t i) { return ((unsigned long)i * (unsigned long)0x9e3779b1); } - static ZT_ALWAYS_INLINE unsigned long _hc(const uint16_t i) { return ((unsigned long)i * (unsigned long)0x9e3779b1); } - static ZT_ALWAYS_INLINE unsigned long _hc(const int i) { return ((unsigned long)i * (unsigned long)0x9e3379b1); } - static ZT_ALWAYS_INLINE unsigned long _hc(void *p) { return ((unsigned long)((uintptr_t)p) * (unsigned long)0x9e3779b1); } - static ZT_ALWAYS_INLINE unsigned long _hc(const void *p) { return ((unsigned long)((uintptr_t)p) * (unsigned long)0x9e3779b1); } + static inline unsigned long _hc(const uint64_t i) { return (unsigned long)(i ^ (i >> 32)); } + static inline unsigned long _hc(const uint32_t i) { return ((unsigned long)i * (unsigned long)0x9e3779b1); } + static inline unsigned long _hc(const uint16_t i) { return ((unsigned long)i * (unsigned long)0x9e3779b1); } + static inline unsigned long _hc(const int i) { return ((unsigned long)i * (unsigned long)0x9e3379b1); } + static inline unsigned long _hc(void *p) { return ((unsigned long)((uintptr_t)p) * (unsigned long)0x9e3779b1); } + static inline unsigned long _hc(const void *p) { return ((unsigned long)((uintptr_t)p) * (unsigned long)0x9e3779b1); } - ZT_ALWAYS_INLINE void _grow() + inline void _grow() { const unsigned long nc = _bc * 2; _Bucket **nt = reinterpret_cast<_Bucket **>(::malloc(sizeof(_Bucket *) * nc)); diff --git a/node/Identity.hpp b/node/Identity.hpp index aeb8c0d96..9003bd930 100644 --- a/node/Identity.hpp +++ b/node/Identity.hpp @@ -51,8 +51,8 @@ public: P384 = ZT_CRYPTO_ALG_P384 // Type 1 -- NIST P-384 with linked Curve25519/Ed25519 secondaries (2.x+) }; - ZT_ALWAYS_INLINE Identity() { memset(reinterpret_cast(this),0,sizeof(Identity)); } - ZT_ALWAYS_INLINE ~Identity() { Utils::burn(reinterpret_cast(&this->_priv),sizeof(this->_priv)); } + inline Identity() { memset(reinterpret_cast(this),0,sizeof(Identity)); } + inline ~Identity() { Utils::burn(reinterpret_cast(&this->_priv),sizeof(this->_priv)); } /** * Construct identity from string @@ -62,20 +62,20 @@ public: * * @param str Identity in canonical string format */ - ZT_ALWAYS_INLINE Identity(const char *str) { fromString(str); } + inline Identity(const char *str) { fromString(str); } template - ZT_ALWAYS_INLINE Identity(const Buffer &b,unsigned int startAt = 0) { deserialize(b,startAt); } + inline Identity(const Buffer &b,unsigned int startAt = 0) { deserialize(b,startAt); } /** * Set identity to NIL value (all zero) */ - ZT_ALWAYS_INLINE void zero() { memset(reinterpret_cast(this),0,sizeof(Identity)); } + inline void zero() { memset(reinterpret_cast(this),0,sizeof(Identity)); } /** * @return Identity type (undefined if identity is null or invalid) */ - ZT_ALWAYS_INLINE Type type() const { return _type; } + inline Type type() const { return _type; } /** * Generate a new identity (address, key pair) @@ -96,7 +96,7 @@ public: /** * @return True if this identity contains a private key */ - ZT_ALWAYS_INLINE bool hasPrivate() const { return _hasPrivate; } + inline bool hasPrivate() const { return _hasPrivate; } /** * This generates a SHA384 hash of this identity's keys. @@ -104,7 +104,7 @@ public: * @param h Buffer to receive SHA384 of public key(s) * @param includePrivate If true, hash private key(s) as well */ - ZT_ALWAYS_INLINE bool hash(uint8_t h[48],const bool includePrivate = false) const + inline bool hash(uint8_t h[48],const bool includePrivate = false) const { switch(_type) { @@ -136,7 +136,7 @@ public: * @param siglen Length of buffer * @return Number of bytes actually written to sig or 0 on error */ - ZT_ALWAYS_INLINE unsigned int sign(const void *data,unsigned int len,void *sig,unsigned int siglen) const + inline unsigned int sign(const void *data,unsigned int len,void *sig,unsigned int siglen) const { if (_hasPrivate) { switch(_type) { @@ -171,7 +171,7 @@ public: * @param siglen Length of signature in bytes * @return True if signature validates and data integrity checks */ - ZT_ALWAYS_INLINE bool verify(const void *data,unsigned int len,const void *sig,unsigned int siglen) const + inline bool verify(const void *data,unsigned int len,const void *sig,unsigned int siglen) const { switch(_type) { @@ -199,7 +199,7 @@ public: * @param key Result parameter to fill with key bytes * @return Was agreement successful? */ - ZT_ALWAYS_INLINE bool agree(const Identity &id,uint8_t key[ZT_PEER_SECRET_KEY_LENGTH]) const + inline bool agree(const Identity &id,uint8_t key[ZT_PEER_SECRET_KEY_LENGTH]) const { uint8_t rawkey[128]; uint8_t h[64]; @@ -239,7 +239,7 @@ public: /** * @return This identity's address */ - ZT_ALWAYS_INLINE const Address &address() const { return _address; } + inline const Address &address() const { return _address; } /** * Serialize this identity (binary) @@ -248,7 +248,7 @@ public: * @param includePrivate If true, include private key component (if present) (default: false) */ template - ZT_ALWAYS_INLINE void serialize(Buffer &b,bool includePrivate = false) const + inline void serialize(Buffer &b,bool includePrivate = false) const { _address.appendTo(b); switch(_type) { @@ -291,7 +291,7 @@ public: * @return Length of serialized data read from buffer */ template - ZT_ALWAYS_INLINE unsigned int deserialize(const Buffer &b,unsigned int startAt = 0) + inline unsigned int deserialize(const Buffer &b,unsigned int startAt = 0) { _hasPrivate = false; unsigned int p = startAt; @@ -366,9 +366,9 @@ public: /** * @return True if this identity contains something */ - ZT_ALWAYS_INLINE operator bool() const { return (_address); } + inline operator bool() const { return (_address); } - ZT_ALWAYS_INLINE bool operator==(const Identity &id) const + inline bool operator==(const Identity &id) const { if ((_address == id._address)&&(_type == id._type)) { switch(_type) { @@ -379,7 +379,7 @@ public: } return false; } - ZT_ALWAYS_INLINE bool operator<(const Identity &id) const + inline bool operator<(const Identity &id) const { if (_address < id._address) return true; @@ -396,12 +396,12 @@ public: } return false; } - ZT_ALWAYS_INLINE bool operator!=(const Identity &id) const { return !(*this == id); } - ZT_ALWAYS_INLINE bool operator>(const Identity &id) const { return (id < *this); } - ZT_ALWAYS_INLINE bool operator<=(const Identity &id) const { return !(id < *this); } - ZT_ALWAYS_INLINE bool operator>=(const Identity &id) const { return !(*this < id); } + inline bool operator!=(const Identity &id) const { return !(*this == id); } + inline bool operator>(const Identity &id) const { return (id < *this); } + inline bool operator<=(const Identity &id) const { return !(id < *this); } + inline bool operator>=(const Identity &id) const { return !(*this < id); } - ZT_ALWAYS_INLINE unsigned long hashCode() const { return ((unsigned long)_address.toInt() + (unsigned long)_pub.c25519[0] + (unsigned long)_pub.c25519[1] + (unsigned long)_pub.c25519[2]); } + inline unsigned long hashCode() const { return ((unsigned long)_address.toInt() + (unsigned long)_pub.c25519[0] + (unsigned long)_pub.c25519[1] + (unsigned long)_pub.c25519[2]); } private: Address _address; diff --git a/node/IncomingPacket.cpp b/node/IncomingPacket.cpp index 8d51782fd..0bd76b7a7 100644 --- a/node/IncomingPacket.cpp +++ b/node/IncomingPacket.cpp @@ -39,6 +39,8 @@ namespace ZeroTier { namespace { ////////////////////////////////////////////////////////////////////////////// +// Implementation of each protocol verb // +////////////////////////////////////////////////////////////////////////////// static void _sendErrorNeedCredentials(IncomingPacket &pkt,const RuntimeEnvironment *RR,void *tPtr,const SharedPtr &peer,const uint64_t nwid,const SharedPtr &path) { @@ -51,7 +53,7 @@ static void _sendErrorNeedCredentials(IncomingPacket &pkt,const RuntimeEnvironme path->send(RR,tPtr,outp.data(),outp.size(),RR->node->now()); } -static ZT_ALWAYS_INLINE bool _doHELLO(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const bool alreadyAuthenticated,const SharedPtr &path) +static inline bool _doHELLO(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const bool alreadyAuthenticated,const SharedPtr &path) { const int64_t now = RR->node->now(); @@ -180,15 +182,15 @@ static ZT_ALWAYS_INLINE bool _doHELLO(IncomingPacket &pkt,const RuntimeEnvironme return true; } -static ZT_ALWAYS_INLINE bool _doACK(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doACK(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { } -static ZT_ALWAYS_INLINE bool _doQOS_MEASUREMENT(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doQOS_MEASUREMENT(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { } -static ZT_ALWAYS_INLINE bool _doERROR(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doERROR(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { const Packet::Verb inReVerb = (Packet::Verb)pkt[ZT_PROTO_VERB_ERROR_IDX_IN_RE_VERB]; const uint64_t inRePacketId = pkt.at(ZT_PROTO_VERB_ERROR_IDX_IN_RE_PACKET_ID); @@ -250,7 +252,7 @@ static ZT_ALWAYS_INLINE bool _doERROR(IncomingPacket &pkt,const RuntimeEnvironme return true; } -static ZT_ALWAYS_INLINE bool _doOK(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doOK(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { const Packet::Verb inReVerb = (Packet::Verb)pkt[ZT_PROTO_VERB_OK_IDX_IN_RE_VERB]; const uint64_t inRePacketId = pkt.at(ZT_PROTO_VERB_OK_IDX_IN_RE_PACKET_ID); @@ -317,7 +319,7 @@ static ZT_ALWAYS_INLINE bool _doOK(IncomingPacket &pkt,const RuntimeEnvironment return true; } -static ZT_ALWAYS_INLINE bool _doWHOIS(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doWHOIS(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { if (!peer->rateGateInboundWhoisRequest(RR->node->now())) return true; @@ -352,7 +354,7 @@ static ZT_ALWAYS_INLINE bool _doWHOIS(IncomingPacket &pkt,const RuntimeEnvironme return true; } -static ZT_ALWAYS_INLINE bool _doRENDEZVOUS(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doRENDEZVOUS(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { if (RR->topology->isRoot(peer->identity())) { const Address with(pkt.field(ZT_PROTO_VERB_RENDEZVOUS_IDX_ZTADDRESS,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); @@ -374,7 +376,7 @@ static ZT_ALWAYS_INLINE bool _doRENDEZVOUS(IncomingPacket &pkt,const RuntimeEnvi return true; } -static ZT_ALWAYS_INLINE bool _doFRAME(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doFRAME(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { const uint64_t nwid = pkt.at(ZT_PROTO_VERB_FRAME_IDX_NETWORK_ID); const SharedPtr network(RR->node->network(nwid)); @@ -397,7 +399,7 @@ static ZT_ALWAYS_INLINE bool _doFRAME(IncomingPacket &pkt,const RuntimeEnvironme return true; } -static ZT_ALWAYS_INLINE bool _doEXT_FRAME(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doEXT_FRAME(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { const uint64_t nwid = pkt.at(ZT_PROTO_VERB_EXT_FRAME_IDX_NETWORK_ID); const SharedPtr network(RR->node->network(nwid)); @@ -475,7 +477,7 @@ static ZT_ALWAYS_INLINE bool _doEXT_FRAME(IncomingPacket &pkt,const RuntimeEnvir return true; } -static ZT_ALWAYS_INLINE bool _doECHO(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doECHO(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { if (!peer->rateGateEchoRequest(RR->node->now())) return true; @@ -494,7 +496,7 @@ static ZT_ALWAYS_INLINE bool _doECHO(IncomingPacket &pkt,const RuntimeEnvironmen return true; } -static ZT_ALWAYS_INLINE bool _doNETWORK_CREDENTIALS(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doNETWORK_CREDENTIALS(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { if (!peer->rateGateCredentialsReceived(RR->node->now())) return true; @@ -576,7 +578,7 @@ static ZT_ALWAYS_INLINE bool _doNETWORK_CREDENTIALS(IncomingPacket &pkt,const Ru return true; } -static ZT_ALWAYS_INLINE bool _doNETWORK_CONFIG_REQUEST(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doNETWORK_CONFIG_REQUEST(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { const uint64_t nwid = pkt.at(ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST_IDX_NETWORK_ID); const unsigned int hopCount = pkt.hops(); @@ -602,7 +604,7 @@ static ZT_ALWAYS_INLINE bool _doNETWORK_CONFIG_REQUEST(IncomingPacket &pkt,const return true; } -static ZT_ALWAYS_INLINE bool _doNETWORK_CONFIG(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doNETWORK_CONFIG(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { const SharedPtr network(RR->node->network(pkt.at(ZT_PACKET_IDX_PAYLOAD))); if (network) { @@ -621,7 +623,7 @@ static ZT_ALWAYS_INLINE bool _doNETWORK_CONFIG(IncomingPacket &pkt,const Runtime return true; } -static ZT_ALWAYS_INLINE bool _doMULTICAST_GATHER(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doMULTICAST_GATHER(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { const uint64_t nwid = pkt.at(ZT_PROTO_VERB_MULTICAST_GATHER_IDX_NETWORK_ID); const unsigned int flags = pkt[ZT_PROTO_VERB_MULTICAST_GATHER_IDX_FLAGS]; @@ -669,7 +671,7 @@ static ZT_ALWAYS_INLINE bool _doMULTICAST_GATHER(IncomingPacket &pkt,const Runti return true; } -static ZT_ALWAYS_INLINE bool _doPUSH_DIRECT_PATHS(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doPUSH_DIRECT_PATHS(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { const int64_t now = RR->node->now(); @@ -719,7 +721,7 @@ static ZT_ALWAYS_INLINE bool _doPUSH_DIRECT_PATHS(IncomingPacket &pkt,const Runt return true; } -static ZT_ALWAYS_INLINE bool _doUSER_MESSAGE(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) +static inline bool _doUSER_MESSAGE(IncomingPacket &pkt,const RuntimeEnvironment *const RR,void *const tPtr,const SharedPtr &peer,const SharedPtr &path) { if (likely(pkt.size() >= (ZT_PACKET_IDX_PAYLOAD + 8))) { ZT_UserMessage um; diff --git a/node/IncomingPacket.hpp b/node/IncomingPacket.hpp index 1e7219380..6451847c6 100644 --- a/node/IncomingPacket.hpp +++ b/node/IncomingPacket.hpp @@ -46,7 +46,7 @@ class Network; class IncomingPacket : public Packet { public: - ZT_ALWAYS_INLINE IncomingPacket() : Packet(),_receiveTime(0),_path() {} + inline IncomingPacket() : Packet(),_receiveTime(0),_path() {} /** * Create a new packet-in-decode @@ -57,7 +57,7 @@ public: * @param now Current time * @throws std::out_of_range Range error processing packet */ - ZT_ALWAYS_INLINE IncomingPacket(const void *data,unsigned int len,const SharedPtr &path,int64_t now) : + inline IncomingPacket(const void *data,unsigned int len,const SharedPtr &path,int64_t now) : Packet(data,len), _receiveTime(now), _path(path) @@ -73,7 +73,7 @@ public: * @param now Current time * @throws std::out_of_range Range error processing packet */ - ZT_ALWAYS_INLINE void init(const void *data,unsigned int len,const SharedPtr &path,int64_t now) + inline void init(const void *data,unsigned int len,const SharedPtr &path,int64_t now) { copyFrom(data,len); _receiveTime = now; @@ -98,7 +98,7 @@ public: /** * @return Time of packet receipt / start of decode */ - ZT_ALWAYS_INLINE uint64_t receiveTime() const { return _receiveTime; } + inline uint64_t receiveTime() const { return _receiveTime; } private: uint64_t _receiveTime; diff --git a/node/InetAddress.hpp b/node/InetAddress.hpp index 011327654..9444b1bbe 100644 --- a/node/InetAddress.hpp +++ b/node/InetAddress.hpp @@ -79,55 +79,55 @@ struct InetAddress : public sockaddr_storage // but this is safe to put here. struct Hasher { - ZT_ALWAYS_INLINE std::size_t operator()(const InetAddress &a) const { return (std::size_t)a.hashCode(); } + inline std::size_t operator()(const InetAddress &a) const { return (std::size_t)a.hashCode(); } }; - ZT_ALWAYS_INLINE InetAddress() { memset(this,0,sizeof(InetAddress)); } - ZT_ALWAYS_INLINE InetAddress(const InetAddress &a) { memcpy(this,&a,sizeof(InetAddress)); } - ZT_ALWAYS_INLINE InetAddress(const InetAddress *a) { memcpy(this,a,sizeof(InetAddress)); } - ZT_ALWAYS_INLINE InetAddress(const struct sockaddr_storage &ss) { *this = ss; } - ZT_ALWAYS_INLINE InetAddress(const struct sockaddr_storage *ss) { *this = ss; } - ZT_ALWAYS_INLINE InetAddress(const struct sockaddr &sa) { *this = sa; } - ZT_ALWAYS_INLINE InetAddress(const struct sockaddr *sa) { *this = sa; } - ZT_ALWAYS_INLINE InetAddress(const struct sockaddr_in &sa) { *this = sa; } - ZT_ALWAYS_INLINE InetAddress(const struct sockaddr_in *sa) { *this = sa; } - ZT_ALWAYS_INLINE InetAddress(const struct sockaddr_in6 &sa) { *this = sa; } - ZT_ALWAYS_INLINE InetAddress(const struct sockaddr_in6 *sa) { *this = sa; } - ZT_ALWAYS_INLINE InetAddress(const void *ipBytes,unsigned int ipLen,unsigned int port) { this->set(ipBytes,ipLen,port); } - ZT_ALWAYS_INLINE InetAddress(const uint32_t ipv4,unsigned int port) { this->set(&ipv4,4,port); } - ZT_ALWAYS_INLINE InetAddress(const char *ipSlashPort) { this->fromString(ipSlashPort); } + inline InetAddress() { memset(this,0,sizeof(InetAddress)); } + inline InetAddress(const InetAddress &a) { memcpy(this,&a,sizeof(InetAddress)); } + inline InetAddress(const InetAddress *a) { memcpy(this,a,sizeof(InetAddress)); } + inline InetAddress(const struct sockaddr_storage &ss) { *this = ss; } + inline InetAddress(const struct sockaddr_storage *ss) { *this = ss; } + inline InetAddress(const struct sockaddr &sa) { *this = sa; } + inline InetAddress(const struct sockaddr *sa) { *this = sa; } + inline InetAddress(const struct sockaddr_in &sa) { *this = sa; } + inline InetAddress(const struct sockaddr_in *sa) { *this = sa; } + inline InetAddress(const struct sockaddr_in6 &sa) { *this = sa; } + inline InetAddress(const struct sockaddr_in6 *sa) { *this = sa; } + inline InetAddress(const void *ipBytes,unsigned int ipLen,unsigned int port) { this->set(ipBytes,ipLen,port); } + inline InetAddress(const uint32_t ipv4,unsigned int port) { this->set(&ipv4,4,port); } + inline InetAddress(const char *ipSlashPort) { this->fromString(ipSlashPort); } - ZT_ALWAYS_INLINE void clear() { memset(this,0,sizeof(InetAddress)); } + inline void clear() { memset(this,0,sizeof(InetAddress)); } - ZT_ALWAYS_INLINE InetAddress &operator=(const InetAddress &a) + inline InetAddress &operator=(const InetAddress &a) { if (&a != this) memcpy(this,&a,sizeof(InetAddress)); return *this; } - ZT_ALWAYS_INLINE InetAddress &operator=(const InetAddress *a) + inline InetAddress &operator=(const InetAddress *a) { if (a != this) memcpy(this,a,sizeof(InetAddress)); return *this; } - ZT_ALWAYS_INLINE InetAddress &operator=(const struct sockaddr_storage &ss) + inline InetAddress &operator=(const struct sockaddr_storage &ss) { if (reinterpret_cast(&ss) != this) memcpy(this,&ss,sizeof(InetAddress)); return *this; } - ZT_ALWAYS_INLINE InetAddress &operator=(const struct sockaddr_storage *ss) + inline InetAddress &operator=(const struct sockaddr_storage *ss) { if (reinterpret_cast(ss) != this) memcpy(this,ss,sizeof(InetAddress)); return *this; } - ZT_ALWAYS_INLINE InetAddress &operator=(const struct sockaddr_in &sa) + inline InetAddress &operator=(const struct sockaddr_in &sa) { if (reinterpret_cast(&sa) != this) { memset(this,0,sizeof(InetAddress)); @@ -136,7 +136,7 @@ struct InetAddress : public sockaddr_storage return *this; } - ZT_ALWAYS_INLINE InetAddress &operator=(const struct sockaddr_in *sa) + inline InetAddress &operator=(const struct sockaddr_in *sa) { if (reinterpret_cast(sa) != this) { memset(this,0,sizeof(InetAddress)); @@ -145,7 +145,7 @@ struct InetAddress : public sockaddr_storage return *this; } - ZT_ALWAYS_INLINE InetAddress &operator=(const struct sockaddr_in6 &sa) + inline InetAddress &operator=(const struct sockaddr_in6 &sa) { if (reinterpret_cast(&sa) != this) { memset(this,0,sizeof(InetAddress)); @@ -154,7 +154,7 @@ struct InetAddress : public sockaddr_storage return *this; } - ZT_ALWAYS_INLINE InetAddress &operator=(const struct sockaddr_in6 *sa) + inline InetAddress &operator=(const struct sockaddr_in6 *sa) { if (reinterpret_cast(sa) != this) { memset(this,0,sizeof(InetAddress)); @@ -163,7 +163,7 @@ struct InetAddress : public sockaddr_storage return *this; } - ZT_ALWAYS_INLINE InetAddress &operator=(const struct sockaddr &sa) + inline InetAddress &operator=(const struct sockaddr &sa) { if (reinterpret_cast(&sa) != this) { memset(this,0,sizeof(InetAddress)); @@ -179,7 +179,7 @@ struct InetAddress : public sockaddr_storage return *this; } - ZT_ALWAYS_INLINE InetAddress &operator=(const struct sockaddr *sa) + inline InetAddress &operator=(const struct sockaddr *sa) { if (reinterpret_cast(sa) != this) { memset(this,0,sizeof(InetAddress)); @@ -214,7 +214,7 @@ struct InetAddress : public sockaddr_storage * * @param port Port, 0 to 65535 */ - ZT_ALWAYS_INLINE void setPort(unsigned int port) + inline void setPort(unsigned int port) { switch(ss_family) { case AF_INET: @@ -229,7 +229,7 @@ struct InetAddress : public sockaddr_storage /** * @return True if this network/netmask route describes a default route (e.g. 0.0.0.0/0) */ - ZT_ALWAYS_INLINE bool isDefaultRoute() const + inline bool isDefaultRoute() const { switch(ss_family) { case AF_INET: @@ -264,7 +264,7 @@ struct InetAddress : public sockaddr_storage /** * @return Port or 0 if no port component defined */ - ZT_ALWAYS_INLINE unsigned int port() const + inline unsigned int port() const { switch(ss_family) { case AF_INET: return Utils::ntoh((uint16_t)(reinterpret_cast(this)->sin_port)); @@ -282,12 +282,12 @@ struct InetAddress : public sockaddr_storage * * @return Netmask bits */ - ZT_ALWAYS_INLINE unsigned int netmaskBits() const { return port(); } + inline unsigned int netmaskBits() const { return port(); } /** * @return True if netmask bits is valid for the address type */ - ZT_ALWAYS_INLINE bool netmaskBitsValid() const + inline bool netmaskBitsValid() const { const unsigned int n = port(); switch(ss_family) { @@ -305,7 +305,7 @@ struct InetAddress : public sockaddr_storage * * @return Gateway metric */ - ZT_ALWAYS_INLINE unsigned int metric() const { return port(); } + inline unsigned int metric() const { return port(); } /** * Construct a full netmask as an InetAddress @@ -350,17 +350,17 @@ struct InetAddress : public sockaddr_storage /** * @return True if this is an IPv4 address */ - ZT_ALWAYS_INLINE bool isV4() const { return (ss_family == AF_INET); } + inline bool isV4() const { return (ss_family == AF_INET); } /** * @return True if this is an IPv6 address */ - ZT_ALWAYS_INLINE bool isV6() const { return (ss_family == AF_INET6); } + inline bool isV6() const { return (ss_family == AF_INET6); } /** * @return pointer to raw address bytes or NULL if not available */ - ZT_ALWAYS_INLINE const void *rawIpData() const + inline const void *rawIpData() const { switch(ss_family) { case AF_INET: return (const void *)&(reinterpret_cast(this)->sin_addr.s_addr); @@ -372,7 +372,7 @@ struct InetAddress : public sockaddr_storage /** * @return InetAddress containing only the IP portion of this address and a zero port, or NULL if not IPv4 or IPv6 */ - ZT_ALWAYS_INLINE InetAddress ipOnly() const + inline InetAddress ipOnly() const { InetAddress r; switch(ss_family) { @@ -394,7 +394,7 @@ struct InetAddress : public sockaddr_storage * @param a InetAddress to compare again * @return True if only IP portions are equal (false for non-IP or null addresses) */ - ZT_ALWAYS_INLINE bool ipsEqual(const InetAddress &a) const + inline bool ipsEqual(const InetAddress &a) const { if (ss_family == a.ss_family) { if (ss_family == AF_INET) @@ -414,7 +414,7 @@ struct InetAddress : public sockaddr_storage * @param a InetAddress to compare again * @return True if only IP portions are equal (false for non-IP or null addresses) */ - ZT_ALWAYS_INLINE bool ipsEqual2(const InetAddress &a) const + inline bool ipsEqual2(const InetAddress &a) const { if (ss_family == a.ss_family) { if (ss_family == AF_INET) @@ -426,7 +426,7 @@ struct InetAddress : public sockaddr_storage return false; } - ZT_ALWAYS_INLINE unsigned long hashCode() const + inline unsigned long hashCode() const { if (ss_family == AF_INET) { return ((unsigned long)reinterpret_cast(this)->sin_addr.s_addr + (unsigned long)reinterpret_cast(this)->sin_port); @@ -448,7 +448,7 @@ struct InetAddress : public sockaddr_storage /** * Set to null/zero */ - ZT_ALWAYS_INLINE void zero() { memset(this,0,sizeof(InetAddress)); } + inline void zero() { memset(this,0,sizeof(InetAddress)); } /** * Check whether this is a network/route rather than an IP assignment @@ -463,7 +463,7 @@ struct InetAddress : public sockaddr_storage /** * @return 14-bit (0-16383) hash of this IP's first 24 or 48 bits (for V4 or V6) for rate limiting code, or 0 if non-IP */ - ZT_ALWAYS_INLINE unsigned long rateGateHash() const + inline unsigned long rateGateHash() const { unsigned long h = 0; switch(ss_family) { @@ -487,10 +487,69 @@ struct InetAddress : public sockaddr_storage /** * @return True if address family is non-zero */ - ZT_ALWAYS_INLINE operator bool() const { return (ss_family != 0); } + inline operator bool() const { return (ss_family != 0); } + + inline unsigned int marshal(uint8_t restrict data[20]) const + { + switch(ss_family) { + case AF_INET: + const unsigned int port = Utils::ntoh((uint16_t)reinterpret_cast(this)->sin_port); + data[0] = 4; + data[1] = reinterpret_cast(&(reinterpret_cast(this)->sin_addr.s_addr))[0]; + data[2] = reinterpret_cast(&(reinterpret_cast(this)->sin_addr.s_addr))[1]; + data[3] = reinterpret_cast(&(reinterpret_cast(this)->sin_addr.s_addr))[2]; + data[4] = reinterpret_cast(&(reinterpret_cast(this)->sin_addr.s_addr))[3]; + data[5] = (uint8_t)((port >> 8) & 0xff); + data[6] = (uint8_t)(port & 0xff); + return 7; + case AF_INET6: + const unsigned int port = Utils::ntoh((uint16_t)reinterpret_cast(this)->sin6_port); + data[0] = 6; + for(int i=0;i<16;++i) + data[i+1] = reinterpret_cast(this)->sin6_addr.s6_addr[i]; + data[17] = (uint8_t)((port >> 8) & 0xff); + data[18] = (uint8_t)(port & 0xff); + return 19; + default: + data[0] = 0; + return 1; + } + } + + inline bool unmarshal(const uint8_t *restrict data,const unsigned int len) + { + if (len) { + memset(this,0,sizeof(InetAddress)); + switch(data[0]) { + case 0: + return true; + case 4: + if (len != 7) + return false; + reinterpret_cast(this)->sin_family = AF_INET; + reinterpret_cast(&(reinterpret_cast(this)->sin_addr.s_addr))[0] = data[1]; + reinterpret_cast(&(reinterpret_cast(this)->sin_addr.s_addr))[1] = data[2]; + reinterpret_cast(&(reinterpret_cast(this)->sin_addr.s_addr))[2] = data[3]; + reinterpret_cast(&(reinterpret_cast(this)->sin_addr.s_addr))[3] = data[4]; + reinterpret_cast(this)->sin_port = Utils::hton((((uint16_t)data[5]) << 8) | (uint16_t)data[6]); + return true; + case 6: + if (len != 19) + return false; + reinterpret_cast(this)->sin6_family = AF_INET6; + for(int i=0;i<16;i++) + (reinterpret_cast(this)->sin6_addr.s6_addr)[i] = data[i+1]; + reinterpret_cast(this)->sin6_port = Utils::hton((((uint16_t)data[17]) << 8) | (uint16_t)data[18]); + return true; + default: + return false; + } + } + return false; + } template - ZT_ALWAYS_INLINE void serialize(Buffer &b) const + inline void serialize(Buffer &b) const { // This is used in the protocol and must be the same as describe in places // like VERB_HELLO in Packet.hpp. @@ -512,7 +571,7 @@ struct InetAddress : public sockaddr_storage } template - ZT_ALWAYS_INLINE unsigned int deserialize(const Buffer &b,unsigned int startAt = 0) + inline unsigned int deserialize(const Buffer &b,unsigned int startAt = 0) { memset(this,0,sizeof(InetAddress)); unsigned int p = startAt; @@ -547,10 +606,10 @@ struct InetAddress : public sockaddr_storage bool operator==(const InetAddress &a) const; bool operator<(const InetAddress &a) const; - ZT_ALWAYS_INLINE bool operator!=(const InetAddress &a) const { return !(*this == a); } - ZT_ALWAYS_INLINE bool operator>(const InetAddress &a) const { return (a < *this); } - ZT_ALWAYS_INLINE bool operator<=(const InetAddress &a) const { return !(a < *this); } - ZT_ALWAYS_INLINE bool operator>=(const InetAddress &a) const { return !(*this < a); } + inline bool operator!=(const InetAddress &a) const { return !(*this == a); } + inline bool operator>(const InetAddress &a) const { return (a < *this); } + inline bool operator<=(const InetAddress &a) const { return !(a < *this); } + inline bool operator>=(const InetAddress &a) const { return !(*this < a); } /** * @param mac MAC address seed diff --git a/node/Locator.hpp b/node/Locator.hpp index d7b557ff4..0de1f8af4 100644 --- a/node/Locator.hpp +++ b/node/Locator.hpp @@ -14,22 +14,15 @@ #ifndef ZT_LOCATOR_HPP #define ZT_LOCATOR_HPP -#include "Constants.hpp" -#include "Identity.hpp" -#include "InetAddress.hpp" -#include "Utils.hpp" -#include "Buffer.hpp" -#include "SHA512.hpp" -#include "Str.hpp" -#include "ScopedPtr.hpp" -#include "SharedPtr.hpp" - #include #include -// These are absolute maximums -- real locators are never this big -#define ZT_LOCATOR_MAX_PHYSICAL_ADDRESSES 64 -#define ZT_LOCATOR_MAX_VIRTUAL_ADDRESSES 64 +#include "Constants.hpp" +#include "Endpoint.hpp" + +#define ZT_LOCATOR_MAX_ENDPOINTS 8 + +#define ZT_LOCATOR_MARSHAL_SIZE_MAX ((ZT_ENDPOINT_MARSHAL_SIZE_MAX * ZT_LOCATOR_MAX_ENDPOINTS) + 8 + 256 + ZT_SIGNATURE_BUFFER_SIZE) namespace ZeroTier { @@ -44,342 +37,27 @@ namespace ZeroTier { */ class Locator { - enum ObjectType - { - OBJECT_TYPE_ZEROTIER_NODE = 1 - }; - friend class SharedPtr; public: - ZT_ALWAYS_INLINE Locator() : _ts(0),_signatureLength(0) {} + inline Locator() : _ts(0),_signatureLength(0) {} - ZT_ALWAYS_INLINE int64_t timestamp() const { return _ts; } - ZT_ALWAYS_INLINE const Identity &id() const { return _id; } + inline int64_t timestamp() const { return _ts; } + inline const Identity &id() const { return _id; } - ZT_ALWAYS_INLINE const std::vector &phy() const { return _physical; } - ZT_ALWAYS_INLINE const std::vector &virt() const { return _virtual; } + inline operator bool() const { return (_ts != 0); } - /** - * Add a physical address to this locator (call before finish() to build a new Locator) - */ - ZT_ALWAYS_INLINE void add(const InetAddress &ip) + inline bool create(const int64_t ts,const Identity &id,const Endpoint *restrict at,const unsigned int endpointCount) { - if (_physical.size() < ZT_LOCATOR_MAX_PHYSICAL_ADDRESSES) - _physical.push_back(ip); } - /** - * Add a forwarding ZeroTier node to this locator (call before finish() to build a new Locator) - */ - ZT_ALWAYS_INLINE void add(const Identity &zt) - { - if (_virtual.size() < ZT_LOCATOR_MAX_VIRTUAL_ADDRESSES) - _virtual.push_back(zt); - } - - /** - * Method to be called after add() is called for each address or forwarding node - * - * @param id Identity that this locator describes (must contain private key) - * @param ts Current time - * @return True if completion and signature were successful - */ - ZT_ALWAYS_INLINE bool finish(const Identity &id,const int64_t ts) - { - _ts = ts; - _id = id; - std::sort(_physical.begin(),_physical.end()); - _physical.erase(std::unique(_physical.begin(),_physical.end()),_physical.end()); - std::sort(_virtual.begin(),_virtual.end()); - _virtual.erase(std::unique(_virtual.begin(),_virtual.end()),_virtual.end()); - try { - ScopedPtr< Buffer<65536> > tmp(new Buffer<65536>()); - serialize(*tmp,true); - _signatureLength = id.sign(tmp->data(),tmp->size(),_signature,ZT_SIGNATURE_BUFFER_SIZE); - return (_signatureLength > 0); - } catch ( ... ) { - return false; - } - } - - /** - * Verify this locator's signature against its embedded signing identity - */ - ZT_ALWAYS_INLINE bool verify() const - { - if ((_signatureLength == 0)||(_signatureLength > sizeof(_signature))) - return false; - try { - ScopedPtr< Buffer<65536> > tmp(new Buffer<65536>()); - serialize(*tmp,true); - return _id.verify(tmp->data(),tmp->size(),_signature,_signatureLength); - } catch ( ... ) { - return false; - } - } - - /** - * Make a DNS name contiaining a public key that can sign DNS entries - * - * This generates the initial fields of a DNS name that contains an - * encoded public key. Users may append any domain suffix to this name. - * - * @return First field(s) of DNS name - */ - static inline Str makeSecureDnsName(const uint8_t p384SigningKeyPublic[ZT_ECC384_PUBLIC_KEY_SIZE]) - { - uint8_t tmp[ZT_ECC384_PUBLIC_KEY_SIZE+2]; - memcpy(tmp,p384SigningKeyPublic,ZT_ECC384_PUBLIC_KEY_SIZE); - const uint16_t crc = Utils::crc16(tmp,ZT_ECC384_PUBLIC_KEY_SIZE); - tmp[ZT_ECC384_PUBLIC_KEY_SIZE-2] = (uint8_t)(crc >> 8); - tmp[ZT_ECC384_PUBLIC_KEY_SIZE-1] = (uint8_t)(crc); - Str name; - char b32[128]; - Utils::b32e(tmp,35,b32,sizeof(b32)); - name << "ztl-"; - name << b32; - Utils::b32e(tmp + 35,(ZT_ECC384_PUBLIC_KEY_SIZE+2) - 35,b32,sizeof(b32)); - name << ".ztl-"; - name << b32; - return name; - } - - /** - * This searches for an extracts a public key from a DNS name, if one is present. - * - * @return True if a key was found and successfully decoded - */ - static inline bool decodeSecureDnsName(const char *name,uint8_t p384SigningKeyPublic[ZT_ECC384_PUBLIC_KEY_SIZE]) - { - uint8_t b32[128]; - unsigned int b32ptr = 0; - char tmp[1024]; - Utils::scopy(tmp,sizeof(tmp),name); - bool ok = false; - for(char *saveptr=(char *)0,*p=Utils::stok(tmp,".",&saveptr);p;p=Utils::stok((char *)0,".",&saveptr)) { - if (b32ptr >= sizeof(b32)) - break; - if ((strlen(p) <= 4)||(memcmp(p,"ztl-",4) != 0)) - continue; - int s = Utils::b32d(p + 4,b32 + b32ptr,sizeof(b32) - b32ptr); - if (s > 0) { - b32ptr += (unsigned int)s; - if (b32ptr > 2) { - const uint16_t crc = Utils::crc16(b32,b32ptr); - if ((b32[b32ptr-2] == (uint8_t)(crc >> 8))&&(b32[b32ptr-1] == (uint8_t)(crc & 0xff))) { - ok = true; - break; - } - } - } else break; - } - - if (ok) { - if (b32ptr == (ZT_ECC384_PUBLIC_KEY_SIZE + 2)) { - memcpy(p384SigningKeyPublic,b32,ZT_ECC384_PUBLIC_KEY_SIZE); - return true; - } - } - - return false; - } - - /** - * Make DNS TXT records for this locator - * - * DNS TXT records are signed by an entirely separate key that is added along - * with DNS names to nodes to allow them to verify DNS results. It's separate - * from the locator's signature so that a single DNS record can point to more - * than one locator or be served by things like geo-aware DNS. - * - * Right now only NIST P-384 is supported for signing DNS records. NIST EDDSA - * is used here so that FIPS-only nodes can always use DNS to locate roots as - * FIPS-only nodes may be required to disable non-FIPS algorithms. - */ - inline std::vector makeTxtRecords(const uint8_t p384SigningKeyPrivate[ZT_ECC384_PUBLIC_KEY_SIZE]) - { - uint8_t s384[48]; - char enc[256]; - - ScopedPtr< Buffer<65536> > tmp(new Buffer<65536>()); - serialize(*tmp,false); - SHA384(s384,tmp->data(),tmp->size()); - const unsigned int sigLocation = tmp->size(); - tmp->addSize(ZT_ECC384_SIGNATURE_SIZE); - ECC384ECDSASign(p384SigningKeyPrivate,s384,((uint8_t *)tmp->unsafeData()) + sigLocation); - - // Blob must be broken into multiple TXT records that must remain sortable so they are prefixed by a hex value. - // 186-byte chunks yield 248-byte base64 chunks which leaves some margin below the limit of 255. - std::vector txtRecords; - unsigned int txtRecNo = 0; - for(unsigned int p=0;psize();) { - unsigned int chunkSize = tmp->size() - p; - if (chunkSize > 186) chunkSize = 186; - - Utils::b64e(((const uint8_t *)tmp->data()) + p,chunkSize,enc,sizeof(enc)); - p += chunkSize; - - txtRecords.push_back(Str()); - txtRecords.back() << Utils::HEXCHARS[(txtRecNo >> 4) & 0xf] << Utils::HEXCHARS[txtRecNo & 0xf] << enc; - ++txtRecNo; - } - - return txtRecords; - } - - /** - * Decode TXT records - * - * TXT records can be provided as an iterator over std::string, Str, or char * - * values, and TXT records can be provided in any order. Any oversize or empty - * entries will be ignored. - * - * This method checks the decoded locator's signature using the supplied DNS TXT - * record signing public key. False is returned if the TXT records are invalid, - * incomplete, or fail signature check. If true is returned this Locator object - * now contains the contents of the supplied TXT records. - * - * @return True if new Locator is valid - */ - template - inline bool decodeTxtRecords(const Str &dnsName,I start,I end) - { - uint8_t dec[256],s384[48]; - try { - std::vector txtRecords; - while (start != end) { - try { - if (start->length() > 2) - txtRecords.push_back(*start); - } catch ( ... ) {} // skip any records that trigger out of bounds exceptions - ++start; - } - if (txtRecords.empty()) - return false; - std::sort(txtRecords.begin(),txtRecords.end()); - - ScopedPtr< Buffer<65536> > tmp(new Buffer<65536>()); - for(std::vector::const_iterator i(txtRecords.begin());i!=txtRecords.end();++i) - tmp->append(dec,Utils::b64d(i->c_str() + 2,dec,sizeof(dec))); - - uint8_t p384SigningKeyPublic[ZT_ECC384_PUBLIC_KEY_SIZE]; - if (decodeSecureDnsName(dnsName.c_str(),p384SigningKeyPublic)) { - if (tmp->size() <= ZT_ECC384_SIGNATURE_SIZE) - return false; - SHA384(s384,tmp->data(),tmp->size() - ZT_ECC384_SIGNATURE_SIZE); - if (!ECC384ECDSAVerify(p384SigningKeyPublic,s384,((const uint8_t *)tmp->data()) + (tmp->size() - ZT_ECC384_SIGNATURE_SIZE))) - return false; - } - - deserialize(*tmp,0); - - return verify(); - } catch ( ... ) { - return false; - } - } - - inline bool deserialize(const void *data,unsigned int len) - { - ScopedPtr< Buffer<65536> > tmp(new Buffer<65536>()); - tmp->append(data,len); - try { - deserialize(*tmp,0); - return true; - } catch ( ... ) { - return false; - } - } - - template - inline void serialize(Buffer &b,const bool forSign = false) const - { - if (forSign) b.append((uint64_t)0x7f7f7f7f7f7f7f7fULL); - - b.append((uint8_t)0); // version/flags, currently 0 - b.append((uint64_t)_ts); - _id.serialize(b,false); - b.append((uint8_t)_physical.size()); - for(std::vector::const_iterator i(_physical.begin());i!=_physical.end();++i) - i->serialize(b); - b.append((uint8_t)_virtual.size()); - for(std::vector::const_iterator i(_virtual.begin());i!=_virtual.end();++i) - i->serialize(b,false); - if (!forSign) { - b.append((uint16_t)_signatureLength); - b.append(_signature,_signatureLength); - } - b.append((uint16_t)0); // length of additional fields, currently 0 - - if (forSign) b.append((uint64_t)0x7f7f7f7f7f7f7f7fULL); - } - - template - inline unsigned int deserialize(const Buffer &b,unsigned int startAt = 0) - { - unsigned int p = startAt; - - if (b[p++] != 0) - throw ZT_EXCEPTION_INVALID_SERIALIZED_DATA_INVALID_TYPE; - _ts = (int64_t)b.template at(p); p += 8; - p += _id.deserialize(b,p); - const unsigned int physicalCount = b[p++]; - _physical.resize(physicalCount); - for(unsigned int i=0;i(p); p += 2; - if (_signatureLength > ZT_SIGNATURE_BUFFER_SIZE) - throw ZT_EXCEPTION_INVALID_SERIALIZED_DATA_OVERFLOW; - memcpy(_signature,b.field(p,_signatureLength),_signatureLength); - p += _signatureLength; - p += b.template at(p) + 2; - - return (p - startAt); - } - - ZT_ALWAYS_INLINE operator bool() const { return (_id); } - - ZT_ALWAYS_INLINE bool addressesEqual(const Locator &l) const { return ((_physical == l._physical)&&(_virtual == l._virtual)); } - - ZT_ALWAYS_INLINE bool operator==(const Locator &l) const - { - return ( - (_ts == l._ts)&& - (_id == l._id)&& - (_physical == l._physical)&& - (_virtual == l._virtual)&& - (_signatureLength == l._signatureLength)&& - (memcmp(_signature,l._signature,_signatureLength) == 0)); - } - ZT_ALWAYS_INLINE bool operator!=(const Locator &l) const { return (!(*this == l)); } - ZT_ALWAYS_INLINE bool operator<(const Locator &l) const - { - if (_ts < l._ts) return true; else if (_ts > l._ts) return false; - if (_id < l._id) return true; else if (_id > l._id) return false; - if (_physical < l._physical) return true; else if (_physical > l._physical) return false; - if (_virtual < l._virtual) return true; else if (_virtual > l._virtual) return false; - if (_signatureLength < l._signatureLength) return true; - return (_signatureLength == l._signatureLength) ? (memcmp(_signature,l._signature,_signatureLength) < 0) : false; - } - ZT_ALWAYS_INLINE bool operator>(const Locator &l) const { return (l < *this); } - ZT_ALWAYS_INLINE bool operator<=(const Locator &l) const { return (!(l < *this)); } - ZT_ALWAYS_INLINE bool operator>=(const Locator &l) const { return (!(*this < l)); } - - ZT_ALWAYS_INLINE unsigned long hashCode() const { return (unsigned long)(_id.address().toInt() ^ (uint64_t)_ts); } - private: int64_t _ts; Identity _id; - std::vector _physical; - std::vector _virtual; + Endpoint *_at; + unsigned int _endpointCount; unsigned int _signatureLength; uint8_t _signature[ZT_SIGNATURE_BUFFER_SIZE]; - AtomicCounter __refCount; }; } // namespace ZeroTier diff --git a/node/MAC.hpp b/node/MAC.hpp index d200a7cad..1044af72a 100644 --- a/node/MAC.hpp +++ b/node/MAC.hpp @@ -31,40 +31,40 @@ namespace ZeroTier { class MAC { public: - ZT_ALWAYS_INLINE MAC() : _m(0ULL) {} - ZT_ALWAYS_INLINE MAC(const MAC &m) : _m(m._m) {} + inline MAC() : _m(0ULL) {} + inline MAC(const MAC &m) : _m(m._m) {} - ZT_ALWAYS_INLINE MAC(const unsigned char a,const unsigned char b,const unsigned char c,const unsigned char d,const unsigned char e,const unsigned char f) : + inline MAC(const unsigned char a,const unsigned char b,const unsigned char c,const unsigned char d,const unsigned char e,const unsigned char f) : _m( ((((uint64_t)a) & 0xffULL) << 40) | ((((uint64_t)b) & 0xffULL) << 32) | ((((uint64_t)c) & 0xffULL) << 24) | ((((uint64_t)d) & 0xffULL) << 16) | ((((uint64_t)e) & 0xffULL) << 8) | (((uint64_t)f) & 0xffULL) ) {} - ZT_ALWAYS_INLINE MAC(const void *bits,unsigned int len) { setTo(bits,len); } - ZT_ALWAYS_INLINE MAC(const Address &ztaddr,uint64_t nwid) { fromAddress(ztaddr,nwid); } - ZT_ALWAYS_INLINE MAC(const uint64_t m) : _m(m & 0xffffffffffffULL) {} + inline MAC(const void *bits,unsigned int len) { setTo(bits,len); } + inline MAC(const Address &ztaddr,uint64_t nwid) { fromAddress(ztaddr,nwid); } + inline MAC(const uint64_t m) : _m(m & 0xffffffffffffULL) {} /** * @return MAC in 64-bit integer */ - ZT_ALWAYS_INLINE uint64_t toInt() const { return _m; } + inline uint64_t toInt() const { return _m; } /** * Set MAC to zero */ - ZT_ALWAYS_INLINE void zero() { _m = 0ULL; } + inline void zero() { _m = 0ULL; } /** * @return True if MAC is non-zero */ - ZT_ALWAYS_INLINE operator bool() const { return (_m != 0ULL); } + inline operator bool() const { return (_m != 0ULL); } /** * @param bits Raw MAC in big-endian byte order * @param len Length, must be >= 6 or result is zero */ - ZT_ALWAYS_INLINE void setTo(const void *bits,unsigned int len) + inline void setTo(const void *bits,unsigned int len) { if (len < 6) { _m = 0ULL; @@ -83,7 +83,7 @@ public: * @param buf Destination buffer for MAC in big-endian byte order * @param len Length of buffer, must be >= 6 or nothing is copied */ - ZT_ALWAYS_INLINE void copyTo(void *buf,unsigned int len) const + inline void copyTo(void *buf,unsigned int len) const { if (len < 6) return; @@ -102,7 +102,7 @@ public: * @param b Buffer to append to */ template - ZT_ALWAYS_INLINE void appendTo(Buffer &b) const + inline void appendTo(Buffer &b) const { unsigned char *p = (unsigned char *)b.appendField(6); *(p++) = (unsigned char)((_m >> 40) & 0xff); @@ -116,17 +116,17 @@ public: /** * @return True if this is broadcast (all 0xff) */ - ZT_ALWAYS_INLINE bool isBroadcast() const { return (_m == 0xffffffffffffULL); } + inline bool isBroadcast() const { return (_m == 0xffffffffffffULL); } /** * @return True if this is a multicast MAC */ - ZT_ALWAYS_INLINE bool isMulticast() const { return ((_m & 0x010000000000ULL) != 0ULL); } + inline bool isMulticast() const { return ((_m & 0x010000000000ULL) != 0ULL); } /** * @param True if this is a locally-administered MAC */ - ZT_ALWAYS_INLINE bool isLocallyAdministered() const { return ((_m & 0x020000000000ULL) != 0ULL); } + inline bool isLocallyAdministered() const { return ((_m & 0x020000000000ULL) != 0ULL); } /** * Set this MAC to a MAC derived from an address and a network ID @@ -134,7 +134,7 @@ public: * @param ztaddr ZeroTier address * @param nwid 64-bit network ID */ - ZT_ALWAYS_INLINE void fromAddress(const Address &ztaddr,uint64_t nwid) + inline void fromAddress(const Address &ztaddr,uint64_t nwid) { uint64_t m = ((uint64_t)firstOctetForNetwork(nwid)) << 40; m |= ztaddr.toInt(); // a is 40 bits @@ -153,7 +153,7 @@ public: * * @param nwid Network ID */ - ZT_ALWAYS_INLINE Address toAddress(uint64_t nwid) const + inline Address toAddress(uint64_t nwid) const { uint64_t a = _m & 0xffffffffffULL; // least significant 40 bits of MAC are formed from address a ^= ((nwid >> 8) & 0xff) << 32; // ... XORed with bits 8-48 of the nwid in little-endian byte order, so unmask it @@ -168,7 +168,7 @@ public: * @param nwid Network ID * @return First octet of MAC for this network */ - static ZT_ALWAYS_INLINE unsigned char firstOctetForNetwork(uint64_t nwid) + static inline unsigned char firstOctetForNetwork(uint64_t nwid) { unsigned char a = ((unsigned char)(nwid & 0xfe) | 0x02); // locally administered, not multicast, from LSB of network ID return ((a == 0x52) ? 0x32 : a); // blacklist 0x52 since it's used by KVM, libvirt, and other popular virtualization engines... seems de-facto standard on Linux @@ -178,16 +178,16 @@ public: * @param i Value from 0 to 5 (inclusive) * @return Byte at said position (address interpreted in big-endian order) */ - ZT_ALWAYS_INLINE uint8_t operator[](unsigned int i) const { return (uint8_t)(_m >> (40 - (i * 8))); } + inline uint8_t operator[](unsigned int i) const { return (uint8_t)(_m >> (40 - (i * 8))); } /** * @return 6, which is the number of bytes in a MAC, for container compliance */ - ZT_ALWAYS_INLINE unsigned int size() const { return 6; } + inline unsigned int size() const { return 6; } - ZT_ALWAYS_INLINE unsigned long hashCode() const { return (unsigned long)_m; } + inline unsigned long hashCode() const { return (unsigned long)_m; } - ZT_ALWAYS_INLINE char *toString(char buf[18]) const + inline char *toString(char buf[18]) const { buf[0] = Utils::HEXCHARS[(_m >> 44) & 0xf]; buf[1] = Utils::HEXCHARS[(_m >> 40) & 0xf]; @@ -210,23 +210,23 @@ public: return buf; } - ZT_ALWAYS_INLINE MAC &operator=(const MAC &m) + inline MAC &operator=(const MAC &m) { _m = m._m; return *this; } - ZT_ALWAYS_INLINE MAC &operator=(const uint64_t m) + inline MAC &operator=(const uint64_t m) { _m = m & 0xffffffffffffULL; return *this; } - ZT_ALWAYS_INLINE bool operator==(const MAC &m) const { return (_m == m._m); } - ZT_ALWAYS_INLINE bool operator!=(const MAC &m) const { return (_m != m._m); } - ZT_ALWAYS_INLINE bool operator<(const MAC &m) const { return (_m < m._m); } - ZT_ALWAYS_INLINE bool operator<=(const MAC &m) const { return (_m <= m._m); } - ZT_ALWAYS_INLINE bool operator>(const MAC &m) const { return (_m > m._m); } - ZT_ALWAYS_INLINE bool operator>=(const MAC &m) const { return (_m >= m._m); } + inline bool operator==(const MAC &m) const { return (_m == m._m); } + inline bool operator!=(const MAC &m) const { return (_m != m._m); } + inline bool operator<(const MAC &m) const { return (_m < m._m); } + inline bool operator<=(const MAC &m) const { return (_m <= m._m); } + inline bool operator>(const MAC &m) const { return (_m > m._m); } + inline bool operator>=(const MAC &m) const { return (_m >= m._m); } private: uint64_t _m; diff --git a/node/Membership.hpp b/node/Membership.hpp index 506831d1b..94248f2a5 100644 --- a/node/Membership.hpp +++ b/node/Membership.hpp @@ -67,7 +67,7 @@ public: /** * @return Time we last pushed credentials to this member */ - ZT_ALWAYS_INLINE int64_t lastPushedCredentials() const { return _lastPushedCredentials; } + inline int64_t lastPushedCredentials() const { return _lastPushedCredentials; } /** * Check whether we should push MULTICAST_LIKEs to this peer, and update last sent time if true @@ -75,7 +75,7 @@ public: * @param now Current time * @return True if we should update multicasts */ - ZT_ALWAYS_INLINE bool multicastLikeGate(const int64_t now) + inline bool multicastLikeGate(const int64_t now) { if ((now - _lastUpdatedMulticast) >= ZT_MULTICAST_ANNOUNCE_PERIOD) { _lastUpdatedMulticast = now; @@ -90,7 +90,7 @@ public: * @param nconf Our network config * @return True if this peer is allowed on this network at all */ - ZT_ALWAYS_INLINE bool isAllowedOnNetwork(const NetworkConfig &nconf) const + inline bool isAllowedOnNetwork(const NetworkConfig &nconf) const { if (nconf.isPublic()) return true; // public network if (_com.timestamp() <= _comRevocationThreshold) return false; // COM has been revoked @@ -100,7 +100,7 @@ public: /** * @return True if this peer has sent us a valid certificate within ZT_PEER_ACTIVITY_TIMEOUT */ - ZT_ALWAYS_INLINE bool recentlyAssociated(const int64_t now) const { return ((_com)&&((now - _com.timestamp()) < ZT_PEER_ACTIVITY_TIMEOUT)); } + inline bool recentlyAssociated(const int64_t now) const { return ((_com)&&((now - _com.timestamp()) < ZT_PEER_ACTIVITY_TIMEOUT)); } /** * Check whether the peer represented by this Membership owns a given address @@ -160,22 +160,22 @@ public: /** * @return Bytes received so far */ - ZT_ALWAYS_INLINE uint64_t receivedBytes() const { return _received; } + inline uint64_t receivedBytes() const { return _received; } /** * @return Bytes sent so far */ - ZT_ALWAYS_INLINE uint64_t sentBytes() const { return _sent; } + inline uint64_t sentBytes() const { return _sent; } /** * @param bytes Bytes received */ - ZT_ALWAYS_INLINE void logReceivedBytes(const unsigned int bytes) { _received = (uint64_t)bytes; } + inline void logReceivedBytes(const unsigned int bytes) { _received = (uint64_t)bytes; } /** * @param bytes Bytes sent */ - ZT_ALWAYS_INLINE void logSentBytes(const unsigned int bytes) { _sent = (uint64_t)bytes; } + inline void logSentBytes(const unsigned int bytes) { _sent = (uint64_t)bytes; } private: // This returns true if a resource is an IPv6 NDP-emulated address. These embed the ZT @@ -275,7 +275,7 @@ public: class CapabilityIterator { public: - ZT_ALWAYS_INLINE CapabilityIterator(Membership &m,const NetworkConfig &nconf) : + inline CapabilityIterator(Membership &m,const NetworkConfig &nconf) : _hti(m._remoteCaps), _k((uint32_t *)0), _c((Capability *)0), @@ -284,7 +284,7 @@ public: { } - ZT_ALWAYS_INLINE Capability *next() + inline Capability *next() { while (_hti.next(_k,_c)) { if (_m._isCredentialTimestampValid(_nconf,*_c)) diff --git a/node/Meter.hpp b/node/Meter.hpp index 301fc97f9..9a12ccdef 100644 --- a/node/Meter.hpp +++ b/node/Meter.hpp @@ -29,7 +29,7 @@ namespace ZeroTier { class Meter { public: - ZT_ALWAYS_INLINE Meter() + inline Meter() { for(int i=0;i - ZT_ALWAYS_INLINE void log(const int64_t now,I count) + inline void log(const int64_t now,I count) { const int64_t since = now - _ts; if (since >= ZT_METER_HISTORY_TICK_DURATION) { @@ -50,7 +50,7 @@ public: } } - ZT_ALWAYS_INLINE double perSecond(const int64_t now) const + inline double perSecond(const int64_t now) const { double r = 0.0,n = 0.0; const int64_t since = (now - _ts); diff --git a/node/MulticastGroup.hpp b/node/MulticastGroup.hpp index 6d90e5d2e..2ce1667ea 100644 --- a/node/MulticastGroup.hpp +++ b/node/MulticastGroup.hpp @@ -41,8 +41,8 @@ namespace ZeroTier { class MulticastGroup { public: - ZT_ALWAYS_INLINE MulticastGroup() : _mac(),_adi(0) {} - ZT_ALWAYS_INLINE MulticastGroup(const MAC &m,uint32_t a) : _mac(m),_adi(a) {} + inline MulticastGroup() : _mac(),_adi(0) {} + inline MulticastGroup(const MAC &m,uint32_t a) : _mac(m),_adi(a) {} /** * Derive the multicast group used for address resolution (ARP/NDP) for an IP @@ -50,7 +50,7 @@ public: * @param ip IP address (port field is ignored) * @return Multicast group for ARP/NDP */ - static ZT_ALWAYS_INLINE MulticastGroup deriveMulticastGroupForAddressResolution(const InetAddress &ip) + static inline MulticastGroup deriveMulticastGroupForAddressResolution(const InetAddress &ip) { if (ip.isV4()) { // IPv4 wants broadcast MACs, so we shove the V4 address itself into @@ -72,17 +72,17 @@ public: /** * @return Ethernet MAC portion of multicast group */ - ZT_ALWAYS_INLINE const MAC &mac() const { return _mac; } + inline const MAC &mac() const { return _mac; } /** * @return Additional distinguishing information, which is normally zero except for IPv4 ARP where it's the IPv4 address */ - ZT_ALWAYS_INLINE uint32_t adi() const { return _adi; } + inline uint32_t adi() const { return _adi; } /** * @return 32-bit non-cryptographic hash ID of this multicast group */ - ZT_ALWAYS_INLINE uint32_t id() const + inline uint32_t id() const { uint64_t m = _mac.toInt(); uint32_t x1 = _adi; @@ -100,9 +100,9 @@ public: return (x1 ^ x2 ^ x3); } - ZT_ALWAYS_INLINE bool operator==(const MulticastGroup &g) const { return ((_mac == g._mac)&&(_adi == g._adi)); } - ZT_ALWAYS_INLINE bool operator!=(const MulticastGroup &g) const { return ((_mac != g._mac)||(_adi != g._adi)); } - ZT_ALWAYS_INLINE bool operator<(const MulticastGroup &g) const + inline bool operator==(const MulticastGroup &g) const { return ((_mac == g._mac)&&(_adi == g._adi)); } + inline bool operator!=(const MulticastGroup &g) const { return ((_mac != g._mac)||(_adi != g._adi)); } + inline bool operator<(const MulticastGroup &g) const { if (_mac < g._mac) return true; @@ -110,11 +110,11 @@ public: return (_adi < g._adi); return false; } - ZT_ALWAYS_INLINE bool operator>(const MulticastGroup &g) const { return (g < *this); } - ZT_ALWAYS_INLINE bool operator<=(const MulticastGroup &g) const { return !(g < *this); } - ZT_ALWAYS_INLINE bool operator>=(const MulticastGroup &g) const { return !(*this < g); } + inline bool operator>(const MulticastGroup &g) const { return (g < *this); } + inline bool operator<=(const MulticastGroup &g) const { return !(g < *this); } + inline bool operator>=(const MulticastGroup &g) const { return !(*this < g); } - ZT_ALWAYS_INLINE unsigned long hashCode() const { return (_mac.hashCode() ^ (unsigned long)_adi); } + inline unsigned long hashCode() const { return (_mac.hashCode() ^ (unsigned long)_adi); } private: MAC _mac; diff --git a/node/Mutex.hpp b/node/Mutex.hpp index c631f13d2..1c713937e 100644 --- a/node/Mutex.hpp +++ b/node/Mutex.hpp @@ -28,23 +28,23 @@ namespace ZeroTier { class Mutex { public: - ZT_ALWAYS_INLINE Mutex() { pthread_mutex_init(&_mh,(const pthread_mutexattr_t *)0); } - ZT_ALWAYS_INLINE ~Mutex() { pthread_mutex_destroy(&_mh); } - ZT_ALWAYS_INLINE void lock() const { pthread_mutex_lock(&((const_cast (this))->_mh)); } - ZT_ALWAYS_INLINE void unlock() const { pthread_mutex_unlock(&((const_cast (this))->_mh)); } + inline Mutex() { pthread_mutex_init(&_mh,(const pthread_mutexattr_t *)0); } + inline ~Mutex() { pthread_mutex_destroy(&_mh); } + inline void lock() const { pthread_mutex_lock(&((const_cast (this))->_mh)); } + inline void unlock() const { pthread_mutex_unlock(&((const_cast (this))->_mh)); } class Lock { public: - ZT_ALWAYS_INLINE Lock(Mutex &m) : _m(&m) { m.lock(); } - ZT_ALWAYS_INLINE Lock(const Mutex &m) : _m(const_cast(&m)) { _m->lock(); } - ZT_ALWAYS_INLINE ~Lock() { _m->unlock(); } + inline Lock(Mutex &m) : _m(&m) { m.lock(); } + inline Lock(const Mutex &m) : _m(const_cast(&m)) { _m->lock(); } + inline ~Lock() { _m->unlock(); } private: Mutex *const _m; }; private: - ZT_ALWAYS_INLINE Mutex(const Mutex &) {} + inline Mutex(const Mutex &) {} const Mutex &operator=(const Mutex &) { return *this; } pthread_mutex_t _mh; @@ -65,25 +65,25 @@ namespace ZeroTier { class Mutex { public: - ZT_ALWAYS_INLINE Mutex() { InitializeCriticalSection(&_cs); } - ZT_ALWAYS_INLINE ~Mutex() { DeleteCriticalSection(&_cs); } - ZT_ALWAYS_INLINE void lock() { EnterCriticalSection(&_cs); } - ZT_ALWAYS_INLINE void unlock() { LeaveCriticalSection(&_cs); } - ZT_ALWAYS_INLINE void lock() const { (const_cast (this))->lock(); } - ZT_ALWAYS_INLINE void unlock() const { (const_cast (this))->unlock(); } + inline Mutex() { InitializeCriticalSection(&_cs); } + inline ~Mutex() { DeleteCriticalSection(&_cs); } + inline void lock() { EnterCriticalSection(&_cs); } + inline void unlock() { LeaveCriticalSection(&_cs); } + inline void lock() const { (const_cast (this))->lock(); } + inline void unlock() const { (const_cast (this))->unlock(); } class Lock { public: - ZT_ALWAYS_INLINE Lock(Mutex &m) : _m(&m) { m.lock(); } - ZT_ALWAYS_INLINE Lock(const Mutex &m) : _m(const_cast(&m)) { _m->lock(); } - ZT_ALWAYS_INLINE ~Lock() { _m->unlock(); } + inline Lock(Mutex &m) : _m(&m) { m.lock(); } + inline Lock(const Mutex &m) : _m(const_cast(&m)) { _m->lock(); } + inline ~Lock() { _m->unlock(); } private: Mutex *const _m; }; private: - ZT_ALWAYS_INLINE Mutex(const Mutex &) {} + inline Mutex(const Mutex &) {} const Mutex &operator=(const Mutex &) { return *this; } CRITICAL_SECTION _cs; diff --git a/node/Network.hpp b/node/Network.hpp index 8d0d5bb5f..744ea8066 100644 --- a/node/Network.hpp +++ b/node/Network.hpp @@ -61,7 +61,7 @@ public: /** * Compute primary controller device ID from network ID */ - static ZT_ALWAYS_INLINE Address controllerFor(uint64_t nwid) { return Address(nwid >> 24); } + static inline Address controllerFor(uint64_t nwid) { return Address(nwid >> 24); } /** * Construct a new network @@ -79,14 +79,14 @@ public: ~Network(); - ZT_ALWAYS_INLINE uint64_t id() const { return _id; } - ZT_ALWAYS_INLINE Address controller() const { return Address(_id >> 24); } - ZT_ALWAYS_INLINE bool multicastEnabled() const { return (_config.multicastLimit > 0); } - ZT_ALWAYS_INLINE bool hasConfig() const { return (_config); } - ZT_ALWAYS_INLINE uint64_t lastConfigUpdate() const { return _lastConfigUpdate; } - ZT_ALWAYS_INLINE ZT_VirtualNetworkStatus status() const { return _status(); } - ZT_ALWAYS_INLINE const NetworkConfig &config() const { return _config; } - ZT_ALWAYS_INLINE const MAC &mac() const { return _mac; } + inline uint64_t id() const { return _id; } + inline Address controller() const { return Address(_id >> 24); } + inline bool multicastEnabled() const { return (_config.multicastLimit > 0); } + inline bool hasConfig() const { return (_config); } + inline uint64_t lastConfigUpdate() const { return _lastConfigUpdate; } + inline ZT_VirtualNetworkStatus status() const { return _status(); } + inline const NetworkConfig &config() const { return _config; } + inline const MAC &mac() const { return _mac; } /** * Apply filters to an outgoing packet @@ -158,7 +158,7 @@ public: * @param includeBridgedGroups If true, also check groups we've learned via bridging * @return True if this network endpoint / peer is a member */ - ZT_ALWAYS_INLINE bool subscribedToMulticastGroup(const MulticastGroup &mg,const bool includeBridgedGroups) const + inline bool subscribedToMulticastGroup(const MulticastGroup &mg,const bool includeBridgedGroups) const { Mutex::Lock l(_myMulticastGroups_l); if (std::binary_search(_myMulticastGroups.begin(),_myMulticastGroups.end(),mg)) @@ -174,7 +174,7 @@ public: * @param tPtr Thread pointer to be handed through to any callbacks called as a result of this call * @param mg New multicast group */ - ZT_ALWAYS_INLINE void multicastSubscribe(void *tPtr,const MulticastGroup &mg) + inline void multicastSubscribe(void *tPtr,const MulticastGroup &mg) { Mutex::Lock l(_myMulticastGroups_l); if (!std::binary_search(_myMulticastGroups.begin(),_myMulticastGroups.end(),mg)) { @@ -189,7 +189,7 @@ public: * * @param mg Multicast group */ - ZT_ALWAYS_INLINE void multicastUnsubscribe(const MulticastGroup &mg) + inline void multicastUnsubscribe(const MulticastGroup &mg) { Mutex::Lock l(_myMulticastGroups_l); std::vector::iterator i(std::lower_bound(_myMulticastGroups.begin(),_myMulticastGroups.end(),mg)); @@ -230,12 +230,12 @@ public: /** * Set netconf failure to 'access denied' -- called in IncomingPacket when controller reports this */ - ZT_ALWAYS_INLINE void setAccessDenied() { _netconfFailure = NETCONF_FAILURE_ACCESS_DENIED; } + inline void setAccessDenied() { _netconfFailure = NETCONF_FAILURE_ACCESS_DENIED; } /** * Set netconf failure to 'not found' -- called by IncomingPacket when controller reports this */ - ZT_ALWAYS_INLINE void setNotFound() { _netconfFailure = NETCONF_FAILURE_NOT_FOUND; } + inline void setNotFound() { _netconfFailure = NETCONF_FAILURE_NOT_FOUND; } /** * Determine whether this peer is permitted to communicate on this network @@ -256,7 +256,7 @@ public: * @param mac MAC address * @return ZeroTier address of bridge to this MAC */ - ZT_ALWAYS_INLINE Address findBridgeTo(const MAC &mac) const + inline Address findBridgeTo(const MAC &mac) const { Mutex::Lock _l(_remoteBridgeRoutes_l); const Address *const br = _remoteBridgeRoutes.get(mac); @@ -283,7 +283,7 @@ public: * @param mg Multicast group * @param now Current time */ - ZT_ALWAYS_INLINE void learnBridgedMulticastGroup(void *tPtr,const MulticastGroup &mg,int64_t now) + inline void learnBridgedMulticastGroup(void *tPtr,const MulticastGroup &mg,int64_t now) { Mutex::Lock l(_myMulticastGroups_l); _multicastGroupsBehindMe.set(mg,now); @@ -292,7 +292,7 @@ public: /** * Validate a credential and learn it if it passes certificate and other checks */ - ZT_ALWAYS_INLINE Membership::AddCredentialResult addCredential(void *tPtr,const CertificateOfMembership &com) + inline Membership::AddCredentialResult addCredential(void *tPtr,const CertificateOfMembership &com) { if (com.networkId() != _id) return Membership::ADD_REJECTED; @@ -303,7 +303,7 @@ public: /** * Validate a credential and learn it if it passes certificate and other checks */ - ZT_ALWAYS_INLINE Membership::AddCredentialResult addCredential(void *tPtr,const Capability &cap) + inline Membership::AddCredentialResult addCredential(void *tPtr,const Capability &cap) { if (cap.networkId() != _id) return Membership::ADD_REJECTED; @@ -314,7 +314,7 @@ public: /** * Validate a credential and learn it if it passes certificate and other checks */ - ZT_ALWAYS_INLINE Membership::AddCredentialResult addCredential(void *tPtr,const Tag &tag) + inline Membership::AddCredentialResult addCredential(void *tPtr,const Tag &tag) { if (tag.networkId() != _id) return Membership::ADD_REJECTED; @@ -330,7 +330,7 @@ public: /** * Validate a credential and learn it if it passes certificate and other checks */ - ZT_ALWAYS_INLINE Membership::AddCredentialResult addCredential(void *tPtr,const CertificateOfOwnership &coo) + inline Membership::AddCredentialResult addCredential(void *tPtr,const CertificateOfOwnership &coo) { if (coo.networkId() != _id) return Membership::ADD_REJECTED; @@ -345,7 +345,7 @@ public: * @param to Destination peer address * @param now Current time */ - ZT_ALWAYS_INLINE void pushCredentialsNow(void *tPtr,const Address &to,const int64_t now) + inline void pushCredentialsNow(void *tPtr,const Address &to,const int64_t now) { Mutex::Lock _l(_memberships_l); _memberships[to].pushCredentials(RR,tPtr,now,to,_config); @@ -358,7 +358,7 @@ public: * @param to Destination peer address * @param now Current time */ - ZT_ALWAYS_INLINE void pushCredentialsIfNeeded(void *tPtr,const Address &to,const int64_t now) + inline void pushCredentialsIfNeeded(void *tPtr,const Address &to,const int64_t now) { const int64_t tout = std::min(_config.credentialTimeMaxDelta,(int64_t)ZT_PEER_ACTIVITY_TIMEOUT); Mutex::Lock _l(_memberships_l); @@ -373,7 +373,7 @@ public: * This sets the network to completely remove itself on delete. This also prevents the * call of the normal port shutdown event on delete. */ - ZT_ALWAYS_INLINE void destroy() + inline void destroy() { _memberships_l.lock(); _config_l.lock(); @@ -387,7 +387,7 @@ public: * * @param ec Buffer to fill with externally-visible network configuration */ - ZT_ALWAYS_INLINE void externalConfig(ZT_VirtualNetworkConfig *ec) const + inline void externalConfig(ZT_VirtualNetworkConfig *ec) const { Mutex::Lock _l(_config_l); _externalConfig(ec); @@ -399,7 +399,7 @@ public: * @param f Function of (const Address,const Membership) */ template - ZT_ALWAYS_INLINE void eachMember(F f) + inline void eachMember(F f) { Mutex::Lock ml(_memberships_l); Hashtable::Iterator i(_memberships); @@ -414,7 +414,7 @@ public: /** * @return Externally usable pointer-to-pointer exported via the core API */ - ZT_ALWAYS_INLINE void **userPtr() { return &_uPtr; } + inline void **userPtr() { return &_uPtr; } private: void _requestConfiguration(void *tPtr); @@ -440,7 +440,7 @@ private: struct _IncomingConfigChunk { - ZT_ALWAYS_INLINE _IncomingConfigChunk() : ts(0),updateId(0),haveChunks(0),haveBytes(0),data() {} + inline _IncomingConfigChunk() : ts(0),updateId(0),haveChunks(0),haveBytes(0),data() {} uint64_t ts; uint64_t updateId; uint64_t haveChunkIds[ZT_NETWORK_MAX_UPDATE_CHUNKS]; diff --git a/node/NetworkConfig.hpp b/node/NetworkConfig.hpp index 140efcfc9..8e9acd527 100644 --- a/node/NetworkConfig.hpp +++ b/node/NetworkConfig.hpp @@ -177,7 +177,7 @@ namespace ZeroTier { */ struct NetworkConfig { - ZT_ALWAYS_INLINE NetworkConfig() : + inline NetworkConfig() : networkId(0), timestamp(0), credentialTimeMaxDelta(0), @@ -218,17 +218,17 @@ struct NetworkConfig /** * @return True if broadcast (ff:ff:ff:ff:ff:ff) address should work on this network */ - ZT_ALWAYS_INLINE bool enableBroadcast() const { return ((this->flags & ZT_NETWORKCONFIG_FLAG_ENABLE_BROADCAST) != 0); } + inline bool enableBroadcast() const { return ((this->flags & ZT_NETWORKCONFIG_FLAG_ENABLE_BROADCAST) != 0); } /** * @return True if IPv6 NDP emulation should be allowed for certain "magic" IPv6 address patterns */ - ZT_ALWAYS_INLINE bool ndpEmulation() const { return ((this->flags & ZT_NETWORKCONFIG_FLAG_ENABLE_IPV6_NDP_EMULATION) != 0); } + inline bool ndpEmulation() const { return ((this->flags & ZT_NETWORKCONFIG_FLAG_ENABLE_IPV6_NDP_EMULATION) != 0); } /** * @return True if frames should not be compressed */ - ZT_ALWAYS_INLINE bool disableCompression() const + inline bool disableCompression() const { #ifndef ZT_DISABLE_COMPRESSION return ((this->flags & ZT_NETWORKCONFIG_FLAG_DISABLE_COMPRESSION) != 0); @@ -244,18 +244,18 @@ struct NetworkConfig /** * @return Network type is public (no access control) */ - ZT_ALWAYS_INLINE bool isPublic() const { return (this->type == ZT_NETWORK_TYPE_PUBLIC); } + inline bool isPublic() const { return (this->type == ZT_NETWORK_TYPE_PUBLIC); } /** * @return Network type is private (certificate access control) */ - ZT_ALWAYS_INLINE bool isPrivate() const { return (this->type == ZT_NETWORK_TYPE_PRIVATE); } + inline bool isPrivate() const { return (this->type == ZT_NETWORK_TYPE_PRIVATE); } /** * @param fromPeer Peer attempting to bridge other Ethernet peers onto network * @return True if this network allows bridging */ - ZT_ALWAYS_INLINE bool permitsBridging(const Address &fromPeer) const + inline bool permitsBridging(const Address &fromPeer) const { for(unsigned int i=0;i &peer,const std::vector &addrs) + inline bool operator()(const SharedPtr &peer,const std::vector &addrs) { unsigned int v4SendCount = 0,v6SendCount = 0; peer->ping(tPtr,now,v4SendCount,v6SendCount); @@ -226,7 +226,7 @@ struct _processBackgroundTasks_ping_eachPeer void *tPtr; Hashtable< void *,bool > *roots; - ZT_ALWAYS_INLINE bool operator()(const SharedPtr &peer) + inline bool operator()(const SharedPtr &peer) { if (!roots->contains((void *)peer.ptr())) { unsigned int v4SendCount = 0,v6SendCount = 0; diff --git a/node/Node.hpp b/node/Node.hpp index 16e6824fc..6f6fb99e8 100644 --- a/node/Node.hpp +++ b/node/Node.hpp @@ -111,9 +111,9 @@ public: // Internal functions ------------------------------------------------------ - ZT_ALWAYS_INLINE int64_t now() const { return _now; } + inline int64_t now() const { return _now; } - ZT_ALWAYS_INLINE bool putPacket(void *tPtr,const int64_t localSocket,const InetAddress &addr,const void *data,unsigned int len,unsigned int ttl = 0) + inline bool putPacket(void *tPtr,const int64_t localSocket,const InetAddress &addr,const void *data,unsigned int len,unsigned int ttl = 0) { return (_cb.wirePacketSendFunction( reinterpret_cast(this), @@ -126,7 +126,7 @@ public: ttl) == 0); } - ZT_ALWAYS_INLINE void putFrame(void *tPtr,uint64_t nwid,void **nuptr,const MAC &source,const MAC &dest,unsigned int etherType,unsigned int vlanId,const void *data,unsigned int len) + inline void putFrame(void *tPtr,uint64_t nwid,void **nuptr,const MAC &source,const MAC &dest,unsigned int etherType,unsigned int vlanId,const void *data,unsigned int len) { _cb.virtualNetworkFrameFunction( reinterpret_cast(this), @@ -142,7 +142,7 @@ public: len); } - ZT_ALWAYS_INLINE SharedPtr network(uint64_t nwid) const + inline SharedPtr network(uint64_t nwid) const { Mutex::Lock _l(_networks_m); const SharedPtr *n = _networks.get(nwid); @@ -151,13 +151,13 @@ public: return SharedPtr(); } - ZT_ALWAYS_INLINE bool belongsToNetwork(uint64_t nwid) const + inline bool belongsToNetwork(uint64_t nwid) const { Mutex::Lock _l(_networks_m); return _networks.contains(nwid); } - ZT_ALWAYS_INLINE std::vector< SharedPtr > allNetworks() const + inline std::vector< SharedPtr > allNetworks() const { std::vector< SharedPtr > nw; Mutex::Lock _l(_networks_m); @@ -169,7 +169,7 @@ public: return nw; } - ZT_ALWAYS_INLINE std::vector directPaths() const + inline std::vector directPaths() const { Mutex::Lock _l(_localInterfaceAddresses_m); return _localInterfaceAddresses; @@ -178,16 +178,16 @@ public: void setInterfaceAddresses(const ZT_InterfaceAddress *addrs,unsigned int addrCount); SharedPtr< const Locator > locator(); - ZT_ALWAYS_INLINE void postEvent(void *tPtr,ZT_Event ev,const void *md = (const void *)0) { _cb.eventCallback(reinterpret_cast(this),_uPtr,tPtr,ev,md); } - ZT_ALWAYS_INLINE void configureVirtualNetworkPort(void *tPtr,uint64_t nwid,void **nuptr,ZT_VirtualNetworkConfigOperation op,const ZT_VirtualNetworkConfig *nc) { _cb.virtualNetworkConfigFunction(reinterpret_cast(this),_uPtr,tPtr,nwid,nuptr,op,nc); } - ZT_ALWAYS_INLINE bool online() const { return _online; } - ZT_ALWAYS_INLINE int stateObjectGet(void *const tPtr,ZT_StateObjectType type,const uint64_t id[2],void *const data,const unsigned int maxlen) { return _cb.stateGetFunction(reinterpret_cast(this),_uPtr,tPtr,type,id,data,maxlen); } - ZT_ALWAYS_INLINE void stateObjectPut(void *const tPtr,ZT_StateObjectType type,const uint64_t id[2],const void *const data,const unsigned int len) { _cb.statePutFunction(reinterpret_cast(this),_uPtr,tPtr,type,id,data,(int)len); } - ZT_ALWAYS_INLINE void stateObjectDelete(void *const tPtr,ZT_StateObjectType type,const uint64_t id[2]) { _cb.statePutFunction(reinterpret_cast(this),_uPtr,tPtr,type,id,(const void *)0,-1); } + inline void postEvent(void *tPtr,ZT_Event ev,const void *md = (const void *)0) { _cb.eventCallback(reinterpret_cast(this),_uPtr,tPtr,ev,md); } + inline void configureVirtualNetworkPort(void *tPtr,uint64_t nwid,void **nuptr,ZT_VirtualNetworkConfigOperation op,const ZT_VirtualNetworkConfig *nc) { _cb.virtualNetworkConfigFunction(reinterpret_cast(this),_uPtr,tPtr,nwid,nuptr,op,nc); } + inline bool online() const { return _online; } + inline int stateObjectGet(void *const tPtr,ZT_StateObjectType type,const uint64_t id[2],void *const data,const unsigned int maxlen) { return _cb.stateGetFunction(reinterpret_cast(this),_uPtr,tPtr,type,id,data,maxlen); } + inline void stateObjectPut(void *const tPtr,ZT_StateObjectType type,const uint64_t id[2],const void *const data,const unsigned int len) { _cb.statePutFunction(reinterpret_cast(this),_uPtr,tPtr,type,id,data,(int)len); } + inline void stateObjectDelete(void *const tPtr,ZT_StateObjectType type,const uint64_t id[2]) { _cb.statePutFunction(reinterpret_cast(this),_uPtr,tPtr,type,id,(const void *)0,-1); } bool shouldUsePathForZeroTierTraffic(void *tPtr,const Address &ztaddr,const int64_t localSocket,const InetAddress &remoteAddress); - ZT_ALWAYS_INLINE bool externalPathLookup(void *tPtr,const Address &ztaddr,int family,InetAddress &addr) { return ( (_cb.pathLookupFunction) ? (_cb.pathLookupFunction(reinterpret_cast(this),_uPtr,tPtr,ztaddr.toInt(),family,reinterpret_cast(&addr)) != 0) : false ); } + inline bool externalPathLookup(void *tPtr,const Address &ztaddr,int family,InetAddress &addr) { return ( (_cb.pathLookupFunction) ? (_cb.pathLookupFunction(reinterpret_cast(this),_uPtr,tPtr,ztaddr.toInt(),family,reinterpret_cast(&addr)) != 0) : false ); } ZT_ResultCode setPhysicalPathConfiguration(const struct sockaddr_storage *pathNetwork,const ZT_PhysicalPathConfiguration *pathConfig); - ZT_ALWAYS_INLINE const Identity &identity() const { return _RR.identity; } + inline const Identity &identity() const { return _RR.identity; } /** * Register that we are expecting a reply to a packet ID @@ -198,7 +198,7 @@ public: * * @param packetId Packet ID to expect reply to */ - ZT_ALWAYS_INLINE void expectReplyTo(const uint64_t packetId) + inline void expectReplyTo(const uint64_t packetId) { const unsigned long pid2 = (unsigned long)(packetId >> 32); const unsigned long bucket = (unsigned long)(pid2 & ZT_EXPECTING_REPLIES_BUCKET_MASK1); @@ -215,7 +215,7 @@ public: * @param packetId Packet ID to check * @return True if we're expecting a reply */ - ZT_ALWAYS_INLINE bool expectingReplyTo(const uint64_t packetId) const + inline bool expectingReplyTo(const uint64_t packetId) const { const uint32_t pid2 = (uint32_t)(packetId >> 32); const unsigned long bucket = (unsigned long)(pid2 & ZT_EXPECTING_REPLIES_BUCKET_MASK1); @@ -233,7 +233,7 @@ public: * @param from Source address of packet * @return True if within rate limits */ - ZT_ALWAYS_INLINE bool rateGateIdentityVerification(const int64_t now,const InetAddress &from) + inline bool rateGateIdentityVerification(const int64_t now,const InetAddress &from) { unsigned long iph = from.rateGateHash(); if ((now - _lastIdentityVerification[iph]) >= ZT_IDENTITY_VALIDATION_SOURCE_RATE_LIMIT) { @@ -247,10 +247,10 @@ public: virtual void ncSendRevocation(const Address &destination,const Revocation &rev); virtual void ncSendError(uint64_t nwid,uint64_t requestPacketId,const Address &destination,NetworkController::ErrorCode errorCode); - ZT_ALWAYS_INLINE void setMultipathMode(uint8_t mode) { _multipathMode = mode; } - ZT_ALWAYS_INLINE uint8_t getMultipathMode() { return _multipathMode; } + inline void setMultipathMode(uint8_t mode) { _multipathMode = mode; } + inline uint8_t getMultipathMode() { return _multipathMode; } - ZT_ALWAYS_INLINE bool localControllerHasAuthorized(const int64_t now,const uint64_t nwid,const Address &addr) const + inline bool localControllerHasAuthorized(const int64_t now,const uint64_t nwid,const Address &addr) const { _localControllerAuthorizations_m.lock(); const int64_t *const at = _localControllerAuthorizations.get(_LocalControllerAuth(nwid,addr)); @@ -281,10 +281,10 @@ private: struct _LocalControllerAuth { uint64_t nwid,address; - ZT_ALWAYS_INLINE _LocalControllerAuth(const uint64_t nwid_,const Address &address_) : nwid(nwid_),address(address_.toInt()) {} - ZT_ALWAYS_INLINE unsigned long hashCode() const { return (unsigned long)(nwid ^ address); } - ZT_ALWAYS_INLINE bool operator==(const _LocalControllerAuth &a) const { return ((a.nwid == nwid)&&(a.address == address)); } - ZT_ALWAYS_INLINE bool operator!=(const _LocalControllerAuth &a) const { return ((a.nwid != nwid)||(a.address != address)); } + inline _LocalControllerAuth(const uint64_t nwid_,const Address &address_) : nwid(nwid_),address(address_.toInt()) {} + inline unsigned long hashCode() const { return (unsigned long)(nwid ^ address); } + inline bool operator==(const _LocalControllerAuth &a) const { return ((a.nwid == nwid)&&(a.address == address)); } + inline bool operator!=(const _LocalControllerAuth &a) const { return ((a.nwid != nwid)||(a.address != address)); } }; Hashtable< _LocalControllerAuth,int64_t > _localControllerAuthorizations; Hashtable< uint64_t,SharedPtr > _networks; diff --git a/node/Packet.hpp b/node/Packet.hpp index 40bee5bda..c5301d7a8 100644 --- a/node/Packet.hpp +++ b/node/Packet.hpp @@ -53,7 +53,7 @@ * 8 - 1.1.17 ... 1.2.0 * + Multipart network configurations for large network configs * + Tags and Capabilities - * + ZT_ALWAYS_INLINE push of CertificateOfMembership deprecated + * + inline push of CertificateOfMembership deprecated * 9 - 1.2.0 ... 1.2.14 * 10 - 1.4.0 ... 1.6.0 * + Multipath capability and load balancing @@ -305,14 +305,14 @@ public: class Fragment : public Buffer { public: - ZT_ALWAYS_INLINE Fragment() : + inline Fragment() : Buffer() {} template - ZT_ALWAYS_INLINE Fragment(const Buffer &b) : + inline Fragment(const Buffer &b) : Buffer(b) {} - ZT_ALWAYS_INLINE Fragment(const void *data,unsigned int len) : + inline Fragment(const void *data,unsigned int len) : Buffer(data,len) {} /** @@ -324,7 +324,7 @@ public: * @param fragNo Which fragment (>= 1, since 0 is Packet with end chopped off) * @param fragTotal Total number of fragments (including 0) */ - ZT_ALWAYS_INLINE Fragment(const Packet &p,unsigned int fragStart,unsigned int fragLen,unsigned int fragNo,unsigned int fragTotal) + inline Fragment(const Packet &p,unsigned int fragStart,unsigned int fragLen,unsigned int fragNo,unsigned int fragTotal) { init(p,fragStart,fragLen,fragNo,fragTotal); } @@ -338,7 +338,7 @@ public: * @param fragNo Which fragment (>= 1, since 0 is Packet with end chopped off) * @param fragTotal Total number of fragments (including 0) */ - ZT_ALWAYS_INLINE void init(const Packet &p,unsigned int fragStart,unsigned int fragLen,unsigned int fragNo,unsigned int fragTotal) + inline void init(const Packet &p,unsigned int fragStart,unsigned int fragLen,unsigned int fragNo,unsigned int fragTotal) { if ((fragStart + fragLen) > p.size()) throw ZT_EXCEPTION_OUT_OF_BOUNDS; @@ -359,37 +359,37 @@ public: * * @return Destination ZT address */ - ZT_ALWAYS_INLINE Address destination() const { return Address(field(ZT_PACKET_FRAGMENT_IDX_DEST,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); } + inline Address destination() const { return Address(field(ZT_PACKET_FRAGMENT_IDX_DEST,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); } /** * @return True if fragment is of a valid length */ - ZT_ALWAYS_INLINE bool lengthValid() const { return (size() >= ZT_PACKET_FRAGMENT_IDX_PAYLOAD); } + inline bool lengthValid() const { return (size() >= ZT_PACKET_FRAGMENT_IDX_PAYLOAD); } /** * @return ID of packet this is a fragment of */ - ZT_ALWAYS_INLINE uint64_t packetId() const { return at(ZT_PACKET_FRAGMENT_IDX_PACKET_ID); } + inline uint64_t packetId() const { return at(ZT_PACKET_FRAGMENT_IDX_PACKET_ID); } /** * @return Total number of fragments in packet */ - ZT_ALWAYS_INLINE unsigned int totalFragments() const { return (((unsigned int)((*this)[ZT_PACKET_FRAGMENT_IDX_FRAGMENT_NO]) >> 4) & 0xf); } + inline unsigned int totalFragments() const { return (((unsigned int)((*this)[ZT_PACKET_FRAGMENT_IDX_FRAGMENT_NO]) >> 4) & 0xf); } /** * @return Fragment number of this fragment */ - ZT_ALWAYS_INLINE unsigned int fragmentNumber() const { return ((unsigned int)((*this)[ZT_PACKET_FRAGMENT_IDX_FRAGMENT_NO]) & 0xf); } + inline unsigned int fragmentNumber() const { return ((unsigned int)((*this)[ZT_PACKET_FRAGMENT_IDX_FRAGMENT_NO]) & 0xf); } /** * @return Fragment ZT hop count */ - ZT_ALWAYS_INLINE unsigned int hops() const { return (unsigned int)((*this)[ZT_PACKET_FRAGMENT_IDX_HOPS]); } + inline unsigned int hops() const { return (unsigned int)((*this)[ZT_PACKET_FRAGMENT_IDX_HOPS]); } /** * Increment this packet's hop count */ - ZT_ALWAYS_INLINE unsigned int incrementHops() + inline unsigned int incrementHops() { return (unsigned int)((*this)[ZT_PACKET_FRAGMENT_IDX_HOPS] = (((*this)[ZT_PACKET_FRAGMENT_IDX_HOPS]) + 1)); } @@ -397,12 +397,12 @@ public: /** * @return Length of payload in bytes */ - ZT_ALWAYS_INLINE unsigned int payloadLength() const { return ((size() > ZT_PACKET_FRAGMENT_IDX_PAYLOAD) ? (size() - ZT_PACKET_FRAGMENT_IDX_PAYLOAD) : 0); } + inline unsigned int payloadLength() const { return ((size() > ZT_PACKET_FRAGMENT_IDX_PAYLOAD) ? (size() - ZT_PACKET_FRAGMENT_IDX_PAYLOAD) : 0); } /** * @return Raw packet payload */ - ZT_ALWAYS_INLINE const unsigned char *payload() const { return field(ZT_PACKET_FRAGMENT_IDX_PAYLOAD,size() - ZT_PACKET_FRAGMENT_IDX_PAYLOAD); } + inline const unsigned char *payload() const { return field(ZT_PACKET_FRAGMENT_IDX_PAYLOAD,size() - ZT_PACKET_FRAGMENT_IDX_PAYLOAD); } }; /** @@ -970,12 +970,12 @@ public: }; template - ZT_ALWAYS_INLINE Packet(const Buffer &b) : + inline Packet(const Buffer &b) : Buffer(b) { } - ZT_ALWAYS_INLINE Packet(const void *data,unsigned int len) : + inline Packet(const void *data,unsigned int len) : Buffer(data,len) { } @@ -987,7 +987,7 @@ public: * Use the header access methods (setDestination() and friends) to fill out * the header. Payload should be appended; initial size is header size. */ - ZT_ALWAYS_INLINE Packet() : + inline Packet() : Buffer(ZT_PROTO_MIN_PACKET_LENGTH) { setAt(ZT_PACKET_IDX_IV,Packet::nextPacketId()); @@ -1003,7 +1003,7 @@ public: * @param prototype Prototype packet * @param dest Destination ZeroTier address for new packet */ - ZT_ALWAYS_INLINE Packet(const Packet &prototype,const Address &dest) : + inline Packet(const Packet &prototype,const Address &dest) : Buffer(prototype) { setAt(ZT_PACKET_IDX_IV,Packet::nextPacketId()); @@ -1017,7 +1017,7 @@ public: * @param source Source ZT address * @param v Verb */ - ZT_ALWAYS_INLINE Packet(const Address &dest,const Address &source,const Verb v) : + inline Packet(const Address &dest,const Address &source,const Verb v) : Buffer(ZT_PROTO_MIN_PACKET_LENGTH) { setAt(ZT_PACKET_IDX_IV,Packet::nextPacketId()); @@ -1034,7 +1034,7 @@ public: * @param source Source ZT address * @param v Verb */ - ZT_ALWAYS_INLINE void reset(const Address &dest,const Address &source,const Verb v) + inline void reset(const Address &dest,const Address &source,const Verb v) { setSize(ZT_PROTO_MIN_PACKET_LENGTH); setAt(ZT_PACKET_IDX_IV,Packet::nextPacketId()); @@ -1051,52 +1051,52 @@ public: * technically different but otherwise identical copies of the same * packet. */ - ZT_ALWAYS_INLINE void newInitializationVector() { setAt(ZT_PACKET_IDX_IV,Packet::nextPacketId()); } + inline void newInitializationVector() { setAt(ZT_PACKET_IDX_IV,Packet::nextPacketId()); } /** * Set this packet's destination * * @param dest ZeroTier address of destination */ - ZT_ALWAYS_INLINE void setDestination(const Address &dest) { dest.copyTo(field(ZT_PACKET_IDX_DEST,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); } + inline void setDestination(const Address &dest) { dest.copyTo(field(ZT_PACKET_IDX_DEST,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); } /** * Set this packet's source * * @param source ZeroTier address of source */ - ZT_ALWAYS_INLINE void setSource(const Address &source) { source.copyTo(field(ZT_PACKET_IDX_SOURCE,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); } + inline void setSource(const Address &source) { source.copyTo(field(ZT_PACKET_IDX_SOURCE,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); } /** * Get this packet's destination * * @return Destination ZT address */ - ZT_ALWAYS_INLINE Address destination() const { return Address(field(ZT_PACKET_IDX_DEST,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); } + inline Address destination() const { return Address(field(ZT_PACKET_IDX_DEST,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); } /** * Get this packet's source * * @return Source ZT address */ - ZT_ALWAYS_INLINE Address source() const { return Address(field(ZT_PACKET_IDX_SOURCE,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); } + inline Address source() const { return Address(field(ZT_PACKET_IDX_SOURCE,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); } /** * @return True if packet is of valid length */ - ZT_ALWAYS_INLINE bool lengthValid() const { return (size() >= ZT_PROTO_MIN_PACKET_LENGTH); } + inline bool lengthValid() const { return (size() >= ZT_PROTO_MIN_PACKET_LENGTH); } /** * @return True if packet is fragmented (expect fragments) */ - ZT_ALWAYS_INLINE bool fragmented() const { return (((unsigned char)(*this)[ZT_PACKET_IDX_FLAGS] & ZT_PROTO_FLAG_FRAGMENTED) != 0); } + inline bool fragmented() const { return (((unsigned char)(*this)[ZT_PACKET_IDX_FLAGS] & ZT_PROTO_FLAG_FRAGMENTED) != 0); } /** * Set this packet's fragmented flag * * @param f Fragmented flag value */ - ZT_ALWAYS_INLINE void setFragmented(bool f) + inline void setFragmented(bool f) { if (f) (*this)[ZT_PACKET_IDX_FLAGS] |= (char)ZT_PROTO_FLAG_FRAGMENTED; @@ -1106,17 +1106,17 @@ public: /** * @return True if compressed (result only valid if unencrypted) */ - ZT_ALWAYS_INLINE bool compressed() const { return (((unsigned char)(*this)[ZT_PACKET_IDX_VERB] & ZT_PROTO_VERB_FLAG_COMPRESSED) != 0); } + inline bool compressed() const { return (((unsigned char)(*this)[ZT_PACKET_IDX_VERB] & ZT_PROTO_VERB_FLAG_COMPRESSED) != 0); } /** * @return ZeroTier forwarding hops (0 to 7) */ - ZT_ALWAYS_INLINE unsigned int hops() const { return ((unsigned int)(*this)[ZT_PACKET_IDX_FLAGS] & 0x07); } + inline unsigned int hops() const { return ((unsigned int)(*this)[ZT_PACKET_IDX_FLAGS] & 0x07); } /** * Increment this packet's hop count */ - ZT_ALWAYS_INLINE unsigned char incrementHops() + inline unsigned char incrementHops() { unsigned char &b = (*this)[ZT_PACKET_IDX_FLAGS]; const unsigned char h = (b + 1) & 0x07; @@ -1127,7 +1127,7 @@ public: /** * @return Cipher suite selector: 0 - 7 (see #defines) */ - ZT_ALWAYS_INLINE unsigned int cipher() const + inline unsigned int cipher() const { return (((unsigned int)(*this)[ZT_PACKET_IDX_FLAGS] & 0x38) >> 3); } @@ -1135,7 +1135,7 @@ public: /** * Set this packet's cipher suite */ - ZT_ALWAYS_INLINE void setCipher(unsigned int c) + inline void setCipher(unsigned int c) { unsigned char &b = (*this)[ZT_PACKET_IDX_FLAGS]; b = (b & 0xc7) | (unsigned char)((c << 3) & 0x38); // bits: FFCCCHHH @@ -1146,14 +1146,14 @@ public: * * @return Trusted path ID (from MAC field) */ - ZT_ALWAYS_INLINE uint64_t trustedPathId() const { return at(ZT_PACKET_IDX_MAC); } + inline uint64_t trustedPathId() const { return at(ZT_PACKET_IDX_MAC); } /** * Set this packet's trusted path ID and set the cipher spec to trusted path * * @param tpid Trusted path ID */ - ZT_ALWAYS_INLINE void setTrusted(const uint64_t tpid) + inline void setTrusted(const uint64_t tpid) { setCipher(ZT_PROTO_CIPHER_SUITE__NONE); setAt(ZT_PACKET_IDX_MAC,tpid); @@ -1170,7 +1170,7 @@ public: * * @return Packet ID */ - ZT_ALWAYS_INLINE uint64_t packetId() const { return at(ZT_PACKET_IDX_IV); } + inline uint64_t packetId() const { return at(ZT_PACKET_IDX_IV); } /** * Set packet verb @@ -1180,22 +1180,22 @@ public: * * @param v New packet verb */ - ZT_ALWAYS_INLINE void setVerb(Verb v) { (*this)[ZT_PACKET_IDX_VERB] = (char)v; } + inline void setVerb(Verb v) { (*this)[ZT_PACKET_IDX_VERB] = (char)v; } /** * @return Packet verb (not including flag bits) */ - ZT_ALWAYS_INLINE Verb verb() const { return (Verb)((*this)[ZT_PACKET_IDX_VERB] & 0x1f); } + inline Verb verb() const { return (Verb)((*this)[ZT_PACKET_IDX_VERB] & 0x1f); } /** * @return Length of packet payload */ - ZT_ALWAYS_INLINE unsigned int payloadLength() const { return ((size() < ZT_PROTO_MIN_PACKET_LENGTH) ? 0 : (size() - ZT_PROTO_MIN_PACKET_LENGTH)); } + inline unsigned int payloadLength() const { return ((size() < ZT_PROTO_MIN_PACKET_LENGTH) ? 0 : (size() - ZT_PROTO_MIN_PACKET_LENGTH)); } /** * @return Raw packet payload */ - ZT_ALWAYS_INLINE const unsigned char *payload() const { return field(ZT_PACKET_IDX_PAYLOAD,size() - ZT_PACKET_IDX_PAYLOAD); } + inline const unsigned char *payload() const { return field(ZT_PACKET_IDX_PAYLOAD,size() - ZT_PACKET_IDX_PAYLOAD); } /** * Armor packet for transport @@ -1255,7 +1255,7 @@ private: * @param in Input key (32 bytes) * @param out Output buffer (32 bytes) */ - ZT_ALWAYS_INLINE void _salsa20MangleKey(const unsigned char *in,unsigned char *out) const + inline void _salsa20MangleKey(const unsigned char *in,unsigned char *out) const { const unsigned char *d = (const unsigned char *)data(); diff --git a/node/Path.hpp b/node/Path.hpp index 0ccffe386..06ec917e9 100644 --- a/node/Path.hpp +++ b/node/Path.hpp @@ -52,9 +52,9 @@ public: class HashKey { public: - ZT_ALWAYS_INLINE HashKey() {} + inline HashKey() {} - ZT_ALWAYS_INLINE HashKey(const int64_t l,const InetAddress &r) + inline HashKey(const int64_t l,const InetAddress &r) { if (r.ss_family == AF_INET) { _k[0] = (uint64_t)reinterpret_cast(&r)->sin_addr.s_addr; @@ -69,16 +69,16 @@ public: } } - ZT_ALWAYS_INLINE unsigned long hashCode() const { return (unsigned long)(_k[0] + _k[1] + _k[2]); } + inline unsigned long hashCode() const { return (unsigned long)(_k[0] + _k[1] + _k[2]); } - ZT_ALWAYS_INLINE bool operator==(const HashKey &k) const { return ( (_k[0] == k._k[0]) && (_k[1] == k._k[1]) && (_k[2] == k._k[2]) ); } - ZT_ALWAYS_INLINE bool operator!=(const HashKey &k) const { return (!(*this == k)); } + inline bool operator==(const HashKey &k) const { return ( (_k[0] == k._k[0]) && (_k[1] == k._k[1]) && (_k[2] == k._k[2]) ); } + inline bool operator!=(const HashKey &k) const { return (!(*this == k)); } private: uint64_t _k[3]; }; - ZT_ALWAYS_INLINE Path() : + inline Path() : _lastOut(0), _lastIn(0), _lastPathQualityComputeTime(0), @@ -110,7 +110,7 @@ public: memset(_addrString, 0, sizeof(_addrString)); } - ZT_ALWAYS_INLINE Path(const int64_t localSocket,const InetAddress &addr) : + inline Path(const int64_t localSocket,const InetAddress &addr) : _lastOut(0), _lastIn(0), _lastPathQualityComputeTime(0), @@ -151,7 +151,7 @@ public: * * @param t Time of receive */ - ZT_ALWAYS_INLINE void received(const uint64_t t) { _lastIn = t; } + inline void received(const uint64_t t) { _lastIn = t; } /** * Send a packet via this path (last out time is also updated) @@ -170,14 +170,14 @@ public: * * @param t Time of send */ - ZT_ALWAYS_INLINE void sent(const int64_t t) { _lastOut = t; } + inline void sent(const int64_t t) { _lastOut = t; } /** * Update path latency with a new measurement * * @param l Measured latency */ - ZT_ALWAYS_INLINE void updateLatency(const unsigned int l, int64_t now) + inline void updateLatency(const unsigned int l, int64_t now) { unsigned int pl = _latency; if (pl < 0xffff) { @@ -192,22 +192,22 @@ public: /** * @return Local socket as specified by external code */ - ZT_ALWAYS_INLINE int64_t localSocket() const { return _localSocket; } + inline int64_t localSocket() const { return _localSocket; } /** * @return Physical address */ - ZT_ALWAYS_INLINE const InetAddress &address() const { return _addr; } + inline const InetAddress &address() const { return _addr; } /** * @return IP scope -- faster shortcut for address().ipScope() */ - ZT_ALWAYS_INLINE InetAddress::IpScope ipScope() const { return _ipScope; } + inline InetAddress::IpScope ipScope() const { return _ipScope; } /** * @return Preference rank, higher == better */ - ZT_ALWAYS_INLINE unsigned int preferenceRank() const + inline unsigned int preferenceRank() const { // This causes us to rank paths in order of IP scope rank (see InetAdddress.hpp) but // within each IP scope class to prefer IPv6 over IPv4. @@ -223,7 +223,7 @@ public: * @param a Address to check * @return True if address is good for ZeroTier path use */ - static ZT_ALWAYS_INLINE bool isAddressValidForPath(const InetAddress &a) + static inline bool isAddressValidForPath(const InetAddress &a) { if ((a.ss_family == AF_INET)||(a.ss_family == AF_INET6)) { switch(a.ipScope()) { @@ -257,12 +257,12 @@ public: /** * @return Latency or 0xffff if unknown */ - ZT_ALWAYS_INLINE unsigned int latency() const { return _latency; } + inline unsigned int latency() const { return _latency; } /** * @return Path quality -- lower is better */ - ZT_ALWAYS_INLINE long quality(const int64_t now) const + inline long quality(const int64_t now) const { const long l = (long)_latency; const long age = (long)std::min((long)(now - _lastIn),(long)(ZT_PEER_PING_PERIOD * 10)); // set an upper sanity limit to avoid overflow @@ -277,7 +277,7 @@ public: * @param payloadLength Length of payload * @param verb Packet verb */ - ZT_ALWAYS_INLINE void recordOutgoingPacket(int64_t now, int64_t packetId, uint16_t payloadLength, Packet::Verb verb) + inline void recordOutgoingPacket(int64_t now, int64_t packetId, uint16_t payloadLength, Packet::Verb verb) { Mutex::Lock _l(_statistics_m); if (verb != Packet::VERB_ACK && verb != Packet::VERB_QOS_MEASUREMENT) { @@ -300,7 +300,7 @@ public: * @param payloadLength Length of payload * @param verb Packet verb */ - ZT_ALWAYS_INLINE void recordIncomingPacket(int64_t now, int64_t packetId, uint16_t payloadLength, Packet::Verb verb) + inline void recordIncomingPacket(int64_t now, int64_t packetId, uint16_t payloadLength, Packet::Verb verb) { Mutex::Lock _l(_statistics_m); if (verb != Packet::VERB_ACK && verb != Packet::VERB_QOS_MEASUREMENT) { @@ -320,7 +320,7 @@ public: * @param now Current time * @param ackedBytes Number of bytes acknowledged by other peer */ - ZT_ALWAYS_INLINE void receivedAck(int64_t now, int32_t ackedBytes) + inline void receivedAck(int64_t now, int32_t ackedBytes) { _expectingAckAsOf = 0; _unackedBytes = (ackedBytes > _unackedBytes) ? 0 : _unackedBytes - ackedBytes; @@ -598,17 +598,17 @@ public: /** * @return True if this path is alive (receiving data) */ - ZT_ALWAYS_INLINE bool alive(const int64_t now) const { return ((now - _lastIn) < ((ZT_PEER_PING_PERIOD * 2) + 5000)); } + inline bool alive(const int64_t now) const { return ((now - _lastIn) < ((ZT_PEER_PING_PERIOD * 2) + 5000)); } /** * @return Last time we sent something */ - ZT_ALWAYS_INLINE int64_t lastOut() const { return _lastOut; } + inline int64_t lastOut() const { return _lastOut; } /** * @return Last time we received anything */ - ZT_ALWAYS_INLINE int64_t lastIn() const { return _lastIn; } + inline int64_t lastIn() const { return _lastIn; } private: Mutex _statistics_m; diff --git a/node/Peer.hpp b/node/Peer.hpp index 3f658b555..028f4787d 100644 --- a/node/Peer.hpp +++ b/node/Peer.hpp @@ -60,12 +60,12 @@ public: /** * @return This peer's ZT address (short for identity().address()) */ - ZT_ALWAYS_INLINE const Address &address() const { return _id.address(); } + inline const Address &address() const { return _id.address(); } /** * @return This peer's identity */ - ZT_ALWAYS_INLINE const Identity &identity() const { return _id; } + inline const Identity &identity() const { return _id; } /** * Log receipt of an authenticated packet @@ -100,7 +100,7 @@ public: * @param addr Remote address * @return True if we have an active path to this destination */ - ZT_ALWAYS_INLINE bool hasActivePathTo(int64_t now,const InetAddress &addr) const + inline bool hasActivePathTo(int64_t now,const InetAddress &addr) const { Mutex::Lock _l(_paths_m); for(unsigned int i=0;i bp(getAppropriatePath(now,force)); if (bp) @@ -262,7 +262,7 @@ public: * @param now Current time * @return All known paths to this peer */ - ZT_ALWAYS_INLINE std::vector< SharedPtr > paths(const int64_t now) const + inline std::vector< SharedPtr > paths(const int64_t now) const { std::vector< SharedPtr > pp; Mutex::Lock _l(_paths_m); @@ -276,17 +276,17 @@ public: /** * @return Time of last receive of anything, whether direct or relayed */ - ZT_ALWAYS_INLINE int64_t lastReceive() const { return _lastReceive; } + inline int64_t lastReceive() const { return _lastReceive; } /** * @return True if we've heard from this peer in less than ZT_PEER_ACTIVITY_TIMEOUT */ - ZT_ALWAYS_INLINE bool alive(const int64_t now) const { return ((now - _lastReceive) < ZT_PEER_ACTIVITY_TIMEOUT); } + inline bool alive(const int64_t now) const { return ((now - _lastReceive) < ZT_PEER_ACTIVITY_TIMEOUT); } /** * @return Latency in milliseconds of best/aggregate path or 0xffff if unknown / no paths */ - ZT_ALWAYS_INLINE unsigned int latency(const int64_t now) + inline unsigned int latency(const int64_t now) { if (_canUseMultipath) { return (int)computeAggregateLinkMeanLatency(); @@ -309,7 +309,7 @@ public: * * @return Relay quality score computed from latency and other factors, lower is better */ - ZT_ALWAYS_INLINE unsigned int relayQuality(const int64_t now) + inline unsigned int relayQuality(const int64_t now) { const uint64_t tsr = now - _lastReceive; if (tsr >= ZT_PEER_ACTIVITY_TIMEOUT) @@ -323,7 +323,7 @@ public: /** * @return 256-bit secret symmetric encryption key */ - ZT_ALWAYS_INLINE const unsigned char *key() const { return _key; } + inline const unsigned char *key() const { return _key; } /** * Set the currently known remote version of this peer's client @@ -333,7 +333,7 @@ public: * @param vmin Minor version * @param vrev Revision */ - ZT_ALWAYS_INLINE void setRemoteVersion(unsigned int vproto,unsigned int vmaj,unsigned int vmin,unsigned int vrev) + inline void setRemoteVersion(unsigned int vproto,unsigned int vmaj,unsigned int vmin,unsigned int vrev) { _vProto = (uint16_t)vproto; _vMajor = (uint16_t)vmaj; @@ -341,11 +341,11 @@ public: _vRevision = (uint16_t)vrev; } - ZT_ALWAYS_INLINE unsigned int remoteVersionProtocol() const { return _vProto; } - ZT_ALWAYS_INLINE unsigned int remoteVersionMajor() const { return _vMajor; } - ZT_ALWAYS_INLINE unsigned int remoteVersionMinor() const { return _vMinor; } - ZT_ALWAYS_INLINE unsigned int remoteVersionRevision() const { return _vRevision; } - ZT_ALWAYS_INLINE bool remoteVersionKnown() const { return ((_vMajor > 0)||(_vMinor > 0)||(_vRevision > 0)); } + inline unsigned int remoteVersionProtocol() const { return _vProto; } + inline unsigned int remoteVersionMajor() const { return _vMajor; } + inline unsigned int remoteVersionMinor() const { return _vMinor; } + inline unsigned int remoteVersionRevision() const { return _vRevision; } + inline bool remoteVersionKnown() const { return ((_vMajor > 0)||(_vMinor > 0)||(_vRevision > 0)); } /** * Periodically update known multipath activation constraints. This is done so that we know when and when @@ -360,28 +360,28 @@ public: * or a VERB_QOS_MEASUREMENT packet at some point in the past. Until this flag is set, the local client * shall assume that multipath is not enabled and should only use classical Protocol 9 logic. */ - ZT_ALWAYS_INLINE void inferRemoteMultipathEnabled() { _remotePeerMultipathEnabled = true; } + inline void inferRemoteMultipathEnabled() { _remotePeerMultipathEnabled = true; } /** * @return Whether the local client supports and is configured to use multipath */ - ZT_ALWAYS_INLINE bool localMultipathSupport() { return _localMultipathSupported; } + inline bool localMultipathSupport() { return _localMultipathSupported; } /** * @return Whether the remote peer supports and is configured to use multipath */ - ZT_ALWAYS_INLINE bool remoteMultipathSupport() { return _remoteMultipathSupported; } + inline bool remoteMultipathSupport() { return _remoteMultipathSupported; } /** * @return Whether this client can use multipath to communicate with this peer. True if both peers are using * the correct protocol and if both peers have multipath enabled. False if otherwise. */ - ZT_ALWAYS_INLINE bool canUseMultipath() { return _canUseMultipath; } + inline bool canUseMultipath() { return _canUseMultipath; } /** * Rate limit gate for VERB_PUSH_DIRECT_PATHS */ - ZT_ALWAYS_INLINE bool rateGatePushDirectPaths(const int64_t now) + inline bool rateGatePushDirectPaths(const int64_t now) { if ((now - _lastDirectPathPushReceive) <= ZT_PUSH_DIRECT_PATHS_CUTOFF_TIME) ++_directPathPushCutoffCount; @@ -393,7 +393,7 @@ public: /** * Rate limit gate for VERB_NETWORK_CREDENTIALS */ - ZT_ALWAYS_INLINE bool rateGateCredentialsReceived(const int64_t now) + inline bool rateGateCredentialsReceived(const int64_t now) { if ((now - _lastCredentialsReceived) <= ZT_PEER_CREDENTIALS_CUTOFF_TIME) ++_credentialsCutoffCount; @@ -405,7 +405,7 @@ public: /** * Rate limit gate for sending of ERROR_NEED_MEMBERSHIP_CERTIFICATE */ - ZT_ALWAYS_INLINE bool rateGateRequestCredentials(const int64_t now) + inline bool rateGateRequestCredentials(const int64_t now) { if ((now - _lastCredentialRequestSent) >= ZT_PEER_GENERAL_RATE_LIMIT) { _lastCredentialRequestSent = now; @@ -417,7 +417,7 @@ public: /** * Rate limit gate for inbound WHOIS requests */ - ZT_ALWAYS_INLINE bool rateGateInboundWhoisRequest(const int64_t now) + inline bool rateGateInboundWhoisRequest(const int64_t now) { if ((now - _lastWhoisRequestReceived) >= ZT_PEER_WHOIS_RATE_LIMIT) { _lastWhoisRequestReceived = now; @@ -429,7 +429,7 @@ public: /** * Rate limit gate for inbound ECHO requests */ - ZT_ALWAYS_INLINE bool rateGateEchoRequest(const int64_t now) + inline bool rateGateEchoRequest(const int64_t now) { if ((now - _lastEchoRequestReceived) >= ZT_PEER_GENERAL_RATE_LIMIT) { _lastEchoRequestReceived = now; @@ -441,7 +441,7 @@ public: /** * Rate limit gate for VERB_ACK */ - ZT_ALWAYS_INLINE bool rateGateACK(const int64_t now) + inline bool rateGateACK(const int64_t now) { if ((now - _lastACKWindowReset) >= ZT_PATH_QOS_ACK_CUTOFF_TIME) { _lastACKWindowReset = now; @@ -455,7 +455,7 @@ public: /** * Rate limit gate for VERB_QOS_MEASUREMENT */ - ZT_ALWAYS_INLINE bool rateGateQoS(const int64_t now) + inline bool rateGateQoS(const int64_t now) { if ((now - _lastQoSWindowReset) >= ZT_PATH_QOS_ACK_CUTOFF_TIME) { _lastQoSWindowReset = now; @@ -469,7 +469,7 @@ public: /** * Rate limit gate for trying externally defined or static path */ - ZT_ALWAYS_INLINE bool rateGateTryStaticPath(const int64_t now) + inline bool rateGateTryStaticPath(const int64_t now) { if ((now - _lastTriedStaticPath) >= ZT_PEER_PING_PERIOD) { _lastTriedStaticPath = now; @@ -481,7 +481,7 @@ public: /** * @return Whether this peer is reachable via an aggregate link */ - ZT_ALWAYS_INLINE bool hasAggregateLink() const + inline bool hasAggregateLink() const { return _localMultipathSupported && _remoteMultipathSupported && _remotePeerMultipathEnabled; } @@ -544,7 +544,7 @@ private: // Add a swap() for shared ptr's to peers to speed up peer sorts namespace std { template<> - ZT_ALWAYS_INLINE void swap(ZeroTier::SharedPtr &a,ZeroTier::SharedPtr &b) { a.swap(b); } + inline void swap(ZeroTier::SharedPtr &a,ZeroTier::SharedPtr &b) { a.swap(b); } } #endif diff --git a/node/Poly1305.cpp b/node/Poly1305.cpp index a4f607629..bd71cf2ad 100644 --- a/node/Poly1305.cpp +++ b/node/Poly1305.cpp @@ -74,7 +74,7 @@ typedef struct poly1305_state_internal_t { } poly1305_state_internal_t; #if defined(ZT_NO_TYPE_PUNNING) || (__BYTE_ORDER != __LITTLE_ENDIAN) -static ZT_ALWAYS_INLINE unsigned long long U8TO64(const unsigned char *p) +static inline unsigned long long U8TO64(const unsigned char *p) { return (((unsigned long long)(p[0] & 0xff) ) | @@ -91,7 +91,7 @@ static ZT_ALWAYS_INLINE unsigned long long U8TO64(const unsigned char *p) #endif #if defined(ZT_NO_TYPE_PUNNING) || (__BYTE_ORDER != __LITTLE_ENDIAN) -static ZT_ALWAYS_INLINE void U64TO8(unsigned char *p, unsigned long long v) +static inline void U64TO8(unsigned char *p, unsigned long long v) { p[0] = (v ) & 0xff; p[1] = (v >> 8) & 0xff; @@ -106,7 +106,7 @@ static ZT_ALWAYS_INLINE void U64TO8(unsigned char *p, unsigned long long v) #define U64TO8(p,v) ((*reinterpret_cast(p)) = (v)) #endif -static ZT_ALWAYS_INLINE void poly1305_init(poly1305_context *ctx, const unsigned char key[32]) +static inline void poly1305_init(poly1305_context *ctx, const unsigned char key[32]) { poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx; unsigned long long t0,t1; @@ -132,7 +132,7 @@ static ZT_ALWAYS_INLINE void poly1305_init(poly1305_context *ctx, const unsigned st->final = 0; } -static ZT_ALWAYS_INLINE void poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, size_t bytes) +static inline void poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, size_t bytes) { const unsigned long long hibit = (st->final) ? 0 : ((unsigned long long)1 << 40); /* 1 << 128 */ unsigned long long r0,r1,r2; @@ -183,7 +183,7 @@ static ZT_ALWAYS_INLINE void poly1305_blocks(poly1305_state_internal_t *st, cons st->h[2] = h2; } -static ZT_ALWAYS_INLINE void poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) +static inline void poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) { poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx; unsigned long long h0,h1,h2,c; @@ -274,7 +274,7 @@ typedef struct poly1305_state_internal_t { } poly1305_state_internal_t; /* interpret four 8 bit unsigned integers as a 32 bit unsigned integer in little endian */ -static ZT_ALWAYS_INLINE unsigned long +static inline unsigned long U8TO32(const unsigned char *p) { return (((unsigned long)(p[0] & 0xff) ) | @@ -284,7 +284,7 @@ U8TO32(const unsigned char *p) { } /* store a 32 bit unsigned integer as four 8 bit unsigned integers in little endian */ -static ZT_ALWAYS_INLINE void +static inline void U32TO8(unsigned char *p, unsigned long v) { p[0] = (v ) & 0xff; p[1] = (v >> 8) & 0xff; @@ -292,7 +292,7 @@ U32TO8(unsigned char *p, unsigned long v) { p[3] = (v >> 24) & 0xff; } -static ZT_ALWAYS_INLINE void +static inline void poly1305_init(poly1305_context *ctx, const unsigned char key[32]) { poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx; @@ -320,7 +320,7 @@ poly1305_init(poly1305_context *ctx, const unsigned char key[32]) { st->final = 0; } -static ZT_ALWAYS_INLINE void +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; @@ -379,7 +379,7 @@ poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, size_t by st->h[4] = h4; } -static ZT_ALWAYS_INLINE void +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; @@ -470,7 +470,7 @@ poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) { #endif // MSC/GCC or not -static ZT_ALWAYS_INLINE void poly1305_update(poly1305_context *ctx, const unsigned char *m, size_t bytes) { +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; diff --git a/node/Revocation.hpp b/node/Revocation.hpp index bc7545d31..0371b0ef2 100644 --- a/node/Revocation.hpp +++ b/node/Revocation.hpp @@ -82,16 +82,16 @@ public: { } - ZT_ALWAYS_INLINE uint32_t id() const { return _id; } - ZT_ALWAYS_INLINE uint32_t credentialId() const { return _credentialId; } - ZT_ALWAYS_INLINE uint64_t networkId() const { return _networkId; } - ZT_ALWAYS_INLINE int64_t threshold() const { return _threshold; } - ZT_ALWAYS_INLINE const Address &target() const { return _target; } - ZT_ALWAYS_INLINE const Address &signer() const { return _signedBy; } - ZT_ALWAYS_INLINE Credential::Type type() const { return _type; } - ZT_ALWAYS_INLINE const uint8_t *signature() const { return _signature; } - ZT_ALWAYS_INLINE unsigned int signatureLength() const { return _signatureLength; } - ZT_ALWAYS_INLINE bool fastPropagate() const { return ((_flags & ZT_REVOCATION_FLAG_FAST_PROPAGATE) != 0); } + inline uint32_t id() const { return _id; } + inline uint32_t credentialId() const { return _credentialId; } + inline uint64_t networkId() const { return _networkId; } + inline int64_t threshold() const { return _threshold; } + inline const Address &target() const { return _target; } + inline const Address &signer() const { return _signedBy; } + inline Credential::Type type() const { return _type; } + inline const uint8_t *signature() const { return _signature; } + inline unsigned int signatureLength() const { return _signatureLength; } + inline bool fastPropagate() const { return ((_flags & ZT_REVOCATION_FLAG_FAST_PROPAGATE) != 0); } /** * @param signer Signing identity, must have private key diff --git a/node/RingBuffer.hpp b/node/RingBuffer.hpp index 9a78d10bf..384022c2f 100644 --- a/node/RingBuffer.hpp +++ b/node/RingBuffer.hpp @@ -43,7 +43,7 @@ private: bool wrap; public: - ZT_ALWAYS_INLINE RingBuffer() : + inline RingBuffer() : begin(0), end(0), wrap(false) @@ -54,7 +54,7 @@ public: /** * @return A pointer to the underlying buffer */ - ZT_ALWAYS_INLINE T *get_buf() + inline T *get_buf() { return buf + begin; } @@ -64,7 +64,7 @@ public: * @param n Number of elements to copy in * @return Number of elements we copied in */ - ZT_ALWAYS_INLINE size_t produce(size_t n) + inline size_t produce(size_t n) { n = std::min(n, getFree()); if (n == 0) { @@ -86,14 +86,14 @@ public: * Fast erase, O(1). * Merely reset the buffer pointer, doesn't erase contents */ - ZT_ALWAYS_INLINE void reset() { consume(count()); } + inline void reset() { consume(count()); } /** * adjust buffer index pointer as if we copied data out * @param n Number of elements we copied from the buffer * @return Number of elements actually available from the buffer */ - ZT_ALWAYS_INLINE size_t consume(size_t n) + inline size_t consume(size_t n) { n = std::min(n, count()); if (n == 0) { @@ -115,7 +115,7 @@ public: * @param data Buffer that is to be written to the ring * @param n Number of elements to write to the buffer */ - ZT_ALWAYS_INLINE size_t write(const T * data, size_t n) + inline size_t write(const T * data, size_t n) { n = std::min(n, getFree()); if (n == 0) { @@ -140,7 +140,7 @@ public: * * @param value A single value to be placed in the buffer */ - ZT_ALWAYS_INLINE void push(const T value) + inline void push(const T value) { if (count() == S) { consume(1); @@ -156,14 +156,14 @@ public: /** * @return The most recently pushed element on the buffer */ - ZT_ALWAYS_INLINE T get_most_recent() { return *(buf + end); } + inline T get_most_recent() { return *(buf + end); } /** * @param dest Destination buffer * @param n Size (in terms of number of elements) of the destination buffer * @return Number of elements read from the buffer */ - ZT_ALWAYS_INLINE size_t read(T *dest,size_t n) + inline size_t read(T *dest,size_t n) { n = std::min(n, count()); if (n == 0) { @@ -188,7 +188,7 @@ public: * * @return The number of elements in the buffer */ - ZT_ALWAYS_INLINE size_t count() + inline size_t count() { if (end == begin) { return wrap ? S : 0; @@ -204,12 +204,12 @@ public: /** * @return The number of slots that are unused in the buffer */ - ZT_ALWAYS_INLINE size_t getFree() { return S - count(); } + inline size_t getFree() { return S - count(); } /** * @return The arithmetic mean of the contents of the buffer */ - ZT_ALWAYS_INLINE float mean() + inline float mean() { size_t iterator = begin; float subtotal = 0; @@ -224,7 +224,7 @@ public: /** * @return The arithmetic mean of the most recent 'n' elements of the buffer */ - ZT_ALWAYS_INLINE float mean(size_t n) + inline float mean(size_t n) { n = n < S ? n : S; size_t iterator = begin; @@ -240,12 +240,12 @@ public: /** * @return The sample standard deviation of element values */ - ZT_ALWAYS_INLINE float stddev() { return sqrt(variance()); } + inline float stddev() { return sqrt(variance()); } /** * @return The variance of element values */ - ZT_ALWAYS_INLINE float variance() + inline float variance() { size_t iterator = begin; float cached_mean = mean(); @@ -263,7 +263,7 @@ public: /** * @return The number of elements of zero value */ - ZT_ALWAYS_INLINE size_t zeroCount() + inline size_t zeroCount() { size_t iterator = begin; size_t zeros = 0; @@ -281,7 +281,7 @@ public: * @param value Value to match against in buffer * @return The number of values held in the ring buffer which match a given value */ - ZT_ALWAYS_INLINE size_t countValue(T value) + inline size_t countValue(T value) { size_t iterator = begin; size_t cnt = 0; diff --git a/node/RuntimeEnvironment.hpp b/node/RuntimeEnvironment.hpp index a863c8197..038c37c5a 100644 --- a/node/RuntimeEnvironment.hpp +++ b/node/RuntimeEnvironment.hpp @@ -36,7 +36,7 @@ class Trace; class RuntimeEnvironment { public: - ZT_ALWAYS_INLINE RuntimeEnvironment(Node *n) : + inline RuntimeEnvironment(Node *n) : node(n) ,localNetworkController((NetworkController *)0) ,rtmem((void *)0) @@ -48,7 +48,7 @@ public: secretIdentityStr[0] = (char)0; } - ZT_ALWAYS_INLINE ~RuntimeEnvironment() { Utils::burn(secretIdentityStr,sizeof(secretIdentityStr)); } + inline ~RuntimeEnvironment() { Utils::burn(secretIdentityStr,sizeof(secretIdentityStr)); } // Node instance that owns this RuntimeEnvironment Node *const node; diff --git a/node/SHA512.cpp b/node/SHA512.cpp index d60eacec1..f8af9ebb3 100644 --- a/node/SHA512.cpp +++ b/node/SHA512.cpp @@ -69,7 +69,7 @@ static const uint64_t K[80] = { #define Gamma0(x) (S(x, 1) ^ S(x, 8) ^ R(x, 7)) #define Gamma1(x) (S(x, 19) ^ S(x, 61) ^ R(x, 6)) -static ZT_ALWAYS_INLINE void sha512_compress(sha512_state *const md,uint8_t *const buf) +static inline void sha512_compress(sha512_state *const md,uint8_t *const buf) { uint64_t S[8], W[80], t0, t1; int i; @@ -102,7 +102,7 @@ static ZT_ALWAYS_INLINE void sha512_compress(sha512_state *const md,uint8_t *con md->state[i] = md->state[i] + S[i]; } -static ZT_ALWAYS_INLINE void sha384_init(sha512_state *const md) +static inline void sha384_init(sha512_state *const md) { md->curlen = 0; md->length = 0; @@ -116,7 +116,7 @@ static ZT_ALWAYS_INLINE void sha384_init(sha512_state *const md) md->state[7] = 0x47b5481dbefa4fa4ULL; } -static ZT_ALWAYS_INLINE void sha512_init(sha512_state *const md) +static inline void sha512_init(sha512_state *const md) { md->curlen = 0; md->length = 0; @@ -130,7 +130,7 @@ static ZT_ALWAYS_INLINE void sha512_init(sha512_state *const md) md->state[7] = 0x5be0cd19137e2179ULL; } -static ZT_ALWAYS_INLINE void sha512_process(sha512_state *const md,const uint8_t *in,unsigned long inlen) +static inline void sha512_process(sha512_state *const md,const uint8_t *in,unsigned long inlen) { while (inlen > 0) { if (md->curlen == 0 && inlen >= 128) { @@ -153,7 +153,7 @@ static ZT_ALWAYS_INLINE void sha512_process(sha512_state *const md,const uint8_t } } -static ZT_ALWAYS_INLINE void sha512_done(sha512_state *const md,uint8_t *out) +static inline void sha512_done(sha512_state *const md,uint8_t *out) { int i; diff --git a/node/SHA512.hpp b/node/SHA512.hpp index 4ecc00fc5..1db7ed8a8 100644 --- a/node/SHA512.hpp +++ b/node/SHA512.hpp @@ -42,21 +42,21 @@ namespace ZeroTier { #ifdef __APPLE__ #define ZT_HAVE_NATIVE_SHA512 1 -static ZT_ALWAYS_INLINE void SHA512(void *digest,const void *data,unsigned int len) +static inline void SHA512(void *digest,const void *data,unsigned int len) { CC_SHA512_CTX ctx; CC_SHA512_Init(&ctx); CC_SHA512_Update(&ctx,data,len); CC_SHA512_Final(reinterpret_cast(digest),&ctx); } -static ZT_ALWAYS_INLINE void SHA384(void *digest,const void *data,unsigned int len) +static inline void SHA384(void *digest,const void *data,unsigned int len) { CC_SHA512_CTX ctx; CC_SHA384_Init(&ctx); CC_SHA384_Update(&ctx,data,len); CC_SHA384_Final(reinterpret_cast(digest),&ctx); } -static ZT_ALWAYS_INLINE void SHA384(void *digest,const void *data0,unsigned int len0,const void *data1,unsigned int len1) +static inline void SHA384(void *digest,const void *data0,unsigned int len0,const void *data1,unsigned int len1) { CC_SHA512_CTX ctx; CC_SHA384_Init(&ctx); @@ -69,21 +69,21 @@ static ZT_ALWAYS_INLINE void SHA384(void *digest,const void *data0,unsigned int #ifndef ZT_HAVE_NATIVE_SHA512 #ifdef ZT_USE_LIBCRYPTO #define ZT_HAVE_NATIVE_SHA512 1 -static ZT_ALWAYS_INLINE void SHA512(void *digest,const void *data,unsigned int len) +static inline void SHA512(void *digest,const void *data,unsigned int len) { SHA512_CTX ctx; SHA512_Init(&ctx); SHA512_Update(&ctx,data,len); SHA512_Final(reinterpret_cast(digest),&ctx); } -static ZT_ALWAYS_INLINE void SHA384(void *digest,const void *data,unsigned int len) +static inline void SHA384(void *digest,const void *data,unsigned int len) { SHA512_CTX ctx; SHA384_Init(&ctx); SHA384_Update(&ctx,data,len); SHA384_Final(reinterpret_cast(digest),&ctx); } -static ZT_ALWAYS_INLINE void SHA384(void *digest,const void *data0,unsigned int len0,const void *data1,unsigned int len1) +static inline void SHA384(void *digest,const void *data0,unsigned int len0,const void *data1,unsigned int len1) { SHA512_CTX ctx; SHA384_Init(&ctx); diff --git a/node/Salsa20.hpp b/node/Salsa20.hpp index 3b27187f7..bedfba770 100644 --- a/node/Salsa20.hpp +++ b/node/Salsa20.hpp @@ -30,14 +30,14 @@ namespace ZeroTier { class Salsa20 { public: - ZT_ALWAYS_INLINE Salsa20() {} - ZT_ALWAYS_INLINE ~Salsa20() { Utils::burn(&_state,sizeof(_state)); } + inline Salsa20() {} + inline ~Salsa20() { Utils::burn(&_state,sizeof(_state)); } /** * @param key 256-bit (32 byte) key * @param iv 64-bit initialization vector */ - ZT_ALWAYS_INLINE Salsa20(const void *key,const void *iv) { init(key,iv); } + inline Salsa20(const void *key,const void *iv) { init(key,iv); } /** * Initialize cipher diff --git a/node/ScopedPtr.hpp b/node/ScopedPtr.hpp index 5fa97729a..189a465ac 100644 --- a/node/ScopedPtr.hpp +++ b/node/ScopedPtr.hpp @@ -27,21 +27,21 @@ template class ScopedPtr { public: - ZT_ALWAYS_INLINE ScopedPtr(T *const p) : _p(p) {} - ZT_ALWAYS_INLINE ~ScopedPtr() { delete _p; } + inline ScopedPtr(T *const p) : _p(p) {} + inline ~ScopedPtr() { delete _p; } - ZT_ALWAYS_INLINE T *operator->() const { return _p; } - ZT_ALWAYS_INLINE T &operator*() const { return *_p; } - ZT_ALWAYS_INLINE operator bool() const { return (_p != (T *)0); } - ZT_ALWAYS_INLINE T *ptr() const { return _p; } + inline T *operator->() const { return _p; } + inline T &operator*() const { return *_p; } + inline operator bool() const { return (_p != (T *)0); } + inline T *ptr() const { return _p; } - ZT_ALWAYS_INLINE bool operator==(const ScopedPtr &p) const { return (_p == p._p); } - ZT_ALWAYS_INLINE bool operator!=(const ScopedPtr &p) const { return (_p != p._p); } - ZT_ALWAYS_INLINE bool operator==(T *const p) const { return (_p == p); } - ZT_ALWAYS_INLINE bool operator!=(T *const p) const { return (_p != p); } + inline bool operator==(const ScopedPtr &p) const { return (_p == p._p); } + inline bool operator!=(const ScopedPtr &p) const { return (_p != p._p); } + inline bool operator==(T *const p) const { return (_p == p); } + inline bool operator!=(T *const p) const { return (_p != p); } private: - ZT_ALWAYS_INLINE ScopedPtr() {} + inline ScopedPtr() {} T *const _p; }; diff --git a/node/SelfAwareness.cpp b/node/SelfAwareness.cpp index 4e91a3ba6..57ce7fde3 100644 --- a/node/SelfAwareness.cpp +++ b/node/SelfAwareness.cpp @@ -36,13 +36,13 @@ namespace ZeroTier { class _ResetWithinScope { public: - ZT_ALWAYS_INLINE _ResetWithinScope(void *tPtr,int64_t now,int inetAddressFamily,InetAddress::IpScope scope) : + inline _ResetWithinScope(void *tPtr,int64_t now,int inetAddressFamily,InetAddress::IpScope scope) : _now(now), _tPtr(tPtr), _family(inetAddressFamily), _scope(scope) {} - ZT_ALWAYS_INLINE bool operator()(const SharedPtr &p) + inline bool operator()(const SharedPtr &p) { p->resetWithinScope(_tPtr,_scope,_family,_now); return true; diff --git a/node/SelfAwareness.hpp b/node/SelfAwareness.hpp index 882cef07e..f76bcc719 100644 --- a/node/SelfAwareness.hpp +++ b/node/SelfAwareness.hpp @@ -59,13 +59,13 @@ private: InetAddress reporterPhysicalAddress; InetAddress::IpScope scope; - ZT_ALWAYS_INLINE PhySurfaceKey() : reporter(),scope(InetAddress::IP_SCOPE_NONE) {} - ZT_ALWAYS_INLINE PhySurfaceKey(const Address &r,const int64_t rol,const InetAddress &ra,InetAddress::IpScope s) : reporter(r),receivedOnLocalSocket(rol),reporterPhysicalAddress(ra),scope(s) {} + inline PhySurfaceKey() : reporter(),scope(InetAddress::IP_SCOPE_NONE) {} + inline PhySurfaceKey(const Address &r,const int64_t rol,const InetAddress &ra,InetAddress::IpScope s) : reporter(r),receivedOnLocalSocket(rol),reporterPhysicalAddress(ra),scope(s) {} - ZT_ALWAYS_INLINE unsigned long hashCode() const { return ((unsigned long)reporter.toInt() + (unsigned long)scope); } + inline unsigned long hashCode() const { return ((unsigned long)reporter.toInt() + (unsigned long)scope); } - ZT_ALWAYS_INLINE bool operator==(const PhySurfaceKey &k) const { return ((reporter == k.reporter)&&(receivedOnLocalSocket == k.receivedOnLocalSocket)&&(reporterPhysicalAddress == k.reporterPhysicalAddress)&&(scope == k.scope)); } - ZT_ALWAYS_INLINE bool operator!=(const PhySurfaceKey &k) const { return (!(*this == k)); } + inline bool operator==(const PhySurfaceKey &k) const { return ((reporter == k.reporter)&&(receivedOnLocalSocket == k.receivedOnLocalSocket)&&(reporterPhysicalAddress == k.reporterPhysicalAddress)&&(scope == k.scope)); } + inline bool operator!=(const PhySurfaceKey &k) const { return (!(*this == k)); } }; struct PhySurfaceEntry { @@ -73,8 +73,8 @@ private: uint64_t ts; bool trusted; - ZT_ALWAYS_INLINE PhySurfaceEntry() : mySurface(),ts(0),trusted(false) {} - ZT_ALWAYS_INLINE PhySurfaceEntry(const InetAddress &a,const uint64_t t) : mySurface(a),ts(t),trusted(false) {} + inline PhySurfaceEntry() : mySurface(),ts(0),trusted(false) {} + inline PhySurfaceEntry(const InetAddress &a,const uint64_t t) : mySurface(a),ts(t),trusted(false) {} }; const RuntimeEnvironment *RR; diff --git a/node/SharedPtr.hpp b/node/SharedPtr.hpp index 2c83ec997..251a0648d 100644 --- a/node/SharedPtr.hpp +++ b/node/SharedPtr.hpp @@ -30,11 +30,11 @@ template class SharedPtr { public: - ZT_ALWAYS_INLINE SharedPtr() : _ptr((T *)0) {} - ZT_ALWAYS_INLINE SharedPtr(T *obj) : _ptr(obj) { ++obj->__refCount; } - ZT_ALWAYS_INLINE SharedPtr(const SharedPtr &sp) : _ptr(sp._getAndInc()) {} + inline SharedPtr() : _ptr((T *)0) {} + inline SharedPtr(T *obj) : _ptr(obj) { ++obj->__refCount; } + inline SharedPtr(const SharedPtr &sp) : _ptr(sp._getAndInc()) {} - ZT_ALWAYS_INLINE ~SharedPtr() + inline ~SharedPtr() { if (_ptr) { if (--_ptr->__refCount <= 0) @@ -42,7 +42,7 @@ public: } } - ZT_ALWAYS_INLINE SharedPtr &operator=(const SharedPtr &sp) + inline SharedPtr &operator=(const SharedPtr &sp) { if (_ptr != sp._ptr) { T *p = sp._getAndInc(); @@ -63,7 +63,7 @@ public: * * @param ptr Naked pointer to assign */ - ZT_ALWAYS_INLINE void set(T *ptr) + inline void set(T *ptr) { zero(); ++ptr->__refCount; @@ -75,26 +75,26 @@ public: * * @param with Pointer to swap with */ - ZT_ALWAYS_INLINE void swap(SharedPtr &with) + inline void swap(SharedPtr &with) { T *tmp = _ptr; _ptr = with._ptr; with._ptr = tmp; } - ZT_ALWAYS_INLINE operator bool() const { return (_ptr != (T *)0); } - ZT_ALWAYS_INLINE T &operator*() const { return *_ptr; } - ZT_ALWAYS_INLINE T *operator->() const { return _ptr; } + inline operator bool() const { return (_ptr != (T *)0); } + inline T &operator*() const { return *_ptr; } + inline T *operator->() const { return _ptr; } /** * @return Raw pointer to held object */ - ZT_ALWAYS_INLINE T *ptr() const { return _ptr; } + inline T *ptr() const { return _ptr; } /** * Set this pointer to NULL */ - ZT_ALWAYS_INLINE void zero() + inline void zero() { if (_ptr) { if (--_ptr->__refCount <= 0) @@ -106,22 +106,22 @@ public: /** * @return Number of references according to this object's ref count or 0 if NULL */ - ZT_ALWAYS_INLINE int references() + inline int references() { if (_ptr) return _ptr->__refCount.load(); return 0; } - ZT_ALWAYS_INLINE bool operator==(const SharedPtr &sp) const { return (_ptr == sp._ptr); } - ZT_ALWAYS_INLINE bool operator!=(const SharedPtr &sp) const { return (_ptr != sp._ptr); } - ZT_ALWAYS_INLINE bool operator>(const SharedPtr &sp) const { return (_ptr > sp._ptr); } - ZT_ALWAYS_INLINE bool operator<(const SharedPtr &sp) const { return (_ptr < sp._ptr); } - ZT_ALWAYS_INLINE bool operator>=(const SharedPtr &sp) const { return (_ptr >= sp._ptr); } - ZT_ALWAYS_INLINE bool operator<=(const SharedPtr &sp) const { return (_ptr <= sp._ptr); } + inline bool operator==(const SharedPtr &sp) const { return (_ptr == sp._ptr); } + inline bool operator!=(const SharedPtr &sp) const { return (_ptr != sp._ptr); } + inline bool operator>(const SharedPtr &sp) const { return (_ptr > sp._ptr); } + inline bool operator<(const SharedPtr &sp) const { return (_ptr < sp._ptr); } + inline bool operator>=(const SharedPtr &sp) const { return (_ptr >= sp._ptr); } + inline bool operator<=(const SharedPtr &sp) const { return (_ptr <= sp._ptr); } private: - ZT_ALWAYS_INLINE T *_getAndInc() const + inline T *_getAndInc() const { if (_ptr) ++_ptr->__refCount; diff --git a/node/Str.hpp b/node/Str.hpp index f2f72c860..9870fecac 100644 --- a/node/Str.hpp +++ b/node/Str.hpp @@ -35,36 +35,36 @@ public: typedef char * iterator; typedef const char * const_iterator; - ZT_ALWAYS_INLINE Str() { _l = 0; _s[0] = 0; } - ZT_ALWAYS_INLINE Str(const Str &s) + inline Str() { _l = 0; _s[0] = 0; } + inline Str(const Str &s) { _l = s._l; memcpy(_s,s._s,_l+1); } - ZT_ALWAYS_INLINE Str(const char *s) + inline Str(const char *s) { _l = 0; _s[0] = 0; (*this) << s; } - ZT_ALWAYS_INLINE Str(const std::string &s) + inline Str(const std::string &s) { *this = s; } - ZT_ALWAYS_INLINE Str &operator=(const Str &s) + inline Str &operator=(const Str &s) { _l = s._l; memcpy(_s,s._s,_l+1); return *this; } - ZT_ALWAYS_INLINE Str &operator=(const char *s) + inline Str &operator=(const char *s) { _l = 0; _s[0] = 0; return ((*this) << s); } - ZT_ALWAYS_INLINE Str &operator=(const std::string &s) + inline Str &operator=(const std::string &s) { if (s.length() > ZT_STR_CAPACITY) { _l = 0; @@ -78,23 +78,23 @@ public: return *this; } - ZT_ALWAYS_INLINE char operator[](const unsigned int i) const + inline char operator[](const unsigned int i) const { if (unlikely(i >= (unsigned int)_l)) throw ZT_EXCEPTION_OUT_OF_BOUNDS; return _s[i]; } - ZT_ALWAYS_INLINE void clear() { _l = 0; _s[0] = 0; } - ZT_ALWAYS_INLINE const char *c_str() const { return _s; } - ZT_ALWAYS_INLINE unsigned int length() const { return (unsigned int)_l; } - ZT_ALWAYS_INLINE bool empty() const { return (_l == 0); } - ZT_ALWAYS_INLINE iterator begin() { return (iterator)_s; } - ZT_ALWAYS_INLINE iterator end() { return (iterator)(_s + (unsigned long)_l); } - ZT_ALWAYS_INLINE const_iterator begin() const { return (const_iterator)_s; } - ZT_ALWAYS_INLINE const_iterator end() const { return (const_iterator)(_s + (unsigned long)_l); } + inline void clear() { _l = 0; _s[0] = 0; } + inline const char *c_str() const { return _s; } + inline unsigned int length() const { return (unsigned int)_l; } + inline bool empty() const { return (_l == 0); } + inline iterator begin() { return (iterator)_s; } + inline iterator end() { return (iterator)(_s + (unsigned long)_l); } + inline const_iterator begin() const { return (const_iterator)_s; } + inline const_iterator end() const { return (const_iterator)(_s + (unsigned long)_l); } - ZT_ALWAYS_INLINE Str &operator<<(const char *s) + inline Str &operator<<(const char *s) { if (likely(s != (const char *)0)) { unsigned long l = _l; @@ -111,8 +111,8 @@ public: } return *this; } - ZT_ALWAYS_INLINE Str &operator<<(const Str &s) { return ((*this) << s._s); } - ZT_ALWAYS_INLINE Str &operator<<(const char c) + inline Str &operator<<(const Str &s) { return ((*this) << s._s); } + inline Str &operator<<(const char c) { if (unlikely(_l >= ZT_STR_CAPACITY)) { _s[ZT_STR_CAPACITY] = 0; @@ -122,35 +122,35 @@ public: _s[(unsigned long)_l] = 0; return *this; } - ZT_ALWAYS_INLINE Str &operator<<(const unsigned long n) + inline Str &operator<<(const unsigned long n) { char tmp[32]; Utils::decimal(n,tmp); return ((*this) << tmp); } - ZT_ALWAYS_INLINE Str &operator<<(const unsigned int n) + inline Str &operator<<(const unsigned int n) { char tmp[32]; Utils::decimal((unsigned long)n,tmp); return ((*this) << tmp); } - ZT_ALWAYS_INLINE Str &operator<<(const Address &a) + inline Str &operator<<(const Address &a) { char tmp[32]; return ((*this) << a.toString(tmp)); } - ZT_ALWAYS_INLINE Str &operator<<(const InetAddress &a) + inline Str &operator<<(const InetAddress &a) { char tmp[128]; return ((*this) << a.toString(tmp)); } - ZT_ALWAYS_INLINE Str &operator<<(const MAC &a) + inline Str &operator<<(const MAC &a) { char tmp[64]; return ((*this) << a.toString(tmp)); } - ZT_ALWAYS_INLINE Str &append(const char *s,const unsigned int max) + inline Str &append(const char *s,const unsigned int max) { if (likely(s != (const char *)0)) { unsigned long l = _l; @@ -171,23 +171,23 @@ public: return *this; } - ZT_ALWAYS_INLINE operator bool() const { return (_l != 0); } + inline operator bool() const { return (_l != 0); } - ZT_ALWAYS_INLINE bool operator==(const Str &s) const { return ((_l == s._l)&&(memcmp(_s,s._s,_l) == 0)); } - ZT_ALWAYS_INLINE bool operator!=(const Str &s) const { return ((_l != s._l)||(memcmp(_s,s._s,_l) != 0)); } - ZT_ALWAYS_INLINE bool operator<(const Str &s) const { return ( (_l < s._l) ? true : ((_l == s._l) ? (memcmp(_s,s._s,_l) < 0) : false) ); } - ZT_ALWAYS_INLINE bool operator>(const Str &s) const { return (s < *this); } - ZT_ALWAYS_INLINE bool operator<=(const Str &s) const { return !(s < *this); } - ZT_ALWAYS_INLINE bool operator>=(const Str &s) const { return !(*this < s); } + inline bool operator==(const Str &s) const { return ((_l == s._l)&&(memcmp(_s,s._s,_l) == 0)); } + inline bool operator!=(const Str &s) const { return ((_l != s._l)||(memcmp(_s,s._s,_l) != 0)); } + inline bool operator<(const Str &s) const { return ( (_l < s._l) ? true : ((_l == s._l) ? (memcmp(_s,s._s,_l) < 0) : false) ); } + inline bool operator>(const Str &s) const { return (s < *this); } + inline bool operator<=(const Str &s) const { return !(s < *this); } + inline bool operator>=(const Str &s) const { return !(*this < s); } - ZT_ALWAYS_INLINE bool operator==(const char *s) const { return (strcmp(_s,s) == 0); } - ZT_ALWAYS_INLINE bool operator!=(const char *s) const { return (strcmp(_s,s) != 0); } - ZT_ALWAYS_INLINE bool operator<(const char *s) const { return (strcmp(_s,s) < 0); } - ZT_ALWAYS_INLINE bool operator>(const char *s) const { return (strcmp(_s,s) > 0); } - ZT_ALWAYS_INLINE bool operator<=(const char *s) const { return (strcmp(_s,s) <= 0); } - ZT_ALWAYS_INLINE bool operator>=(const char *s) const { return (strcmp(_s,s) >= 0); } + inline bool operator==(const char *s) const { return (strcmp(_s,s) == 0); } + inline bool operator!=(const char *s) const { return (strcmp(_s,s) != 0); } + inline bool operator<(const char *s) const { return (strcmp(_s,s) < 0); } + inline bool operator>(const char *s) const { return (strcmp(_s,s) > 0); } + inline bool operator<=(const char *s) const { return (strcmp(_s,s) <= 0); } + inline bool operator>=(const char *s) const { return (strcmp(_s,s) >= 0); } - ZT_ALWAYS_INLINE unsigned long hashCode() const + inline unsigned long hashCode() const { const char *p = _s; unsigned long h = 0; diff --git a/node/Switch.hpp b/node/Switch.hpp index 66ea340d8..7d7278635 100644 --- a/node/Switch.hpp +++ b/node/Switch.hpp @@ -225,7 +225,7 @@ private: AtomicCounter _rxQueuePtr; // Returns matching or next available RX queue entry - ZT_ALWAYS_INLINE RXQueueEntry *_findRXQueueEntry(uint64_t packetId) + inline RXQueueEntry *_findRXQueueEntry(uint64_t packetId) { const unsigned int current = static_cast(_rxQueuePtr.load()); for(unsigned int k=1;k<=ZT_RX_QUEUE_SIZE;++k) { @@ -238,7 +238,7 @@ private: } // Returns current entry in rx queue ring buffer and increments ring pointer - ZT_ALWAYS_INLINE RXQueueEntry *_nextRXQueueEntry() + inline RXQueueEntry *_nextRXQueueEntry() { return &(_rxQueue[static_cast((++_rxQueuePtr) - 1) % ZT_RX_QUEUE_SIZE]); } @@ -276,9 +276,9 @@ private: y = a2.toInt(); } } - ZT_ALWAYS_INLINE unsigned long hashCode() const { return ((unsigned long)x ^ (unsigned long)y); } - ZT_ALWAYS_INLINE bool operator==(const _LastUniteKey &k) const { return ((x == k.x)&&(y == k.y)); } - ZT_ALWAYS_INLINE bool operator!=(const _LastUniteKey &k) const { return ((x != k.x)||(y != k.y)); } + inline unsigned long hashCode() const { return ((unsigned long)x ^ (unsigned long)y); } + inline bool operator==(const _LastUniteKey &k) const { return ((x == k.x)&&(y == k.y)); } + inline bool operator!=(const _LastUniteKey &k) const { return ((x != k.x)||(y != k.y)); } uint64_t x,y; }; Hashtable< _LastUniteKey,uint64_t > _lastUniteAttempt; // key is always sorted in ascending order, for set-like behavior diff --git a/node/Tag.hpp b/node/Tag.hpp index 50f787f43..e0405a76d 100644 --- a/node/Tag.hpp +++ b/node/Tag.hpp @@ -52,9 +52,9 @@ class Tag : public Credential friend class Credential; public: - static ZT_ALWAYS_INLINE Credential::Type credentialType() { return Credential::CREDENTIAL_TYPE_TAG; } + static inline Credential::Type credentialType() { return Credential::CREDENTIAL_TYPE_TAG; } - ZT_ALWAYS_INLINE Tag() : + inline Tag() : _id(0), _value(0), _networkId(0), @@ -70,7 +70,7 @@ public: * @param id Tag ID * @param value Tag value */ - ZT_ALWAYS_INLINE Tag(const uint64_t nwid,const int64_t ts,const Address &issuedTo,const uint32_t id,const uint32_t value) : + inline Tag(const uint64_t nwid,const int64_t ts,const Address &issuedTo,const uint32_t id,const uint32_t value) : _id(id), _value(value), _networkId(nwid), @@ -81,14 +81,14 @@ public: { } - ZT_ALWAYS_INLINE uint32_t id() const { return _id; } - ZT_ALWAYS_INLINE const uint32_t &value() const { return _value; } - ZT_ALWAYS_INLINE uint64_t networkId() const { return _networkId; } - ZT_ALWAYS_INLINE int64_t timestamp() const { return _ts; } - ZT_ALWAYS_INLINE const Address &issuedTo() const { return _issuedTo; } - ZT_ALWAYS_INLINE const Address &signer() const { return _signedBy; } - ZT_ALWAYS_INLINE const uint8_t *signature() const { return _signature; } - ZT_ALWAYS_INLINE unsigned int signatureLength() const { return _signatureLength; } + inline uint32_t id() const { return _id; } + inline const uint32_t &value() const { return _value; } + inline uint64_t networkId() const { return _networkId; } + inline int64_t timestamp() const { return _ts; } + inline const Address &issuedTo() const { return _issuedTo; } + inline const Address &signer() const { return _signedBy; } + inline const uint8_t *signature() const { return _signature; } + inline unsigned int signatureLength() const { return _signatureLength; } /** * Sign this tag @@ -96,7 +96,7 @@ public: * @param signer Signing identity, must have private key * @return True if signature was successful */ - ZT_ALWAYS_INLINE bool sign(const Identity &signer) + inline bool sign(const Identity &signer) { if (signer.hasPrivate()) { Buffer tmp; @@ -114,7 +114,7 @@ public: * @param RR Runtime environment to allow identity lookup for signedBy * @param tPtr Thread pointer to be handed through to any callbacks called as a result of this call */ - ZT_ALWAYS_INLINE Credential::VerifyResult verify(const RuntimeEnvironment *RR,void *tPtr) const { return _verify(RR,tPtr,*this); } + inline Credential::VerifyResult verify(const RuntimeEnvironment *RR,void *tPtr) const { return _verify(RR,tPtr,*this); } template inline void serialize(Buffer &b,const bool forSign = false) const @@ -172,23 +172,23 @@ public: } // Provides natural sort order by ID - ZT_ALWAYS_INLINE bool operator<(const Tag &t) const { return (_id < t._id); } + inline bool operator<(const Tag &t) const { return (_id < t._id); } - ZT_ALWAYS_INLINE bool operator==(const Tag &t) const { return (memcmp(this,&t,sizeof(Tag)) == 0); } - ZT_ALWAYS_INLINE bool operator!=(const Tag &t) const { return (memcmp(this,&t,sizeof(Tag)) != 0); } + inline bool operator==(const Tag &t) const { return (memcmp(this,&t,sizeof(Tag)) == 0); } + inline bool operator!=(const Tag &t) const { return (memcmp(this,&t,sizeof(Tag)) != 0); } // For searching sorted arrays or lists of Tags by ID struct IdComparePredicate { - ZT_ALWAYS_INLINE bool operator()(const Tag &a,const Tag &b) const { return (a.id() < b.id()); } - ZT_ALWAYS_INLINE bool operator()(const uint32_t a,const Tag &b) const { return (a < b.id()); } - ZT_ALWAYS_INLINE bool operator()(const Tag &a,const uint32_t b) const { return (a.id() < b); } - ZT_ALWAYS_INLINE bool operator()(const Tag *a,const Tag *b) const { return (a->id() < b->id()); } - ZT_ALWAYS_INLINE bool operator()(const Tag *a,const Tag &b) const { return (a->id() < b.id()); } - ZT_ALWAYS_INLINE bool operator()(const Tag &a,const Tag *b) const { return (a.id() < b->id()); } - ZT_ALWAYS_INLINE bool operator()(const uint32_t a,const Tag *b) const { return (a < b->id()); } - ZT_ALWAYS_INLINE bool operator()(const Tag *a,const uint32_t b) const { return (a->id() < b); } - ZT_ALWAYS_INLINE bool operator()(const uint32_t a,const uint32_t b) const { return (a < b); } + inline bool operator()(const Tag &a,const Tag &b) const { return (a.id() < b.id()); } + inline bool operator()(const uint32_t a,const Tag &b) const { return (a < b.id()); } + inline bool operator()(const Tag &a,const uint32_t b) const { return (a.id() < b); } + inline bool operator()(const Tag *a,const Tag *b) const { return (a->id() < b->id()); } + inline bool operator()(const Tag *a,const Tag &b) const { return (a->id() < b.id()); } + inline bool operator()(const Tag &a,const Tag *b) const { return (a.id() < b->id()); } + inline bool operator()(const uint32_t a,const Tag *b) const { return (a < b->id()); } + inline bool operator()(const Tag *a,const uint32_t b) const { return (a->id() < b); } + inline bool operator()(const uint32_t a,const uint32_t b) const { return (a < b); } }; private: diff --git a/node/Topology.hpp b/node/Topology.hpp index eb4f3240a..4a084624d 100644 --- a/node/Topology.hpp +++ b/node/Topology.hpp @@ -49,8 +49,8 @@ class Topology private: struct _RootRankingFunction { - ZT_ALWAYS_INLINE _RootRankingFunction() : bestRoot(),bestRootLatency(0xffff) {} - ZT_ALWAYS_INLINE bool operator()(const SharedPtr &peer,const std::vector &phy) + inline _RootRankingFunction() : bestRoot(),bestRootLatency(0xffff) {} + inline bool operator()(const SharedPtr &peer,const std::vector &phy) { const unsigned int lat = peer->latency(now); if ((!bestRoot)||((lat <= bestRootLatency)&&(peer->getAppropriatePath(now,false)))) { @@ -64,7 +64,7 @@ private: unsigned int bestRootLatency; }; - ZT_ALWAYS_INLINE void _updateRoots() + inline void _updateRoots() { // assumes _roots_l is locked _rootIdentities.clear(); @@ -78,7 +78,7 @@ private: } public: - ZT_ALWAYS_INLINE Topology(const RuntimeEnvironment *renv,const Identity &myId) : + inline Topology(const RuntimeEnvironment *renv,const Identity &myId) : RR(renv), _myIdentity(myId), _numConfiguredPhysicalPaths(0), @@ -87,7 +87,7 @@ public: _roots(8), _rootIdentities(8), _lastUpdatedBestRoot(0) {} - ZT_ALWAYS_INLINE ~Topology() {} + inline ~Topology() {} /** * Add a peer to database @@ -99,7 +99,7 @@ public: * @param peer Peer to add * @return New or existing peer (should replace 'peer') */ - ZT_ALWAYS_INLINE SharedPtr add(const SharedPtr &peer) + inline SharedPtr add(const SharedPtr &peer) { SharedPtr np; { @@ -119,7 +119,7 @@ public: * @param zta ZeroTier address of peer * @return Peer or NULL if not found */ - ZT_ALWAYS_INLINE SharedPtr get(const Address &zta) + inline SharedPtr get(const Address &zta) { if (zta == _myIdentity.address()) return SharedPtr(); @@ -135,7 +135,7 @@ public: * @param zta ZeroTier address of peer * @return Identity or NULL identity if not found */ - ZT_ALWAYS_INLINE Identity getIdentity(void *tPtr,const Address &zta) + inline Identity getIdentity(void *tPtr,const Address &zta) { if (zta == _myIdentity.address()) { return _myIdentity; @@ -155,7 +155,7 @@ public: * @param r Remote address * @return Pointer to canonicalized Path object */ - ZT_ALWAYS_INLINE SharedPtr getPath(const int64_t l,const InetAddress &r) + inline SharedPtr getPath(const int64_t l,const InetAddress &r) { Mutex::Lock _l(_paths_l); SharedPtr &p = _paths[Path::HashKey(l,r)]; @@ -168,7 +168,7 @@ public: * @param id Identity to check * @return True if this identity corresponds to a root */ - ZT_ALWAYS_INLINE bool isRoot(const Identity &id) const + inline bool isRoot(const Identity &id) const { Mutex::Lock l(_roots_l); return _rootIdentities.contains(id); @@ -177,7 +177,7 @@ public: /** * Do periodic tasks such as database cleanup */ - ZT_ALWAYS_INLINE void doPeriodicTasks(int64_t now) + inline void doPeriodicTasks(int64_t now) { { Mutex::Lock _l1(_peers_l); @@ -231,7 +231,7 @@ public: * @tparam F Function or function object type */ template - ZT_ALWAYS_INLINE void eachPeer(F f) + inline void eachPeer(F f) { Mutex::Lock l(_peers_l); Hashtable< Address,SharedPtr >::Iterator i(_peers); @@ -253,7 +253,7 @@ public: * @tparam F function or function object type */ template - ZT_ALWAYS_INLINE void eachRoot(F f) + inline void eachRoot(F f) { Mutex::Lock l(_roots_l); Hashtable< Str,Locator >::Iterator i(_roots); @@ -306,7 +306,7 @@ public: * @param f Function of (Str,Locator) */ template - ZT_ALWAYS_INLINE void eachRootName(F f) const + inline void eachRootName(F f) const { Mutex::Lock l(_roots_l); Str *k = (Str *)0; @@ -405,7 +405,7 @@ public: * @param toAddr Destination address * @return Best current relay or NULL if none */ - ZT_ALWAYS_INLINE SharedPtr findRelayTo(const int64_t now,const Address &toAddr) + inline SharedPtr findRelayTo(const int64_t now,const Address &toAddr) { // TODO: in the future this will check 'mesh-like' relays and if enabled consult LF for other roots (for if this is a root) return root(now); @@ -414,7 +414,7 @@ public: /** * @param allPeers vector to fill with all current peers */ - ZT_ALWAYS_INLINE void getAllPeers(std::vector< SharedPtr > &allPeers) const + inline void getAllPeers(std::vector< SharedPtr > &allPeers) const { Mutex::Lock l(_peers_l); allPeers.clear(); @@ -436,7 +436,7 @@ public: * @param mtu Variable set to MTU * @param trustedPathId Variable set to trusted path ID */ - ZT_ALWAYS_INLINE void getOutboundPathInfo(const InetAddress &physicalAddress,unsigned int &mtu,uint64_t &trustedPathId) + inline void getOutboundPathInfo(const InetAddress &physicalAddress,unsigned int &mtu,uint64_t &trustedPathId) { for(unsigned int i=0,j=_numConfiguredPhysicalPaths;i> 1] |= ( ((thisRuleMatches + 1) << 2) | (thisSetMatches + 1) ) << ((rn & 1) << 2); } - ZT_ALWAYS_INLINE void logSkipped(const unsigned int rn,const uint8_t thisSetMatches) + inline void logSkipped(const unsigned int rn,const uint8_t thisSetMatches) { _l[rn >> 1] |= (thisSetMatches + 1) << ((rn & 1) << 2); } - ZT_ALWAYS_INLINE void clear() + inline void clear() { memset(_l,0,sizeof(_l)); } - ZT_ALWAYS_INLINE const uint8_t *data() const { return _l; } - ZT_ALWAYS_INLINE unsigned int sizeBytes() const { return (ZT_MAX_NETWORK_RULES / 2); } + inline const uint8_t *data() const { return _l; } + inline unsigned int sizeBytes() const { return (ZT_MAX_NETWORK_RULES / 2); } private: uint8_t _l[ZT_MAX_NETWORK_RULES / 2]; }; - ZT_ALWAYS_INLINE Trace(const RuntimeEnvironment *renv) : + inline Trace(const RuntimeEnvironment *renv) : RR(renv), _byNet(8) {} diff --git a/node/Utils.hpp b/node/Utils.hpp index 219414a97..be98f28dd 100644 --- a/node/Utils.hpp +++ b/node/Utils.hpp @@ -44,7 +44,7 @@ const char HEXCHARS[16]; * @param len Length of strings * @return True if strings are equal */ -ZT_ALWAYS_INLINE bool secureEq(const void *a,const void *b,unsigned int len) +inline bool secureEq(const void *a,const void *b,unsigned int len) { uint8_t diff = 0; for(unsigned int i=0;i -static ZT_ALWAYS_INLINE char *hex(I x,char *s) +static inline char *hex(I x,char *s) { char *const r = s; for(unsigned int i=0,b=(sizeof(x)*8);i> 36) & 0xf]; s[1] = HEXCHARS[(i >> 32) & 0xf]; @@ -119,7 +119,7 @@ static ZT_ALWAYS_INLINE char *hex10(uint64_t i,char s[11]) * @param s String buffer, must be at least (l*2)+1 in size or overflow will occur * @return Pointer to filled string buffer */ -static ZT_ALWAYS_INLINE char *hex(const void *d,unsigned int l,char *s) +static inline char *hex(const void *d,unsigned int l,char *s) { char *const save = s; for(unsigned int i=0;i -static ZT_ALWAYS_INLINE unsigned int countBits(T v) +static inline unsigned int countBits(T v) { v = v - ((v >> 1) & (T)~(T)0/3); v = (v & (T)~(T)0/15*3) + ((v >> 2) & (T)~(T)0/15*3); @@ -285,11 +285,11 @@ static ZT_ALWAYS_INLINE unsigned int countBits(T v) // Byte swappers for big/little endian conversion #if __BYTE_ORDER == __LITTLE_ENDIAN -static ZT_ALWAYS_INLINE uint8_t hton(uint8_t n) { return n; } -static ZT_ALWAYS_INLINE int8_t hton(int8_t n) { return n; } -static ZT_ALWAYS_INLINE uint16_t hton(uint16_t n) { return htons(n); } -static ZT_ALWAYS_INLINE int16_t hton(int16_t n) { return (int16_t)Utils::hton((uint16_t)n); } -static ZT_ALWAYS_INLINE uint32_t hton(uint32_t n) +static inline uint8_t hton(uint8_t n) { return n; } +static inline int8_t hton(int8_t n) { return n; } +static inline uint16_t hton(uint16_t n) { return htons(n); } +static inline int16_t hton(int16_t n) { return (int16_t)Utils::hton((uint16_t)n); } +static inline uint32_t hton(uint32_t n) { #if defined(__GNUC__) #if defined(__FreeBSD__) @@ -301,8 +301,8 @@ static ZT_ALWAYS_INLINE uint32_t hton(uint32_t n) return htonl(n); #endif } -static ZT_ALWAYS_INLINE int32_t hton(int32_t n) { return (int32_t)Utils::hton((uint32_t)n); } -static ZT_ALWAYS_INLINE uint64_t hton(uint64_t n) +static inline int32_t hton(int32_t n) { return (int32_t)Utils::hton((uint32_t)n); } +static inline uint64_t hton(uint64_t n) { #if defined(__GNUC__) #if defined(__FreeBSD__) @@ -323,18 +323,18 @@ static ZT_ALWAYS_INLINE uint64_t hton(uint64_t n) ); #endif } -static ZT_ALWAYS_INLINE int64_t hton(int64_t n) { return (int64_t)hton((uint64_t)n); } +static inline int64_t hton(int64_t n) { return (int64_t)hton((uint64_t)n); } #else template -static ZT_ALWAYS_INLINE T hton(T n) { return n; } +static inline T hton(T n) { return n; } #endif #if __BYTE_ORDER == __LITTLE_ENDIAN -static ZT_ALWAYS_INLINE uint8_t ntoh(uint8_t n) { return n; } -static ZT_ALWAYS_INLINE int8_t ntoh(int8_t n) { return n; } -static ZT_ALWAYS_INLINE uint16_t ntoh(uint16_t n) { return ntohs(n); } -static ZT_ALWAYS_INLINE int16_t ntoh(int16_t n) { return (int16_t)Utils::ntoh((uint16_t)n); } -static ZT_ALWAYS_INLINE uint32_t ntoh(uint32_t n) +static inline uint8_t ntoh(uint8_t n) { return n; } +static inline int8_t ntoh(int8_t n) { return n; } +static inline uint16_t ntoh(uint16_t n) { return ntohs(n); } +static inline int16_t ntoh(int16_t n) { return (int16_t)Utils::ntoh((uint16_t)n); } +static inline uint32_t ntoh(uint32_t n) { #if defined(__GNUC__) #if defined(__FreeBSD__) @@ -346,8 +346,8 @@ static ZT_ALWAYS_INLINE uint32_t ntoh(uint32_t n) return ntohl(n); #endif } -static ZT_ALWAYS_INLINE int32_t ntoh(int32_t n) { return (int32_t)Utils::ntoh((uint32_t)n); } -static ZT_ALWAYS_INLINE uint64_t ntoh(uint64_t n) +static inline int32_t ntoh(int32_t n) { return (int32_t)Utils::ntoh((uint32_t)n); } +static inline uint64_t ntoh(uint64_t n) { #if defined(__GNUC__) #if defined(__FreeBSD__) @@ -368,10 +368,10 @@ static ZT_ALWAYS_INLINE uint64_t ntoh(uint64_t n) ); #endif } -static ZT_ALWAYS_INLINE int64_t ntoh(int64_t n) { return (int64_t)ntoh((uint64_t)n); } +static inline int64_t ntoh(int64_t n) { return (int64_t)ntoh((uint64_t)n); } #else template -static ZT_ALWAYS_INLINE T ntoh(T n) { return n; } +static inline T ntoh(T n) { return n; } #endif } // namespace Utils