Adam Ierymenko
11 years ago
14 changed files with 470 additions and 726 deletions
@ -0,0 +1,264 @@
|
||||
/*
|
||||
* 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 <stdint.h> |
||||
#include <string.h> |
||||
|
||||
#include "Http.hpp" |
||||
#include "Phy.hpp" |
||||
#include "OSUtils.hpp" |
||||
#include "../node/Constants.hpp" |
||||
#include "../node/Utils.hpp" |
||||
#include "../ext/http-parser/http_parser.h" |
||||
|
||||
namespace ZeroTier { |
||||
|
||||
namespace { |
||||
|
||||
static int ShttpOnMessageBegin(http_parser *parser); |
||||
static int ShttpOnUrl(http_parser *parser,const char *ptr,size_t length); |
||||
static int ShttpOnStatus(http_parser *parser,const char *ptr,size_t length); |
||||
static int ShttpOnHeaderField(http_parser *parser,const char *ptr,size_t length); |
||||
static int ShttpOnValue(http_parser *parser,const char *ptr,size_t length); |
||||
static int ShttpOnHeadersComplete(http_parser *parser); |
||||
static int ShttpOnBody(http_parser *parser,const char *ptr,size_t length); |
||||
static int ShttpOnMessageComplete(http_parser *parser); |
||||
static const struct http_parser_settings HTTP_PARSER_SETTINGS = { |
||||
ShttpOnMessageBegin, |
||||
ShttpOnUrl, |
||||
ShttpOnStatus, |
||||
ShttpOnHeaderField, |
||||
ShttpOnValue, |
||||
ShttpOnHeadersComplete, |
||||
ShttpOnBody, |
||||
ShttpOnMessageComplete |
||||
}; |
||||
|
||||
struct HttpPhyHandler |
||||
{ |
||||
// not used
|
||||
inline void phyOnDatagram(PhySocket *sock,void **uptr,const struct sockaddr *from,void *data,unsigned long len) {} |
||||
inline void phyOnTcpAccept(PhySocket *sockL,PhySocket *sockN,void **uptrL,void **uptrN,const struct sockaddr *from) {} |
||||
|
||||
inline void phyOnTcpConnect(PhySocket *sock,void **uptr,bool success) |
||||
{ |
||||
if (success) { |
||||
phy->tcpSetNotifyWritable(sock,true); |
||||
} else { |
||||
*responseBody = "connection failed"; |
||||
error = true; |
||||
done = true; |
||||
} |
||||
} |
||||
|
||||
inline void phyOnTcpClose(PhySocket *sock,void **uptr) |
||||
{ |
||||
done = true; |
||||
} |
||||
|
||||
inline void phyOnTcpData(PhySocket *sock,void **uptr,void *data,unsigned long len) |
||||
{ |
||||
lastActivity = OSUtils::now(); |
||||
http_parser_execute(&parser,&HTTP_PARSER_SETTINGS,(const char *)data,len); |
||||
if ((parser.upgrade)||(parser.http_errno != HPE_OK)) |
||||
phy->close(sock); |
||||
} |
||||
|
||||
inline void phyOnTcpWritable(PhySocket *sock,void **uptr) |
||||
{ |
||||
if (writePtr < writeSize) { |
||||
long n = phy->tcpSend(sock,writeBuf + writePtr,writeSize - writePtr,true); |
||||
if (n > 0) |
||||
writePtr += n; |
||||
} |
||||
if (writePtr >= writeSize) |
||||
phy->tcpSetNotifyWritable(sock,false); |
||||
} |
||||
|
||||
http_parser parser; |
||||
std::string currentHeaderField; |
||||
std::string currentHeaderValue; |
||||
unsigned long messageSize; |
||||
unsigned long writePtr; |
||||
uint64_t lastActivity; |
||||
unsigned long writeSize; |
||||
char writeBuf[32768]; |
||||
|
||||
unsigned long maxResponseSize; |
||||
std::map<std::string,std::string> *responseHeaders; |
||||
std::string *responseBody; |
||||
bool error; |
||||
bool done; |
||||
|
||||
Phy<HttpPhyHandler *> *phy; |
||||
PhySocket *sock; |
||||
}; |
||||
|
||||
static int ShttpOnMessageBegin(http_parser *parser) |
||||
{ |
||||
return 0; |
||||
} |
||||
static int ShttpOnUrl(http_parser *parser,const char *ptr,size_t length) |
||||
{ |
||||
return 0; |
||||
} |
||||
static int ShttpOnStatus(http_parser *parser,const char *ptr,size_t length) |
||||
{ |
||||
HttpPhyHandler *hh = reinterpret_cast<HttpPhyHandler *>(parser->data); |
||||
hh->messageSize += length; |
||||
if (hh->messageSize > hh->maxResponseSize) |
||||
return -1; |
||||
return 0; |
||||
} |
||||
static int ShttpOnHeaderField(http_parser *parser,const char *ptr,size_t length) |
||||
{ |
||||
HttpPhyHandler *hh = reinterpret_cast<HttpPhyHandler *>(parser->data); |
||||
hh->messageSize += length; |
||||
if (hh->messageSize > hh->maxResponseSize) |
||||
return -1; |
||||
if ((hh->currentHeaderField.length())&&(hh->currentHeaderValue.length())) { |
||||
(*hh->responseHeaders)[hh->currentHeaderField] = hh->currentHeaderValue; |
||||
hh->currentHeaderField.assign("",0); |
||||
hh->currentHeaderValue.assign("",0); |
||||
} |
||||
for(size_t i=0;i<length;++i) |
||||
hh->currentHeaderField.push_back(OSUtils::toLower(ptr[i])); |
||||
return 0; |
||||
} |
||||
static int ShttpOnValue(http_parser *parser,const char *ptr,size_t length) |
||||
{ |
||||
HttpPhyHandler *hh = reinterpret_cast<HttpPhyHandler *>(parser->data); |
||||
hh->messageSize += length; |
||||
if (hh->messageSize > hh->maxResponseSize) |
||||
return -1; |
||||
hh->currentHeaderValue.append(ptr,length); |
||||
return 0; |
||||
} |
||||
static int ShttpOnHeadersComplete(http_parser *parser) |
||||
{ |
||||
HttpPhyHandler *hh = reinterpret_cast<HttpPhyHandler *>(parser->data); |
||||
if ((hh->currentHeaderField.length())&&(hh->currentHeaderValue.length())) |
||||
(*hh->responseHeaders)[hh->currentHeaderField] = hh->currentHeaderValue; |
||||
return 0; |
||||
} |
||||
static int ShttpOnBody(http_parser *parser,const char *ptr,size_t length) |
||||
{ |
||||
HttpPhyHandler *hh = reinterpret_cast<HttpPhyHandler *>(parser->data); |
||||
hh->messageSize += length; |
||||
if (hh->messageSize > hh->maxResponseSize) |
||||
return -1; |
||||
hh->responseBody->append(ptr,length); |
||||
return 0; |
||||
} |
||||
static int ShttpOnMessageComplete(http_parser *parser) |
||||
{ |
||||
HttpPhyHandler *hh = reinterpret_cast<HttpPhyHandler *>(parser->data); |
||||
hh->phy->close(hh->sock); |
||||
return 0; |
||||
} |
||||
|
||||
} // anonymous namespace
|
||||
|
||||
unsigned int Http::_do( |
||||
const char *method, |
||||
unsigned long maxResponseSize, |
||||
unsigned long timeout, |
||||
const struct sockaddr *remoteAddress, |
||||
const char *path, |
||||
const std::map<std::string,std::string> &requestHeaders, |
||||
const void *requestBody, |
||||
unsigned long requestBodyLength, |
||||
std::map<std::string,std::string> &responseHeaders, |
||||
std::string &responseBody) |
||||
{ |
||||
try { |
||||
responseHeaders.clear(); |
||||
responseBody.assign("",0); |
||||
|
||||
HttpPhyHandler handler; |
||||
|
||||
http_parser_init(&(handler.parser),HTTP_RESPONSE); |
||||
handler.parser.data = (void *)&handler; |
||||
handler.messageSize = 0; |
||||
handler.writePtr = 0; |
||||
handler.lastActivity = OSUtils::now(); |
||||
|
||||
try { |
||||
handler.writeSize = Utils::snprintf(handler.writeBuf,sizeof(handler.writeBuf),"GET %s HTTP/1.1\r\n",path); |
||||
for(std::map<std::string,std::string>::const_iterator h(requestHeaders.begin());h!=requestHeaders.end();++h) |
||||
handler.writeSize += Utils::snprintf(handler.writeBuf + handler.writeSize,sizeof(handler.writeBuf) - handler.writeSize,"%s: %s\r\n",h->first.c_str(),h->second.c_str()); |
||||
handler.writeSize += Utils::snprintf(handler.writeBuf + handler.writeSize,sizeof(handler.writeBuf) - handler.writeSize,"\r\n"); |
||||
if ((requestBody)&&(requestBodyLength)) { |
||||
if ((handler.writeSize + requestBodyLength) > sizeof(handler.writeBuf)) { |
||||
responseBody = "request too large"; |
||||
return 0; |
||||
} |
||||
memcpy(handler.writeBuf + handler.writeSize,requestBody,requestBodyLength); |
||||
handler.writeSize += requestBodyLength; |
||||
} |
||||
} catch ( ... ) { |
||||
responseBody = "request too large"; |
||||
return 0; |
||||
} |
||||
|
||||
handler.maxResponseSize = maxResponseSize; |
||||
handler.responseHeaders = &responseHeaders; |
||||
handler.responseBody = &responseBody; |
||||
handler.error = false; |
||||
handler.done = false; |
||||
|
||||
Phy<HttpPhyHandler *> phy(&handler,true); |
||||
|
||||
bool instantConnect = false; |
||||
handler.phy = &phy; |
||||
handler.sock = phy.tcpConnect((const struct sockaddr *)remoteAddress,instantConnect,(void *)0,true); |
||||
if (!handler.sock) { |
||||
responseBody = "connection failed (2)"; |
||||
return 0; |
||||
} |
||||
|
||||
while (!handler.done) { |
||||
phy.poll(timeout / 2); |
||||
if ((timeout)&&((unsigned long)(OSUtils::now() - handler.lastActivity) > timeout)) { |
||||
phy.close(handler.sock); |
||||
responseBody = "timed out"; |
||||
return 0; |
||||
} |
||||
} |
||||
|
||||
return ((handler.error) ? 0 : ((handler.parser.http_errno != HPE_OK) ? 0 : handler.parser.status_code)); |
||||
} catch (std::exception &exc) { |
||||
responseBody = exc.what(); |
||||
return 0; |
||||
} catch ( ... ) { |
||||
responseBody = "unknown exception"; |
||||
return 0; |
||||
} |
||||
} |
||||
|
||||
} // namespace ZeroTier
|
||||
@ -0,0 +1,134 @@
|
||||
/*
|
||||
* 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_HTTP_HPP |
||||
#define ZT_HTTP_HPP |
||||
|
||||
#include <string> |
||||
#include <map> |
||||
#include <stdexcept> |
||||
|
||||
#if defined(_WIN32) || defined(_WIN64) |
||||
#include <WinSock2.h> |
||||
#include <WS2tcpip.h> |
||||
#include <Windows.h> |
||||
#else |
||||
#include <unistd.h> |
||||
#include <sys/time.h> |
||||
#include <sys/types.h> |
||||
#include <sys/socket.h> |
||||
#include <arpa/inet.h> |
||||
#include <netinet/in.h> |
||||
#endif |
||||
|
||||
namespace ZeroTier { |
||||
|
||||
/**
|
||||
* Simple synchronous HTTP client used for updater and cli |
||||
*/ |
||||
class Http |
||||
{ |
||||
public: |
||||
/**
|
||||
* Make HTTP GET request |
||||
* |
||||
* The caller must set all headers, including Host. |
||||
* |
||||
* @return HTTP status code or 0 on error (responseBody will contain error message) |
||||
*/ |
||||
static inline unsigned int GET( |
||||
unsigned long maxResponseSize, |
||||
unsigned long timeout, |
||||
const struct sockaddr *remoteAddress, |
||||
const char *path, |
||||
const std::map<std::string,std::string> &requestHeaders, |
||||
std::map<std::string,std::string> &responseHeaders, |
||||
std::string &responseBody) |
||||
{ |
||||
return _do( |
||||
"GET", |
||||
maxResponseSize, |
||||
timeout, |
||||
remoteAddress, |
||||
path, |
||||
requestHeaders, |
||||
(const void *)0, |
||||
0, |
||||
responseHeaders, |
||||
responseBody); |
||||
} |
||||
|
||||
/**
|
||||
* Make HTTP POST request |
||||
* |
||||
* It is the responsibility of the caller to set all headers. With POST, the |
||||
* Content-Length and Content-Type headers must be set or the POST will not |
||||
* work. |
||||
* |
||||
* @return HTTP status code or 0 on error (responseBody will contain error message) |
||||
*/ |
||||
static inline unsigned int POST( |
||||
unsigned long maxResponseSize, |
||||
unsigned long timeout, |
||||
const struct sockaddr *remoteAddress, |
||||
const char *path, |
||||
const std::map<std::string,std::string> &requestHeaders, |
||||
const void *postData, |
||||
unsigned long postDataLength, |
||||
std::map<std::string,std::string> &responseHeaders, |
||||
std::string &responseBody) |
||||
{ |
||||
return _do( |
||||
"POST", |
||||
maxResponseSize, |
||||
timeout, |
||||
remoteAddress, |
||||
path, |
||||
requestHeaders, |
||||
postData, |
||||
postDataLength, |
||||
responseHeaders, |
||||
responseBody); |
||||
} |
||||
|
||||
private: |
||||
static unsigned int _do( |
||||
const char *method, |
||||
unsigned long maxResponseSize, |
||||
unsigned long timeout, |
||||
const struct sockaddr *remoteAddress, |
||||
const char *path, |
||||
const std::map<std::string,std::string> &requestHeaders, |
||||
const void *requestBody, |
||||
unsigned long requestBodyLength, |
||||
std::map<std::string,std::string> &responseHeaders, |
||||
std::string &responseBody); |
||||
}; |
||||
|
||||
} // namespace ZeroTier
|
||||
|
||||
#endif |
||||
@ -1,590 +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 "../node/Constants.hpp" |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
|
||||
#ifdef __WINDOWS__ |
||||
#include <WinSock2.h> |
||||
#include <Windows.h> |
||||
#include <winhttp.h> |
||||
#include <locale> |
||||
#include <codecvt> |
||||
#endif // __WINDOWS__
|
||||
|
||||
#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> |
||||
#include <sys/wait.h> |
||||
#endif // __UNIX_LIKE__
|
||||
|
||||
#include <vector> |
||||
#include <utility> |
||||
#include <algorithm> |
||||
|
||||
#include "HttpClient.hpp" |
||||
#include "Thread.hpp" |
||||
#include "OSUtils.hpp" |
||||
#include "../node/Utils.hpp" |
||||
|
||||
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.
|
||||
|
||||
#ifdef __APPLE__ |
||||
// TODO: get proxy configuration
|
||||
#endif |
||||
|
||||
// Paths where "curl" may be found on the system
|
||||
#define NUM_CURL_PATHS 6 |
||||
static const char *CURL_PATHS[NUM_CURL_PATHS] = { "/usr/bin/curl","/bin/curl","/usr/local/bin/curl","/usr/sbin/curl","/sbin/curl","/usr/libexec/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 HttpClient_Private_Request |
||||
{ |
||||
public: |
||||
HttpClient_Private_Request(HttpClient *parent,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 &,const std::string &),void *arg) : |
||||
_url(url), |
||||
_headers(headers), |
||||
_timeout(timeout), |
||||
_handler(handler), |
||||
_arg(arg), |
||||
_parent(parent), |
||||
_pid(0), |
||||
_cancelled(false) |
||||
{ |
||||
_myThread = Thread::start(this); |
||||
} |
||||
|
||||
~HttpClient_Private_Request() |
||||
{ |
||||
Mutex::Lock _l(_parent->_requests_m); |
||||
_parent->_requests.erase((HttpClient::Request)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 (OSUtils::fileExists(CURL_PATHS[i])) { |
||||
curlPath = CURL_PATHS[i]; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
if (!curlPath.length()) { |
||||
_doH(_arg,-1,_url,"unable to locate 'curl' binary in /usr/bin, /bin, /usr/local/bin, /usr/sbin, or /sbin"); |
||||
delete this; |
||||
return; |
||||
} |
||||
if (!_url.length()) { |
||||
_doH(_arg,-1,_url,"cannot fetch empty URL"); |
||||
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 - 4)) // leave room for terminating NULL and URL
|
||||
break; |
||||
curlArgs[argPtr++] = const_cast <char *>("-H"); |
||||
curlArgs[argPtr++] = const_cast <char *>(h->c_str()); |
||||
} |
||||
curlArgs[argPtr++] = const_cast <char *>(_url.c_str()); |
||||
curlArgs[argPtr] = (char *)0; |
||||
|
||||
if (_cancelled) { |
||||
delete this; |
||||
return; |
||||
} |
||||
|
||||
int curlStdout[2]; |
||||
int curlStderr[2]; |
||||
::pipe(curlStdout); |
||||
::pipe(curlStderr); |
||||
|
||||
_pid = (long)vfork(); |
||||
if (_pid < 0) { |
||||
// fork() failed
|
||||
::close(curlStdout[0]); |
||||
::close(curlStdout[1]); |
||||
::close(curlStderr[0]); |
||||
::close(curlStderr[1]); |
||||
_doH(_arg,-1,_url,"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 = OSUtils::now() + ((unsigned long long)_timeout * 1000ULL); |
||||
bool timedOut = false; |
||||
bool tooLong = false; |
||||
|
||||
while (!_cancelled) { |
||||
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); |
||||
// Reset timeout when data is read...
|
||||
timesOutAt = OSUtils::now() + ((unsigned long long)_timeout * 1000ULL); |
||||
} else if (n < 0) |
||||
break; |
||||
if (_body.length() > CURL_MAX_MESSAGE_LENGTH) { |
||||
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 (OSUtils::now() >= timesOutAt) { |
||||
timedOut = true; |
||||
break; |
||||
} |
||||
|
||||
if (waitpid(_pid,&exitCode,WNOHANG) > 0) { |
||||
for(;;) { |
||||
// Drain output...
|
||||
int n = (int)::read(curlStdout[0],buf,sizeof(buf)); |
||||
if (n <= 0) |
||||
break; |
||||
else { |
||||
_body.append(buf,n); |
||||
if (_body.length() > CURL_MAX_MESSAGE_LENGTH) { |
||||
tooLong = true; |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
_pid = 0; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
if (_pid > 0) { |
||||
::kill(_pid,SIGKILL); |
||||
waitpid(_pid,&exitCode,0); |
||||
} |
||||
_pid = 0; |
||||
|
||||
::close(curlStdout[0]); |
||||
::close(curlStderr[0]); |
||||
|
||||
if (timedOut) |
||||
_doH(_arg,-1,_url,"connection timed out"); |
||||
else if (tooLong) |
||||
_doH(_arg,-1,_url,"response too long"); |
||||
else if (exitCode) |
||||
_doH(_arg,-1,_url,"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 headers.push_back(std::string()); |
||||
} else if (c != '\r') |
||||
headers.back().push_back(c); |
||||
} |
||||
if (headers.empty()||(!headers.front().length())) { |
||||
_doH(_arg,-1,_url,"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) { |
||||
_doH(_arg,-1,_url,"invalid HTTP response (no status line)"); |
||||
delete this; |
||||
return; |
||||
} |
||||
++scPos; |
||||
unsigned int rcode = Utils::strToUInt(headers.front().substr(scPos,3).c_str()); |
||||
if ((!rcode)||(rcode > 999)) { |
||||
_doH(_arg,-1,_url,"invalid HTTP response (invalid response code)"); |
||||
delete this; |
||||
return; |
||||
} |
||||
|
||||
// Serve up the resulting data to the handler
|
||||
if (rcode == 200) |
||||
_doH(_arg,rcode,_url,_body.substr(idx)); |
||||
else if ((scPos + 4) < headers.front().length()) |
||||
_doH(_arg,rcode,_url,headers.front().substr(scPos+4)); |
||||
else _doH(_arg,rcode,_url,"(no status message from server)"); |
||||
} |
||||
|
||||
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
|
||||
} |
||||
} |
||||
|
||||
inline void cancel() |
||||
{
|
||||
{ |
||||
Mutex::Lock _l(_cancelled_m); |
||||
_cancelled = true; |
||||
if (_pid > 0) |
||||
::kill(_pid,SIGKILL); |
||||
} |
||||
Thread::join(_myThread); |
||||
} |
||||
|
||||
private: |
||||
inline void _doH(void *arg,int code,const std::string &url,const std::string &body) |
||||
{ |
||||
Mutex::Lock _l(_cancelled_m); |
||||
try { |
||||
if ((!_cancelled)&&(_handler)) |
||||
_handler(arg,code,url,body); |
||||
} catch ( ... ) {} |
||||
} |
||||
|
||||
const std::string _url; |
||||
std::string _body; |
||||
std::map<std::string,std::string> _headers; |
||||
unsigned int _timeout; |
||||
void (*_handler)(void *,int,const std::string &,const std::string &); |
||||
void *_arg; |
||||
HttpClient *_parent; |
||||
long _pid; |
||||
volatile bool _cancelled; |
||||
Mutex _cancelled_m; |
||||
Thread _myThread; |
||||
}; |
||||
|
||||
#endif // __UNIX_LIKE__
|
||||
|
||||
#ifdef __WINDOWS__ |
||||
|
||||
#define WIN_MAX_MESSAGE_LENGTH (1024 * 1024 * 64) |
||||
|
||||
// Internal private thread class that performs request, notifies handler,
|
||||
// and then commits suicide by deleting itself.
|
||||
class HttpClient_Private_Request : NonCopyable |
||||
{ |
||||
public: |
||||
HttpClient_Private_Request(HttpClient *parent,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 &,const std::string &),void *arg) : |
||||
_url(url), |
||||
_headers(headers), |
||||
_timeout(timeout), |
||||
_handler(handler), |
||||
_arg(arg), |
||||
_parent(parent), |
||||
_hRequest((HINTERNET)0) |
||||
{ |
||||
_myThread = Thread::start(this); |
||||
} |
||||
|
||||
~HttpClient_Private_Request() |
||||
{ |
||||
Mutex::Lock _l(_parent->_requests_m); |
||||
_parent->_requests.erase((HttpClient::Request)this); |
||||
} |
||||
|
||||
void threadMain() |
||||
{ |
||||
HINTERNET hSession = (HINTERNET)0; |
||||
HINTERNET hConnect = (HINTERNET)0; |
||||
HINTERNET hRequest = (HINTERNET)0; |
||||
|
||||
try { |
||||
hSession = WinHttpOpen(L"ZeroTier One HttpClient/1.0 (WinHttp)",WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,WINHTTP_NO_PROXY_NAME,WINHTTP_NO_PROXY_BYPASS,0); |
||||
if (!hSession) { |
||||
_handler(_arg,-1,_url,"WinHttpOpen() failed"); |
||||
goto closeAndReturnFromHttp; |
||||
} |
||||
int timeoutMs = (int)_timeout * 1000; |
||||
WinHttpSetTimeouts(hSession,timeoutMs,timeoutMs,timeoutMs,timeoutMs); |
||||
|
||||
std::wstring_convert< std::codecvt_utf8<wchar_t> > wcconv; |
||||
std::wstring wurl(wcconv.from_bytes(_url)); |
||||
|
||||
URL_COMPONENTS uc; |
||||
memset(&uc,0,sizeof(uc)); |
||||
uc.dwStructSize = sizeof(uc); |
||||
uc.dwSchemeLength = -1; |
||||
uc.dwHostNameLength = -1; |
||||
uc.dwUrlPathLength = -1; |
||||
uc.dwExtraInfoLength = -1; |
||||
if (!WinHttpCrackUrl(wurl.c_str(),(DWORD)wurl.length(),0,&uc)) { |
||||
_handler(_arg,-1,_url,"unable to parse URL: WinHttpCrackUrl() failed"); |
||||
goto closeAndReturnFromHttp; |
||||
} |
||||
if ((!uc.lpszHostName)||(!uc.lpszUrlPath)||(!uc.lpszScheme)||(uc.dwHostNameLength <= 0)||(uc.dwUrlPathLength <= 0)||(uc.dwSchemeLength <= 0)) { |
||||
_handler(_arg,-1,_url,"unable to parse URL: missing scheme, host name, or path"); |
||||
goto closeAndReturnFromHttp; |
||||
} |
||||
std::wstring urlScheme(uc.lpszScheme,uc.dwSchemeLength); |
||||
std::wstring urlHostName(uc.lpszHostName,uc.dwHostNameLength); |
||||
std::wstring urlPath(uc.lpszUrlPath,uc.dwUrlPathLength); |
||||
if ((uc.lpszExtraInfo)&&(uc.dwExtraInfoLength > 0)) |
||||
urlPath.append(uc.lpszExtraInfo,uc.dwExtraInfoLength); |
||||
|
||||
if (urlScheme != L"http") { |
||||
_handler(_arg,-1,_url,"only 'http' scheme is supported"); |
||||
goto closeAndReturnFromHttp; |
||||
} |
||||
|
||||
hConnect = WinHttpConnect(hSession,urlHostName.c_str(),((uc.nPort > 0) ? uc.nPort : 80),0); |
||||
if (!hConnect) { |
||||
_handler(_arg,-1,_url,"connection failed"); |
||||
goto closeAndReturnFromHttp; |
||||
} |
||||
|
||||
{ |
||||
Mutex::Lock _rl(_hRequest_m); |
||||
_hRequest = WinHttpOpenRequest(hConnect,L"GET",urlPath.c_str(),NULL,WINHTTP_NO_REFERER,WINHTTP_DEFAULT_ACCEPT_TYPES,0); |
||||
if (!_hRequest) { |
||||
_handler(_arg,-1,_url,"error sending request (1)"); |
||||
goto closeAndReturnFromHttp; |
||||
} |
||||
if (!WinHttpSendRequest(_hRequest,WINHTTP_NO_ADDITIONAL_HEADERS,0,WINHTTP_NO_REQUEST_DATA,0,0,0)) { |
||||
_handler(_arg,-1,_url,"error sending request (2)"); |
||||
goto closeAndReturnFromHttp; |
||||
} |
||||
hRequest = _hRequest; |
||||
} |
||||
|
||||
if (WinHttpReceiveResponse(hRequest,NULL)) { |
||||
DWORD dwStatusCode = 0; |
||||
DWORD dwTmp = sizeof(dwStatusCode); |
||||
WinHttpQueryHeaders(hRequest,WINHTTP_QUERY_STATUS_CODE| WINHTTP_QUERY_FLAG_NUMBER,NULL,&dwStatusCode,&dwTmp,NULL); |
||||
|
||||
DWORD dwSize; |
||||
do { |
||||
dwSize = 0; |
||||
if (!WinHttpQueryDataAvailable(hRequest,&dwSize)) { |
||||
_handler(_arg,-1,_url,"receive error (1)"); |
||||
goto closeAndReturnFromHttp; |
||||
} |
||||
|
||||
{ |
||||
Mutex::Lock _rl(_hRequest_m); |
||||
if (!_hRequest) { |
||||
_handler(_arg,-1,_url,"request cancelled"); |
||||
goto closeAndReturnFromHttp; |
||||
} |
||||
} |
||||
|
||||
char *outBuffer = new char[dwSize]; |
||||
DWORD dwRead = 0; |
||||
if (!WinHttpReadData(hRequest,(LPVOID)outBuffer,dwSize,&dwRead)) { |
||||
_handler(_arg,-1,_url,"receive error (2)"); |
||||
goto closeAndReturnFromHttp; |
||||
} |
||||
|
||||
{ |
||||
Mutex::Lock _rl(_hRequest_m); |
||||
if (!_hRequest) { |
||||
_handler(_arg,-1,_url,"request cancelled"); |
||||
goto closeAndReturnFromHttp; |
||||
} |
||||
|
||||
_body.append(outBuffer,dwRead); |
||||
delete [] outBuffer; |
||||
if (_body.length() > WIN_MAX_MESSAGE_LENGTH) { |
||||
_handler(_arg,-1,_url,"result too large"); |
||||
goto closeAndReturnFromHttp; |
||||
} |
||||
} |
||||
} while ((dwSize > 0)&&(_hRequest)); |
||||
|
||||
{ |
||||
Mutex::Lock _rl(_hRequest_m); |
||||
if (!_hRequest) { |
||||
_handler(_arg,-1,_url,"request cancelled"); |
||||
goto closeAndReturnFromHttp; |
||||
} |
||||
|
||||
_handler(_arg,dwStatusCode,_url,_body); |
||||
} |
||||
} else { |
||||
_handler(_arg,-1,_url,"receive response failed"); |
||||
} |
||||
} catch ( ... ) { |
||||
_handler(_arg,-1,_url,"unexpected exception"); |
||||
} |
||||
|
||||
closeAndReturnFromHttp: |
||||
{ |
||||
Mutex::Lock _rl(_hRequest_m); |
||||
if (_hRequest) { |
||||
WinHttpCloseHandle(_hRequest); |
||||
_hRequest = (HINTERNET)0; |
||||
} |
||||
} |
||||
if (hConnect) |
||||
WinHttpCloseHandle(hConnect); |
||||
if (hSession) |
||||
WinHttpCloseHandle(hSession); |
||||
delete this; |
||||
return; |
||||
} |
||||
|
||||
inline void cancel() |
||||
{ |
||||
Mutex::Lock _rl(_hRequest_m); |
||||
if (_hRequest) { |
||||
WinHttpCloseHandle(_hRequest); |
||||
_hRequest = (HINTERNET)0; |
||||
} |
||||
} |
||||
|
||||
const std::string _url; |
||||
std::string _body; |
||||
std::map<std::string,std::string> _headers; |
||||
unsigned int _timeout; |
||||
void (*_handler)(void *,int,const std::string &,const std::string &); |
||||
void *_arg; |
||||
HttpClient *_parent; |
||||
HINTERNET _hRequest; |
||||
Mutex _hRequest_m; |
||||
Thread _myThread; |
||||
}; |
||||
|
||||
#endif // __WINDOWS__
|
||||
|
||||
const std::map<std::string,std::string> HttpClient::NO_HEADERS; |
||||
|
||||
HttpClient::HttpClient() |
||||
{ |
||||
} |
||||
|
||||
HttpClient::~HttpClient() |
||||
{ |
||||
std::set<Request> reqs; |
||||
{ |
||||
Mutex::Lock _l(_requests_m); |
||||
reqs = _requests; |
||||
} |
||||
|
||||
for(std::set<Request>::iterator r(reqs.begin());r!=reqs.end();++r) |
||||
this->cancel(*r); |
||||
|
||||
for(;;) { |
||||
_requests_m.lock(); |
||||
if (_requests.empty()) { |
||||
_requests_m.unlock(); |
||||
break; |
||||
} else { |
||||
_requests_m.unlock(); |
||||
Thread::sleep(250); |
||||
} |
||||
} |
||||
} |
||||
|
||||
void HttpClient::cancel(HttpClient::Request req) |
||||
{ |
||||
Mutex::Lock _l(_requests_m); |
||||
if (_requests.count(req) == 0) |
||||
return; |
||||
((HttpClient_Private_Request *)req)->cancel(); |
||||
} |
||||
|
||||
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 &,const std::string &), |
||||
void *arg) |
||||
{ |
||||
HttpClient::Request r = (HttpClient::Request)(new HttpClient_Private_Request(this,method,url,headers,timeout,handler,arg)); |
||||
Mutex::Lock _l(_requests_m); |
||||
_requests.insert(r); |
||||
return r; |
||||
} |
||||
|
||||
} // namespace ZeroTier
|
||||
@ -1,110 +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_HTTPCLIENT_HPP |
||||
#define ZT_HTTPCLIENT_HPP |
||||
|
||||
#include <string> |
||||
#include <map> |
||||
#include <set> |
||||
|
||||
#include "../node/Mutex.hpp" |
||||
|
||||
namespace ZeroTier { |
||||
|
||||
class HttpClient_Private_Request; |
||||
|
||||
/**
|
||||
* 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: |
||||
friend class HttpClient_Private_Request; |
||||
typedef void * Request; |
||||
|
||||
HttpClient(); |
||||
~HttpClient(); |
||||
|
||||
/**
|
||||
* Empty map for convenience use |
||||
*/ |
||||
static const std::map<std::string,std::string> NO_HEADERS; |
||||
|
||||
/**
|
||||
* Request a URL using the GET method |
||||
*/ |
||||
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 &,const std::string &), |
||||
void *arg) |
||||
{ |
||||
return _do("GET",url,headers,timeout,handler,arg); |
||||
} |
||||
|
||||
/**
|
||||
* Cancel a request |
||||
* |
||||
* If the request is not active, this does nothing. This may take some time |
||||
* depending on HTTP implementation. It may also not kill instantly, but |
||||
* it will prevent the handler function from ever being called and cause the |
||||
* request to die silently when complete. |
||||
*/ |
||||
void cancel(Request req); |
||||
|
||||
private: |
||||
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 &,const std::string &), |
||||
void *arg); |
||||
|
||||
std::set<Request> _requests; |
||||
Mutex _requests_m; |
||||
}; |
||||
|
||||
} // namespace ZeroTier
|
||||
|
||||
#endif |
||||
Loading…
Reference in new issue