ExternalVendorCode/ZeroTierOne
1
0
Fork 0
mirror of https://github.com/zerotier/ZeroTierOne.git synced 2024-12-19 04:57:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Clean out attic.

Browse Source
This commit is contained in:
Adam Ierymenko 2015-04-08 16:50:14 -07:00
parent 4d5a6a25d3
commit 12431ce95d
4 changed files with 0 additions and 453 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
attic/Logger.cpp
View File

@ -1,153 +0,0 @@
/*
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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 <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <time.h>
#include "Constants.hpp"
#include "Logger.hpp"
namespace ZeroTier {
Logger::Logger(const char *p,const char *prefix,unsigned long maxLogSize) :
_path((p) ? p : ""),
_prefix((prefix) ? (std::string(prefix) + " ") : ""),
_maxLogSize(maxLogSize),
_log_m(),
_log((FILE *)0)
{
if (_path.length())
_log = fopen(_path.c_str(),"a");
else _log = stdout;
}
Logger::~Logger()
{
fflush(_log);
if ((_log)&&(_log != stdout)&&(_log != stderr))
fclose(_log);
}
void Logger::log(const char *fmt,...)
{
va_list ap;
char tmp[128];
if (_log) {
Mutex::Lock _l(_log_m);
_rotateIfNeeded();
if (_log) {
time_t now = time(0);
#ifdef __WINDOWS__
ctime_s(tmp,sizeof(tmp),&now);
char *nowstr = tmp;
#else
char *nowstr = ctime_r(&now,tmp);
#endif
for(char *c=nowstr;*c;++c) {
if (*c == '\n')
*c = '\0';
}
if (_prefix.length())
fwrite(_prefix.data(),1,_prefix.length(),_log);
fprintf(_log,"[%s] ",nowstr);
va_start(ap,fmt);
vfprintf(_log,fmt,ap);
va_end(ap);
#ifdef _WIN32
fwrite("\r\n",1,2,_log);
#else
fwrite("\n",1,1,_log);
#endif
fflush(_log);
}
}
}
#ifdef ZT_TRACE
void Logger::trace(const char *module,unsigned int line,const char *fmt,...)
{
va_list ap;
char tmp[128];
if (_log) {
Mutex::Lock _l(_log_m);
_rotateIfNeeded();
if (_log) {
time_t now = time(0);
#ifdef __WINDOWS__
ctime_s(tmp,sizeof(tmp),&now);
char *nowstr = tmp;
#else
char *nowstr = ctime_r(&now,tmp);
#endif
for(char *c=nowstr;*c;++c) {
if (*c == '\n')
*c = '\0';
}
if (_prefix.length())
fwrite(_prefix.data(),1,_prefix.length(),_log);
fprintf(_log,"[%s] TRACE/%s:%u ",nowstr,module,line);
va_start(ap,fmt);
vfprintf(_log,fmt,ap);
va_end(ap);
#ifdef _WIN32
fwrite("\r\n",1,2,_log);
#else
fwrite("\n",1,1,_log);
#endif
fflush(_log);
}
}
}
#endif
void Logger::_rotateIfNeeded()
{
if ((_maxLogSize)&&(_log != stdout)&&(_log != stderr)) {
long pos = ftell(_log);
if (pos > (long)_maxLogSize) {
fclose(_log);
rename(_path.c_str(),std::string(_path).append(".old").c_str());
_log = fopen(_path.c_str(),"w");
}
}
}
} // namespace ZeroTier

92
attic/Logger.hpp
View File

@ -1,92 +0,0 @@
/*
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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/
*/
#ifndef ZT_LOGGER_HPP
#define ZT_LOGGER_HPP
#include <stdio.h>
#include <string>
#include <stdexcept>
#include "NonCopyable.hpp"
#include "Mutex.hpp"
#undef LOG
#define LOG(f,...) if (RR->log) RR->log->log(f,##__VA_ARGS__)
#undef TRACE
#ifdef ZT_TRACE
#define TRACE(f,...) if (RR->log) RR->log->trace(__FILE__,__LINE__,f,##__VA_ARGS__)
#else
#define TRACE(f,...) {}
#endif
namespace ZeroTier {
/**
* Utility for outputting logs to a file or stdout/stderr
*/
class Logger : NonCopyable
{
public:
/**
* Construct a logger to log to a file or stdout
*
* If a path is supplied to log to a file, maxLogSize indicates the size
* at which this file is closed, renamed to .old, and then a new log is
* opened (essentially a log rotation). If stdout is used, this is ignored.
*
* @param p Path to log to or NULL to use stdout
* @param prefix Prefix to prepend to log lines or NULL for none
* @param maxLogSize Maximum log size (0 for no limit)
*/
Logger(const char *p,const char *prefix,unsigned long maxLogSize);
~Logger();
void log(const char *fmt,...);
#ifdef ZT_TRACE
void trace(const char *module,unsigned int line,const char *fmt,...);
#else
inline void trace(const char *module,unsigned int line,const char *fmt,...) {}
#endif
private:
void _rotateIfNeeded();
std::string _path;
std::string _prefix;
unsigned long _maxLogSize;
Mutex _log_m;
FILE *_log;
};
} // namespace ZeroTier
#endif

99
attic/Socket.hpp
View File

@ -1,99 +0,0 @@
/*
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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/
*/
#ifndef ZT_SOCKET_HPP
#define ZT_SOCKET_HPP
#include "Constants.hpp"
#include "InetAddress.hpp"
#include "AtomicCounter.hpp"
#include "SharedPtr.hpp"
#include "NonCopyable.hpp"
/**
* Maximum discrete message length supported by all socket types
*/
#define ZT_SOCKET_MAX_MESSAGE_LEN 2048
namespace ZeroTier {
class Socket;
/**
* Base class for transport-layer socket implementations
*/
class Socket : NonCopyable
{
friend class SharedPtr<Socket>;
public:
enum Type
{
ZT_SOCKET_TYPE_UDP_V4 = 1,
ZT_SOCKET_TYPE_UDP_V6 = 2,
ZT_SOCKET_TYPE_TCP_IN = 3, // incoming connection accepted from listen socket
ZT_SOCKET_TYPE_TCP_OUT = 4, // outgoing connection to remote endpoint
ZT_SOCKET_TYPE_ETHERNET = 5 // unused, for future SDN backplane support
};
virtual ~Socket() {}
/**
* @return Socket type
*/
inline Type type() const throw() { return _type; }
/**
* @return True if this is a UDP socket
*/
inline bool udp() const throw() { return ((_type == ZT_SOCKET_TYPE_UDP_V4)||(_type == ZT_SOCKET_TYPE_UDP_V6)); }
/**
* @return True if this is a TCP socket
*/
inline bool tcp() const throw() { return ((_type == ZT_SOCKET_TYPE_TCP_IN)||(_type == ZT_SOCKET_TYPE_TCP_OUT)); }
/**
* Send a ZeroTier message packet
*
* @param to Destination address (ignored in connected TCP sockets)
* @param msg Message data
* @param msglen Message length (max 16384 bytes)
* @return True if send appears successful on our end, false if e.g. address type unreachable from this socket
*/
virtual bool send(const InetAddress &to,const void *msg,unsigned int msglen) = 0;
protected:
Socket(const Type &t) : _type(t) {}
Type _type;
AtomicCounter __refCount;
};
} // namespace ZeroTier
#endif

109
attic/SocketManager.hpp
View File

@ -1,109 +0,0 @@
/*
* ZeroTier One - Network Virtualization Everywhere
* Copyright (C) 2011-2015 ZeroTier, Inc.
*
* 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/
*/
#ifndef ZT_SOCKETMANAGER_HPP
#define ZT_SOCKETMANAGER_HPP
#include <stdio.h>
#include <stdlib.h>
#include <map>
#include <stdexcept>
#include "Constants.hpp"
#include "InetAddress.hpp"
#include "Buffer.hpp"
#include "NonCopyable.hpp"
#include "Socket.hpp"
namespace ZeroTier {
/**
* Socket I/O implementation
*/
class SocketManager : NonCopyable
{
public:
SocketManager() {}
virtual ~SocketManager() {}
/**
* Send a message to a remote peer
*
* @param to Destination address
* @param tcp Use TCP?
* @param autoConnectTcp If true, automatically initiate TCP connection if there is none
* @param msg Message to send
* @param msglen Length of message
*/
virtual bool send(
const InetAddress &to,
bool tcp,
bool autoConnectTcp,
const void *msg,
unsigned int msglen) = 0;
/**
* Send a message to a remote peer via UDP (shortcut for setting both TCP params to false in send)
*
* @param to Destination address
* @param msg Message to send
* @param msglen Length of message
*/
inline bool sendUdp(
const InetAddress &to,
const void *msg,
unsigned int msglen) { return send(to,false,false,msg,msglen); }
/**
* Perform I/O polling operation (e.g. select())
*
* If called concurrently, one will block until the other completes.
*
* @param timeout Timeout in milliseconds, may return sooner if whack() is called
* @param handler Packet data handler
* @param arg Void argument to packet data handler
*/
virtual void poll(
unsigned long timeout,
void (*handler)(const SharedPtr<Socket> &,void *,const InetAddress &,Buffer<ZT_SOCKET_MAX_MESSAGE_LEN> &),
void *arg) = 0;
/**
* Cause current or next blocking poll() operation to timeout immediately
*/
virtual void whack() = 0;
/**
* Close TCP sockets
*/
virtual void closeTcpSockets() = 0;
};
} // namespace ZeroTier
#endif