2 * Empire - A multi-player, client/server Internet based war game.
3 * Copyright (C) 1986-2010, Dave Pare, Jeff Bailey, Thomas Ruschak,
4 * Ken Stevens, Steve McClure
6 * This program 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 2 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, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 * See files README, COPYING and CREDITS in the root of the source
23 * tree for related information and legal notices. It is expected
24 * that future projects/authors will amend these files as needed.
28 * w32sockets.c: POSIX socket emulation layer for Windows
30 * Known contributors to this file:
31 * Ron Koenderink, 2007
32 * Markus Armbruster, 2007-2009
36 * POSIX sockets are file descriptors. Windows sockets are something
37 * else, with a separate set of functions to operate on them. To
38 * present a more POSIX-like interface to our application code, we
39 * provide a compatibility layer that wraps file descriptors around
49 * Need to include winsock2.h before ws2tcpip.h.
50 * Use sys/socket.h to ensure the #undef NS_ALL
51 * is not missed after including winsock2.h.
53 #include "sys/socket.h"
58 #define W32_FD_TO_SOCKET(fd) ((SOCKET)_get_osfhandle((fd)))
59 #define W32_SOCKET_TO_FD(fh) (_open_osfhandle((long)(fh), O_RDWR | O_BINARY))
64 return W32_FD_TO_SOCKET(fd);
68 fd_is_socket(int fd, SOCKET *sockp)
72 int size = sizeof(val);
74 sock = W32_FD_TO_SOCKET(fd);
77 return getsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&val, &size) == 0;
78 //WSAEnumNetworkEvents(sock, NULL, &ev) == 0;
82 w32_set_winsock_errno(void)
84 int err = WSAGetLastError();
87 /* Map some WSAE* errors to the runtime library's error codes. */
90 case WSA_INVALID_HANDLE:
93 case WSA_NOT_ENOUGH_MEMORY:
96 case WSA_INVALID_PARAMETER:
102 case WSAENAMETOOLONG:
103 errno = ENAMETOOLONG;
109 errno = (err > 10000 && err < 10025) ? err - 10000 : err;
114 #define SOCKET_FUNCTION(expr) do { \
115 SOCKET sock = W32_FD_TO_SOCKET(fd); \
117 if (res == SOCKET_ERROR) { \
118 w32_set_winsock_errno(); \
125 * POSIX equivalent for accept().
129 w32_accept(int fd, struct sockaddr *addr, socklen_t *addrlen)
133 sock = accept(W32_FD_TO_SOCKET(fd), addr, addrlen);
134 if (sock == INVALID_SOCKET) {
135 w32_set_winsock_errno();
139 return W32_SOCKET_TO_FD(sock);
143 * POSIX equivalent for bind().
147 w32_bind(int fd, const struct sockaddr *name, socklen_t namelen)
149 SOCKET_FUNCTION(bind(sock, name, namelen));
153 * POSIX compatible connect() replacement
157 w32_connect(int sockfd, const struct sockaddr *addr, int addrlen)
159 SOCKET sock = W32_FD_TO_SOCKET(sockfd);
162 result = connect(sock, addr, addrlen);
163 if (result == SOCKET_ERROR) {
164 /* FIXME map WSAEWOULDBLOCK to EINPROGRESS */
165 w32_set_winsock_errno();
172 * POSIX equivalent for listen().
176 w32_listen(int fd, int backlog)
178 SOCKET_FUNCTION(listen(sock, backlog));
182 * POSIX equivalent for setsockopt().
186 w32_setsockopt(int fd, int level, int optname,
187 const void *optval, socklen_t optlen)
190 * SO_REUSEADDR requests to permit another bind even when the
191 * port is still in state TIME_WAIT. Windows' SO_REUSEADDR is
192 * broken: it makes bind() succeed no matter what, even if
193 * there's another server running on the same port. Luckily,
194 * bind() seems to be broken as well: it seems to succeed while
195 * the port is in state TIME_WAIT by default; thus we get the
196 * behavior we want by not setting SO_REUSEADDR.
198 if (level == SOL_SOCKET && optname == SO_REUSEADDR)
201 SOCKET_FUNCTION(setsockopt(sock, level, optname, optval, optlen));
206 * POSIX equivalent for shutdown().
210 w32_shutdown(int fd, int how)
212 SOCKET_FUNCTION(shutdown(sock, how));
216 * POSIX equivalent for socket().
220 w32_socket(int domain, int type, int protocol)
225 * We have to use WSASocket() to create non-overlapped IO sockets.
226 * Overlapped IO sockets cannot be used with read/write.
228 sock = WSASocket(domain, type, protocol, NULL, 0, 0);
229 if (sock == INVALID_SOCKET) {
230 w32_set_winsock_errno();
233 return W32_SOCKET_TO_FD(sock);
236 #ifdef HAVE_GETADDRINFO
238 inet_ntop(int af, const void *src, char *dst, socklen_t len)
241 struct sockaddr_in sin;
242 struct sockaddr_in6 sin6;
246 memset(&sin, 0, sizeof(sin));
248 memcpy(&sin.sin_addr, src, sizeof(sin.sin_addr));
249 sa = (struct sockaddr *)&sin;
251 } else if (af == AF_INET6) {
252 memset(&sin6, 0, sizeof(sin6));
253 sin6.sin6_family = af;
254 memcpy(&sin6.sin6_addr, src, sizeof(sin6.sin6_addr));
255 sa = (struct sockaddr *)&sin6;
256 salen = sizeof(sin6);
258 WSASetLastError(WSAEAFNOSUPPORT);
259 w32_set_winsock_errno();
263 if (getnameinfo(sa, salen, dst, len, NULL, 0, NI_NUMERICHOST)) {
264 WSASetLastError(WSAEAFNOSUPPORT);
265 w32_set_winsock_errno();
274 * POSIX equivalent for fcntl().
275 * Horrible hacks, just good enough support Empire's use of fcntl().
276 * F_GETFL / F_SETFL support making a socket (non-)blocking by getting
277 * flags, adding or removing O_NONBLOCK, and setting the result.
280 fcntl(int fd, int cmd, ...)
284 unsigned long nonblocking;
292 sock = W32_FD_TO_SOCKET(fd);
294 value = va_arg(ap, int);
296 nonblocking = (value & O_NONBLOCK) != 0;
298 if (ioctlsocket(sock, FIONBIO, &nonblocking) == SOCKET_ERROR) {
299 w32_set_winsock_errno();
309 * close() replacement that does the right thing for sockets
312 w32_close_maybe_socket(int fd)
316 if (fd_is_socket(fd, &sock)) {
317 if (closesocket(sock)) {
318 w32_set_winsock_errno();
322 * This always fails because the underlying handle is already
323 * gone, but it closes the fd just fine.
332 * read() replacement that does the right thing for sockets
335 w32_read_maybe_socket(int fd, void *buf, unsigned sz)
340 if (fd_is_socket(fd, &sock)) {
341 res = recv(sock, buf, sz, 0);
343 w32_set_winsock_errno();
346 return _read(fd, buf, sz);
350 * write() replacement that does the right thing for sockets
353 w32_write_maybe_socket(int fd, const void *buf, unsigned sz)
358 if (fd_is_socket(fd, &sock)) {
359 res = send(sock, buf, sz, 0);
361 w32_set_winsock_errno();
364 return _write(fd, buf, sz);
368 w32_socket_init(void)
371 WORD wVersionRequested;
374 wVersionRequested = MAKEWORD(2, 0);
375 rc = WSAStartup(wVersionRequested, &wsaData);
379 w32_close_function = w32_close_maybe_socket;
380 w32_read_function = w32_read_maybe_socket;
381 w32_write_function = w32_write_maybe_socket;