path: root/src/microhttpd/test_shutdown_select.c

/*
     This file is part of libmicrohttpd
     Copyright (C) 2016 Karlson2k (Evgeny Grin)

     libmicrohttpd 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, or (at your
     option) any later version.

     libmicrohttpd 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 libmicrohttpd; see the file COPYING.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
*/

/**
 * @file microhttpd/test_shutdown_select.c
 * @brief  Test whether shutdown socket triggers select()/poll()
 * @details On some platforms shutting down the socket in one thread
 *          triggers select() or poll() waiting for this socket in
 *          other thread. libmicrohttpd depends on this behavior on
 *          these platforms. This program check whether select()
 *          and poll() (if available) work as expected.
 * @author Karlson2k (Evgeny Grin)
 */

#include "MHD_config.h"
#include "platform.h"
#include "mhd_sockets.h"
#include <stdlib.h>
#include <stdio.h>

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif /* HAVE_UNISTD_H */

#ifdef HAVE_TIME_H
#include <time.h>
#endif /* HAVE_TIME_H */

#if defined(MHD_USE_POSIX_THREADS)
#include <pthread.h>
#endif /* MHD_USE_POSIX_THREADS */

#if defined(MHD_WINSOCK_SOCKETS)
#include <winsock2.h>
#include <windows.h>
#define sock_errno (WSAGetLastError ())
#elif defined(MHD_POSIX_SOCKETS)
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif /* HAVE_SYS_TYPES_H */
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif /* HAVE_SYS_SOCKET_H */
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif /* HAVE_NETINET_IN_H */
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif /* HAVE_ARPA_INET_H */
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif /* HAVE_SYS_SELECT_H */
#if defined(HAVE_POLL) && defined(HAVE_POLL_H)
#include <poll.h>
#endif /* HAVE_POLL && HAVE_POLL_H */
#define sock_errno (errno)
#endif /* MHD_POSIX_SOCKETS */

#ifdef HAVE_STDBOOL_H
#include <stdbool.h>
#endif /* HAVE_STDBOOL_H */

#include "mhd_threads.h"

#ifndef SOMAXCONN
#define SOMAXCONN 511
#endif /* ! SOMAXCONN */

#if ! defined(SHUT_RDWR) && defined(SD_BOTH)
#define SHUT_RDWR SD_BOTH
#endif

static bool check_err;


static bool
has_in_name (const char *prog_name, const char *marker)
{
  size_t name_pos;
  size_t pos;

  if (! prog_name || ! marker)
    return 0;

  pos = 0;
  name_pos = 0;
  while (prog_name[pos])
  {
    if ('/' == prog_name[pos])
      name_pos = pos + 1;
#if defined(_WIN32) || defined(__CYGWIN__)
    else if ('\\' == prog_name[pos])
      name_pos = pos + 1;
#endif /* _WIN32 || __CYGWIN__ */
    pos++;
  }
  if (name_pos == pos)
    return true;
  return strstr (prog_name + name_pos, marker) != NULL;
}


static MHD_socket
start_socket_listen (int domain)
{
/* Create sockets similarly to daemon.c */
  MHD_socket fd;
  int cloexec_set;
  struct sockaddr_in sock_addr;
  socklen_t addrlen;

#ifdef MHD_WINSOCK_SOCKETS
  unsigned long flags = 1;
#else  /* MHD_POSIX_SOCKETS */
  int flags;
#endif /* MHD_POSIX_SOCKETS */

#if defined(MHD_POSIX_SOCKETS) && defined(SOCK_CLOEXEC)
  fd = socket (domain, SOCK_STREAM | SOCK_CLOEXEC, 0);
  cloexec_set = 1;
#elif defined(MHD_WINSOCK_SOCKETS) && defined (WSA_FLAG_NO_HANDLE_INHERIT)
  fd = WSASocketW (domain, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_NO_HANDLE_INHERIT);
  cloexec_set = 1;
#else  /* !SOCK_CLOEXEC */
  fd = socket (domain, SOCK_STREAM, 0);
  cloexec_set = 0;
#endif /* !SOCK_CLOEXEC */
  if ( (MHD_INVALID_SOCKET == fd) && (cloexec_set) )
  {
    fd = socket (domain, SOCK_STREAM, 0);
    cloexec_set = 0;
  }
  if (MHD_INVALID_SOCKET == fd)
  {
    fprintf (stderr, "Can't create socket: %u\n",
             (unsigned) sock_errno);
    return MHD_INVALID_SOCKET;
  }

  if (! cloexec_set)
  {
#ifdef MHD_WINSOCK_SOCKETS
    if (! SetHandleInformation ((HANDLE) fd, HANDLE_FLAG_INHERIT, 0))
      fprintf (stderr, "Failed to make socket non-inheritable: %u\n",
               (unsigned int) GetLastError ());
#else  /* MHD_POSIX_SOCKETS */
    flags = fcntl (fd, F_GETFD);
    if ( ( (-1 == flags) ||
           ( (flags != (flags | FD_CLOEXEC)) &&
             (0 != fcntl (fd, F_SETFD, flags | FD_CLOEXEC)) ) ) )
      fprintf (stderr, "Failed to make socket non-inheritable: %s\n",
               MHD_socket_last_strerr_ ());
#endif /* MHD_POSIX_SOCKETS */
  }

  memset (&sock_addr, 0, sizeof (struct sockaddr_in));
  sock_addr.sin_family = AF_INET;
  sock_addr.sin_port = htons (0);
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
  sock_addr.sin_len = sizeof (struct sockaddr_in);
#endif
  addrlen = sizeof (struct sockaddr_in);

  if (bind (fd, (const struct sockaddr*) &sock_addr, addrlen) < 0)
  {
    fprintf (stderr, "Failed to bind socket: %u\n",
             (unsigned) sock_errno);
    MHD_socket_close_chk_ (fd);
    return MHD_INVALID_SOCKET;
  }

#ifdef MHD_WINSOCK_SOCKETS
  if (0 != ioctlsocket (fd, FIONBIO, &flags))
  {
    fprintf (stderr, "Failed to make socket non-blocking: %u\n",
             (unsigned) sock_errno);
    MHD_socket_close_chk_ (fd);
    return MHD_INVALID_SOCKET;
  }
#else  /* MHD_POSIX_SOCKETS */
  flags = fcntl (fd, F_GETFL);
  if ( ( (-1 == flags) ||
         ( (flags != (flags | O_NONBLOCK)) &&
           (0 != fcntl (fd, F_SETFL, flags | O_NONBLOCK)) ) ) )
  {
    fprintf (stderr, "Failed to make socket non-blocking: %s\n",
             MHD_socket_last_strerr_ ());
    MHD_socket_close_chk_ (fd);
    return MHD_INVALID_SOCKET;
  }
#endif /* MHD_POSIX_SOCKETS */

  if (listen (fd, SOMAXCONN) < 0)
  {
    fprintf (stderr, "Failed to listen on socket: %u\n",
             (unsigned) sock_errno);
    MHD_socket_close_chk_ (fd);
    return MHD_INVALID_SOCKET;
  }

  return fd;
}


MHD_THRD_RTRN_TYPE_ MHD_THRD_CALL_SPEC_
select_thread (void*data)
{
  /* use select() like in daemon.c */
  MHD_socket listen_sock = *((MHD_socket*) data);
  fd_set rs, ws;
  struct timeval timeout;

  FD_ZERO (&rs);
  FD_ZERO (&ws);
  FD_SET (listen_sock, &rs);
  timeout.tv_usec = 0;
  timeout.tv_sec = 7;

  check_err = (0 > MHD_SYS_select_ (listen_sock + 1, &rs, &ws, NULL, &timeout));

  return (MHD_THRD_RTRN_TYPE_) 0;
}


#ifdef HAVE_POLL
MHD_THRD_RTRN_TYPE_ MHD_THRD_CALL_SPEC_
poll_thread (void*data)
{
  /* use poll() like in daemon.c */
  struct pollfd p[1];
  MHD_socket listen_sock = *((MHD_socket*) data);

  p[0].fd = listen_sock;
  p[0].events = POLLIN;
  p[0].revents = 0;

  check_err = (0 > MHD_sys_poll_ (p, 1, 7000));

  return (MHD_THRD_RTRN_TYPE_) 0;
}


#endif /* HAVE_POLL */


static void
local_sleep (unsigned seconds)
{
#if defined(_WIN32) && ! defined(__CYGWIN__)
  Sleep (seconds * 1000);
#else
  unsigned seconds_left = seconds;
  do
  {
    seconds_left = sleep (seconds_left);
  } while (seconds_left > 0);
#endif
}


int
main (int argc, char *const *argv)
{
  int i;
  time_t start_t, end_t;
  int result = 0;
  MHD_THRD_RTRN_TYPE_ (MHD_THRD_CALL_SPEC_ * test_func)(void*data);
#ifdef MHD_WINSOCK_SOCKETS
  WORD ver_req;
  WSADATA wsa_data;
  int err;
#endif /* MHD_WINSOCK_SOCKETS */
  bool test_poll;
  bool must_ignore;
  (void) argc; /* Unused. Silent compiler warning. */

  test_poll = has_in_name (argv[0], "_poll");
  must_ignore = has_in_name (argv[0], "_ignore");
  if (! test_poll)
    test_func = &select_thread;
  else
  {
#ifndef HAVE_POLL
    return 77;
#else  /* ! HAVE_POLL */
    test_func = &poll_thread;
#endif /* ! HAVE_POLL */
  }

#ifdef MHD_WINSOCK_SOCKETS
  ver_req = MAKEWORD (2, 2);

  err = WSAStartup (ver_req, &wsa_data);
  if ((err != 0) || (MAKEWORD (2, 2) != wsa_data.wVersion))
  {
    printf ("WSAStartup() failed\n");
    WSACleanup ();
    return 99;
  }
#endif /* MHD_WINSOCK_SOCKETS */

  /* try several times to ensure that accidental incoming connection
   * didn't interfere with test results
   */
  for (i = 0; i < 5 && result == 0; i++)
  {
    MHD_thread_handle_ sel_thrd;
    /* fprintf(stdout, "Creating, binding and listening socket...\n"); */
    MHD_socket listen_socket = start_socket_listen (AF_INET);
    if (MHD_INVALID_SOCKET == listen_socket)
      return 99;

    check_err = true;
    /* fprintf (stdout, "Starting select() thread...\n"); */
#if defined(MHD_USE_POSIX_THREADS)
    if (0 != pthread_create (&sel_thrd, NULL, test_func, &listen_socket))
    {
      MHD_socket_close_chk_ (listen_socket);
      fprintf (stderr, "Can't start thread\n");
      return 99;
    }
#elif defined(MHD_USE_W32_THREADS)
    sel_thrd = (HANDLE) _beginthreadex (NULL, 0, test_func, &listen_socket, 0,
                                        NULL);
    if (0 == (sel_thrd))
    {
      MHD_socket_close_chk_ (listen_socket);
      fprintf (stderr, "Can't start select() thread\n");
      return 99;
    }
#else
#error No threading lib available
#endif
    /* fprintf (stdout, "Waiting...\n"); */
    local_sleep (1);  /* make sure that select() is started */

    /* fprintf (stdout, "Shutting down socket...\n"); */
    start_t = time (NULL);
    shutdown (listen_socket, SHUT_RDWR);

    /* fprintf (stdout, "Waiting for thread to finish...\n"); */
    if (! MHD_join_thread_ (sel_thrd))
    {
      MHD_socket_close_chk_ (listen_socket);
      fprintf (stderr, "Can't join select() thread\n");
      return 99;
    }
    if (check_err)
    {
      MHD_socket_close_chk_ (listen_socket);
      fprintf (stderr, "Error in waiting thread\n");
      return 99;
    }
    end_t = time (NULL);
    /* fprintf (stdout, "Thread finished.\n"); */
    MHD_socket_close_chk_ (listen_socket);

    if ((start_t == (time_t) -1) || (end_t == (time_t) -1) )
    {
      MHD_socket_close_chk_ (listen_socket);
      fprintf (stderr, "Can't get current time\n");
      return 99;
    }
    if (end_t - start_t > 3)
      result++;
  }

#ifdef MHD_WINSOCK_SOCKETS
  WSACleanup ();
#endif /* MHD_WINSOCK_SOCKETS */

  return must_ignore ? (! result) : (result);
}