diff options
Diffstat (limited to 'attic/oldcontrol')
| -rw-r--r-- | attic/oldcontrol/IpcConnection.cpp | 281 | ||||
| -rw-r--r-- | attic/oldcontrol/IpcConnection.hpp | 107 | ||||
| -rw-r--r-- | attic/oldcontrol/IpcListener.cpp | 165 | ||||
| -rw-r--r-- | attic/oldcontrol/IpcListener.hpp | 91 | ||||
| -rw-r--r-- | attic/oldcontrol/NodeControlClient.cpp | 167 | ||||
| -rw-r--r-- | attic/oldcontrol/NodeControlClient.hpp | 118 | ||||
| -rw-r--r-- | attic/oldcontrol/NodeControlService.cpp | 250 | ||||
| -rw-r--r-- | attic/oldcontrol/NodeControlService.hpp | 84 | ||||
| -rw-r--r-- | attic/oldcontrol/README.md | 4 |
9 files changed, 1267 insertions, 0 deletions
diff --git a/attic/oldcontrol/IpcConnection.cpp b/attic/oldcontrol/IpcConnection.cpp new file mode 100644 index 00000000..370b4680 --- /dev/null +++ b/attic/oldcontrol/IpcConnection.cpp @@ -0,0 +1,281 @@ +/* + * 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 <errno.h> +#include <stdarg.h> + +#include <stdexcept> + +#include "IpcConnection.hpp" + +#ifndef __WINDOWS__ +#include <unistd.h> +#include <sys/ioctl.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <sys/socket.h> +#include <sys/select.h> +#endif + +namespace ZeroTier { + +IpcConnection::IpcConnection(const char *endpoint,unsigned int timeout,void (*commandHandler)(void *,IpcConnection *,IpcConnection::EventType,const char *),void *arg) : + _handler(commandHandler), + _arg(arg), + _timeout(timeout), +#ifdef __WINDOWS__ + _sock(INVALID_HANDLE_VALUE), + _incoming(false), +#else + _sock(-1), +#endif + _run(true), + _running(true) +{ +#ifdef __WINDOWS__ + _sock = CreateFileA(endpoint,GENERIC_READ|GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,NULL,OPEN_EXISTING,0,NULL); + if (_sock == INVALID_HANDLE_VALUE) + throw std::runtime_error("IPC endpoint unreachable"); + DWORD pipeMode = PIPE_READMODE_BYTE; + SetNamedPipeHandleState(_sock,&pipeMode,NULL,NULL); +#else + struct sockaddr_un unaddr; + unaddr.sun_family = AF_UNIX; + strncpy(unaddr.sun_path,endpoint,sizeof(unaddr.sun_path)); + unaddr.sun_path[sizeof(unaddr.sun_path) - 1] = (char)0; + + _sock = socket(AF_UNIX,SOCK_STREAM,0); + if (_sock <= 0) + throw std::runtime_error("unable to create socket of type AF_UNIX"); + + if (connect(_sock,(struct sockaddr *)&unaddr,sizeof(unaddr))) { + ::close(_sock); + throw std::runtime_error("IPC endpoint unreachable"); + } +#endif + + _thread = Thread::start(this); +} + +#ifdef __WINDOWS__ +IpcConnection::IpcConnection(HANDLE s,unsigned int timeout,void (*commandHandler)(void *,IpcConnection *,IpcConnection::EventType,const char *),void *arg) : +#else +IpcConnection::IpcConnection(int s,unsigned int timeout,void (*commandHandler)(void *,IpcConnection *,IpcConnection::EventType,const char *),void *arg) : +#endif + _handler(commandHandler), + _arg(arg), + _timeout(timeout), + _sock(s), +#ifdef __WINDOWS__ + _incoming(true), +#endif + _run(true), + _running(true) +{ + _thread = Thread::start(this); +} + +IpcConnection::~IpcConnection() +{ + _writeLock.lock(); + _run = false; + _writeLock.unlock(); + +#ifdef __WINDOWS__ + + while (_running) { + Thread::cancelIO(_thread); // cause Windows to break from blocking read and detect shutdown + Sleep(100); + } + +#else // !__WINDOWS__ + + int s = _sock; + _sock = 0; + if (s > 0) { + ::shutdown(s,SHUT_RDWR); + ::close(s); + } + Thread::join(_thread); + +#endif // __WINDOWS__ / !__WINDOWS__ +} + +void IpcConnection::printf(const char *format,...) +{ + va_list ap; + int n; + char tmp[65536]; + + va_start(ap,format); + n = (int)::vsnprintf(tmp,sizeof(tmp),format,ap); + va_end(ap); + if (n <= 0) + return; + + Mutex::Lock _l(_writeLock); + +#ifdef __WINDOWS__ + _writeBuf.append(tmp,n); + Thread::cancelIO(_thread); // cause Windows to break from blocking read and service write buffer +#else + if (_sock > 0) + ::write(_sock,tmp,n); +#endif +} + +void IpcConnection::threadMain() + throw() +{ + char tmp[16384]; + char linebuf[16384]; + unsigned int lineptr = 0; + char c; + +#ifdef __WINDOWS__ + + DWORD n,i; + std::string wbuf; + +#else // !__WINDOWS__ + + int s,n,i; + fd_set readfds,writefds,errorfds; + struct timeval tout; + +#ifdef SO_NOSIGPIPE + if (_sock > 0) { + i = 1; + ::setsockopt(_sock,SOL_SOCKET,SO_NOSIGPIPE,(char *)&i,sizeof(i)); + } +#endif // SO_NOSIGPIPE + +#endif // __WINDOWS__ / !__WINDOWS__ + + while (_run) { + +#ifdef __WINDOWS__ + + /* Note that we do not use fucking timeouts in Windows, since it does seem + * to properly detect named pipe endpoint close. But we do use a write buffer + * because Windows won't let you divorce reading and writing threads without + * all that OVERLAPPED cruft. */ + { + Mutex::Lock _l(_writeLock); + if (!_run) + break; + if (_writeBuf.length() > 0) { + wbuf.append(_writeBuf); + _writeBuf.clear(); + } + } + if (wbuf.length() > 0) { + n = 0; + if ((WriteFile(_sock,wbuf.data(),(DWORD)(wbuf.length()),&n,NULL))&&(n > 0)) { + if (n < (DWORD)wbuf.length()) + wbuf.erase(0,n); + else wbuf.clear(); + } else if (GetLastError() != ERROR_OPERATION_ABORTED) + break; + FlushFileBuffers(_sock); + } + if (!_run) + break; + n = 0; + if ((!ReadFile(_sock,tmp,sizeof(tmp),&n,NULL))||(n <= 0)) { + if (GetLastError() == ERROR_OPERATION_ABORTED) + n = 0; + else break; + } + if (!_run) + break; + +#else // !__WINDOWS__ + + /* So today I learned that there is no reliable way to detect a half-closed + * Unix domain socket. So to make sure we don't leave orphaned sockets around + * we just use fucking timeouts. If a socket fucking times out, we break from + * the I/O loop and terminate the thread. But this IpcConnection code is ugly + * so maybe the OS is simply offended by it and refuses to reveal its mysteries + * to me. Oh well... this IPC code will probably get canned when we go to + * local HTTP RESTful interfaces or soemthing like that. */ + if ((s = _sock) <= 0) + break; + FD_ZERO(&readfds); + FD_ZERO(&writefds); + FD_ZERO(&errorfds); + FD_SET(s,&readfds); + FD_SET(s,&errorfds); + tout.tv_sec = _timeout; // use a fucking timeout + tout.tv_usec = 0; + if (select(s+1,&readfds,&writefds,&errorfds,&tout) <= 0) { + break; // socket has fucking timed out + } else { + if (FD_ISSET(s,&errorfds)) + break; // socket has an exception... sometimes works + else { + n = (int)::read(s,tmp,sizeof(tmp)); + if ((n <= 0)||(_sock <= 0)) + break; // read returned error... sometimes works + } + } + +#endif // __WINDOWS__ / !__WINDOWS__ + + for(i=0;i<n;++i) { + c = (linebuf[lineptr] = tmp[i]); + if ((c == '\r')||(c == '\n')||(c == (char)0)||(lineptr == (sizeof(linebuf) - 1))) { + if (lineptr) { + linebuf[lineptr] = (char)0; + _handler(_arg,this,IPC_EVENT_COMMAND,linebuf); + lineptr = 0; + } + } else ++lineptr; + } + } + + _writeLock.lock(); + bool r = _run; + _writeLock.unlock(); + +#ifdef __WINDOWS__ + + if (_incoming) + DisconnectNamedPipe(_sock); + CloseHandle(_sock); + _running = false; + +#endif // __WINDOWS__ + + if (r) + _handler(_arg,this,IPC_EVENT_CONNECTION_CLOSED,(const char *)0); +} + +} // namespace ZeroTier diff --git a/attic/oldcontrol/IpcConnection.hpp b/attic/oldcontrol/IpcConnection.hpp new file mode 100644 index 00000000..2466f1a5 --- /dev/null +++ b/attic/oldcontrol/IpcConnection.hpp @@ -0,0 +1,107 @@ +/* + * 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_IPCCONNECTION_HPP +#define ZT_IPCCONNECTION_HPP + +#include "../node/Constants.hpp" +#include "../node/Thread.hpp" +#include "../node/NonCopyable.hpp" +#include "../node/Mutex.hpp" + +#ifdef __WINDOWS__ +#include <WinSock2.h> +#include <Windows.h> +#endif + +namespace ZeroTier { + +class IpcListener; + +/** + * Interprocess communication connection + */ +class IpcConnection : NonCopyable +{ + friend class IpcListener; + +public: + enum EventType + { + IPC_EVENT_COMMAND, + IPC_EVENT_NEW_CONNECTION, + IPC_EVENT_CONNECTION_CLOSED + }; + + /** + * Connect to an IPC endpoint + * + * @param endpoint Endpoint path + * @param timeout Inactivity timeout in seconds + * @param commandHandler Command handler function + * @param arg First argument to command handler + * @throws std::runtime_error Unable to connect + */ + IpcConnection(const char *endpoint,unsigned int timeout,void (*commandHandler)(void *,IpcConnection *,IpcConnection::EventType,const char *),void *arg); + ~IpcConnection(); + + /** + * @param format Printf format string + * @param ... Printf arguments + */ + void printf(const char *format,...); + + void threadMain() + throw(); + +private: + // Used by IpcListener to construct incoming connections +#ifdef __WINDOWS__ + IpcConnection(HANDLE s,unsigned int timeout,void (*commandHandler)(void *,IpcConnection *,IpcConnection::EventType,const char *),void *arg); +#else + IpcConnection(int s,unsigned int timeout,void (*commandHandler)(void *,IpcConnection *,IpcConnection::EventType,const char *),void *arg); +#endif + + void (*_handler)(void *,IpcConnection *,IpcConnection::EventType,const char *); + void *_arg; + unsigned int _timeout; +#ifdef __WINDOWS__ + HANDLE _sock; + std::string _writeBuf; + bool _incoming; +#else + volatile int _sock; +#endif + Mutex _writeLock; + Thread _thread; + volatile bool _run; + volatile bool _running; +}; + +} // namespace ZeroTier + +#endif diff --git a/attic/oldcontrol/IpcListener.cpp b/attic/oldcontrol/IpcListener.cpp new file mode 100644 index 00000000..6f8f839a --- /dev/null +++ b/attic/oldcontrol/IpcListener.cpp @@ -0,0 +1,165 @@ +/* + * ZeroTier One - Network Virtualization Everywhere + * Copyright (C) 2011-2014 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 <stdlib.h> +#include <string.h> +#include <errno.h> + +#include "IpcListener.hpp" + +#ifndef __WINDOWS__ +#include <sys/socket.h> +#include <sys/un.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <unistd.h> +#endif + +namespace ZeroTier { + +IpcListener::IpcListener(const char *ep,unsigned int timeout,void (*commandHandler)(void *,IpcConnection *,IpcConnection::EventType,const char *),void *arg) : + _endpoint(ep), + _handler(commandHandler), + _arg(arg), + _timeout(timeout), +#ifdef __WINDOWS__ + _run(true), + _running(true) +#else + _sock(0) +#endif +{ +#ifndef __WINDOWS__ + struct sockaddr_un unaddr; + unaddr.sun_family = AF_UNIX; + strncpy(unaddr.sun_path,_endpoint.c_str(),sizeof(unaddr.sun_path)); + unaddr.sun_path[sizeof(unaddr.sun_path) - 1] = (char)0; + + struct stat stattmp; + if (stat(_endpoint.c_str(),&stattmp)) { + int testSock = socket(AF_UNIX,SOCK_STREAM,0); + if (testSock <= 0) + throw std::runtime_error("unable to create socket of type AF_UNIX"); + if (connect(testSock,(struct sockaddr *)&unaddr,sizeof(unaddr))) { + // error means nothing is listening, orphaned name + ::close(testSock); + } else { + // success means endpoint is being actively listened to by a process + ::close(testSock); + throw std::runtime_error("IPC endpoint address in use"); + } + } + ::unlink(_endpoint.c_str()); + + _sock = socket(AF_UNIX,SOCK_STREAM,0); + if (_sock <= 0) + throw std::runtime_error("unable to create socket of type AF_UNIX"); + if (bind(_sock,(struct sockaddr *)&unaddr,sizeof(unaddr))) { + ::close(_sock); + throw std::runtime_error("IPC endpoint could not be bound"); + } + if (listen(_sock,8)) { + ::close(_sock); + throw std::runtime_error("listen() failed for bound AF_UNIX socket"); + } + ::chmod(_endpoint.c_str(),0777); +#endif + + _thread = Thread::start(this); +} + +IpcListener::~IpcListener() +{ +#ifdef __WINDOWS__ + _run = false; + while (_running) { + Thread::cancelIO(_thread); + HANDLE tmp = CreateFileA(_endpoint.c_str(),GENERIC_READ|GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,NULL,OPEN_EXISTING,0,NULL); + if (tmp != INVALID_HANDLE_VALUE) + CloseHandle(tmp); + Sleep(250); + } +#else + int s = _sock; + _sock = 0; + if (s > 0) { + ::shutdown(s,SHUT_RDWR); + ::close(s); + } + Thread::join(_thread); + ::unlink(_endpoint.c_str()); +#endif +} + +void IpcListener::threadMain() + throw() +{ +#ifdef __WINDOWS__ + HANDLE s; + while (_run) { + s = CreateNamedPipeA(_endpoint.c_str(),PIPE_ACCESS_DUPLEX,PIPE_READMODE_BYTE|PIPE_TYPE_BYTE|PIPE_WAIT,PIPE_UNLIMITED_INSTANCES,1024,1024,0,NULL); + if (s != INVALID_HANDLE_VALUE) { + if ((ConnectNamedPipe(s,NULL))||(GetLastError() == ERROR_PIPE_CONNECTED)) { + if (!_run) { + DisconnectNamedPipe(s); + CloseHandle(s); + break; + } + try { + _handler(_arg,new IpcConnection(s,_timeout,_handler,_arg),IpcConnection::IPC_EVENT_NEW_CONNECTION,(const char *)0); + } catch ( ... ) {} // handlers should not throw + } else { + CloseHandle(s); + } + } + } + _running = false; +#else + struct sockaddr_un unaddr; + socklen_t socklen; + int s; + while (_sock > 0) { + unaddr.sun_family = AF_UNIX; + strncpy(unaddr.sun_path,_endpoint.c_str(),sizeof(unaddr.sun_path)); + unaddr.sun_path[sizeof(unaddr.sun_path) - 1] = (char)0; + socklen = sizeof(unaddr); + s = accept(_sock,(struct sockaddr *)&unaddr,&socklen); + if (s <= 0) + break; + if (!_sock) { + ::close(s); + break; + } + try { + _handler(_arg,new IpcConnection(s,_timeout,_handler,_arg),IpcConnection::IPC_EVENT_NEW_CONNECTION,(const char *)0); + } catch ( ... ) {} // handlers should not throw + } +#endif +} + +} // namespace ZeroTier diff --git a/attic/oldcontrol/IpcListener.hpp b/attic/oldcontrol/IpcListener.hpp new file mode 100644 index 00000000..8f080c6d --- /dev/null +++ b/attic/oldcontrol/IpcListener.hpp @@ -0,0 +1,91 @@ +/* + * ZeroTier One - Network Virtualization Everywhere + * Copyright (C) 2011-2014 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/ + */ + +#ifndef ZT_IPCLISTENER_HPP +#define ZT_IPCLISTENER_HPP + +#include "../node/Constants.hpp" +#include "../node/Thread.hpp" +#include "../node/NonCopyable.hpp" +#include "IpcConnection.hpp" + +#include <string> +#include <stdexcept> + +namespace ZeroTier { + +/** + * IPC incoming connection listener (Unix domain sockets or named pipes on Windows) + */ +class IpcListener : NonCopyable +{ +public: + /** + * Listen for IPC connections + * + * The supplied handler is passed on to incoming instances of IpcConnection. When + * a connection is first opened, it is called with IPC_EVENT_NEW_CONNECTION. The + * receiver must take ownership of the connection object. When a connection is + * closed, IPC_EVENT_CONNECTION_CLOSED is generated. At this point (or after) the + * receiver must delete the object. IPC_EVENT_COMMAND is generated when lines of + * text are read, and in this cases the last argument is not NULL. No closed event + * is generated in the event of manual delete if the connection is still open. + * + * Yeah, this whole callback model sort of sucks. Might rethink and replace with + * some kind of actor model or something if it gets too unweildy. But for now the + * use cases are simple enough that it's not too bad. + * + * @param IPC endpoint name (OS-specific) + * @param timeout Endpoint inactivity timeout in seconds + * @param commandHandler Function to call for each command + * @param arg First argument to pass to handler + * @throws std::runtime_error Unable to bind to endpoint + */ + IpcListener(const char *ep,unsigned int timeout,void (*commandHandler)(void *,IpcConnection *,IpcConnection::EventType,const char *),void *arg); + + ~IpcListener(); + + void threadMain() + throw(); + +private: + std::string _endpoint; + void (*_handler)(void *,IpcConnection *,IpcConnection::EventType,const char *); + void *_arg; + unsigned int _timeout; +#ifdef __WINDOWS__ + volatile bool _run; + volatile bool _running; +#else + volatile int _sock; +#endif + Thread _thread; +}; + +} // namespace ZeroTier + +#endif diff --git a/attic/oldcontrol/NodeControlClient.cpp b/attic/oldcontrol/NodeControlClient.cpp new file mode 100644 index 00000000..92eadf7c --- /dev/null +++ b/attic/oldcontrol/NodeControlClient.cpp @@ -0,0 +1,167 @@ +/* + * 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 "NodeControlClient.hpp" +#include "../node/Constants.hpp" +#include "../node/Utils.hpp" +#include "../node/Defaults.hpp" +#include "IpcConnection.hpp" +#include "IpcListener.hpp" +#include "NodeControlService.hpp" + +#ifdef __WINDOWS__ +#include <WinSock2.h> +#include <Windows.h> +#include <tchar.h> +#include <wchar.h> +#include <ShlObj.h> +#endif // __WINDOWS__ + +namespace ZeroTier { + +struct _NodeControlClientImpl +{ + void (*resultHandler)(void *,const char *); + void *arg; + bool ignoreNextBreak; + IpcConnection *ipcc; + std::string err; +}; + +static void _CBipcResultHandler(void *arg,IpcConnection *ipcc,IpcConnection::EventType event,const char *result) +{ + if ((event == IpcConnection::IPC_EVENT_COMMAND)&&(result)) { + if (!strcmp(result,"200 auth OK")) { + ((_NodeControlClientImpl *)arg)->ignoreNextBreak = true; + } else if ((((_NodeControlClientImpl *)arg)->ignoreNextBreak)&&(!strcmp(result,"."))) { + ((_NodeControlClientImpl *)arg)->ignoreNextBreak = false; + } else ((_NodeControlClientImpl *)arg)->resultHandler(((_NodeControlClientImpl *)arg)->arg,result); + } +} + +NodeControlClient::NodeControlClient(const char *ep,const char *authToken,void (*resultHandler)(void *,const char *),void *arg) + throw() : + _impl((void *)new _NodeControlClientImpl) +{ + _NodeControlClientImpl *impl = (_NodeControlClientImpl *)_impl; + impl->resultHandler = resultHandler; + impl->arg = arg; + impl->ignoreNextBreak = false; + try { + impl->ipcc = new IpcConnection(ep,ZT_IPC_TIMEOUT,&_CBipcResultHandler,_impl); + impl->ipcc->printf("auth %s"ZT_EOL_S,authToken); + } catch ( ... ) { + impl->ipcc = (IpcConnection *)0; + impl->err = "failure connecting to running ZeroTier One service"; + } +} + +NodeControlClient::~NodeControlClient() +{ + if (_impl) { + delete ((_NodeControlClientImpl *)_impl)->ipcc; + delete (_NodeControlClientImpl *)_impl; + } +} + +const char *NodeControlClient::error() const + throw() +{ + if (((_NodeControlClientImpl *)_impl)->err.length()) + return ((_NodeControlClientImpl *)_impl)->err.c_str(); + return (const char *)0; +} + +void NodeControlClient::send(const char *command) + throw() +{ + try { + if (((_NodeControlClientImpl *)_impl)->ipcc) + ((_NodeControlClientImpl *)_impl)->ipcc->printf("%s"ZT_EOL_S,command); + } catch ( ... ) {} +} + +std::vector<std::string> NodeControlClient::splitLine(const char *line) +{ + return Utils::split(line," ","\\","\""); +} + +const char *NodeControlClient::authTokenDefaultUserPath() +{ + static std::string dlp; + static Mutex dlp_m; + + Mutex::Lock _l(dlp_m); + +#ifdef __WINDOWS__ + + if (!dlp.length()) { + char buf[16384]; + if (SUCCEEDED(SHGetFolderPathA(NULL,CSIDL_APPDATA,NULL,0,buf))) + dlp = (std::string(buf) + "\\ZeroTier\\One\\authtoken.secret"); + } + +#else // not __WINDOWS__ + + if (!dlp.length()) { + const char *home = getenv("HOME"); + if (home) { +#ifdef __APPLE__ + dlp = (std::string(home) + "/Library/Application Support/ZeroTier/One/authtoken.secret"); +#else + dlp = (std::string(home) + "/.zeroTierOneAuthToken"); +#endif + } + } + +#endif // __WINDOWS__ or not __WINDOWS__ + + return dlp.c_str(); +} + +std::string NodeControlClient::getAuthToken(const char *path,bool generateIfNotFound) +{ + unsigned char randbuf[24]; + std::string token; + + if (Utils::readFile(path,token)) + return Utils::trim(token); + else token = ""; + + if (generateIfNotFound) { + Utils::getSecureRandom(randbuf,sizeof(randbuf)); + for(unsigned int i=0;i<sizeof(randbuf);++i) + token.push_back(("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")[(unsigned int)randbuf[i] % 62]); + if (!Utils::writeFile(path,token)) + return std::string(); + Utils::lockDownFile(path,false); + } + + return token; +} + +} // namespace ZeroTier diff --git a/attic/oldcontrol/NodeControlClient.hpp b/attic/oldcontrol/NodeControlClient.hpp new file mode 100644 index 00000000..71bf7679 --- /dev/null +++ b/attic/oldcontrol/NodeControlClient.hpp @@ -0,0 +1,118 @@ +/* + * 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_NODECONTROLCLIENT_HPP +#define ZT_NODECONTROLCLIENT_HPP + +#include <string> +#include <vector> + +#include "../node/Constants.hpp" + +#ifdef __WINDOWS__ +#define ZT_IPC_ENDPOINT_BASE "\\\\.\\pipe\\ZeroTierOne-" +#else +#define ZT_IPC_ENDPOINT_BASE "/tmp/.ZeroTierOne-" +#endif + +namespace ZeroTier { + +/** + * Client for controlling a local ZeroTier One node + */ +class NodeControlClient +{ +public: + /** + * Create a new node config client + * + * Initialization may fail. Call error() to check. + * + * @param ep Endpoint to connect to (OS-dependent) + * @param resultHandler Function to call when commands provide results + * @param arg First argument to result handler + */ + NodeControlClient(const char *ep,const char *authToken,void (*resultHandler)(void *,const char *),void *arg) + throw(); + + ~NodeControlClient(); + + /** + * @return Initialization error or NULL if none + */ + const char *error() const + throw(); + + /** + * Send a command to the local node + * + * 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. + * + * @param command + * @return Conversation ID that will be provided to result handler when/if results are sent back + */ + void send(const char *command) + throw(); + inline void send(const std::string &command) + throw() { return send(command.c_str()); } + + /** + * Split a line of results + * + * @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()); } + + /** + * @return Default path for current user's authtoken.secret or ~/.zeroTierOneAuthToken (location is platform-dependent) + */ + static const char *authTokenDefaultUserPath(); + + /** + * Load (or generate) the authentication token + * + * @param path Full path to authtoken.secret + * @param generateIfNotFound If true, generate and save if not found or readable (requires appropriate privileges, returns empty on failure) + * @return Authentication token or empty string on failure + */ + static std::string getAuthToken(const char *path,bool generateIfNotFound); + +private: + // NodeControlClient is not copyable + NodeControlClient(const NodeControlClient&); + const NodeControlClient& operator=(const NodeControlClient&); + + void *_impl; +}; + +} // namespace ZeroTier + +#endif diff --git a/attic/oldcontrol/NodeControlService.cpp b/attic/oldcontrol/NodeControlService.cpp new file mode 100644 index 00000000..9f14764b --- /dev/null +++ b/attic/oldcontrol/NodeControlService.cpp @@ -0,0 +1,250 @@ +/* + * 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 <string.h> +#include <stdlib.h> + +#include "NodeControlService.hpp" +#include "NodeControlClient.hpp" + +#include "../node/Constants.hpp" +#include "../node/MAC.hpp" +#include "../node/Node.hpp" +#include "../node/Utils.hpp" + +namespace ZeroTier { + +NodeControlService::NodeControlService(Node *node,const char *authToken) : + _node(node), + _listener((IpcListener *)0), + _authToken(authToken), + _running(true), + _thread(Thread::start(this)) +{ +} + +NodeControlService::~NodeControlService() +{ + _running = false; + Thread::join(_thread); + { + Mutex::Lock _l(_connections_m); + for(std::map< IpcConnection *,bool >::iterator c(_connections.begin());c!=_connections.end();++c) + delete c->first; + _connections.clear(); + } + delete _listener; +} + +void NodeControlService::threadMain() + throw() +{ + char tmp[1024]; + try { + while (_running) { + if (!_node->running()) { + if (_node->started()) + break; + } else if ((_node->initialized())&&(_node->address())) { + Utils::snprintf(tmp,sizeof(tmp),"%s%.10llx",ZT_IPC_ENDPOINT_BASE,(unsigned long long)_node->address()); + _listener = new IpcListener(tmp,ZT_IPC_TIMEOUT,&_CBcommandHandler,this); + break; + } + Thread::sleep(100); // wait for Node to start + } + } catch ( ... ) { + delete _listener; + _listener = (IpcListener *)0; + } +} + +void NodeControlService::_CBcommandHandler(void *arg,IpcConnection *ipcc,IpcConnection::EventType event,const char *commandLine) +{ + switch(event) { + case IpcConnection::IPC_EVENT_COMMAND: { + if ((!((NodeControlService *)arg)->_running)||(!commandLine)||(!commandLine[0])) + return; + ((NodeControlService *)arg)->_doCommand(ipcc,commandLine); + } break; + + case IpcConnection::IPC_EVENT_NEW_CONNECTION: { + Mutex::Lock _l(((NodeControlService *)arg)->_connections_m); + ((NodeControlService *)arg)->_connections[ipcc] = false; // not yet authenticated + } break; + + case IpcConnection::IPC_EVENT_CONNECTION_CLOSED: { + Mutex::Lock _l(((NodeControlService *)arg)->_connections_m); + ((NodeControlService *)arg)->_connections.erase(ipcc); + delete ipcc; + } break; + } +} + +void NodeControlService::_doCommand(IpcConnection *ipcc,const char *commandLine) +{ + std::vector<std::string> r; + std::vector<std::string> cmd(Utils::split(commandLine,"\r\n \t","\\","'")); + + if ((cmd.empty())||(cmd[0] == "help")) { + ipcc->printf("200 help help"ZT_EOL_S); + ipcc->printf("200 help auth <token>"ZT_EOL_S); + ipcc->printf("200 help info"ZT_EOL_S); + ipcc->printf("200 help listpeers"ZT_EOL_S); + ipcc->printf("200 help listnetworks"ZT_EOL_S); + ipcc->printf("200 help join <network ID>"ZT_EOL_S); + ipcc->printf("200 help leave <network ID>"ZT_EOL_S); + ipcc->printf("200 help terminate [<reason>]"ZT_EOL_S); + ipcc->printf("200 help updatecheck"ZT_EOL_S); + } else if (cmd[0] == "auth") { + if ((cmd.size() > 1)&&(_authToken.length() > 0)&&(_authToken == cmd[1])) { + Mutex::Lock _l(_connections_m); + _connections[ipcc] = true; + ipcc->printf("200 auth OK"ZT_EOL_S); + } else ipcc->printf("403 auth failed"ZT_EOL_S); + } else { + { + Mutex::Lock _l(_connections_m); + if (!_connections[ipcc]) { + ipcc->printf("403 %s unauthorized"ZT_EOL_S"."ZT_EOL_S,cmd[0].c_str()); + return; + } + } + + if (cmd[0] == "info") { + ipcc->printf("200 info %.10llx %s %s"ZT_EOL_S,_node->address(),(_node->online() ? "ONLINE" : "OFFLINE"),Node::versionString()); + } else if (cmd[0] == "listpeers") { + ipcc->printf("200 listpeers <ztaddr> <paths> <latency> <version> <role>"ZT_EOL_S); + ZT1_Node_PeerList *pl = _node->listPeers(); + if (pl) { + for(unsigned int i=0;i<pl->numPeers;++i) { + ipcc->printf("200 listpeers %.10llx ",(unsigned long long)pl->peers[i].rawAddress); + if (pl->peers[i].numPaths == 0) + ipcc->printf("-"); + else { + for(unsigned int j=0;j<pl->peers[i].numPaths;++j) { + if (j > 0) + ipcc->printf(","); + switch(pl->peers[i].paths[j].type) { + default: + ipcc->printf("unknown;"); + break; + case ZT1_Node_PhysicalPath_TYPE_UDP: + ipcc->printf("udp;"); + break; + case ZT1_Node_PhysicalPath_TYPE_TCP_OUT: + ipcc->printf("tcp_out;"); + break; + case ZT1_Node_PhysicalPath_TYPE_TCP_IN: + ipcc->printf("tcp_in;"); + break; + case ZT1_Node_PhysicalPath_TYPE_ETHERNET: + ipcc->printf("eth;"); + break; + } + ipcc->printf("%s/%d;%ld;%ld;%ld;%s", + pl->peers[i].paths[j].address.ascii, + (int)pl->peers[i].paths[j].address.port, + pl->peers[i].paths[j].lastSend, + pl->peers[i].paths[j].lastReceive, + pl->peers[i].paths[j].lastPing, + (pl->peers[i].paths[j].fixed ? "fixed" : (pl->peers[i].paths[j].active ? "active" : "inactive"))); + } + } + const char *rolestr; + switch(pl->peers[i].role) { + case ZT1_Node_Peer_SUPERNODE: rolestr = "SUPERNODE"; break; + case ZT1_Node_Peer_HUB: rolestr = "HUB"; break; + case ZT1_Node_Peer_NODE: rolestr = "NODE"; break; + default: rolestr = "?"; break; + } + ipcc->printf(" %u %s %s"ZT_EOL_S, + pl->peers[i].latency, + ((pl->peers[i].remoteVersion[0]) ? pl->peers[i].remoteVersion : "-"), + rolestr); + } + _node->freeQueryResult(pl); + } + } else if (cmd[0] == "listnetworks") { + ipcc->printf("200 listnetworks <nwid> <name> <mac> <status> <config age> <type> <dev> <ips>"ZT_EOL_S); + ZT1_Node_NetworkList *nl = _node->listNetworks(); + if (nl) { + for(unsigned int i=0;i<nl->numNetworks;++i) { + ipcc->printf("200 listnetworks %s %s %s %s %ld %s %s ", + nl->networks[i].nwidHex, + nl->networks[i].name, + nl->networks[i].macStr, + nl->networks[i].statusStr, + nl->networks[i].configAge, + (nl->networks[i].isPrivate ? "private" : "public"), + nl->networks[i].device); + if (nl->networks[i].numIps > 0) { + for(unsigned int j=0;j<nl->networks[i].numIps;++j) { + if (j > 0) + ipcc->printf(","); + ipcc->printf("%s/%d",nl->networks[i].ips[j].ascii,(int)nl->networks[i].ips[j].port); + } + } else ipcc->printf("-"); + ipcc->printf(ZT_EOL_S); + } + _node->freeQueryResult(nl); + } + } else if (cmd[0] == "join") { + if (cmd.size() > 1) { + uint64_t nwid = Utils::hexStrToU64(cmd[1].c_str()); + _node->join(nwid); + ipcc->printf("200 join %.16llx OK"ZT_EOL_S,(unsigned long long)nwid); + } else { + ipcc->printf("400 join requires a network ID (>0) in hexadecimal format"ZT_EOL_S); + } + } else if (cmd[0] == "leave") { + if (cmd.size() > 1) { + uint64_t nwid = Utils::hexStrToU64(cmd[1].c_str()); + _node->leave(nwid); + ipcc->printf("200 leave %.16llx OK"ZT_EOL_S,(unsigned long long)nwid); + } else { + ipcc->printf("400 leave requires a network ID (>0) in hexadecimal format"ZT_EOL_S); + } + } else if (cmd[0] == "terminate") { + if (cmd.size() > 1) + _node->terminate(Node::NODE_NORMAL_TERMINATION,cmd[1].c_str()); + else _node->terminate(Node::NODE_NORMAL_TERMINATION,"terminate via IPC command"); + } else if (cmd[0] == "updatecheck") { + if (_node->updateCheck()) { + ipcc->printf("500 software updates are not enabled"ZT_EOL_S); + } else { + ipcc->printf("200 OK"ZT_EOL_S); + } + } else { + ipcc->printf("404 %s No such command. Use 'help' for help."ZT_EOL_S,cmd[0].c_str()); + } + } + + ipcc->printf("."ZT_EOL_S); +} + +} // namespace ZeroTier diff --git a/attic/oldcontrol/NodeControlService.hpp b/attic/oldcontrol/NodeControlService.hpp new file mode 100644 index 00000000..ac647d7e --- /dev/null +++ b/attic/oldcontrol/NodeControlService.hpp @@ -0,0 +1,84 @@ +/* + * 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_NODECONTROLSERVICE_HPP +#define ZT_NODECONTROLSERVICE_HPP + +#include <string> +#include <map> + +#include "IpcConnection.hpp" +#include "IpcListener.hpp" + +#include "../node/Constants.hpp" +#include "../node/NonCopyable.hpp" +#include "../node/Thread.hpp" + +namespace ZeroTier { + +class Node; + +/** + * Background controller service that controls and configures a node + * + * This is used with system-installed instances of ZeroTier One to + * provide the IPC-based control bus service for node configuration. + */ +class NodeControlService : NonCopyable +{ +public: + /** + * @param node Node to control and configure + * @param authToken Authorization token for clients + */ + NodeControlService(Node *node,const char *authToken); + + ~NodeControlService(); + + // Background thread waits for node to initialize, then creates IpcListener and + // terminates. It also terminates on delete if it hasn't bootstrapped yet. + void threadMain() + throw(); + +private: + static void _CBcommandHandler(void *arg,IpcConnection *ipcc,IpcConnection::EventType event,const char *commandLine); + void _doCommand(IpcConnection *ipcc,const char *commandLine); + + Node *_node; + IpcListener *_listener; + std::string _authToken; + + std::map< IpcConnection *,bool > _connections; + Mutex _connections_m; + + volatile bool _running; + Thread _thread; +}; + +} // namespace ZeroTier + +#endif diff --git a/attic/oldcontrol/README.md b/attic/oldcontrol/README.md new file mode 100644 index 00000000..c1c69a90 --- /dev/null +++ b/attic/oldcontrol/README.md @@ -0,0 +1,4 @@ +ZeroTier Control Plane +====== + +This code is responsible for the local command bus used to control the ZeroTier One service on a local machine via zerotier-cli or the Qt GUI. It's not part of the core node implementation. It uses Unix domain sockets on unix-like OSes and named pipes on Windows. Authentication is via a simple token mechanism. (Eventually this part of the software is getting a rework.)
\ No newline at end of file |