| /* |
| 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 */ |
