summaryrefslogtreecommitdiff
path: root/node/HttpClient.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'node/HttpClient.cpp')
-rw-r--r--node/HttpClient.cpp291
1 files changed, 291 insertions, 0 deletions
diff --git a/node/HttpClient.cpp b/node/HttpClient.cpp
new file mode 100644
index 00000000..a9c40205
--- /dev/null
+++ b/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
generated by cgit v1.2.3 (git 2.39.1) at 2025-03-01 10:56:22 +0000