| /*------------------------------------------------------------------------- |
| * drawElements Quality Program Execution Server |
| * --------------------------------------------- |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * 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. |
| * |
| *//*! |
| * \file |
| * \brief TCP Server. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "xsTcpServer.hpp" |
| |
| #include <algorithm> |
| #include <iterator> |
| #include <cstdio> |
| |
| namespace xs |
| { |
| |
| TcpServer::TcpServer(deSocketFamily family, int port) : m_socket() |
| { |
| de::SocketAddress address; |
| address.setFamily(family); |
| address.setPort(port); |
| address.setType(DE_SOCKETTYPE_STREAM); |
| address.setProtocol(DE_SOCKETPROTOCOL_TCP); |
| |
| m_socket.listen(address); |
| m_socket.setFlags(DE_SOCKET_CLOSE_ON_EXEC); |
| } |
| |
| void TcpServer::runServer(void) |
| { |
| de::Socket *clientSocket = DE_NULL; |
| de::SocketAddress clientAddr; |
| |
| while ((clientSocket = m_socket.accept(clientAddr)) != DE_NULL) |
| { |
| ConnectionHandler *handler = DE_NULL; |
| |
| try |
| { |
| handler = createHandler(clientSocket, clientAddr); |
| } |
| catch (...) |
| { |
| delete clientSocket; |
| throw; |
| } |
| |
| try |
| { |
| addLiveConnection(handler); |
| } |
| catch (...) |
| { |
| delete handler; |
| throw; |
| } |
| |
| // Start handler. |
| handler->start(); |
| |
| // Perform connection list cleanup. |
| deleteDoneConnections(); |
| } |
| |
| // One more cleanup pass. |
| deleteDoneConnections(); |
| } |
| |
| void TcpServer::connectionDone(ConnectionHandler *handler) |
| { |
| de::ScopedLock lock(m_connectionListLock); |
| |
| std::vector<ConnectionHandler *>::iterator liveListPos = |
| std::find(m_liveConnections.begin(), m_liveConnections.end(), handler); |
| DE_ASSERT(liveListPos != m_liveConnections.end()); |
| |
| m_doneConnections.reserve(m_doneConnections.size() + 1); |
| m_liveConnections.erase(liveListPos); |
| m_doneConnections.push_back(handler); |
| } |
| |
| void TcpServer::addLiveConnection(ConnectionHandler *handler) |
| { |
| de::ScopedLock lock(m_connectionListLock); |
| m_liveConnections.push_back(handler); |
| } |
| |
| void TcpServer::deleteDoneConnections(void) |
| { |
| de::ScopedLock lock(m_connectionListLock); |
| |
| for (std::vector<ConnectionHandler *>::iterator i = m_doneConnections.begin(); i != m_doneConnections.end(); i++) |
| delete *i; |
| |
| m_doneConnections.clear(); |
| } |
| |
| void TcpServer::stopServer(void) |
| { |
| // Close socket. This should get accept() to return null. |
| m_socket.close(); |
| } |
| |
| TcpServer::~TcpServer(void) |
| { |
| try |
| { |
| std::vector<ConnectionHandler *> allConnections; |
| |
| if (m_connectionListLock.tryLock()) |
| { |
| // \note [pyry] It is possible that cleanup actually fails. |
| try |
| { |
| std::copy(m_liveConnections.begin(), m_liveConnections.end(), |
| std::inserter(allConnections, allConnections.end())); |
| std::copy(m_doneConnections.begin(), m_doneConnections.end(), |
| std::inserter(allConnections, allConnections.end())); |
| } |
| catch (...) |
| { |
| } |
| m_connectionListLock.unlock(); |
| } |
| |
| for (std::vector<ConnectionHandler *>::const_iterator i = allConnections.begin(); i != allConnections.end(); |
| i++) |
| delete *i; |
| |
| if (m_socket.getState() != DE_SOCKETSTATE_CLOSED) |
| m_socket.close(); |
| } |
| catch (...) |
| { |
| // Nada, we're at destructor. |
| } |
| } |
| |
| ConnectionHandler::~ConnectionHandler(void) |
| { |
| delete m_socket; |
| } |
| |
| void ConnectionHandler::run(void) |
| { |
| try |
| { |
| handle(); |
| } |
| catch (const std::exception &e) |
| { |
| printf("ConnectionHandler::run(): %s\n", e.what()); |
| } |
| |
| // Notify server that this connection is done. |
| m_server->connectionDone(this); |
| } |
| |
| } // namespace xs |