HTTP client work...

node/HttpClient.cpp

@@ -0,0 +1,291 @@
+/*
+ * 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 <stdlib.h>
+#include <string.h>
+
+#include <vector>
+#include <utility>
+#include <algorithm>
+
+#include "Constants.hpp"
+#include "HttpClient.hpp"
+#include "Thread.hpp"
+#include "Utils.hpp"
+#include "NonCopyable.hpp"
+#include "Defaults.hpp"
+
+#ifdef __UNIX_LIKE__
+#include <unistd.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <sys/select.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+#endif
+
+namespace ZeroTier {
+
+#ifdef __UNIX_LIKE__
+
+// The *nix implementation calls 'curl' externally rather than linking to it.
+// This makes it an optional dependency that can be avoided in tiny systems
+// provided you don't want to have automatic software updates... or want to
+// do them via another method.
+
+// Paths where "curl" may be found on the system
+#define NUM_CURL_PATHS 5
+static const char *CURL_PATHS[NUM_CURL_PATHS] = { "/usr/bin/curl","/bin/curl","/usr/local/bin/curl","/usr/sbin/curl","/sbin/curl" };
+static const std::string CURL_IN_HOME(ZT_DEFAULTS.defaultHomePath + "/curl");
+
+// Maximum message length
+#define CURL_MAX_MESSAGE_LENGTH (1024 * 1024 * 64)
+
+// Internal private thread class that performs request, notifies handler,
+// and then commits suicide by deleting itself.
+class P_Req : NonCopyable
+{
+public:
+	P_Req(const char *method,const std::string &url,const std::map<std::string,std::string> &headers,unsigned int timeout,void (*handler)(void *,int,const std::string &,bool,const std::string &),void *arg) :
+		_url(url),
+		_headers(headers),
+		_timeout(timeout),
+		_handler(handler),
+		_arg(arg)
+	{
+		_myThread = Thread::start(this);
+	}
+
+	void threadMain()
+	{
+		char *curlArgs[1024];
+		char buf[16384];
+		fd_set readfds,writefds,errfds;
+		struct timeval tv;
+
+		std::string curlPath;
+		for(int i=0;i<NUM_CURL_PATHS;++i) {
+			if (Utils::fileExists(CURL_PATHS[i])) {
+				curlPath = CURL_PATHS[i];
+				break;
+			}
+		}
+		if (!curlPath.length()) {
+			if (Utils::fileExists(CURL_IN_HOME.c_str()))
+				curlPath = CURL_IN_HOME;
+		}
+		if (!curlPath.length()) {
+			_handler(_arg,-1,_url,false,"unable to locate 'curl' binary in /usr/bin, /bin, /usr/local/bin, /usr/sbin, or /sbin");
+			delete this;
+			return;
+		}
+
+		curlArgs[0] = const_cast <char *>(curlPath.c_str());
+		curlArgs[1] = const_cast <char *>("-D");
+		curlArgs[2] = const_cast <char *>("-"); // append headers before output
+		int argPtr = 3;
+		std::vector<std::string> headerArgs;
+		for(std::map<std::string,std::string>::const_iterator h(_headers.begin());h!=_headers.end();++h) {
+			headerArgs.push_back(h->first);
+			headerArgs.back().append(": ");
+			headerArgs.back().append(h->second);
+		}
+		for(std::vector<std::string>::iterator h(headerArgs.begin());h!=headerArgs.end();++h) {
+			if (argPtr >= (1024 - 3)) // leave room for terminating NULL
+				break;
+			curlArgs[argPtr++] = const_cast <char *>("-H");
+			curlArgs[argPtr++] = const_cast <char *>(h->c_str());
+		}
+		curlArgs[argPtr] = (char *)0;
+
+		int curlStdout[2];
+		int curlStderr[2];
+		::pipe(curlStdout);
+		::pipe(curlStderr);
+
+		long pid = (long)vfork();
+		if (pid < 0) {
+			// fork() failed
+			::close(curlStdout[0]);
+			::close(curlStdout[1]);
+			::close(curlStderr[0]);
+			::close(curlStderr[1]);
+			_handler(_arg,-1,_url,false,"unable to fork()");
+			delete this;
+			return;
+		} else if (pid > 0) {
+			// fork() succeeded, in parent process
+			::close(curlStdout[1]);
+			::close(curlStderr[1]);
+			fcntl(curlStdout[0],F_SETFL,O_NONBLOCK);
+			fcntl(curlStderr[0],F_SETFL,O_NONBLOCK);
+
+			int exitCode = -1;
+			unsigned long long timesOutAt = Utils::now() + ((unsigned long long)_timeout * 1000ULL);
+			bool timedOut = false;
+			bool tooLong = false;
+			for(;;) {
+				FD_ZERO(&readfds);
+				FD_ZERO(&writefds);
+				FD_ZERO(&errfds);
+				FD_SET(curlStdout[0],&readfds);
+				FD_SET(curlStderr[0],&readfds);
+				FD_SET(curlStdout[0],&errfds);
+				FD_SET(curlStderr[0],&errfds);
+				tv.tv_sec = 1;
+				tv.tv_usec = 0;
+				select(std::max(curlStdout[0],curlStderr[0])+1,&readfds,&writefds,&errfds,&tv);
+
+				if (FD_ISSET(curlStdout[0],&readfds)) {
+					int n = (int)::read(curlStdout[0],buf,sizeof(buf));
+					if (n > 0)
+						_body.append(buf,n);
+					else break;
+					if (_body.length() > CURL_MAX_MESSAGE_LENGTH) {
+						::kill(pid,SIGKILL);
+						tooLong = true;
+						break;
+					}
+				}
+				if (FD_ISSET(curlStderr[0],&readfds))
+					::read(curlStderr[0],buf,sizeof(buf));
+				if (FD_ISSET(curlStdout[0],&errfds)||FD_ISSET(curlStderr[0],&errfds))
+					break;
+
+				if (Utils::now() >= timesOutAt) {
+					::kill(pid,SIGKILL);
+					timedOut = true;
+					break;
+				}
+
+				if (waitpid(pid,&exitCode,WNOHANG) > 0) {
+					pid = 0;
+					break;
+				}
+			}
+
+			if (pid > 0)
+				waitpid(pid,&exitCode,0);
+
+			::close(curlStdout[0]);
+			::close(curlStderr[0]);
+
+			if (timedOut)
+				_handler(_arg,-1,_url,false,"connection timed out");
+			else if (tooLong)
+				_handler(_arg,-1,_url,false,"response too long");
+			else if (exitCode)
+				_handler(_arg,-1,_url,false,"connection failed (curl returned non-zero exit code)");
+			else {
+				unsigned long idx = 0;
+
+				// Grab status line and headers, which will prefix output on
+				// success and will end with an empty line.
+				std::vector<std::string> headers;
+				headers.push_back(std::string());
+				while (idx < _body.length()) {
+					char c = _body[idx++];
+					if (c == '\n') {
+						if (!headers.back().length()) {
+							headers.pop_back();
+							break;
+						}
+					} else if (c != '\r') // \r's shouldn't be present but ignore them if they are
+						headers.back().push_back(c);
+				}
+				if (headers.empty()||(!headers.front().length())) {
+					_handler(_arg,-1,_url,false,"HTTP response empty");
+					delete this;
+					return;
+				}
+
+				// Parse first line -- HTTP status code and response
+				size_t scPos = headers.front().find(' ');
+				if (scPos == std::string::npos) {
+					_handler(_arg,-1,_url,false,"invalid HTTP response (no status line)");
+					delete this;
+					return;
+				}
+				++scPos;
+				size_t msgPos = headers.front().find(' ',scPos);
+				if (msgPos == std::string::npos)
+					msgPos = headers.front().length();
+				if ((msgPos - scPos) != 3) {
+					_handler(_arg,-1,_url,false,"invalid HTTP response (no response code)");
+					delete this;
+					return;
+				}
+				unsigned int rcode = Utils::strToUInt(headers.front().substr(scPos,3).c_str());
+				if ((!rcode)||(rcode > 999)) {
+					_handler(_arg,-1,_url,false,"invalid HTTP response (invalid response code)");
+					delete this;
+					return;
+				}
+
+				// Serve up the resulting data to the handler
+				if (rcode == 200)
+					_handler(_arg,rcode,_url,false,_body.substr(idx));
+				else _handler(_arg,rcode,_url,false,headers.front().substr(scPos+3));
+			}
+
+			delete this;
+			return;
+		} else {
+			// fork() succeeded, in child process
+			::dup2(curlStdout[1],STDOUT_FILENO);
+			::close(curlStdout[1]);
+			::dup2(curlStderr[1],STDERR_FILENO);
+			::close(curlStderr[1]);
+			::execv(curlPath.c_str(),curlArgs);
+			::exit(-1); // only reached if execv() fails
+		}
+	}
+
+	const std::string _url;
+	std::string _body;
+	std::map<std::string,std::string> _headers;
+	unsigned int _timeout;
+	void (*_handler)(void *,int,const std::string &,bool,const std::string &);
+	void *_arg;
+	Thread _myThread;
+};
+
+HttpClient::Request HttpClient::_do(
+	const char *method,
+	const std::string &url,
+	const std::map<std::string,std::string> &headers,
+	unsigned int timeout,
+	void (*handler)(void *,int,const std::string &,bool,const std::string &),
+	void *arg)
+{
+}
+
+#endif
+
+} // namespace ZeroTier

node/HttpClient.hpp

@@ -0,0 +1,85 @@
+/*
+ * 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/
+ */
+
+#ifndef ZT_HTTPCLIENT_HPP
+#define ZT_HTTPCLIENT_HPP
+
+#include <string>
+#include <map>
+
+#include "Constants.hpp"
+
+namespace ZeroTier {
+
+/**
+ * HTTP client that does queries in the background
+ *
+ * The handler method takes the following arguments: an arbitrary pointer, an
+ * HTTP response code, the URL queried, whether or not the message body was
+ * stored on disk, and the message body.
+ *
+ * If stored on disk, the body string contains the path and the file must be
+ * moved or deleted by the receiver when it's done. If an error occurs, the
+ * response code will be negative and the body will be the error message.
+ *
+ * All headers in the returned headers map will have their header names
+ * converted to lower case, e.g. "content-type".
+ *
+ * Currently only the "http" transport is guaranteed to be supported on all
+ * platforms.
+ */
+class HttpClient
+{
+public:
+	typedef void * Request;
+
+	/**
+	 * Request a URL using the GET method
+	 */
+	static inline Request GET(
+		const std::string &url,
+		const std::map<std::string,std::string> &headers,
+		unsigned int timeout,
+		void (*handler)(void *,int,const std::string &,bool,const std::string &),
+		void *arg)
+	{
+		return _do("GET",url,headers,timeout,handler,arg);
+	}
+
+private:
+	static Request _do(
+		const char *method,
+		const std::string &url,
+		const std::map<std::string,std::string> &headers,
+		unsigned int timeout,
+		void (*handler)(void *,int,const std::string &,bool,const std::string &),
+		void *arg);
+};
+
+} // namespace ZeroTier
+
+#endif

objects.mk

@@ -6,6 +6,7 @@ OBJS=\
 	node/Defaults.o \
 	node/Demarc.o \
 	node/EthernetTap.o \
+	node/HttpClient.o \
 	node/Identity.o \
 	node/InetAddress.o \
 	node/Logger.o \