mirror of
https://github.com/zerotier/ZeroTierOne.git
synced 2024-12-27 08:22:31 +00:00
486 lines
12 KiB
C++
486 lines
12 KiB
C++
/*
|
|
* ZeroTier One - Global Peer to Peer Ethernet
|
|
* Copyright (C) 2012-2013 ZeroTier Networks LLC
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* --
|
|
*
|
|
* ZeroTier may be used and distributed under the terms of the GPLv3, which
|
|
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
|
|
*
|
|
* If you would like to embed ZeroTier into a commercial application or
|
|
* redistribute it in a modified binary form, please contact ZeroTier Networks
|
|
* LLC. Start here: http://www.zerotier.com/
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include "Constants.hpp"
|
|
|
|
#ifdef __UNIX_LIKE__
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <sys/types.h>
|
|
#include <sys/uio.h>
|
|
#include <dirent.h>
|
|
#endif
|
|
|
|
#include "Utils.hpp"
|
|
#include "Mutex.hpp"
|
|
#include "Salsa20.hpp"
|
|
|
|
namespace ZeroTier {
|
|
|
|
const char Utils::HEXCHARS[16] = { '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f' };
|
|
|
|
static const char *DAY_NAMES[7] = { "Sun","Mon","Tue","Wed","Thu","Fri","Sat" };
|
|
static const char *MONTH_NAMES[12] = { "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec" };
|
|
|
|
std::map<std::string,bool> Utils::listDirectory(const char *path)
|
|
{
|
|
std::map<std::string,bool> r;
|
|
|
|
#ifdef __WINDOWS__
|
|
HANDLE hFind;
|
|
WIN32_FIND_DATAA ffd;
|
|
if ((hFind = FindFirstFileA((std::string(path) + "\\*").c_str(),&ffd)) != INVALID_HANDLE_VALUE) {
|
|
do {
|
|
r[std::string(ffd.cFileName)] = ((ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0);
|
|
} while (FindNextFileA(hFind,&ffd));
|
|
FindClose(hFind);
|
|
}
|
|
#else
|
|
struct dirent de;
|
|
struct dirent *dptr;
|
|
|
|
DIR *d = opendir(path);
|
|
if (!d)
|
|
return r;
|
|
|
|
dptr = (struct dirent *)0;
|
|
for(;;) {
|
|
if (readdir_r(d,&de,&dptr))
|
|
break;
|
|
if (dptr) {
|
|
if ((strcmp(dptr->d_name,"."))&&(strcmp(dptr->d_name,"..")))
|
|
r[std::string(dptr->d_name)] = (dptr->d_type == DT_DIR);
|
|
} else break;
|
|
}
|
|
#endif
|
|
|
|
return r;
|
|
}
|
|
|
|
std::string Utils::hex(const void *data,unsigned int len)
|
|
{
|
|
std::string r;
|
|
r.reserve(len * 2);
|
|
for(unsigned int i=0;i<len;++i) {
|
|
r.push_back(HEXCHARS[(((const unsigned char *)data)[i] & 0xf0) >> 4]);
|
|
r.push_back(HEXCHARS[((const unsigned char *)data)[i] & 0x0f]);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
std::string Utils::unhex(const char *hex)
|
|
{
|
|
int n = 1;
|
|
unsigned char c,b = 0;
|
|
std::string r;
|
|
|
|
while ((c = (unsigned char)*(hex++))) {
|
|
if ((c >= 48)&&(c <= 57)) { // 0..9
|
|
if ((n ^= 1))
|
|
r.push_back((char)(b | (c - 48)));
|
|
else b = (c - 48) << 4;
|
|
} else if ((c >= 65)&&(c <= 70)) { // A..F
|
|
if ((n ^= 1))
|
|
r.push_back((char)(b | (c - (65 - 10))));
|
|
else b = (c - (65 - 10)) << 4;
|
|
} else if ((c >= 97)&&(c <= 102)) { // a..f
|
|
if ((n ^= 1))
|
|
r.push_back((char)(b | (c - (97 - 10))));
|
|
else b = (c - (97 - 10)) << 4;
|
|
}
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
unsigned int Utils::unhex(const char *hex,void *buf,unsigned int len)
|
|
{
|
|
int n = 1;
|
|
unsigned char c,b = 0;
|
|
unsigned int l = 0;
|
|
|
|
while ((c = (unsigned char)*(hex++))) {
|
|
if ((c >= 48)&&(c <= 57)) { // 0..9
|
|
if ((n ^= 1)) {
|
|
if (l >= len) break;
|
|
((unsigned char *)buf)[l++] = (b | (c - 48));
|
|
} else b = (c - 48) << 4;
|
|
} else if ((c >= 65)&&(c <= 70)) { // A..F
|
|
if ((n ^= 1)) {
|
|
if (l >= len) break;
|
|
((unsigned char *)buf)[l++] = (b | (c - (65 - 10)));
|
|
} else b = (c - (65 - 10)) << 4;
|
|
} else if ((c >= 97)&&(c <= 102)) { // a..f
|
|
if ((n ^= 1)) {
|
|
if (l >= len) break;
|
|
((unsigned char *)buf)[l++] = (b | (c - (97 - 10)));
|
|
} else b = (c - (97 - 10)) << 4;
|
|
}
|
|
}
|
|
|
|
return l;
|
|
}
|
|
|
|
unsigned int Utils::unhex(const char *hex,unsigned int hexlen,void *buf,unsigned int len)
|
|
throw()
|
|
{
|
|
int n = 1;
|
|
unsigned char c,b = 0;
|
|
unsigned int l = 0;
|
|
const char *const end = hex + hexlen;
|
|
|
|
while (hex != end) {
|
|
c = (unsigned char)*(hex++);
|
|
if ((c >= 48)&&(c <= 57)) { // 0..9
|
|
if ((n ^= 1)) {
|
|
if (l >= len) break;
|
|
((unsigned char *)buf)[l++] = (b | (c - 48));
|
|
} else b = (c - 48) << 4;
|
|
} else if ((c >= 65)&&(c <= 70)) { // A..F
|
|
if ((n ^= 1)) {
|
|
if (l >= len) break;
|
|
((unsigned char *)buf)[l++] = (b | (c - (65 - 10)));
|
|
} else b = (c - (65 - 10)) << 4;
|
|
} else if ((c >= 97)&&(c <= 102)) { // a..f
|
|
if ((n ^= 1)) {
|
|
if (l >= len) break;
|
|
((unsigned char *)buf)[l++] = (b | (c - (97 - 10)));
|
|
} else b = (c - (97 - 10)) << 4;
|
|
}
|
|
}
|
|
|
|
return l;
|
|
}
|
|
|
|
void Utils::getSecureRandom(void *buf,unsigned int bytes)
|
|
{
|
|
static Mutex randomLock;
|
|
static char randbuf[16384];
|
|
static unsigned int randptr = sizeof(randbuf);
|
|
static Salsa20 s20;
|
|
static bool randInitialized = false;
|
|
|
|
Mutex::Lock _l(randomLock);
|
|
|
|
// A Salsa20 instance is used to mangle whatever our base
|
|
// random source happens to be.
|
|
if (!randInitialized) {
|
|
randInitialized = true;
|
|
memset(randbuf,0,sizeof(randbuf));
|
|
char s20key[33];
|
|
uint64_t s20iv = now();
|
|
Utils::snprintf(s20key,sizeof(s20key),"%.16llx%.16llx",(unsigned long long)now(),(unsigned long long)((void *)&s20iv));
|
|
s20.init(s20key,256,&s20iv,8);
|
|
}
|
|
|
|
for(unsigned int i=0;i<bytes;++i) {
|
|
if (randptr >= sizeof(randbuf)) {
|
|
#ifdef __UNIX_LIKE__
|
|
{
|
|
int fd = ::open("/dev/urandom",O_RDONLY);
|
|
if (fd < 0) {
|
|
fprintf(stderr,"FATAL ERROR: unable to open /dev/urandom: %s"ZT_EOL_S,strerror(errno));
|
|
exit(-1);
|
|
}
|
|
if ((int)::read(fd,randbuf,sizeof(randbuf)) != (int)sizeof(randbuf)) {
|
|
fprintf(stderr,"FATAL ERROR: unable to read from /dev/urandom"ZT_EOL_S);
|
|
exit(-1);
|
|
}
|
|
::close(fd);
|
|
}
|
|
#else
|
|
#ifdef __WINDOWS__
|
|
{
|
|
char ktmp[32];
|
|
char ivtmp[8];
|
|
for(int i=0;i<32;++i) ktmp[i] = (char)rand();
|
|
for(int i=0;i<8;++i) ivtmp[i] = (char)rand();
|
|
double now = Utils::nowf();
|
|
memcpy(ktmp,&now,sizeof(now));
|
|
DWORD tmp = GetCurrentProcessId();
|
|
memcpy(ktmp + sizeof(now),&tmp,sizeof(tmp));
|
|
tmp = GetTickCount();
|
|
memcpy(ktmp + sizeof(now) + sizeof(DWORD),&tmp,sizeof(tmp));
|
|
Salsa20 s20tmp(ktmp,256,ivtmp,8);
|
|
s20tmp.encrypt(randbuf,randbuf,sizeof(randbuf));
|
|
}
|
|
#else
|
|
no getSecureRandom() implementation;
|
|
#endif
|
|
#endif
|
|
s20.encrypt(randbuf,randbuf,sizeof(randbuf));
|
|
randptr = 0;
|
|
}
|
|
((char *)buf)[i] = randbuf[randptr++];
|
|
}
|
|
}
|
|
|
|
void Utils::lockDownFile(const char *path,bool isDir)
|
|
{
|
|
#if defined(__APPLE__) || defined(__linux__) || defined(linux) || defined(__LINUX__) || defined(__linux)
|
|
chmod(path,isDir ? 0700 : 0600);
|
|
#else
|
|
#ifdef _WIN32
|
|
// TODO: windows ACL hell...
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
uint64_t Utils::getLastModified(const char *path)
|
|
{
|
|
struct stat s;
|
|
if (stat(path,&s))
|
|
return 0;
|
|
return (((uint64_t)s.st_mtime) * 1000ULL);
|
|
}
|
|
|
|
std::string Utils::toRfc1123(uint64_t t64)
|
|
{
|
|
struct tm t;
|
|
char buf[128];
|
|
time_t utc = (time_t)(t64 / 1000ULL);
|
|
#ifdef __WINDOWS__
|
|
gmtime_s(&t,&utc);
|
|
#else
|
|
gmtime_r(&utc,&t);
|
|
#endif
|
|
Utils::snprintf(buf,sizeof(buf),"%3s, %02d %3s %4d %02d:%02d:%02d GMT",DAY_NAMES[t.tm_wday],t.tm_mday,MONTH_NAMES[t.tm_mon],t.tm_year + 1900,t.tm_hour,t.tm_min,t.tm_sec);
|
|
return std::string(buf);
|
|
}
|
|
|
|
#ifdef __WINDOWS__
|
|
static int is_leap(unsigned y) {
|
|
y += 1900;
|
|
return (y % 4) == 0 && ((y % 100) != 0 || (y % 400) == 0);
|
|
}
|
|
static time_t timegm(struct tm *tm) {
|
|
static const unsigned ndays[2][12] = {
|
|
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
|
|
{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
|
|
};
|
|
time_t res = 0;
|
|
int i;
|
|
for (i = 70; i < tm->tm_year; ++i)
|
|
res += is_leap(i) ? 366 : 365;
|
|
|
|
for (i = 0; i < tm->tm_mon; ++i)
|
|
res += ndays[is_leap(tm->tm_year)][i];
|
|
res += tm->tm_mday - 1;
|
|
res *= 24;
|
|
res += tm->tm_hour;
|
|
res *= 60;
|
|
res += tm->tm_min;
|
|
res *= 60;
|
|
res += tm->tm_sec;
|
|
return res;
|
|
}
|
|
#endif
|
|
|
|
uint64_t Utils::fromRfc1123(const char *tstr)
|
|
{
|
|
struct tm t;
|
|
char wdays[128],mons[128];
|
|
|
|
int l = (int)strlen(tstr);
|
|
if ((l < 29)||(l > 64))
|
|
return 0;
|
|
int assigned = sscanf(tstr,"%3s, %02d %3s %4d %02d:%02d:%02d GMT",wdays,&t.tm_mday,mons,&t.tm_year,&t.tm_hour,&t.tm_min,&t.tm_sec);
|
|
if (assigned != 7)
|
|
return 0;
|
|
|
|
wdays[3] = '\0';
|
|
for(t.tm_wday=0;t.tm_wday<7;++t.tm_wday) {
|
|
#ifdef __WINDOWS__
|
|
if (!_stricmp(DAY_NAMES[t.tm_wday],wdays))
|
|
break;
|
|
#else
|
|
if (!strcasecmp(DAY_NAMES[t.tm_wday],wdays))
|
|
break;
|
|
#endif
|
|
}
|
|
if (t.tm_wday == 7)
|
|
return 0;
|
|
mons[3] = '\0';
|
|
for(t.tm_mon=0;t.tm_mon<12;++t.tm_mon) {
|
|
#ifdef __WINDOWS__
|
|
if (!_stricmp(MONTH_NAMES[t.tm_mday],mons))
|
|
break;
|
|
#else
|
|
if (!strcasecmp(MONTH_NAMES[t.tm_mday],mons))
|
|
break;
|
|
#endif
|
|
}
|
|
if (t.tm_mon == 12)
|
|
return 0;
|
|
|
|
t.tm_wday = 0; // ignored by timegm
|
|
t.tm_yday = 0; // ignored by timegm
|
|
t.tm_isdst = 0; // ignored by timegm
|
|
|
|
time_t utc = timegm(&t);
|
|
|
|
return ((utc > 0) ? (1000ULL * (uint64_t)utc) : 0ULL);
|
|
}
|
|
|
|
bool Utils::readFile(const char *path,std::string &buf)
|
|
{
|
|
char tmp[4096];
|
|
FILE *f = fopen(path,"rb");
|
|
if (f) {
|
|
for(;;) {
|
|
long n = (long)fread(tmp,1,sizeof(tmp),f);
|
|
if (n > 0)
|
|
buf.append(tmp,n);
|
|
else break;
|
|
}
|
|
fclose(f);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Utils::writeFile(const char *path,const void *buf,unsigned int len)
|
|
{
|
|
FILE *f = fopen(path,"wb");
|
|
if (f) {
|
|
if ((long)fwrite(buf,1,len,f) != (long)len) {
|
|
fclose(f);
|
|
return false;
|
|
} else {
|
|
fclose(f);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
std::vector<std::string> Utils::split(const char *s,const char *const sep,const char *esc,const char *quot)
|
|
{
|
|
std::vector<std::string> fields;
|
|
std::string buf;
|
|
|
|
if (!esc)
|
|
esc = "";
|
|
if (!quot)
|
|
quot = "";
|
|
|
|
bool escapeState = false;
|
|
char quoteState = 0;
|
|
while (*s) {
|
|
if (escapeState) {
|
|
escapeState = false;
|
|
buf.push_back(*s);
|
|
} else if (quoteState) {
|
|
if (*s == quoteState) {
|
|
quoteState = 0;
|
|
fields.push_back(buf);
|
|
buf.clear();
|
|
} else buf.push_back(*s);
|
|
} else {
|
|
const char *quotTmp;
|
|
if (strchr(esc,*s))
|
|
escapeState = true;
|
|
else if ((buf.size() <= 0)&&((quotTmp = strchr(quot,*s))))
|
|
quoteState = *quotTmp;
|
|
else if (strchr(sep,*s)) {
|
|
if (buf.size() > 0) {
|
|
fields.push_back(buf);
|
|
buf.clear();
|
|
} // else skip runs of seperators
|
|
} else buf.push_back(*s);
|
|
}
|
|
++s;
|
|
}
|
|
|
|
if (buf.size())
|
|
fields.push_back(buf);
|
|
|
|
return fields;
|
|
}
|
|
|
|
std::string Utils::trim(const std::string &s)
|
|
{
|
|
unsigned long end = (unsigned long)s.length();
|
|
while (end) {
|
|
char c = s[end - 1];
|
|
if ((c == ' ')||(c == '\r')||(c == '\n')||(!c)||(c == '\t'))
|
|
--end;
|
|
else break;
|
|
}
|
|
unsigned long start = 0;
|
|
while (start < end) {
|
|
char c = s[start];
|
|
if ((c == ' ')||(c == '\r')||(c == '\n')||(!c)||(c == '\t'))
|
|
++start;
|
|
else break;
|
|
}
|
|
return s.substr(start,end - start);
|
|
}
|
|
|
|
void Utils::stdsprintf(std::string &s,const char *fmt,...)
|
|
throw(std::bad_alloc,std::length_error)
|
|
{
|
|
char buf[65536];
|
|
va_list ap;
|
|
|
|
va_start(ap,fmt);
|
|
int n = vsnprintf(buf,sizeof(buf),fmt,ap);
|
|
va_end(ap);
|
|
|
|
if ((n >= (int)sizeof(buf))||(n < 0))
|
|
throw std::length_error("printf result too large");
|
|
|
|
s.append(buf);
|
|
}
|
|
|
|
unsigned int Utils::snprintf(char *buf,unsigned int len,const char *fmt,...)
|
|
throw(std::length_error)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap,fmt);
|
|
int n = (int)vsnprintf(buf,len,fmt,ap);
|
|
va_end(ap);
|
|
|
|
if ((n >= (int)len)||(n < 0)) {
|
|
if (len)
|
|
buf[len - 1] = (char)0;
|
|
throw std::length_error("buf[] overflow in Utils::snprintf");
|
|
}
|
|
|
|
return (unsigned int)n;
|
|
}
|
|
|
|
} // namespace ZeroTier
|