2013-07-04 20:56:19 +00:00
|
|
|
/*
|
|
|
|
* 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/
|
|
|
|
*/
|
|
|
|
|
2013-12-07 00:49:20 +00:00
|
|
|
#ifndef ZT_NODE_HPP
|
|
|
|
#define ZT_NODE_HPP
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2013-11-20 21:16:30 +00:00
|
|
|
#include <string>
|
|
|
|
#include <vector>
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
namespace ZeroTier {
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A ZeroTier One node
|
|
|
|
*
|
|
|
|
* This class hides all its implementation details and all other classes in
|
|
|
|
* preparation for ZeroTier One being made available in library form for
|
|
|
|
* embedding in mobile apps.
|
|
|
|
*/
|
|
|
|
class Node
|
|
|
|
{
|
|
|
|
public:
|
2013-07-18 15:43:46 +00:00
|
|
|
/**
|
|
|
|
* Client for controlling a local ZeroTier One node
|
2014-01-27 06:24:29 +00:00
|
|
|
*
|
|
|
|
* Windows note: be sure you call WSAStartup() before using this,
|
|
|
|
* otherwise it will be unable to open a local UDP socket to
|
|
|
|
* communicate with the service.
|
2013-07-18 15:43:46 +00:00
|
|
|
*/
|
|
|
|
class LocalClient
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Create a new node config client
|
|
|
|
*
|
|
|
|
* @param authToken Authentication token
|
2013-09-17 18:47:48 +00:00
|
|
|
* @param controlPort Control port or 0 for 39393 (default)
|
2013-07-18 15:43:46 +00:00
|
|
|
* @param resultHandler Function to call when commands provide results
|
|
|
|
*/
|
2013-09-17 18:47:48 +00:00
|
|
|
LocalClient(const char *authToken,unsigned int controlPort,void (*resultHandler)(void *,unsigned long,const char *),void *arg)
|
2013-07-18 15:43:46 +00:00
|
|
|
throw();
|
|
|
|
|
|
|
|
~LocalClient();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Send a command to the local node
|
|
|
|
*
|
2013-07-18 20:35:52 +00:00
|
|
|
* Note that the returned conversation ID will never be 0. A return value
|
|
|
|
* of 0 indicates a fatal error such as failure to bind to any local UDP
|
|
|
|
* port.
|
|
|
|
*
|
2013-07-18 15:43:46 +00:00
|
|
|
* @param command
|
2013-07-18 20:35:52 +00:00
|
|
|
* @return Conversation ID that will be provided to result handler when/if results are sent back
|
2013-07-18 15:43:46 +00:00
|
|
|
*/
|
|
|
|
unsigned long send(const char *command)
|
|
|
|
throw();
|
2013-11-20 21:16:30 +00:00
|
|
|
inline unsigned long send(const std::string &command) throw() { return send(command.c_str()); }
|
2013-07-18 15:43:46 +00:00
|
|
|
|
2013-11-20 19:10:33 +00:00
|
|
|
/**
|
|
|
|
* Split a line of results by space
|
|
|
|
*
|
|
|
|
* @param line Line to split
|
|
|
|
* @return Vector of fields
|
|
|
|
*/
|
|
|
|
static std::vector<std::string> splitLine(const char *line);
|
|
|
|
static inline std::vector<std::string> splitLine(const std::string &line) { return splitLine(line.c_str()); }
|
|
|
|
|
2014-01-03 22:03:29 +00:00
|
|
|
/**
|
|
|
|
* @return Default path for user-local authorization token for the current user or empty string if cannot be determined
|
|
|
|
*/
|
|
|
|
static std::string authTokenDefaultUserPath();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Default system path for auth token on this platform
|
|
|
|
*/
|
|
|
|
static std::string authTokenDefaultSystemPath();
|
|
|
|
|
2013-07-18 15:43:46 +00:00
|
|
|
private:
|
|
|
|
// LocalClient is not copyable
|
|
|
|
LocalClient(const LocalClient&);
|
|
|
|
const LocalClient& operator=(const LocalClient&);
|
|
|
|
|
|
|
|
void *_impl;
|
|
|
|
};
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
|
|
|
* Returned by node main if/when it terminates
|
|
|
|
*/
|
|
|
|
enum ReasonForTermination
|
|
|
|
{
|
2013-12-10 23:30:53 +00:00
|
|
|
/**
|
|
|
|
* Node is currently in run()
|
|
|
|
*/
|
2013-07-04 20:56:19 +00:00
|
|
|
NODE_RUNNING = 0,
|
2013-12-10 23:30:53 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Node is shutting down for normal reasons, including a signal
|
|
|
|
*/
|
2013-07-04 20:56:19 +00:00
|
|
|
NODE_NORMAL_TERMINATION = 1,
|
2013-12-10 23:30:53 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* An upgrade is available. Its path is in reasonForTermination().
|
|
|
|
*/
|
|
|
|
NODE_RESTART_FOR_UPGRADE = 2,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A serious unrecoverable error has occurred.
|
|
|
|
*/
|
2013-08-30 19:02:12 +00:00
|
|
|
NODE_UNRECOVERABLE_ERROR = 3
|
2013-07-04 20:56:19 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create a new node
|
|
|
|
*
|
|
|
|
* The node is not executed until run() is called.
|
|
|
|
*
|
|
|
|
* @param hp Home directory path
|
2013-09-17 18:47:48 +00:00
|
|
|
* @param port Port to bind for talking to the ZT1 network or 0 for 9993 (default)
|
|
|
|
* @param controlPort Port to bind locally for control packets or 0 for 39393 (default)
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-09-17 18:47:48 +00:00
|
|
|
Node(const char *hp,unsigned int port,unsigned int controlPort)
|
2013-07-04 20:56:19 +00:00
|
|
|
throw();
|
|
|
|
|
|
|
|
~Node();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Execute node in current thread
|
|
|
|
*
|
|
|
|
* This does not return until the node shuts down. Shutdown may be caused
|
|
|
|
* by an internally detected condition such as a new upgrade being
|
|
|
|
* available or a fatal error, or it may be signaled externally using
|
|
|
|
* the terminate() method.
|
|
|
|
*
|
|
|
|
* @return Reason for termination
|
|
|
|
*/
|
|
|
|
ReasonForTermination run()
|
|
|
|
throw();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Obtain a human-readable reason for node termination
|
|
|
|
*
|
|
|
|
* @return Reason for node termination or NULL if run() has not returned
|
|
|
|
*/
|
|
|
|
const char *reasonForTermination() const
|
|
|
|
throw();
|
|
|
|
|
|
|
|
/**
|
2013-08-30 19:02:12 +00:00
|
|
|
* Cause run() to return
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
|
|
|
* This can be called from a signal handler or another thread to signal a
|
|
|
|
* running node to shut down. Shutdown may take a few seconds, so run()
|
|
|
|
* may not return instantly. Multiple calls are ignored.
|
2013-08-30 19:02:12 +00:00
|
|
|
*
|
|
|
|
* @param reason Reason for termination
|
|
|
|
* @param reasonText Text to be returned by reasonForTermination()
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-08-30 19:02:12 +00:00
|
|
|
void terminate(ReasonForTermination reason,const char *reasonText)
|
2013-07-04 20:56:19 +00:00
|
|
|
throw();
|
2014-01-30 01:24:55 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Forget p2p links and resynchronize with peers
|
|
|
|
*/
|
|
|
|
void resync()
|
|
|
|
throw();
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the ZeroTier version in major.minor.revision string format
|
2013-11-20 19:10:33 +00:00
|
|
|
*
|
2013-07-04 20:56:19 +00:00
|
|
|
* @return Version in string form
|
|
|
|
*/
|
|
|
|
static const char *versionString()
|
|
|
|
throw();
|
|
|
|
|
|
|
|
static unsigned int versionMajor() throw();
|
|
|
|
static unsigned int versionMinor() throw();
|
|
|
|
static unsigned int versionRevision() throw();
|
|
|
|
|
|
|
|
private:
|
2013-07-18 15:43:46 +00:00
|
|
|
// Nodes are not copyable
|
|
|
|
Node(const Node&);
|
|
|
|
const Node& operator=(const Node&);
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
void *const _impl; // private implementation
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace ZeroTier
|
|
|
|
|
2013-08-26 21:22:20 +00:00
|
|
|
extern "C" {
|
|
|
|
|
|
|
|
// Functions with C-style linkage for easy DLL symbol table
|
|
|
|
// lookup. These just create instances of Node and LocalClient.
|
|
|
|
|
2013-09-17 18:47:48 +00:00
|
|
|
ZeroTier::Node *zeroTierCreateNode(const char *hp,unsigned int port,unsigned int controlPort);
|
2013-08-26 21:22:20 +00:00
|
|
|
void zeroTierDeleteNode(ZeroTier::Node *n);
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2013-09-17 18:47:48 +00:00
|
|
|
ZeroTier::Node::LocalClient *zeroTierCreateLocalClient(const char *authToken,unsigned int controlPort,void (*resultHandler)(void *,unsigned long,const char *),void *arg);
|
2013-08-26 21:22:20 +00:00
|
|
|
void zeroTierDeleteLocalClient(ZeroTier::Node::LocalClient *lc);
|
|
|
|
|
|
|
|
} // extern "C"
|
|
|
|
|
|
|
|
#endif
|