LCOV - code coverage report
Current view: top level - net - tcpserver.cc (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core 954b5873a738 Lines: 50 87 57.5 %
Date: 2019-06-30 05:20:33 Functions: 7 9 77.8 %
Branches: 28 114 24.6 %

           Branch data     Line data    Source code
       1                 :            : /** @file tcpserver.cc
       2                 :            :  * @brief class for TCP/IP-based server.
       3                 :            :  */
       4                 :            : /* Copyright 1999,2000,2001 BrightStation PLC
       5                 :            :  * Copyright 2002 Ananova Ltd
       6                 :            :  * Copyright 2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2015,2017,2018 Olly Betts
       7                 :            :  *
       8                 :            :  * This program is free software; you can redistribute it and/or
       9                 :            :  * modify it under the terms of the GNU General Public License as
      10                 :            :  * published by the Free Software Foundation; either version 2 of the
      11                 :            :  * License, or (at your option) any later version.
      12                 :            :  *
      13                 :            :  * This program is distributed in the hope that it will be useful,
      14                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16                 :            :  * GNU General Public License for more details.
      17                 :            :  *
      18                 :            :  * You should have received a copy of the GNU General Public License
      19                 :            :  * along with this program; if not, write to the Free Software
      20                 :            :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
      21                 :            :  * USA
      22                 :            :  */
      23                 :            : 
      24                 :            : #include <config.h>
      25                 :            : 
      26                 :            : #include "tcpserver.h"
      27                 :            : 
      28                 :            : #include <xapian/error.h>
      29                 :            : 
      30                 :            : #include "safefcntl.h"
      31                 :            : #include "safenetdb.h"
      32                 :            : #include "safesyssocket.h"
      33                 :            : 
      34                 :            : #include "remoteconnection.h"
      35                 :            : #include "resolver.h"
      36                 :            : #include "socket_utils.h"
      37                 :            : #include "str.h"
      38                 :            : 
      39                 :            : #ifdef __WIN32__
      40                 :            : # include <process.h>    /* _beginthreadex, _endthreadex */
      41                 :            : #else
      42                 :            : # include <netinet/in_systm.h>
      43                 :            : # include <netinet/in.h>
      44                 :            : # include <netinet/ip.h>
      45                 :            : # include <netinet/tcp.h>
      46                 :            : # include <arpa/inet.h>
      47                 :            : # include <signal.h>
      48                 :            : # include <sys/wait.h>
      49                 :            : #endif
      50                 :            : 
      51                 :            : #include <iostream>
      52                 :            : 
      53                 :            : #include <cerrno>
      54                 :            : #include <cstring>
      55                 :            : #include <cstdlib>
      56                 :            : #include <sys/types.h>
      57                 :            : 
      58                 :            : using namespace std;
      59                 :            : 
      60                 :            : // Handle older systems.
      61                 :            : #if !defined SIGCHLD && defined SIGCLD
      62                 :            : # define SIGCHLD SIGCLD
      63                 :            : #endif
      64                 :            : 
      65                 :            : #ifdef __WIN32__
      66                 :            : // We must call closesocket() (instead of just close()) under __WIN32__ or
      67                 :            : // else the socket remains in the CLOSE_WAIT state.
      68                 :            : # define CLOSESOCKET(S) closesocket(S)
      69                 :            : #else
      70                 :            : # define CLOSESOCKET(S) close(S)
      71                 :            : #endif
      72                 :            : 
      73                 :            : /// The TcpServer constructor, taking a database and a listening port.
      74                 :        423 : TcpServer::TcpServer(const std::string & host, int port, bool tcp_nodelay,
      75                 :            :                      bool verbose_)
      76                 :            :     :
      77                 :            : #if defined __CYGWIN__ || defined __WIN32__
      78                 :            :       mutex(NULL),
      79                 :            : #endif
      80                 :            :       listen_socket(get_listening_socket(host, port, tcp_nodelay
      81                 :            : #if defined __CYGWIN__ || defined __WIN32__
      82                 :            :                                          , mutex
      83                 :            : #endif
      84                 :        423 :                                          )),
      85                 :        806 :       verbose(verbose_)
      86                 :            : {
      87                 :        383 : }
      88                 :            : 
      89                 :            : int
      90                 :        423 : TcpServer::get_listening_socket(const std::string & host, int port,
      91                 :            :                                 bool tcp_nodelay
      92                 :            : #if defined __CYGWIN__ || defined __WIN32__
      93                 :            :                                 , HANDLE &mutex
      94                 :            : #endif
      95                 :            :                                 )
      96                 :            : {
      97                 :        423 :     int socketfd = -1;
      98                 :        423 :     int bind_errno = 0;
      99 [ +  - ][ +  + ]:        463 :     for (auto&& r : Resolver(host, port, AI_PASSIVE)) {
     100                 :        423 :         int socktype = r.ai_socktype | SOCK_CLOEXEC;
     101                 :        423 :         int fd = socket(r.ai_family, socktype, r.ai_protocol);
     102         [ -  + ]:        423 :         if (fd == -1)
     103                 :          0 :             continue;
     104                 :            : 
     105                 :            : #if !defined __WIN32__ && defined F_SETFD && defined FD_CLOEXEC
     106                 :            :         // We can't use a preprocessor check on the *value* of SOCK_CLOEXEC as on
     107                 :            :         // Linux SOCK_CLOEXEC is an enum, with '#define SOCK_CLOEXEC SOCK_CLOEXEC'
     108                 :            :         // to allow '#ifdef SOCK_CLOEXEC' to work.
     109                 :            :         if (SOCK_CLOEXEC == 0)
     110                 :            :             (void)fcntl(fd, F_SETFD, FD_CLOEXEC);
     111                 :            : #endif
     112                 :            : 
     113                 :        423 :         int retval = 0;
     114                 :            : 
     115         [ +  - ]:        423 :         if (tcp_nodelay) {
     116                 :        423 :             int optval = 1;
     117                 :            :             // 4th argument might need to be void* or char* - cast it to char*
     118                 :            :             // since C++ allows implicit conversion to void* but not from
     119                 :            :             // void*.
     120                 :            :             retval = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY,
     121                 :            :                                 reinterpret_cast<char *>(&optval),
     122                 :        423 :                                 sizeof(optval));
     123                 :            :         }
     124                 :            : 
     125                 :        423 :         int optval = 1;
     126                 :            : #if defined __CYGWIN__ || defined __WIN32__
     127                 :            :         // Windows has screwy semantics for SO_REUSEADDR - it allows the user
     128                 :            :         // to bind to a port which is already bound and listening!  That's
     129                 :            :         // just not suitable as we don't want multiple processes listening on
     130                 :            :         // the same port, so we guard against that by using a named win32 mutex
     131                 :            :         // object (and we create it in the 'Global namespace' so that this
     132                 :            :         // still works in a Terminal Services environment).
     133                 :            :         string name = "Global\\xapian-tcpserver-listening-" + str(port);
     134                 :            :         if ((mutex = CreateMutex(NULL, TRUE, name.c_str())) == NULL) {
     135                 :            :             // We failed to create the mutex, probably the error is
     136                 :            :             // ERROR_ACCESS_DENIED, which simply means that TcpServer is
     137                 :            :             // already running on this port but as a different user.
     138                 :            :         } else if (GetLastError() == ERROR_ALREADY_EXISTS) {
     139                 :            :             // The mutex already existed, so TcpServer is already running
     140                 :            :             // on this port.
     141                 :            :             CloseHandle(mutex);
     142                 :            :             mutex = NULL;
     143                 :            :         }
     144                 :            :         if (mutex == NULL) {
     145                 :            :             cerr << "Server is already running on port " << port << endl;
     146                 :            :             // 69 is EX_UNAVAILABLE.  Scripts can use this to detect if the
     147                 :            :             // server failed to bind to the requested port.
     148                 :            :             exit(69); // FIXME: calling exit() here isn't ideal...
     149                 :            :         }
     150                 :            : #endif
     151         [ +  - ]:        423 :         if (retval >= 0) {
     152                 :            :             retval = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
     153                 :            :                                 reinterpret_cast<char *>(&optval),
     154                 :        423 :                                 sizeof(optval));
     155                 :            :         }
     156                 :            : 
     157                 :            : #if defined SO_EXCLUSIVEADDRUSE
     158                 :            :         // NT4 sp4 and later offer SO_EXCLUSIVEADDRUSE which nullifies the
     159                 :            :         // security issues from SO_REUSEADDR (which affect *any* listening
     160                 :            :         // process, even if doesn't use SO_REUSEADDR itself).  There's still no
     161                 :            :         // way of addressing the issue of not being able to listen on a port
     162                 :            :         // which has closed connections in TIME_WAIT state though.
     163                 :            :         //
     164                 :            :         // Note: SO_EXCLUSIVEADDRUSE requires admin privileges prior to XP SP2.
     165                 :            :         // Because of this and the lack support on older versions, we don't
     166                 :            :         // currently check the return value.
     167                 :            :         if (retval >= 0) {
     168                 :            :             (void)setsockopt(fd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
     169                 :            :                              reinterpret_cast<char *>(&optval),
     170                 :            :                              sizeof(optval));
     171                 :            :         }
     172                 :            : #endif
     173                 :            : 
     174         [ -  + ]:        423 :         if (retval < 0) {
     175                 :          0 :             int saved_errno = socket_errno(); // note down in case close hits an error
     176         [ #  # ]:          0 :             CLOSESOCKET(fd);
     177 [ #  # ][ #  # ]:          0 :             throw Xapian::NetworkError("setsockopt failed", saved_errno);
     178                 :            :         }
     179                 :            : 
     180         [ +  + ]:        423 :         if (::bind(fd, r.ai_addr, r.ai_addrlen) == 0) {
     181                 :        383 :             socketfd = fd;
     182                 :        383 :             break;
     183                 :            :         }
     184                 :            : 
     185                 :            :         // Note down the error code for the first address we try, which seems
     186                 :            :         // likely to be more helpful than the last in the case where they
     187                 :            :         // differ.
     188         [ +  - ]:         40 :         if (bind_errno == 0)
     189                 :         40 :             bind_errno = socket_errno();
     190                 :            : 
     191         [ +  - ]:         40 :         CLOSESOCKET(fd);
     192                 :        423 :     }
     193                 :            : 
     194         [ +  + ]:        423 :     if (socketfd == -1) {
     195         [ +  - ]:         40 :         if (bind_errno == EADDRINUSE) {
     196                 :         40 :             cerr << host << ':' << port << " already in use" << endl;
     197                 :            :             // 69 is EX_UNAVAILABLE.  Scripts can use this to detect if the
     198                 :            :             // server failed to bind to the requested port.
     199                 :         40 :             exit(69); // FIXME: calling exit() here isn't ideal...
     200                 :            :         }
     201         [ #  # ]:          0 :         if (bind_errno == EACCES) {
     202                 :          0 :             cerr << "Can't bind to privileged port " << port << endl;
     203                 :            :             // 77 is EX_NOPERM.  Scripts can use this to detect if
     204                 :            :             // xapian-tcpsrv failed to bind to the requested port.
     205                 :          0 :             exit(77); // FIXME: calling exit() here isn't ideal...
     206                 :            :         }
     207 [ #  # ][ #  # ]:          0 :         throw Xapian::NetworkError("bind failed", bind_errno);
     208                 :            :     }
     209                 :            : 
     210         [ -  + ]:        383 :     if (listen(socketfd, 5) < 0) {
     211                 :          0 :         int saved_errno = socket_errno(); // note down in case close hits an error
     212                 :          0 :         CLOSESOCKET(socketfd);
     213 [ #  # ][ #  # ]:          0 :         throw Xapian::NetworkError("listen failed", saved_errno);
     214                 :            :     }
     215                 :        383 :     return socketfd;
     216                 :            : }
     217                 :            : 
     218                 :            : int
     219                 :        383 : TcpServer::accept_connection()
     220                 :            : {
     221                 :            :     struct sockaddr_storage remote_address;
     222                 :        383 :     SOCKLEN_T remote_address_size = sizeof(remote_address);
     223                 :            :     // accept connections
     224                 :            :     int con_socket = accept(listen_socket,
     225                 :            :                             reinterpret_cast<sockaddr *>(&remote_address),
     226         [ +  - ]:        383 :                             &remote_address_size);
     227                 :            : 
     228         [ -  + ]:        383 :     if (con_socket < 0) {
     229                 :            : #ifdef __WIN32__
     230                 :            :         if (WSAGetLastError() == WSAEINTR) {
     231                 :            :             // Our CtrlHandler function closed the socket.
     232                 :            :             if (mutex) CloseHandle(mutex);
     233                 :            :             mutex = NULL;
     234                 :            :             return -1;
     235                 :            :         }
     236                 :            : #endif
     237 [ #  # ][ #  # ]:          0 :         throw Xapian::NetworkError("accept failed", socket_errno());
     238                 :            :     }
     239                 :            : 
     240         [ +  - ]:        383 :     if (verbose) {
     241                 :            :         char host[PRETTY_IP6_LEN];
     242         [ +  - ]:        383 :         int port = pretty_ip6(&remote_address, host);
     243         [ +  - ]:        383 :         if (port >= 0) {
     244 [ +  - ][ +  - ]:        383 :             cout << "Connection from " << host << " port " << port << endl;
         [ +  - ][ +  - ]
                 [ +  - ]
     245                 :            :         } else {
     246 [ #  # ][ #  # ]:        383 :             cout << "Connection from unknown host" << endl;
     247                 :            :         }
     248                 :            :     }
     249                 :            : 
     250                 :        383 :     return con_socket;
     251                 :            : }
     252                 :            : 
     253                 :        383 : TcpServer::~TcpServer()
     254                 :            : {
     255                 :        383 :     CLOSESOCKET(listen_socket);
     256                 :            : #if defined __CYGWIN__ || defined __WIN32__
     257                 :            :     if (mutex) CloseHandle(mutex);
     258                 :            : #endif
     259         [ -  + ]:        383 : }
     260                 :            : 
     261                 :            : #ifdef HAVE_FORK
     262                 :            : // A fork() based implementation.
     263                 :            : 
     264                 :            : extern "C" {
     265                 :            : 
     266                 :            : [[noreturn]]
     267                 :            : static void
     268                 :          0 : on_SIGTERM(int /*sig*/)
     269                 :            : {
     270                 :          0 :     signal(SIGTERM, SIG_DFL);
     271                 :            :     /* terminate all processes in my process group */
     272                 :            : #ifdef HAVE_KILLPG
     273                 :            :     killpg(0, SIGTERM);
     274                 :            : #else
     275                 :          0 :     kill(0, SIGTERM);
     276                 :            : #endif
     277                 :          0 :     exit(0);
     278                 :            : }
     279                 :            : 
     280                 :            : #ifdef HAVE_WAITPID
     281                 :            : static void
     282                 :            : on_SIGCHLD(int /*sig*/)
     283                 :            : {
     284                 :            :     int status;
     285                 :            :     while (waitpid(-1, &status, WNOHANG) > 0);
     286                 :            : }
     287                 :            : #endif
     288                 :            : 
     289                 :            : }
     290                 :            : 
     291                 :            : void
     292                 :          0 : TcpServer::run()
     293                 :            : {
     294                 :            :     // Handle connections until shutdown.
     295                 :            : 
     296                 :            :     // Set up signal handlers.
     297                 :            : #ifdef HAVE_WAITPID
     298                 :            :     signal(SIGCHLD, on_SIGCHLD);
     299                 :            : #else
     300                 :          0 :     signal(SIGCHLD, SIG_IGN);
     301                 :            : #endif
     302                 :          0 :     signal(SIGTERM, on_SIGTERM);
     303                 :            : 
     304                 :            :     while (true) {
     305                 :            :         try {
     306         [ #  # ]:          0 :             int connected_socket = accept_connection();
     307                 :          0 :             pid_t pid = fork();
     308         [ #  # ]:          0 :             if (pid == 0) {
     309                 :            :                 // Child process.
     310         [ #  # ]:          0 :                 close(listen_socket);
     311                 :            : 
     312         [ #  # ]:          0 :                 handle_one_connection(connected_socket);
     313         [ #  # ]:          0 :                 close(connected_socket);
     314                 :            : 
     315 [ #  # ][ #  # ]:          0 :                 if (verbose) cout << "Connection closed." << endl;
                 [ #  # ]
     316                 :          0 :                 exit(0);
     317                 :            :             }
     318                 :            : 
     319                 :            :             // Parent process.
     320                 :            : 
     321         [ #  # ]:          0 :             if (pid < 0) {
     322                 :            :                 // fork() failed.
     323                 :            : 
     324                 :            :                 // Note down errno from fork() in case close() hits an error.
     325                 :          0 :                 int saved_errno = socket_errno();
     326         [ #  # ]:          0 :                 close(connected_socket);
     327 [ #  # ][ #  # ]:          0 :                 throw Xapian::NetworkError("fork failed", saved_errno);
     328                 :            :             }
     329                 :            : 
     330         [ #  # ]:          0 :             close(connected_socket);
     331                 :          0 :         } catch (const Xapian::Error &e) {
     332                 :            :             // FIXME: better error handling.
     333   [ #  #  #  #  :          0 :             cerr << "Caught " << e.get_description() << endl;
             #  #  #  # ]
     334         [ #  # ]:          0 :         } catch (...) {
     335                 :            :             // FIXME: better error handling.
     336   [ #  #  #  # ]:          0 :             cerr << "Caught exception." << endl;
     337                 :            :         }
     338                 :          0 :     }
     339                 :            : }
     340                 :            : 
     341                 :            : #elif defined __WIN32__
     342                 :            : 
     343                 :            : // A threaded, Windows specific, implementation.
     344                 :            : 
     345                 :            : /** The socket which will be closed by CtrlHandler.
     346                 :            :  *
     347                 :            :  *  FIXME - is there any way to avoid using a global variable here?
     348                 :            :  */
     349                 :            : static const int *pShutdownSocket = NULL;
     350                 :            : 
     351                 :            : /// Console interrupt handler.
     352                 :            : static BOOL
     353                 :            : CtrlHandler(DWORD fdwCtrlType)
     354                 :            : {
     355                 :            :     switch (fdwCtrlType) {
     356                 :            :         case CTRL_C_EVENT:
     357                 :            :         case CTRL_CLOSE_EVENT:
     358                 :            :             //  Console is about to die.
     359                 :            :             // CTRL_CLOSE_EVENT gives us 5 seconds before displaying a
     360                 :            :             // confirmation dialog asking if we really are sure.
     361                 :            :         case CTRL_LOGOFF_EVENT:
     362                 :            :         case CTRL_SHUTDOWN_EVENT:
     363                 :            :             // These 2 will probably need to change when we get service
     364                 :            :             // support - the service will prevent these being seen, so only
     365                 :            :             // apply interactively.
     366                 :            :             cout << "Shutting down..." << endl;
     367                 :            :             break; // default behaviour
     368                 :            :         case CTRL_BREAK_EVENT:
     369                 :            :             // This (probably) means the developer is struggling to get
     370                 :            :             // things to behave, and really wants to shutdown so let the OS
     371                 :            :             // handle Ctrl+Break in the default way.
     372                 :            :             cout << "Ctrl+Break: aborting process" << endl;
     373                 :            :             return FALSE;
     374                 :            :         default:
     375                 :            :             cerr << "unexpected CtrlHandler: " << fdwCtrlType << endl;
     376                 :            :             return FALSE;
     377                 :            :     }
     378                 :            : 
     379                 :            :     // Note: close() does not cause a blocking accept() call to terminate.
     380                 :            :     // However, it appears closesocket() does.  This is much easier than trying
     381                 :            :     // to setup a non-blocking accept().
     382                 :            :     if (!pShutdownSocket || closesocket(*pShutdownSocket) == SOCKET_ERROR) {
     383                 :            :         // We failed to close the socket, so just let the OS handle the
     384                 :            :         // event in the default way.
     385                 :            :         return FALSE;
     386                 :            :     }
     387                 :            : 
     388                 :            :     pShutdownSocket = NULL;
     389                 :            :     return TRUE; // Tell the OS that we've handled the event.
     390                 :            : }
     391                 :            : 
     392                 :            : /// Structure which is used to pass parameters to the new threads.
     393                 :            : struct thread_param
     394                 :            : {
     395                 :            :     thread_param(TcpServer *s, int c) : server(s), connected_socket(c) {}
     396                 :            :     TcpServer *server;
     397                 :            :     int connected_socket;
     398                 :            : };
     399                 :            : 
     400                 :            : /// The thread entry-point.
     401                 :            : static unsigned __stdcall
     402                 :            : run_thread(void * param_)
     403                 :            : {
     404                 :            :     thread_param * param(reinterpret_cast<thread_param *>(param_));
     405                 :            :     int socket = param->connected_socket;
     406                 :            : 
     407                 :            :     param->server->handle_one_connection(socket);
     408                 :            :     closesocket(socket);
     409                 :            : 
     410                 :            :     delete param;
     411                 :            : 
     412                 :            :     _endthreadex(0);
     413                 :            :     return 0;
     414                 :            : }
     415                 :            : 
     416                 :            : void
     417                 :            : TcpServer::run()
     418                 :            : {
     419                 :            :     // Handle connections until shutdown.
     420                 :            : 
     421                 :            :     // Set up the shutdown handler - this is a bit hacky, and sadly involves
     422                 :            :     // a global variable.
     423                 :            :     pShutdownSocket = &listen_socket;
     424                 :            :     if (!::SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE))
     425                 :            :         throw Xapian::NetworkError("Failed to install shutdown handler");
     426                 :            : 
     427                 :            :     while (true) {
     428                 :            :         try {
     429                 :            :             int connected_socket = accept_connection();
     430                 :            :             if (connected_socket == -1)
     431                 :            :                return; // Shutdown has happened
     432                 :            : 
     433                 :            :             // Spawn a new thread to handle the connection.
     434                 :            :             // (This seems like lots of hoops just to end up calling
     435                 :            :             // this->handle_one_connection() on a new thread. There might be a
     436                 :            :             // better way...)
     437                 :            :             thread_param *param = new thread_param(this, connected_socket);
     438                 :            :             HANDLE hthread = (HANDLE)_beginthreadex(NULL, 0, ::run_thread, param, 0, NULL);
     439                 :            :             if (hthread == 0) {
     440                 :            :                 // errno holds the error code from _beginthreadex, and
     441                 :            :                 // closesocket() doesn't set errno.
     442                 :            :                 closesocket(connected_socket);
     443                 :            :                 throw Xapian::NetworkError("_beginthreadex failed", errno);
     444                 :            :             }
     445                 :            : 
     446                 :            :             // FIXME: keep track of open thread handles so we can gracefully
     447                 :            :             // close each thread down.  OTOH, when we want to kill them all its
     448                 :            :             // likely to mean the process is on its way down, so it doesn't
     449                 :            :             // really matter...
     450                 :            :             CloseHandle(hthread);
     451                 :            :         } catch (const Xapian::Error &e) {
     452                 :            :             // FIXME: better error handling.
     453                 :            :             cerr << "Caught " << e.get_description() << endl;
     454                 :            :         } catch (...) {
     455                 :            :             // FIXME: better error handling.
     456                 :            :             cerr << "Caught exception." << endl;
     457                 :            :         }
     458                 :            :     }
     459                 :            : }
     460                 :            : 
     461                 :            : #else
     462                 :            : # error Neither HAVE_FORK nor __WIN32__ are defined.
     463                 :            : #endif
     464                 :            : 
     465                 :            : void
     466                 :        383 : TcpServer::run_once()
     467                 :            : {
     468                 :            :     // Run a single request in the current process/thread.
     469                 :        383 :     int fd = accept_connection();
     470                 :        383 :     handle_one_connection(fd);
     471                 :        383 :     CLOSESOCKET(fd);
     472 [ +  - ][ +  - ]:       3268 : }
     473                 :            : 
     474                 :            : #ifdef DISABLE_GPL_LIBXAPIAN
     475                 :            : # error GPL source we cannot relicense included in libxapian
     476                 :            : #endif

Generated by: LCOV version 1.11