void/ZeroTierOne
2
0
Fork 0
mirror of https://github.com/zerotier/ZeroTierOne.git synced 2025-06-07 13:03:45 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Moar refactoring

Browse source
This commit is contained in:
Adam Ierymenko 2019-12-11 13:46:44 -08:00
parent 72361fb1c8
commit 23d6a3aacd
No known key found for this signature in database
GPG key ID: C8877CF2D7A5D7F3
3 changed files with 294 additions and 310 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
node/Str.hpp
View file

@ -22,7 +22,7 @@
#include <string> #include <string>
#define ZT_STR_CAPACITY 254 #define ZT_STR_CAPACITY 1021
namespace ZeroTier { namespace ZeroTier {
@ -197,25 +197,8 @@ public:
return h; return h;
} }
template<unsigned int C>
inline void serialize(Buffer<C> &b,const bool forSign = false) const
{
b.append(_l);
b.append(_s,(unsigned int)_l);
}
template<unsigned int C>
inline unsigned int deserialize(const Buffer<C> &b,unsigned int startAt = 0)
{
unsigned int p = startAt;
_l = (uint8_t)b[p++];
memcpy(_s,b.field(p,(unsigned int)_l),(unsigned long)_l);
p += (unsigned int)_l;
return (p - startAt);
}
private: private:
uint8_t _l; uint16_t _l;
char _s[ZT_STR_CAPACITY+1]; char _s[ZT_STR_CAPACITY+1];
}; };

32
node/Utils.cpp
View file

@ -40,8 +40,6 @@
#include "AES.hpp" #include "AES.hpp"
#include "SHA512.hpp" #include "SHA512.hpp"
namespace ZeroTier {
#if (defined(__amd64) || defined(__amd64__) || defined(__x86_64) || defined(__x86_64__) || defined(__AMD64) || defined(__AMD64__) || defined(_M_X64)) #if (defined(__amd64) || defined(__amd64__) || defined(__x86_64) || defined(__x86_64__) || defined(__AMD64) || defined(__AMD64__) || defined(_M_X64))
#include <immintrin.h> #include <immintrin.h>
static bool _zt_rdrand_supported() static bool _zt_rdrand_supported()
@ -63,7 +61,11 @@ static bool _zt_rdrand_supported()
static const bool _rdrandSupported = _zt_rdrand_supported(); static const bool _rdrandSupported = _zt_rdrand_supported();
#endif #endif
const char Utils::HEXCHARS[16] = { '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f' }; namespace ZeroTier {
namespace Utils {
const char HEXCHARS[16] = { '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f' };
// Crazy hack to force memory to be securely zeroed in spite of the best efforts of optimizing compilers. // Crazy hack to force memory to be securely zeroed in spite of the best efforts of optimizing compilers.
static void _Utils_doBurn(volatile uint8_t *ptr,unsigned int len) static void _Utils_doBurn(volatile uint8_t *ptr,unsigned int len)
@ -72,7 +74,7 @@ static void _Utils_doBurn(volatile uint8_t *ptr,unsigned int len)
while (ptr != end) *(ptr++) = (uint8_t)0; while (ptr != end) *(ptr++) = (uint8_t)0;
} }
static void (*volatile _Utils_doBurn_ptr)(volatile uint8_t *,unsigned int) = _Utils_doBurn; static void (*volatile _Utils_doBurn_ptr)(volatile uint8_t *,unsigned int) = _Utils_doBurn;
void Utils::burn(void *ptr,unsigned int len) { (_Utils_doBurn_ptr)((volatile uint8_t *)ptr,len); } void burn(void *ptr,unsigned int len) { (_Utils_doBurn_ptr)((volatile uint8_t *)ptr,len); }
static unsigned long _Utils_itoa(unsigned long n,char *s) static unsigned long _Utils_itoa(unsigned long n,char *s)
{ {
@ -84,7 +86,7 @@ static unsigned long _Utils_itoa(unsigned long n,char *s)
s[pos] = '0' + (char)(n % 10); s[pos] = '0' + (char)(n % 10);
return pos + 1; return pos + 1;
} }
char *Utils::decimal(unsigned long n,char s[24]) char *decimal(unsigned long n,char s[24])
{ {
if (n == 0) { if (n == 0) {
s[0] = '0'; s[0] = '0';
@ -95,7 +97,7 @@ char *Utils::decimal(unsigned long n,char s[24])
return s; return s;
} }
unsigned short Utils::crc16(const void *buf,unsigned int len) unsigned short crc16(const void *buf,unsigned int len)
{ {
static const uint16_t crc16tab[256]= { static const uint16_t crc16tab[256]= {
0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7, 0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
@ -138,7 +140,7 @@ unsigned short Utils::crc16(const void *buf,unsigned int len)
return crc; return crc;
} }
unsigned int Utils::unhex(const char *h,void *buf,unsigned int buflen) unsigned int unhex(const char *h,void *buf,unsigned int buflen)
{ {
unsigned int l = 0; unsigned int l = 0;
while (l < buflen) { while (l < buflen) {
@ -169,7 +171,7 @@ unsigned int Utils::unhex(const char *h,void *buf,unsigned int buflen)
return l; return l;
} }
unsigned int Utils::unhex(const char *h,unsigned int hlen,void *buf,unsigned int buflen) unsigned int unhex(const char *h,unsigned int hlen,void *buf,unsigned int buflen)
{ {
unsigned int l = 0; unsigned int l = 0;
const char *hend = h + hlen; const char *hend = h + hlen;
@ -203,7 +205,7 @@ unsigned int Utils::unhex(const char *h,unsigned int hlen,void *buf,unsigned int
return l; return l;
} }
void Utils::getSecureRandom(void *buf,unsigned int bytes) void getSecureRandom(void *buf,unsigned int bytes)
{ {
static Mutex globalLock; static Mutex globalLock;
static bool initialized = false; static bool initialized = false;
@ -281,7 +283,7 @@ void Utils::getSecureRandom(void *buf,unsigned int bytes)
} }
} }
int Utils::b32e(const uint8_t *data,int length,char *result,int bufSize) int b32e(const uint8_t *data,int length,char *result,int bufSize)
{ {
if (length < 0 || length > (1 << 28)) { if (length < 0 || length > (1 << 28)) {
result[0] = (char)0; result[0] = (char)0;
@ -317,7 +319,7 @@ int Utils::b32e(const uint8_t *data,int length,char *result,int bufSize)
return -1; return -1;
} }
int Utils::b32d(const char *encoded,uint8_t *result,int bufSize) int b32d(const char *encoded,uint8_t *result,int bufSize)
{ {
int buffer = 0; int buffer = 0;
int bitsLeft = 0; int bitsLeft = 0;
@ -357,7 +359,7 @@ int Utils::b32d(const char *encoded,uint8_t *result,int bufSize)
return count; return count;
} }
unsigned int Utils::b64e(const uint8_t *in,unsigned int inlen,char *out,unsigned int outlen) unsigned int b64e(const uint8_t *in,unsigned int inlen,char *out,unsigned int outlen)
{ {
static const char base64en[64] = { 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/' }; static const char base64en[64] = { 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/' };
unsigned int i = 0,j = 0; unsigned int i = 0,j = 0;
@ -404,7 +406,7 @@ unsigned int Utils::b64e(const uint8_t *in,unsigned int inlen,char *out,unsigned
return j; return j;
} }
unsigned int Utils::b64d(const char *in,unsigned char *out,unsigned int outlen) unsigned int b64d(const char *in,unsigned char *out,unsigned int outlen)
{ {
static const uint8_t base64de[256] = { 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,62,255,255,255,63,52,53,54,55,56,57,58,59,60,61,255,255,255,255,255,255,255,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,255,255,255,255,255,255,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,255,255,255,255,255 }; static const uint8_t base64de[256] = { 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,62,255,255,255,63,52,53,54,55,56,57,58,59,60,61,255,255,255,255,255,255,255,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,255,255,255,255,255,255,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,255,255,255,255,255 };
unsigned int i = 0; unsigned int i = 0;
@ -437,7 +439,7 @@ unsigned int Utils::b64d(const char *in,unsigned char *out,unsigned int outlen)
} }
#define ROL64(x,k) (((x) << (k)) | ((x) >> (64 - (k)))) #define ROL64(x,k) (((x) << (k)) | ((x) >> (64 - (k))))
uint64_t Utils::random() uint64_t random()
{ {
// https://en.wikipedia.org/wiki/Xorshift#xoshiro256** // https://en.wikipedia.org/wiki/Xorshift#xoshiro256**
static Mutex l; static Mutex l;
@ -460,4 +462,6 @@ uint64_t Utils::random()
return result; return result;
} }
} // namespace Utils
} // namespace ZeroTier } // namespace ZeroTier

225
node/Utils.hpp
View file

@ -29,18 +29,14 @@
namespace ZeroTier { namespace ZeroTier {
namespace Utils {
/** /**
* Miscellaneous utility functions and global constants
*/
class Utils
{
public:
/**
* Hexadecimal characters 0-f * Hexadecimal characters 0-f
*/ */
static const char HEXCHARS[16]; const char HEXCHARS[16];
/** /**
* Perform a time-invariant binary comparison * Perform a time-invariant binary comparison
* *
* @param a First binary string * @param a First binary string
@ -48,41 +44,41 @@ public:
* @param len Length of strings * @param len Length of strings
* @return True if strings are equal * @return True if strings are equal
*/ */
static ZT_ALWAYS_INLINE bool secureEq(const void *a,const void *b,unsigned int len) ZT_ALWAYS_INLINE bool secureEq(const void *a,const void *b,unsigned int len)
{ {
uint8_t diff = 0; uint8_t diff = 0;
for(unsigned int i=0;i<len;++i) for(unsigned int i=0;i<len;++i)
diff |= ( (reinterpret_cast<const uint8_t *>(a))[i] ^ (reinterpret_cast<const uint8_t *>(b))[i] ); diff |= ( (reinterpret_cast<const uint8_t *>(a))[i] ^ (reinterpret_cast<const uint8_t *>(b))[i] );
return (diff == 0); return (diff == 0);
} }
/** /**
* Zero memory, ensuring to avoid any compiler optimizations or other things that may stop this. * Zero memory, ensuring to avoid any compiler optimizations or other things that may stop this.
*/ */
static void burn(void *ptr,unsigned int len); void burn(void *ptr,unsigned int len);
/** /**
* @param n Number to convert * @param n Number to convert
* @param s Buffer, at least 24 bytes in size * @param s Buffer, at least 24 bytes in size
* @return String containing 'n' in base 10 form * @return String containing 'n' in base 10 form
*/ */
static char *decimal(unsigned long n,char s[24]); char *decimal(unsigned long n,char s[24]);
/** /**
* Compute CRC16-CCITT * Compute CRC16-CCITT
*/ */
static uint16_t crc16(const void *buf,unsigned int len); uint16_t crc16(const void *buf,unsigned int len);
/** /**
* Convert an unsigned integer into hex * Convert an unsigned integer into hex
* *
* @param i Any unsigned integer * @param i Any unsigned integer
* @param s Buffer to receive hex, must be at least (2*sizeof(i))+1 in size or overflow will occur. * @param s Buffer to receive hex, must be at least (2*sizeof(i))+1 in size or overflow will occur.
* @return Pointer to s containing hex string with trailing zero byte * @return Pointer to s containing hex string with trailing zero byte
*/ */
template<typename I> template<typename I>
static ZT_ALWAYS_INLINE char *hex(I x,char *s) static ZT_ALWAYS_INLINE char *hex(I x,char *s)
{ {
char *const r = s; char *const r = s;
for(unsigned int i=0,b=(sizeof(x)*8);i<sizeof(x);++i) { for(unsigned int i=0,b=(sizeof(x)*8);i<sizeof(x);++i) {
*(s++) = HEXCHARS[(x >> (b -= 4)) & 0xf]; *(s++) = HEXCHARS[(x >> (b -= 4)) & 0xf];
@ -90,17 +86,17 @@ public:
} }
*s = (char)0; *s = (char)0;
return r; return r;
} }
/** /**
* Convert the least significant 40 bits of a uint64_t to hex * Convert the least significant 40 bits of a uint64_t to hex
* *
* @param i Unsigned 64-bit int * @param i Unsigned 64-bit int
* @param s Buffer of size [11] to receive 10 hex characters * @param s Buffer of size [11] to receive 10 hex characters
* @return Pointer to buffer * @return Pointer to buffer
*/ */
static ZT_ALWAYS_INLINE char *hex10(uint64_t i,char s[11]) static ZT_ALWAYS_INLINE char *hex10(uint64_t i,char s[11])
{ {
s[0] = HEXCHARS[(i >> 36) & 0xf]; s[0] = HEXCHARS[(i >> 36) & 0xf];
s[1] = HEXCHARS[(i >> 32) & 0xf]; s[1] = HEXCHARS[(i >> 32) & 0xf];
s[2] = HEXCHARS[(i >> 28) & 0xf]; s[2] = HEXCHARS[(i >> 28) & 0xf];
@ -113,9 +109,9 @@ public:
s[9] = HEXCHARS[i & 0xf]; s[9] = HEXCHARS[i & 0xf];
s[10] = (char)0; s[10] = (char)0;
return s; return s;
} }
/** /**
* Convert a byte array into hex * Convert a byte array into hex
* *
* @param d Bytes * @param d Bytes
@ -123,8 +119,8 @@ public:
* @param s String buffer, must be at least (l*2)+1 in size or overflow will occur * @param s String buffer, must be at least (l*2)+1 in size or overflow will occur
* @return Pointer to filled string buffer * @return Pointer to filled string buffer
*/ */
static ZT_ALWAYS_INLINE char *hex(const void *d,unsigned int l,char *s) static ZT_ALWAYS_INLINE char *hex(const void *d,unsigned int l,char *s)
{ {
char *const save = s; char *const save = s;
for(unsigned int i=0;i<l;++i) { for(unsigned int i=0;i<l;++i) {
const unsigned int b = reinterpret_cast<const uint8_t *>(d)[i]; const unsigned int b = reinterpret_cast<const uint8_t *>(d)[i];
@ -133,12 +129,12 @@ public:
} }
*s = (char)0; *s = (char)0;
return save; return save;
} }
static unsigned int unhex(const char *h,void *buf,unsigned int buflen); unsigned int unhex(const char *h,void *buf,unsigned int buflen);
static unsigned int unhex(const char *h,unsigned int hlen,void *buf,unsigned int buflen); unsigned int unhex(const char *h,unsigned int hlen,void *buf,unsigned int buflen);
/** /**
* Generate secure random bytes * Generate secure random bytes
* *
* This will try to use whatever OS sources of entropy are available. It's * This will try to use whatever OS sources of entropy are available. It's
@ -147,96 +143,96 @@ public:
* @param buf Buffer to fill * @param buf Buffer to fill
* @param bytes Number of random bytes to generate * @param bytes Number of random bytes to generate
*/ */
static void getSecureRandom(void *buf,unsigned int bytes); void getSecureRandom(void *buf,unsigned int bytes);
/** /**
* Get a 64-bit unsigned secure random number * Get a 64-bit unsigned secure random number
*/ */
static ZT_ALWAYS_INLINE uint64_t getSecureRandom64() static ZT_ALWAYS_INLINE uint64_t getSecureRandom64()
{ {
uint64_t x; uint64_t x;
getSecureRandom(&x,sizeof(x)); getSecureRandom(&x,sizeof(x));
return x; return x;
} }
static int b32e(const uint8_t *data,int length,char *result,int bufSize); int b32e(const uint8_t *data,int length,char *result,int bufSize);
static int b32d(const char *encoded, uint8_t *result, int bufSize); int b32d(const char *encoded, uint8_t *result, int bufSize);
static ZT_ALWAYS_INLINE unsigned int b64MaxEncodedSize(const unsigned int s) { return ((((s + 2) / 3) * 4) + 1); } static ZT_ALWAYS_INLINE unsigned int b64MaxEncodedSize(const unsigned int s) { return ((((s + 2) / 3) * 4) + 1); }
static unsigned int b64e(const uint8_t *in,unsigned int inlen,char *out,unsigned int outlen); unsigned int b64e(const uint8_t *in,unsigned int inlen,char *out,unsigned int outlen);
static unsigned int b64d(const char *in,uint8_t *out,unsigned int outlen); unsigned int b64d(const char *in,uint8_t *out,unsigned int outlen);
/** /**
* Get a non-cryptographic random integer * Get a non-cryptographic random integer
*/ */
static uint64_t random(); uint64_t random();
static ZT_ALWAYS_INLINE float normalize(float value, int64_t bigMin, int64_t bigMax, int32_t targetMin, int32_t targetMax) static ZT_ALWAYS_INLINE float normalize(float value, int64_t bigMin, int64_t bigMax, int32_t targetMin, int32_t targetMax)
{ {
int64_t bigSpan = bigMax - bigMin; int64_t bigSpan = bigMax - bigMin;
int64_t smallSpan = targetMax - targetMin; int64_t smallSpan = targetMax - targetMin;
float valueScaled = (value - (float)bigMin) / (float)bigSpan; float valueScaled = (value - (float)bigMin) / (float)bigSpan;
return (float)targetMin + valueScaled * (float)smallSpan; return (float)targetMin + valueScaled * (float)smallSpan;
} }
/** /**
* Tokenize a string (alias for strtok_r or strtok_s depending on platform) * Tokenize a string (alias for strtok_r or strtok_s depending on platform)
* *
* @param str String to split * @param str String to split
* @param delim Delimiters * @param delim Delimiters
* @param saveptr Pointer to a char * for temporary reentrant storage * @param saveptr Pointer to a char * for temporary reentrant storage
*/ */
static ZT_ALWAYS_INLINE char *stok(char *str,const char *delim,char **saveptr) static ZT_ALWAYS_INLINE char *stok(char *str,const char *delim,char **saveptr)
{ {
#ifdef __WINDOWS__ #ifdef __WINDOWS__
return strtok_s(str,delim,saveptr); return strtok_s(str,delim,saveptr);
#else #else
return strtok_r(str,delim,saveptr); return strtok_r(str,delim,saveptr);
#endif #endif
} }
static ZT_ALWAYS_INLINE unsigned int strToUInt(const char *s) { return (unsigned int)strtoul(s,(char **)0,10); } static ZT_ALWAYS_INLINE unsigned int strToUInt(const char *s) { return (unsigned int)strtoul(s,(char **)0,10); }
static ZT_ALWAYS_INLINE int strToInt(const char *s) { return (int)strtol(s,(char **)0,10); } static ZT_ALWAYS_INLINE int strToInt(const char *s) { return (int)strtol(s,(char **)0,10); }
static ZT_ALWAYS_INLINE unsigned long strToULong(const char *s) { return strtoul(s,(char **)0,10); } static ZT_ALWAYS_INLINE unsigned long strToULong(const char *s) { return strtoul(s,(char **)0,10); }
static ZT_ALWAYS_INLINE long strToLong(const char *s) { return strtol(s,(char **)0,10); } static ZT_ALWAYS_INLINE long strToLong(const char *s) { return strtol(s,(char **)0,10); }
static ZT_ALWAYS_INLINE unsigned long long strToU64(const char *s) static ZT_ALWAYS_INLINE unsigned long long strToU64(const char *s)
{ {
#ifdef __WINDOWS__ #ifdef __WINDOWS__
return (unsigned long long)_strtoui64(s,(char **)0,10); return (unsigned long long)_strtoui64(s,(char **)0,10);
#else #else
return strtoull(s,(char **)0,10); return strtoull(s,(char **)0,10);
#endif #endif
} }
static ZT_ALWAYS_INLINE long long strTo64(const char *s) static ZT_ALWAYS_INLINE long long strTo64(const char *s)
{ {
#ifdef __WINDOWS__ #ifdef __WINDOWS__
return (long long)_strtoi64(s,(char **)0,10); return (long long)_strtoi64(s,(char **)0,10);
#else #else
return strtoll(s,(char **)0,10); return strtoll(s,(char **)0,10);
#endif #endif
} }
static ZT_ALWAYS_INLINE unsigned int hexStrToUInt(const char *s) { return (unsigned int)strtoul(s,(char **)0,16); } static ZT_ALWAYS_INLINE unsigned int hexStrToUInt(const char *s) { return (unsigned int)strtoul(s,(char **)0,16); }
static ZT_ALWAYS_INLINE int hexStrToInt(const char *s) { return (int)strtol(s,(char **)0,16); } static ZT_ALWAYS_INLINE int hexStrToInt(const char *s) { return (int)strtol(s,(char **)0,16); }
static ZT_ALWAYS_INLINE unsigned long hexStrToULong(const char *s) { return strtoul(s,(char **)0,16); } static ZT_ALWAYS_INLINE unsigned long hexStrToULong(const char *s) { return strtoul(s,(char **)0,16); }
static ZT_ALWAYS_INLINE long hexStrToLong(const char *s) { return strtol(s,(char **)0,16); } static ZT_ALWAYS_INLINE long hexStrToLong(const char *s) { return strtol(s,(char **)0,16); }
static ZT_ALWAYS_INLINE unsigned long long hexStrToU64(const char *s) static ZT_ALWAYS_INLINE unsigned long long hexStrToU64(const char *s)
{ {
#ifdef __WINDOWS__ #ifdef __WINDOWS__
return (unsigned long long)_strtoui64(s,(char **)0,16); return (unsigned long long)_strtoui64(s,(char **)0,16);
#else #else
return strtoull(s,(char **)0,16); return strtoull(s,(char **)0,16);
#endif #endif
} }
static ZT_ALWAYS_INLINE long long hexStrTo64(const char *s) static ZT_ALWAYS_INLINE long long hexStrTo64(const char *s)
{ {
#ifdef __WINDOWS__ #ifdef __WINDOWS__
return (long long)_strtoi64(s,(char **)0,16); return (long long)_strtoi64(s,(char **)0,16);
#else #else
return strtoll(s,(char **)0,16); return strtoll(s,(char **)0,16);
#endif #endif
} }
/** /**
* Perform a safe C string copy, ALWAYS null-terminating the result * Perform a safe C string copy, ALWAYS null-terminating the result
* *
* This will never ever EVER result in dest[] not being null-terminated * This will never ever EVER result in dest[] not being null-terminated
@ -247,8 +243,8 @@ public:
* @param src Source string (if NULL, dest will receive a zero-length string and true is returned) * @param src Source string (if NULL, dest will receive a zero-length string and true is returned)
* @return True on success, false on overflow (buffer will still be 0-terminated) * @return True on success, false on overflow (buffer will still be 0-terminated)
*/ */
static ZT_ALWAYS_INLINE bool scopy(char *dest,unsigned int len,const char *src) static ZT_ALWAYS_INLINE bool scopy(char *dest,unsigned int len,const char *src)
{ {
if (!len) if (!len)
return false; // sanity check return false; // sanity check
if (!src) { if (!src) {
@ -263,38 +259,38 @@ public:
} }
} }
return true; return true;
} }
#ifdef __GNUC__ #ifdef __GNUC__
static ZT_ALWAYS_INLINE unsigned int countBits(const uint8_t v) { return (unsigned int)__builtin_popcount((unsigned int)v); } static ZT_ALWAYS_INLINE unsigned int countBits(const uint8_t v) { return (unsigned int)__builtin_popcount((unsigned int)v); }
static ZT_ALWAYS_INLINE unsigned int countBits(const uint16_t v) { return (unsigned int)__builtin_popcount((unsigned int)v); } static ZT_ALWAYS_INLINE unsigned int countBits(const uint16_t v) { return (unsigned int)__builtin_popcount((unsigned int)v); }
static ZT_ALWAYS_INLINE unsigned int countBits(const uint32_t v) { return (unsigned int)__builtin_popcountl((unsigned long)v); } static ZT_ALWAYS_INLINE unsigned int countBits(const uint32_t v) { return (unsigned int)__builtin_popcountl((unsigned long)v); }
static ZT_ALWAYS_INLINE unsigned int countBits(const uint64_t v) { return (unsigned int)__builtin_popcountll((unsigned long long)v); } static ZT_ALWAYS_INLINE unsigned int countBits(const uint64_t v) { return (unsigned int)__builtin_popcountll((unsigned long long)v); }
#else #else
/** /**
* Count the number of bits set in an integer * Count the number of bits set in an integer
* *
* @param v Unsigned integer * @param v Unsigned integer
* @return Number of bits set in this integer (0-bits in integer) * @return Number of bits set in this integer (0-bits in integer)
*/ */
template<typename T> template<typename T>
static ZT_ALWAYS_INLINE unsigned int countBits(T v) static ZT_ALWAYS_INLINE unsigned int countBits(T v)
{ {
v = v - ((v >> 1) & (T)~(T)0/3); v = v - ((v >> 1) & (T)~(T)0/3);
v = (v & (T)~(T)0/15*3) + ((v >> 2) & (T)~(T)0/15*3); v = (v & (T)~(T)0/15*3) + ((v >> 2) & (T)~(T)0/15*3);
v = (v + (v >> 4)) & (T)~(T)0/255*15; v = (v + (v >> 4)) & (T)~(T)0/255*15;
return (unsigned int)((v * ((~((T)0))/((T)255))) >> ((sizeof(T) - 1) * 8)); return (unsigned int)((v * ((~((T)0))/((T)255))) >> ((sizeof(T) - 1) * 8));
} }
#endif #endif
// Byte swappers for big/little endian conversion // Byte swappers for big/little endian conversion
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
static ZT_ALWAYS_INLINE uint8_t hton(uint8_t n) { return n; } 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 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 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 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 ZT_ALWAYS_INLINE uint32_t hton(uint32_t n)
{ {
#if defined(__GNUC__) #if defined(__GNUC__)
#if defined(__FreeBSD__) #if defined(__FreeBSD__)
return htonl(n); return htonl(n);
@ -304,10 +300,10 @@ public:
#else #else
return htonl(n); return htonl(n);
#endif #endif
} }
static ZT_ALWAYS_INLINE int32_t hton(int32_t n) { return (int32_t)Utils::hton((uint32_t)n); } 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 ZT_ALWAYS_INLINE uint64_t hton(uint64_t n)
{ {
#if defined(__GNUC__) #if defined(__GNUC__)
#if defined(__FreeBSD__) #if defined(__FreeBSD__)
return bswap64(n); return bswap64(n);
@ -326,20 +322,20 @@ public:
((n & 0xFF00000000000000ULL) >> 56) ((n & 0xFF00000000000000ULL) >> 56)
); );
#endif #endif
} }
static ZT_ALWAYS_INLINE int64_t hton(int64_t n) { return (int64_t)hton((uint64_t)n); } static ZT_ALWAYS_INLINE int64_t hton(int64_t n) { return (int64_t)hton((uint64_t)n); }
#else #else
template<typename T> template<typename T>
static ZT_ALWAYS_INLINE T hton(T n) { return n; } static ZT_ALWAYS_INLINE T hton(T n) { return n; }
#endif #endif
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
static ZT_ALWAYS_INLINE uint8_t ntoh(uint8_t n) { return n; } 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 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 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 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 ZT_ALWAYS_INLINE uint32_t ntoh(uint32_t n)
{ {
#if defined(__GNUC__) #if defined(__GNUC__)
#if defined(__FreeBSD__) #if defined(__FreeBSD__)
return ntohl(n); return ntohl(n);
@ -349,10 +345,10 @@ public:
#else #else
return ntohl(n); return ntohl(n);
#endif #endif
} }
static ZT_ALWAYS_INLINE int32_t ntoh(int32_t n) { return (int32_t)Utils::ntoh((uint32_t)n); } 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 ZT_ALWAYS_INLINE uint64_t ntoh(uint64_t n)
{ {
#if defined(__GNUC__) #if defined(__GNUC__)
#if defined(__FreeBSD__) #if defined(__FreeBSD__)
return bswap64(n); return bswap64(n);
@ -371,13 +367,14 @@ public:
((n & 0xFF00000000000000ULL) >> 56) ((n & 0xFF00000000000000ULL) >> 56)
); );
#endif #endif
} }
static ZT_ALWAYS_INLINE int64_t ntoh(int64_t n) { return (int64_t)ntoh((uint64_t)n); } static ZT_ALWAYS_INLINE int64_t ntoh(int64_t n) { return (int64_t)ntoh((uint64_t)n); }
#else #else
template<typename T> template<typename T>
static ZT_ALWAYS_INLINE T ntoh(T n) { return n; } static ZT_ALWAYS_INLINE T ntoh(T n) { return n; }
#endif #endif
};
} // namespace Utils
} // namespace ZeroTier } // namespace ZeroTier