1 files changed, 523 insertions, 0 deletions

diff --git a/src/lib/mhd_sockets.c b/src/lib/mhd_sockets.c
new file mode 100644
index 00000000..ddcc1f25
--- /dev/null
+++ b/src/lib/mhd_sockets.c
@@ -0,0 +1,523 @@
+/*
+  This file is part of libmicrohttpd
+  Copyright (C) 2014-2016 Karlson2k (Evgeny Grin)
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library 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
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+/**
+ * @file microhttpd/mhd_sockets.c
+ * @brief  Implementation for sockets functions
+ * @author Karlson2k (Evgeny Grin)
+ */
+
+#include "mhd_sockets.h"
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif /* HAVE_UNISTD_H */
+#include <fcntl.h>
+
+#ifdef MHD_WINSOCK_SOCKETS
+
+/**
+ * Return pointer to string description of specified WinSock error
+ * @param err the WinSock error code.
+ * @return pointer to string description of specified WinSock error.
+ */
+const char* MHD_W32_strerror_winsock_(int err)
+{
+  switch (err)
+    {
+  case 0:
+    return "No error";
+  case WSA_INVALID_HANDLE:
+    return "Specified event object handle is invalid";
+  case WSA_NOT_ENOUGH_MEMORY:
+    return "Insufficient memory available";
+  case WSA_INVALID_PARAMETER:
+    return "One or more parameters are invalid";
+  case WSA_OPERATION_ABORTED:
+    return "Overlapped operation aborted";
+  case WSA_IO_INCOMPLETE:
+    return "Overlapped I/O event object not in signaled state";
+  case WSA_IO_PENDING:
+    return "Overlapped operations will complete later";
+  case WSAEINTR:
+    return "Interrupted function call";
+  case WSAEBADF:
+    return "File handle is not valid";
+  case WSAEACCES:
+    return "Permission denied";
+  case WSAEFAULT:
+    return "Bad address";
+  case WSAEINVAL:
+    return "Invalid argument";
+  case WSAEMFILE:
+    return "Too many open files";
+  case WSAEWOULDBLOCK:
+    return "Resource temporarily unavailable";
+  case WSAEINPROGRESS:
+    return "Operation now in progress";
+  case WSAEALREADY:
+    return "Operation already in progress";
+  case WSAENOTSOCK:
+    return "Socket operation on nonsocket";
+  case WSAEDESTADDRREQ:
+    return "Destination address required";
+  case WSAEMSGSIZE:
+    return "Message too long";
+  case WSAEPROTOTYPE:
+    return "Protocol wrong type for socket";
+  case WSAENOPROTOOPT:
+    return "Bad protocol option";
+  case WSAEPROTONOSUPPORT:
+    return "Protocol not supported";
+  case WSAESOCKTNOSUPPORT:
+    return "Socket type not supported";
+  case WSAEOPNOTSUPP:
+    return "Operation not supported";
+  case WSAEPFNOSUPPORT:
+    return "Protocol family not supported";
+  case WSAEAFNOSUPPORT:
+    return "Address family not supported by protocol family";
+  case WSAEADDRINUSE:
+    return "Address already in use";
+  case WSAEADDRNOTAVAIL:
+    return "Cannot assign requested address";
+  case WSAENETDOWN:
+    return "Network is down";
+  case WSAENETUNREACH:
+    return "Network is unreachable";
+  case WSAENETRESET:
+    return "Network dropped connection on reset";
+  case WSAECONNABORTED:
+    return "Software caused connection abort";
+  case WSAECONNRESET:
+    return "Connection reset by peer";
+  case WSAENOBUFS:
+    return "No buffer space available";
+  case WSAEISCONN:
+    return "Socket is already connected";
+  case WSAENOTCONN:
+    return "Socket is not connected";
+  case WSAESHUTDOWN:
+    return "Cannot send after socket shutdown";
+  case WSAETOOMANYREFS:
+    return "Too many references";
+  case WSAETIMEDOUT:
+    return "Connection timed out";
+  case WSAECONNREFUSED:
+    return "Connection refused";
+  case WSAELOOP:
+    return "Cannot translate name";
+  case WSAENAMETOOLONG:
+    return "Name too long";
+  case WSAEHOSTDOWN:
+    return "Host is down";
+  case WSAEHOSTUNREACH:
+    return "No route to host";
+  case WSAENOTEMPTY:
+    return "Directory not empty";
+  case WSAEPROCLIM:
+    return "Too many processes";
+  case WSAEUSERS:
+    return "User quota exceeded";
+  case WSAEDQUOT:
+    return "Disk quota exceeded";
+  case WSAESTALE:
+    return "Stale file handle reference";
+  case WSAEREMOTE:
+    return "Item is remote";
+  case WSASYSNOTREADY:
+    return "Network subsystem is unavailable";
+  case WSAVERNOTSUPPORTED:
+    return "Winsock.dll version out of range";
+  case WSANOTINITIALISED:
+    return "Successful WSAStartup not yet performed";
+  case WSAEDISCON:
+    return "Graceful shutdown in progress";
+  case WSAENOMORE:
+    return "No more results";
+  case WSAECANCELLED:
+    return "Call has been canceled";
+  case WSAEINVALIDPROCTABLE:
+    return "Procedure call table is invalid";
+  case WSAEINVALIDPROVIDER:
+    return "Service provider is invalid";
+  case WSAEPROVIDERFAILEDINIT:
+    return "Service provider failed to initialize";
+  case WSASYSCALLFAILURE:
+    return "System call failure";
+  case WSASERVICE_NOT_FOUND:
+    return "Service not found";
+  case WSATYPE_NOT_FOUND:
+    return "Class type not found";
+  case WSA_E_NO_MORE:
+    return "No more results";
+  case WSA_E_CANCELLED:
+    return "Call was canceled";
+  case WSAEREFUSED:
+    return "Database query was refused";
+  case WSAHOST_NOT_FOUND:
+    return "Host not found";
+  case WSATRY_AGAIN:
+    return "Nonauthoritative host not found";
+  case WSANO_RECOVERY:
+    return "This is a nonrecoverable error";
+  case WSANO_DATA:
+    return "Valid name, no data record of requested type";
+  case WSA_QOS_RECEIVERS:
+    return "QoS receivers";
+  case WSA_QOS_SENDERS:
+    return "QoS senders";
+  case WSA_QOS_NO_SENDERS:
+    return "No QoS senders";
+  case WSA_QOS_NO_RECEIVERS:
+    return "QoS no receivers";
+  case WSA_QOS_REQUEST_CONFIRMED:
+    return "QoS request confirmed";
+  case WSA_QOS_ADMISSION_FAILURE:
+    return "QoS admission error";
+  case WSA_QOS_POLICY_FAILURE:
+    return "QoS policy failure";
+  case WSA_QOS_BAD_STYLE:
+    return "QoS bad style";
+  case WSA_QOS_BAD_OBJECT:
+    return "QoS bad object";
+  case WSA_QOS_TRAFFIC_CTRL_ERROR:
+    return "QoS traffic control error";
+  case WSA_QOS_GENERIC_ERROR:
+    return "QoS generic error";
+  case WSA_QOS_ESERVICETYPE:
+    return "QoS service type error";
+  case WSA_QOS_EFLOWSPEC:
+    return "QoS flowspec error";
+  case WSA_QOS_EPROVSPECBUF:
+    return "Invalid QoS provider buffer";
+  case WSA_QOS_EFILTERSTYLE:
+    return "Invalid QoS filter style";
+  case WSA_QOS_EFILTERTYPE:
+    return "Invalid QoS filter type";
+  case WSA_QOS_EFILTERCOUNT:
+    return "Incorrect QoS filter count";
+  case WSA_QOS_EOBJLENGTH:
+    return "Invalid QoS object length";
+  case WSA_QOS_EFLOWCOUNT:
+    return "Incorrect QoS flow count";
+  case WSA_QOS_EUNKOWNPSOBJ:
+    return "Unrecognized QoS object";
+  case WSA_QOS_EPOLICYOBJ:
+    return "Invalid QoS policy object";
+  case WSA_QOS_EFLOWDESC:
+    return "Invalid QoS flow descriptor";
+  case WSA_QOS_EPSFLOWSPEC:
+    return "Invalid QoS provider-specific flowspec";
+  case WSA_QOS_EPSFILTERSPEC:
+    return "Invalid QoS provider-specific filterspec";
+  case WSA_QOS_ESDMODEOBJ:
+    return "Invalid QoS shape discard mode object";
+  case WSA_QOS_ESHAPERATEOBJ:
+    return "Invalid QoS shaping rate object";
+  case WSA_QOS_RESERVED_PETYPE:
+    return "Reserved policy QoS element type";
+    }
+  return "Unknown winsock error";
+}
+
+
+/**
+ * Create pair of mutually connected TCP/IP sockets on loopback address
+ * @param sockets_pair array to receive resulted sockets
+ * @param non_blk if set to non-zero value, sockets created in non-blocking mode
+ *                otherwise sockets will be in blocking mode
+ * @return non-zero if succeeded, zero otherwise
+ */
+int
+MHD_W32_socket_pair_(SOCKET sockets_pair[2], int non_blk)
+{
+  int i;
+
+  if (! sockets_pair)
+    {
+      WSASetLastError (WSAEFAULT);
+      return 0;
+    }
+
+#define PAIRMAXTRYIES 800
+  for (i = 0; i < PAIRMAXTRYIES; i++)
+    {
+      struct sockaddr_in listen_addr;
+      SOCKET listen_s;
+      static const int c_addinlen = sizeof(struct sockaddr_in); /* help compiler to optimize */
+      int addr_len = c_addinlen;
+      unsigned long on_val = 1;
+      unsigned long off_val = 0;
+
+      listen_s = socket (AF_INET,
+                         SOCK_STREAM,
+                         IPPROTO_TCP);
+      if (INVALID_SOCKET == listen_s)
+        break; /* can't create even single socket */
+
+      listen_addr.sin_family = AF_INET;
+      listen_addr.sin_port = 0; /* same as htons(0) */
+      listen_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+      if ( (0 == bind (listen_s,
+                       (struct sockaddr*) &listen_addr,
+                       c_addinlen) &&
+            (0 == listen (listen_s,
+                          1) ) &&
+            (0 == getsockname (listen_s,
+                               (struct sockaddr*) &listen_addr,
+                               &addr_len))) )
+        {
+          SOCKET client_s = socket(AF_INET,
+                                   SOCK_STREAM,
+                                   IPPROTO_TCP);
+          struct sockaddr_in accepted_from_addr;
+          struct sockaddr_in client_addr;
+          SOCKET server_s;
+
+          if (INVALID_SOCKET == client_s)
+            {
+              /* try again */
+              closesocket (listen_s);
+              continue;
+            }
+
+          if ( (0 != ioctlsocket (client_s,
+                                  FIONBIO,
+                                  &on_val)) ||
+               ( (0 != connect (client_s,
+                                (struct sockaddr*) &listen_addr,
+                                c_addinlen)) &&
+                 (WSAGetLastError() != WSAEWOULDBLOCK)) )
+            {
+              /* try again */
+              closesocket (listen_s);
+              closesocket (client_s);
+              continue;
+            }
+
+          addr_len = c_addinlen;
+          server_s = accept (listen_s,
+                             (struct sockaddr*) &accepted_from_addr,
+                             &addr_len);
+          if (INVALID_SOCKET == server_s)
+            {
+              /* try again */
+              closesocket (listen_s);
+              closesocket (client_s);
+              continue;
+            }
+
+          addr_len = c_addinlen;
+          if ( (0 == getsockname (client_s,
+                                  (struct sockaddr*) &client_addr,
+                                  &addr_len)) &&
+               (accepted_from_addr.sin_family == client_addr.sin_family) &&
+               (accepted_from_addr.sin_port == client_addr.sin_port) &&
+               (accepted_from_addr.sin_addr.s_addr == client_addr.sin_addr.s_addr) &&
+               ( (0 != non_blk) ?
+                    (0 == ioctlsocket(server_s,
+                                      FIONBIO,
+                                      &on_val)) :
+                    (0 == ioctlsocket(client_s,
+                                      FIONBIO,
+                                      &off_val)) ) )
+            {
+              closesocket (listen_s);
+              sockets_pair[0] = server_s;
+              sockets_pair[1] = client_s;
+              return !0;
+            }
+          closesocket (server_s);
+          closesocket (client_s);
+        }
+      closesocket(listen_s);
+    }
+
+  sockets_pair[0] = INVALID_SOCKET;
+  sockets_pair[1] = INVALID_SOCKET;
+  WSASetLastError(WSAECONNREFUSED);
+
+  return 0;
+}
+
+#endif /* MHD_WINSOCK_SOCKETS */
+
+
+/**
+ * Add @a fd to the @a set.  If @a fd is
+ * greater than @a max_fd, set @a max_fd to @a fd.
+ *
+ * @param fd file descriptor to add to the @a set
+ * @param set set to modify
+ * @param max_fd maximum value to potentially update
+ * @param fd_setsize value of FD_SETSIZE
+ * @return non-zero if succeeded, zero otherwise
+ */
+int
+MHD_add_to_fd_set_ (MHD_socket fd,
+                    fd_set *set,
+                    MHD_socket *max_fd,
+                    unsigned int fd_setsize)
+{
+  if ( (NULL == set) ||
+       (MHD_INVALID_SOCKET == fd) )
+    return 0;
+  if (! MHD_SCKT_FD_FITS_FDSET_SETSIZE_ (fd,
+                                         set,
+                                         fd_setsize))
+    return 0;
+  MHD_SCKT_ADD_FD_TO_FDSET_SETSIZE_(fd,
+                                    set,
+                                    fd_setsize);
+  if ( (NULL != max_fd) &&
+       ( (fd > *max_fd) ||
+         (MHD_INVALID_SOCKET == *max_fd) ) )
+    *max_fd = fd;
+  return ! 0;
+}
+
+
+/**
+ * Change socket options to be non-blocking.
+ *
+ * @param sock socket to manipulate
+ * @return non-zero if succeeded, zero otherwise
+ */
+int
+MHD_socket_nonblocking_ (MHD_socket sock)
+{
+#if defined(MHD_POSIX_SOCKETS)
+  int flags;
+
+  flags = fcntl (sock,
+                 F_GETFL);
+  if (-1 == flags)
+    return 0;
+
+  if ( ((flags | O_NONBLOCK) != flags) &&
+       (0 != fcntl (sock,
+                    F_SETFL,
+                    flags | O_NONBLOCK)) )
+    return 0;
+#elif defined(MHD_WINSOCK_SOCKETS)
+  unsigned long flags = 1;
+
+  if (0 != ioctlsocket (sock,
+                        FIONBIO,
+                        &flags))
+    return 0;
+#endif /* MHD_WINSOCK_SOCKETS */
+  return !0;
+}
+
+
+/**
+ * Change socket options to be non-inheritable.
+ *
+ * @param sock socket to manipulate
+ * @return non-zero if succeeded, zero otherwise
+ * @warning Does not set socket error on W32.
+ */
+int
+MHD_socket_noninheritable_ (MHD_socket sock)
+{
+#if defined(MHD_POSIX_SOCKETS)
+  int flags;
+
+  flags = fcntl (sock,
+                 F_GETFD);
+  if (-1 == flags)
+    return 0;
+
+  if ( ((flags | FD_CLOEXEC) != flags) &&
+       (0 != fcntl (sock,
+                    F_SETFD,
+                    flags | FD_CLOEXEC)) )
+    return 0;
+#elif defined(MHD_WINSOCK_SOCKETS)
+  if (! SetHandleInformation ((HANDLE)sock,
+                              HANDLE_FLAG_INHERIT,
+                              0))
+    return 0;
+#endif /* MHD_WINSOCK_SOCKETS */
+  return !0;
+}
+
+
+/**
+ * Create a listen socket, with noninheritable flag if possible.
+ *
+ * @param use_ipv6 if set to non-zero IPv6 is used
+ * @return created socket or MHD_INVALID_SOCKET in case of errors
+ */
+MHD_socket
+MHD_socket_create_listen_ (bool use_ipv6)
+{
+  int domain;
+  MHD_socket fd;
+  int cloexec_set;
+
+#ifdef HAVE_INET6
+  domain = (use_ipv6) ? PF_INET6 : PF_INET;
+#else  /* ! HAVE_INET6 */
+  if (use_ipv6)
+    return MHD_INVALID_SOCKET;
+  domain = PF_INET;
+#endif /* ! HAVE_INET6 */
+
+#if defined(MHD_POSIX_SOCKETS) && defined(SOCK_CLOEXEC)
+  fd = socket (domain,
+               SOCK_STREAM | SOCK_CLOEXEC,
+               0);
+  cloexec_set = !0;
+#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 = !0;
+#else  /* !SOCK_CLOEXEC */
+  fd = MHD_INVALID_SOCKET;
+#endif /* !SOCK_CLOEXEC */
+  if (MHD_INVALID_SOCKET == fd)
+    {
+      fd = socket (domain,
+                   SOCK_STREAM,
+                   0);
+      cloexec_set = 0;
+    }
+  if (MHD_INVALID_SOCKET == fd)
+    return MHD_INVALID_SOCKET;
+#ifdef MHD_socket_nosignal_
+  if(! MHD_socket_nosignal_(fd))
+    {
+      const int err = MHD_socket_get_error_ ();
+      (void) MHD_socket_close_ (fd);
+      MHD_socket_fset_error_ (err);
+      return MHD_INVALID_SOCKET;
+    }
+#endif /* MHD_socket_nosignal_ */
+  if (! cloexec_set)
+    (void) MHD_socket_noninheritable_ (fd);
+
+  return fd;
+}