mirror of https://gitee.com/bigwinds/arangodb
289 lines
8.6 KiB
C++
289 lines
8.6 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tasks used to establish connections
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2014 ArangoDB GmbH, Cologne, Germany
|
|
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
|
|
///
|
|
/// Licensed under the Apache License, Version 2.0 (the "License");
|
|
/// you may not use this file except in compliance with the License.
|
|
/// You may obtain a copy of the License at
|
|
///
|
|
/// http://www.apache.org/licenses/LICENSE-2.0
|
|
///
|
|
/// Unless required by applicable law or agreed to in writing, software
|
|
/// distributed under the License is distributed on an "AS IS" BASIS,
|
|
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
/// See the License for the specific language governing permissions and
|
|
/// limitations under the License.
|
|
///
|
|
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
|
|
///
|
|
/// @author Dr. Frank Celler
|
|
/// @author Achim Brandt
|
|
/// @author Copyright 2014, ArangoDB GmbH, Cologne, Germany
|
|
/// @author Copyright 2008-2013, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "ListenTask.h"
|
|
|
|
#include <errno.h>
|
|
|
|
#ifdef TRI_HAVE_LINUX_SOCKETS
|
|
#include <netinet/in.h>
|
|
#include <netinet/tcp.h>
|
|
#include <netdb.h>
|
|
#include <sys/socket.h>
|
|
#include <arpa/inet.h>
|
|
#endif
|
|
|
|
#ifdef TRI_HAVE_WINSOCK2_H
|
|
#include "Basics/win-utils.h"
|
|
#include <WinSock2.h>
|
|
#include <WS2tcpip.h>
|
|
#endif
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include "Basics/logging.h"
|
|
#include "Basics/MutexLocker.h"
|
|
#include "Basics/socket-utils.h"
|
|
#include "Basics/StringUtils.h"
|
|
#include "Scheduler/Scheduler.h"
|
|
|
|
using namespace triagens::basics;
|
|
using namespace triagens::rest;
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// constructors and destructors
|
|
// -----------------------------------------------------------------------------
|
|
|
|
ListenTask::ListenTask (Endpoint* endpoint)
|
|
: Task("ListenTask"),
|
|
_readWatcher(nullptr),
|
|
_endpoint(endpoint),
|
|
_acceptFailures(0) {
|
|
|
|
TRI_invalidatesocket(&_listenSocket);
|
|
bindSocket();
|
|
}
|
|
|
|
ListenTask::~ListenTask () {
|
|
if (_readWatcher != nullptr) {
|
|
_scheduler->uninstallEvent(_readWatcher);
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// public methods
|
|
// -----------------------------------------------------------------------------
|
|
|
|
bool ListenTask::isBound () const {
|
|
MUTEX_LOCKER(_changeLock); // FIX_MUTEX ?
|
|
|
|
return _endpoint != nullptr && _endpoint->isConnected();
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Task methods
|
|
// -----------------------------------------------------------------------------
|
|
|
|
bool ListenTask::setup (Scheduler* scheduler, EventLoop loop) {
|
|
if (! isBound()) {
|
|
return true;
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
|
|
// ..........................................................................
|
|
// The problem we have here is that this opening of the fs handle may fail.
|
|
// There is no mechanism to the calling function to report failure.
|
|
// ..........................................................................
|
|
|
|
LOG_TRACE("attempting to convert socket handle to socket descriptor");
|
|
|
|
if (! TRI_isvalidsocket(_listenSocket)) {
|
|
LOG_ERROR("In ListenTask::setup could not convert socket handle to socket descriptor -- invalid socket handle");
|
|
return false;
|
|
}
|
|
|
|
// For the official version of libev we would do this:
|
|
// int res = _open_osfhandle (_listenSocket.fileHandle, 0);
|
|
// However, this opens a whole lot of problems and in general one should
|
|
// never use _open_osfhandle for sockets.
|
|
// Therefore, we do the following, although it has the potential to
|
|
// lose the higher bits of the socket handle:
|
|
int res = (int) _listenSocket.fileHandle;
|
|
|
|
if (res == - 1) {
|
|
LOG_ERROR("In ListenTask::setup could not convert socket handle to socket descriptor -- _open_osfhandle(...) failed");
|
|
|
|
res = TRI_CLOSE_SOCKET(_listenSocket);
|
|
|
|
if (res != 0) {
|
|
res = WSAGetLastError();
|
|
LOG_ERROR("In ListenTask::setup closesocket(...) failed with error code: %d", (int) res);
|
|
}
|
|
|
|
TRI_invalidatesocket(&_listenSocket);
|
|
return false;
|
|
}
|
|
|
|
_listenSocket.fileDescriptor = res;
|
|
|
|
#endif
|
|
|
|
this->_scheduler = scheduler;
|
|
this->_loop = loop;
|
|
_readWatcher = scheduler->installSocketEvent(loop, EVENT_SOCKET_READ, this, _listenSocket);
|
|
|
|
return true;
|
|
}
|
|
|
|
void ListenTask::cleanup () {
|
|
if (_scheduler != nullptr &&
|
|
_readWatcher != nullptr) {
|
|
_scheduler->uninstallEvent(_readWatcher);
|
|
}
|
|
|
|
_readWatcher = nullptr;
|
|
}
|
|
|
|
bool ListenTask::handleEvent (EventToken token,
|
|
EventType revents) {
|
|
if (token == _readWatcher) {
|
|
if ((revents & EVENT_SOCKET_READ) == 0) {
|
|
return true;
|
|
}
|
|
|
|
static_assert(sizeof(sockaddr_in) <= sizeof(sockaddr_in6),
|
|
"expect sockaddr size to be less or equal to the v6 version");
|
|
|
|
sockaddr_in6 addrmem;
|
|
sockaddr_in* addr = (sockaddr_in*) &addrmem;
|
|
socklen_t len = sizeof(sockaddr_in6);
|
|
|
|
memset(addr, 0, sizeof(sockaddr_in6));
|
|
|
|
// accept connection
|
|
TRI_socket_t connectionSocket;
|
|
connectionSocket = TRI_accept(_listenSocket, (sockaddr*) addr, &len);
|
|
|
|
if (! TRI_isvalidsocket(connectionSocket)) {
|
|
++_acceptFailures;
|
|
|
|
if (_acceptFailures < MAX_ACCEPT_ERRORS) {
|
|
LOG_WARNING("accept failed with %d (%s)", (int) errno, strerror(errno));
|
|
}
|
|
else if (_acceptFailures == MAX_ACCEPT_ERRORS) {
|
|
LOG_ERROR("too many accept failures, stopping logging");
|
|
}
|
|
|
|
// TODO GeneralFigures::incCounter<GeneralFigures::GeneralServerStatistics::connectErrorsAccessor>();
|
|
|
|
return true;
|
|
}
|
|
|
|
_acceptFailures = 0;
|
|
|
|
struct sockaddr_in6 addr_out_mem;
|
|
struct sockaddr_in* addr_out = (sockaddr_in*) &addr_out_mem;;
|
|
socklen_t len_out = sizeof(addr_out_mem);
|
|
|
|
int res = TRI_getsockname(connectionSocket, (sockaddr*) addr_out, &len_out);
|
|
|
|
if (res != TRI_ERROR_NO_ERROR) {
|
|
TRI_CLOSE_SOCKET(connectionSocket);
|
|
|
|
LOG_WARNING("getsockname failed with %d (%s)", errno, strerror(errno));
|
|
|
|
// TODO GeneralFigures::incCounter<GeneralFigures::GeneralServerStatistics::connectErrorsAccessor>();
|
|
|
|
return true;
|
|
}
|
|
|
|
// disable nagle's algorithm, set to non-blocking and close-on-exec
|
|
bool result = _endpoint->initIncoming(connectionSocket);
|
|
|
|
if (! result) {
|
|
TRI_CLOSE_SOCKET(connectionSocket);
|
|
|
|
// TODO GeneralFigures::incCounter<GeneralFigures::GeneralServerStatistics::connectErrorsAccessor>();
|
|
|
|
return true;
|
|
}
|
|
|
|
// set client address and port
|
|
ConnectionInfo info;
|
|
|
|
char host[NI_MAXHOST], serv[NI_MAXSERV];
|
|
|
|
if (getnameinfo((sockaddr*) addr, len,
|
|
host, sizeof(host),
|
|
serv, sizeof(serv), NI_NUMERICHOST | NI_NUMERICSERV) == 0) {
|
|
|
|
info.clientAddress = std::string(host);
|
|
info.clientPort = addr->sin_port;
|
|
}
|
|
else {
|
|
Endpoint::DomainType type = _endpoint->getDomainType();
|
|
|
|
if (type == Endpoint::DOMAIN_IPV4) {
|
|
char buf[INET_ADDRSTRLEN + 1];
|
|
char const* p = inet_ntop(AF_INET, &addr->sin_addr, buf, sizeof(buf) - 1);
|
|
|
|
if (p != nullptr) {
|
|
buf[INET_ADDRSTRLEN] = '\0';
|
|
info.clientAddress = p;
|
|
}
|
|
info.clientPort = addr->sin_port;
|
|
}
|
|
else if (type == Endpoint::DOMAIN_IPV6) {
|
|
char buf[INET6_ADDRSTRLEN + 1];
|
|
char const* p = inet_ntop(AF_INET6, &addrmem.sin6_addr, buf, sizeof(buf) - 1);
|
|
|
|
if (p != nullptr) {
|
|
buf[INET6_ADDRSTRLEN] = '\0';
|
|
info.clientAddress = p;
|
|
}
|
|
info.clientPort = addrmem.sin6_port;
|
|
}
|
|
}
|
|
|
|
info.serverAddress = _endpoint->getHost();
|
|
info.serverPort = _endpoint->getPort();
|
|
info.endpoint = _endpoint->getSpecification();
|
|
info.endpointType = _endpoint->getDomainType();
|
|
|
|
return handleConnected(connectionSocket, info);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// private methods
|
|
// -----------------------------------------------------------------------------
|
|
|
|
bool ListenTask::bindSocket () {
|
|
_listenSocket = _endpoint->connect(30, 300); // connect timeout in seconds
|
|
|
|
if (! TRI_isvalidsocket(_listenSocket)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- END-OF-FILE
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// Local Variables:
|
|
// mode: outline-minor
|
|
// outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @page\\|// --SECTION--\\|/// @\\}"
|
|
// End:
|