2 * Empire - A multi-player, client/server Internet based war game.
3 * Copyright (C) 1986-2013, Dave Pare, Jeff Bailey, Thomas Ruschak,
4 * Ken Stevens, Steve McClure, Markus Armbruster
6 * Empire is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21 * See files README, COPYING and CREDITS in the root of the source
22 * tree for related information and legal notices. It is expected
23 * that future projects/authors will amend these files as needed.
27 * w32sockets.c: POSIX socket emulation layer for Windows
29 * Known contributors to this file:
30 * Ron Koenderink, 2007-2010
31 * Markus Armbruster, 2007-2010
35 * POSIX sockets are file descriptors. Windows sockets are something
36 * else, with a separate set of functions to operate on them. To
37 * present a more POSIX-like interface to our application code, we
38 * provide a compatibility layer that wraps file descriptors around
48 * Need to include winsock2.h before ws2tcpip.h.
49 * Use sys/socket.h to ensure the #undef NS_ALL
50 * is not missed after including winsock2.h.
52 #include "sys/socket.h"
57 #define W32_FD_TO_SOCKET(fd) ((SOCKET)_get_osfhandle((fd)))
58 #define W32_SOCKET_TO_FD(fh) (_open_osfhandle((long)(fh), O_RDWR | O_BINARY))
63 return W32_FD_TO_SOCKET(fd);
67 fd_is_socket(int fd, SOCKET *sockp)
71 int size = sizeof(val);
73 sock = W32_FD_TO_SOCKET(fd);
76 return getsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&val, &size)
81 w32_set_winsock_errno(void)
83 int err = WSAGetLastError();
86 /* Map some WSAE* errors to the runtime library's error codes. */
88 case WSA_INVALID_HANDLE:
91 case WSA_NOT_ENOUGH_MEMORY:
94 case WSA_INVALID_PARAMETER:
100 case WSAENAMETOOLONG:
101 errno = ENAMETOOLONG;
107 errno = (err > 10000 && err < 10025) ? err - 10000 : err;
112 #define SOCKET_FUNCTION(expr) do { \
113 SOCKET sock = W32_FD_TO_SOCKET(fd); \
115 if (res == SOCKET_ERROR) { \
116 w32_set_winsock_errno(); \
123 * POSIX equivalent for accept().
127 w32_accept(int fd, struct sockaddr *addr, socklen_t *addrlen)
131 sock = accept(W32_FD_TO_SOCKET(fd), addr, addrlen);
132 if (sock == INVALID_SOCKET) {
133 w32_set_winsock_errno();
137 return W32_SOCKET_TO_FD(sock);
141 * POSIX equivalent for bind().
145 w32_bind(int fd, const struct sockaddr *name, socklen_t namelen)
147 SOCKET_FUNCTION(bind(sock, name, namelen));
151 * POSIX compatible connect() replacement
155 w32_connect(int sockfd, const struct sockaddr *addr, int addrlen)
157 SOCKET sock = W32_FD_TO_SOCKET(sockfd);
160 result = connect(sock, addr, addrlen);
161 if (result == SOCKET_ERROR) {
162 /* FIXME map WSAEWOULDBLOCK to EINPROGRESS */
163 w32_set_winsock_errno();
170 * POSIX equivalent for listen().
174 w32_listen(int fd, int backlog)
176 SOCKET_FUNCTION(listen(sock, backlog));
180 * POSIX equivalent for setsockopt().
184 w32_setsockopt(int fd, int level, int optname,
185 const void *optval, socklen_t optlen)
188 * SO_REUSEADDR requests to permit another bind even when the
189 * port is still in state TIME_WAIT. Windows' SO_REUSEADDR is
190 * broken: it makes bind() succeed no matter what, even if
191 * there's another server running on the same port. Luckily,
192 * bind() seems to be broken as well: it seems to succeed while
193 * the port is in state TIME_WAIT by default; thus we get the
194 * behavior we want by not setting SO_REUSEADDR.
196 if (level == SOL_SOCKET && optname == SO_REUSEADDR)
199 SOCKET_FUNCTION(setsockopt(sock, level, optname, optval, optlen));
204 * POSIX equivalent for shutdown().
208 w32_shutdown(int fd, int how)
210 SOCKET_FUNCTION(shutdown(sock, how));
214 * POSIX equivalent for socket().
218 w32_socket(int domain, int type, int protocol)
223 * We have to use WSASocket() to create non-overlapped IO sockets.
224 * Overlapped IO sockets cannot be used with read/write.
226 sock = WSASocket(domain, type, protocol, NULL, 0, 0);
227 if (sock == INVALID_SOCKET) {
228 w32_set_winsock_errno();
231 return W32_SOCKET_TO_FD(sock);
234 #ifdef HAVE_GETADDRINFO
236 inet_ntop(int af, const void *src, char *dst, socklen_t len)
239 struct sockaddr_in sin;
240 struct sockaddr_in6 sin6;
244 memset(&sin, 0, sizeof(sin));
246 memcpy(&sin.sin_addr, src, sizeof(sin.sin_addr));
247 sa = (struct sockaddr *)&sin;
249 } else if (af == AF_INET6) {
250 memset(&sin6, 0, sizeof(sin6));
251 sin6.sin6_family = af;
252 memcpy(&sin6.sin6_addr, src, sizeof(sin6.sin6_addr));
253 sa = (struct sockaddr *)&sin6;
254 salen = sizeof(sin6);
256 WSASetLastError(WSAEAFNOSUPPORT);
257 w32_set_winsock_errno();
261 if (getnameinfo(sa, salen, dst, len, NULL, 0, NI_NUMERICHOST)) {
262 WSASetLastError(WSAEAFNOSUPPORT);
263 w32_set_winsock_errno();
272 * POSIX equivalent for fcntl().
273 * Horrible hacks, just good enough support Empire's use of fcntl().
274 * F_GETFL / F_SETFL support making a socket (non-)blocking by getting
275 * flags, adding or removing O_NONBLOCK, and setting the result.
278 fcntl(int fd, int cmd, ...)
282 unsigned long nonblocking;
289 sock = W32_FD_TO_SOCKET(fd);
291 value = va_arg(ap, int);
293 nonblocking = (value & O_NONBLOCK) != 0;
295 if (ioctlsocket(sock, FIONBIO, &nonblocking) == SOCKET_ERROR) {
296 w32_set_winsock_errno();
306 * close() replacement that does the right thing for sockets
309 w32_close_maybe_socket(int fd)
313 if (fd_is_socket(fd, &sock)) {
314 if (closesocket(sock)) {
315 w32_set_winsock_errno();
319 * This always fails because the underlying handle is already
320 * gone, but it closes the fd just fine.
329 * read() replacement that does the right thing for sockets
332 w32_read_maybe_socket(int fd, void *buf, unsigned sz)
337 if (fd_is_socket(fd, &sock)) {
338 res = recv(sock, buf, sz, 0);
340 w32_set_winsock_errno();
343 return _read(fd, buf, sz);
347 * write() replacement that does the right thing for sockets
350 w32_write_maybe_socket(int fd, const void *buf, unsigned sz)
355 if (fd_is_socket(fd, &sock)) {
356 res = send(sock, buf, sz, 0);
358 w32_set_winsock_errno();
361 return _write(fd, buf, sz);
365 w32_socket_init(void)
368 WORD wVersionRequested;
371 wVersionRequested = MAKEWORD(2, 0);
372 rc = WSAStartup(wVersionRequested, &wsaData);
376 w32_close_function = w32_close_maybe_socket;
377 w32_read_function = w32_read_maybe_socket;
378 w32_write_function = w32_write_maybe_socket;