/*
  This file is part of libmicrohttpd
  Copyright (C) 2014 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, see <http://www.gnu.org/licenses/>.
*/

/**
 * @file platform/w32functions.h
 * @brief  internal functions for W32 systems
 * @author Karlson2k (Evgeny Grin)
 */

#include "w32functions.h"
#include <errno.h>
#include <winsock2.h>
#include <string.h>
#include <stdint.h>
#include <time.h>
#include <stdio.h>
#include <stdarg.h>


/**
 * Return errno equivalent of last winsock error
 * @return errno equivalent of last winsock error
 */
int MHD_W32_errno_from_winsock_(void)
{
  switch(WSAGetLastError())
  {
  case 0:                      return 0;
  case WSA_INVALID_HANDLE:     return EBADF;
  case WSA_NOT_ENOUGH_MEMORY:  return ENOMEM;
  case WSA_INVALID_PARAMETER:  return EINVAL;
  case WSAEINTR:               return EINTR;
  case WSAEWOULDBLOCK:         return EWOULDBLOCK;
  case WSAEINPROGRESS:         return EINPROGRESS;
  case WSAEALREADY:            return EALREADY;
  case WSAENOTSOCK:            return ENOTSOCK;
  case WSAEDESTADDRREQ:        return EDESTADDRREQ;
  case WSAEMSGSIZE:            return EMSGSIZE;
  case WSAEPROTOTYPE:          return EPROTOTYPE;
  case WSAENOPROTOOPT:         return ENOPROTOOPT;
  case WSAEPROTONOSUPPORT:     return EPROTONOSUPPORT;
  case WSAESOCKTNOSUPPORT:     return ESOCKTNOSUPPORT;
  case WSAEOPNOTSUPP:          return EOPNOTSUPP;
  case WSAEPFNOSUPPORT:        return EPFNOSUPPORT;
  case WSAEAFNOSUPPORT:        return EAFNOSUPPORT;
  case WSAEADDRINUSE:          return EADDRINUSE;
  case WSAEADDRNOTAVAIL:       return EADDRNOTAVAIL;
  case WSAENETDOWN:            return ENETDOWN;
  case WSAENETUNREACH:         return ENETUNREACH;
  case WSAENETRESET:           return ENETRESET;
  case WSAECONNABORTED:        return ECONNABORTED;
  case WSAECONNRESET:          return ECONNRESET;
  case WSAENOBUFS:             return ENOBUFS;
  case WSAEISCONN:             return EISCONN;
  case WSAENOTCONN:            return ENOTCONN;
  case WSAESHUTDOWN:           return ESHUTDOWN;
  case WSAETOOMANYREFS:        return ETOOMANYREFS;
  case WSAETIMEDOUT:           return ETIMEDOUT;
  case WSAECONNREFUSED:        return ECONNREFUSED;
  case WSAELOOP:               return ELOOP;
  case WSAENAMETOOLONG:        return ENAMETOOLONG;
  case WSAEHOSTDOWN:           return EHOSTDOWN;
  case WSAEHOSTUNREACH:        return EHOSTUNREACH;
  case WSAENOTEMPTY:           return ENOTEMPTY;
  case WSAEPROCLIM:            return EPROCLIM;
  case WSAEUSERS:              return EUSERS;
  case WSAEDQUOT:              return EDQUOT;
  case WSAESTALE:              return ESTALE;
  case WSAEREMOTE:             return EREMOTE;
  case WSAEINVAL:              return EINVAL;
  case WSAEFAULT:              return EFAULT;
  case WSANO_DATA:             return ENODATA;
  /* Rough equivalents */
  case WSAEDISCON:             return ECONNRESET;
  case WSAEINVALIDPROCTABLE:   return EFAULT;
  case WSASYSNOTREADY:
  case WSANOTINITIALISED:
  case WSASYSCALLFAILURE:      return ENOBUFS;
  case WSAVERNOTSUPPORTED:     return EOPNOTSUPP;
  case WSAEREFUSED:            return EIO;
  }
  return EINVAL;
}

/**
 * Return pointer to string description of errnum error
 * Works fine with both standard errno errnums
 * and errnums from MHD_W32_errno_from_winsock_
 * @param errnum the errno or value from MHD_W32_errno_from_winsock_()
 * @return pointer to string description of error
 */
const char* MHD_W32_strerror_(int errnum)
{
  switch(errnum)
  {
  case 0:
    return "No error";
  case EWOULDBLOCK:
    return "Operation would block";
  case EINPROGRESS:
    return "Connection already in progress";
  case EALREADY:
    return "Socket already connected";
  case ENOTSOCK:
    return "Socket operation on non-socket";
  case EDESTADDRREQ:
    return "Destination address required";
  case EMSGSIZE:
    return "Message too long";
  case EPROTOTYPE:
    return "Protocol wrong type for socket";
  case ENOPROTOOPT:
    return "Protocol not available";
  case EPROTONOSUPPORT:
    return "Unknown protocol";
  case ESOCKTNOSUPPORT:
    return "Socket type not supported";
  case EOPNOTSUPP:
    return "Operation not supported on socket";
  case EPFNOSUPPORT:
    return "Protocol family not supported";
  case EAFNOSUPPORT:
    return "Address family not supported by protocol family";
  case EADDRINUSE:
    return "Address already in use";
  case EADDRNOTAVAIL:
    return "Cannot assign requested address";
  case ENETDOWN:
    return "Network is down";
  case ENETUNREACH:
    return "Network is unreachable";
  case ENETRESET:
    return "Network dropped connection on reset";
  case ECONNABORTED:
    return "Software caused connection abort";
  case ECONNRESET:
    return "Connection reset by peer";
  case ENOBUFS:
    return "No system resources available";
  case EISCONN:
    return "Socket is already connected";
  case ENOTCONN:
    return "Socket is not connected";
  case ESHUTDOWN:
    return "Can't send after socket shutdown";
  case ETOOMANYREFS:
    return "Too many references: cannot splice";
  case ETIMEDOUT:
    return "Connection timed out";
  case ECONNREFUSED:
    return "Connection refused";
  case ELOOP:
    return "Cannot translate name";
  case EHOSTDOWN:
    return "Host is down";
  case EHOSTUNREACH:
    return "Host is unreachable";
  case EPROCLIM:
    return "Too many processes";
  case EUSERS:
    return "Too many users";
  case EDQUOT:
    return "Disk quota exceeded";
  case ESTALE:
    return "Stale file handle reference";
  case EREMOTE:
    return "Resource is remote";
  case ENODATA:
    return "No data available";
  }
  return strerror(errnum);
}

/**
 * Return pointer to string description of last winsock error
 * @return pointer to string description of last winsock error
 */
const char* MHD_W32_strerror_last_winsock_(void)
{
  switch (WSAGetLastError())
    {
  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";
}

/**
 * Set last winsock error to equivalent of given errno value
 * @param errnum the errno value to set
 */
void MHD_W32_set_last_winsock_error_(int errnum)
{
  switch (errnum)
    {
  case 0:
    WSASetLastError(0);
    break;
  case EBADF:
    WSASetLastError(WSA_INVALID_HANDLE);
    break;
  case ENOMEM:
    WSASetLastError(WSA_NOT_ENOUGH_MEMORY);
    break;
  case EINVAL:
    WSASetLastError(WSA_INVALID_PARAMETER);
    break;
  case EINTR:
    WSASetLastError(WSAEINTR);
    break;
  case EWOULDBLOCK:
    WSASetLastError(WSAEWOULDBLOCK);
    break;
  case EINPROGRESS:
    WSASetLastError(WSAEINPROGRESS);
    break;
  case EALREADY:
    WSASetLastError(WSAEALREADY);
    break;
  case ENOTSOCK:
    WSASetLastError(WSAENOTSOCK);
    break;
  case EDESTADDRREQ:
    WSASetLastError(WSAEDESTADDRREQ);
    break;
  case EMSGSIZE:
    WSASetLastError(WSAEMSGSIZE);
    break;
  case EPROTOTYPE:
    WSASetLastError(WSAEPROTOTYPE);
    break;
  case ENOPROTOOPT:
    WSASetLastError(WSAENOPROTOOPT);
    break;
  case EPROTONOSUPPORT:
    WSASetLastError(WSAEPROTONOSUPPORT);
    break;
  case ESOCKTNOSUPPORT:
    WSASetLastError(WSAESOCKTNOSUPPORT);
    break;
  case EOPNOTSUPP:
    WSASetLastError(WSAEOPNOTSUPP);
    break;
  case EPFNOSUPPORT:
    WSASetLastError(WSAEPFNOSUPPORT);
    break;
  case EAFNOSUPPORT:
    WSASetLastError(WSAEAFNOSUPPORT);
    break;
  case EADDRINUSE:
    WSASetLastError(WSAEADDRINUSE);
    break;
  case EADDRNOTAVAIL:
    WSASetLastError(WSAEADDRNOTAVAIL);
    break;
  case ENETDOWN:
    WSASetLastError(WSAENETDOWN);
    break;
  case ENETUNREACH:
    WSASetLastError(WSAENETUNREACH);
    break;
  case ENETRESET:
    WSASetLastError(WSAENETRESET);
    break;
  case ECONNABORTED:
    WSASetLastError(WSAECONNABORTED);
    break;
  case ECONNRESET:
    WSASetLastError(WSAECONNRESET);
    break;
  case ENOBUFS:
    WSASetLastError(WSAENOBUFS);
    break;
  case EISCONN:
    WSASetLastError(WSAEISCONN);
    break;
  case ENOTCONN:
    WSASetLastError(WSAENOTCONN);
    break;
  case ESHUTDOWN:
    WSASetLastError(WSAESHUTDOWN);
    break;
  case ETOOMANYREFS:
    WSASetLastError(WSAETOOMANYREFS);
    break;
  case ETIMEDOUT:
    WSASetLastError(WSAETIMEDOUT);
    break;
  case ECONNREFUSED:
    WSASetLastError(WSAECONNREFUSED);
    break;
  case ELOOP:
    WSASetLastError(WSAELOOP);
    break;
  case ENAMETOOLONG:
    WSASetLastError(WSAENAMETOOLONG);
    break;
  case EHOSTDOWN:
    WSASetLastError(WSAEHOSTDOWN);
    break;
  case EHOSTUNREACH:
    WSASetLastError(WSAEHOSTUNREACH);
    break;
  case ENOTEMPTY:
    WSASetLastError(WSAENOTEMPTY);
    break;
  case EPROCLIM:
    WSASetLastError(WSAEPROCLIM);
    break;
  case EUSERS:
    WSASetLastError(WSAEUSERS);
    break;
  case EDQUOT:
    WSASetLastError(WSAEDQUOT);
    break;
  case ESTALE:
    WSASetLastError(WSAESTALE);
    break;
  case EREMOTE:
    WSASetLastError(WSAEREMOTE);
    break;
  case EFAULT:
    WSASetLastError(WSAEFAULT);
    break;
  case ENODATA:
    WSASetLastError(WSANO_DATA);
    break;
#if EAGAIN != EWOULDBLOCK
  case EAGAIN:
    WSASetLastError(WSAEWOULDBLOCK);
    break;
#endif
  /* Rough equivalent */
  case EIO:
    WSASetLastError(WSAEREFUSED);
    break;

  default: /* Unmapped errors */
    WSASetLastError(WSAENOBUFS);
    break;
    }
}

/**
 * Create pair of mutually connected TCP/IP sockets on loopback address
 * @param sockets_pair array to receive resulted sockets
 * @return zero on success, -1 otherwise
 */
int MHD_W32_pair_of_sockets_(SOCKET sockets_pair[2])
{
  int i;
  if (!sockets_pair)
    {
      errno = EINVAL;
      return -1;
    }

#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;
      int opt = 1;

      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 = 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);
          if (INVALID_SOCKET != client_s)
            {
              if (0 == ioctlsocket(client_s, FIONBIO, (u_long*) &opt)
                  && (0 == connect(client_s, (struct sockaddr*) &listen_addr, c_addinlen)
                      || WSAGetLastError() == WSAEWOULDBLOCK))
                {
                  struct sockaddr_in accepted_from_addr;
                  addr_len = c_addinlen;
                  SOCKET server_s = accept(listen_s,
                      (struct sockaddr*) &accepted_from_addr, &addr_len);
                  if (INVALID_SOCKET != server_s)
                    {
                      struct sockaddr_in client_addr;
                      addr_len = c_addinlen;
                      opt = 0;
                      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 == ioctlsocket(client_s, FIONBIO, (u_long*) &opt)
                          && 0 == ioctlsocket(server_s, FIONBIO, (u_long*) &opt))
                        {
                          closesocket(listen_s);
                          sockets_pair[0] = client_s;
                          sockets_pair[1] = server_s;
                          return 0;
                        }
                      closesocket(server_s);
                    }
                }
              closesocket(client_s);
            }
        }
      closesocket(listen_s);
    }

  sockets_pair[0] = INVALID_SOCKET;
  sockets_pair[1] = INVALID_SOCKET;
  return -1;
}

/**
 * Static variable used by pseudo random number generator
 */
static int32_t rnd_val = 0;
/**
 * Generate 31-bit pseudo random number.
 * Function initialize itself at first call to current time.
 * @return 31-bit pseudo random number.
 */
int MHD_W32_random_(void)
{
  if (0 == rnd_val)
    rnd_val = (int32_t)time(NULL);
  /* stolen from winsup\cygwin\random.cc */
  rnd_val = (16807 * (rnd_val % 127773) - 2836 * (rnd_val / 127773))
               & 0x7fffffff;
  return (int)rnd_val;
}

/* Emulate snprintf function on W32 */
int W32_snprintf(char *__restrict s, size_t n, const char *__restrict format, ...)
{
  int ret;
  va_list args;
  if (0 != n && NULL != s )
  {
    va_start(args, format);
    ret = _vsnprintf(s, n, format, args);
    va_end(args);
    if (n == ret)
      s[n - 1] = 0;
    if (ret >= 0)
      return ret;
  }
  va_start(args, format);
  ret = _vscprintf(format, args);
  va_end(args);
  if (0 <= ret && 0 != n && NULL == s)
    return -1;

  return ret;
}

#ifdef _MSC_FULL_VER
/**
 * Set thread name
 * @param thread_id ID of thread, -1 for current thread
 * @param thread_name name to set
 */
void W32_SetThreadName(const DWORD thread_id, const char *thread_name)
{
  static const DWORD VC_SETNAME_EXC = 0x406D1388;
#pragma pack(push,8)
  struct thread_info_struct
  {
    DWORD type;   // Must be 0x1000.
    LPCSTR name;  // Pointer to name (in user address space).
    DWORD ID;     // Thread ID (-1=caller thread).
    DWORD flags;  // Reserved for future use, must be zero.
  } thread_info;
#pragma pack(pop)

  if (NULL == thread_name)
    return;

  thread_info.type  = 0x1000;
  thread_info.name  = thread_name;
  thread_info.ID    = thread_id;
  thread_info.flags = 0;

  __try
  { /* This exception is intercepted by debugger */
    RaiseException(VC_SETNAME_EXC, 0, sizeof(thread_info) / sizeof(ULONG_PTR), (ULONG_PTR*)&thread_info);
  }
  __except (EXCEPTION_EXECUTE_HANDLER)
  {}
}
#endif /* _MSC_FULL_VER */