?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removed some unnecessary #includes and dll dependencies.
[wine/multimedia.git] / dlls / winsock / socket.c
blob41eee910d3ce07ac4b2527efc3a49b4fe3fcbafa
1 /*
2 * based on Windows Sockets 1.1 specs
3 * (ftp.microsoft.com:/Advsys/winsock/spec11/WINSOCK.TXT)
4 *
5 * (C) 1993,1994,1996,1997 John Brezak, Erik Bos, Alex Korobka.
6 *
7 * NOTE: If you make any changes to fix a particular app, make sure
8 * they don't break something else like Netscape or telnet and ftp
9 * clients and servers (www.winsite.com got a lot of those).
10 *
11 * NOTE 2: Many winsock structs such as servent, hostent, protoent, ...
12 * are used with 1-byte alignment for Win16 programs and 4-byte alignment
13 * for Win32 programs in winsock.h. winsock2.h uses forced 4-byte alignment.
14 * So we have non-forced (just as MSDN) ws_XXXXent (winsock.h), 4-byte forced
15 * ws_XXXXent32 (winsock2.h) and 1-byte forced ws_XXXXent16 (winsock16.h).
16 */
17
18 #include "config.h"
19
20 #include <string.h>
21 #include <sys/types.h>
22 #ifdef HAVE_SYS_IPC_H
23 # include <sys/ipc.h>
24 #endif
25 #include <sys/ioctl.h>
26 #ifdef HAVE_SYS_FILIO_H
27 # include <sys/filio.h>
28 #endif
29 #ifdef HAVE_SYS_SOCKIO_H
30 # include <sys/sockio.h>
31 #endif
32
33 #if defined(__EMX__)
34 # include <sys/so_ioctl.h>
35 #endif
36
37 #ifdef HAVE_SYS_PARAM_H
38 # include <sys/param.h>
39 #endif
40
41 #ifdef HAVE_SYS_MSG_H
42 # include <sys/msg.h>
43 #endif
44 #ifdef HAVE_SYS_WAIT_H
45 # include <sys/wait.h>
46 #endif
47 #ifdef HAVE_SYS_SOCKET_H
48 #include <sys/socket.h>
49 #endif
50 #ifdef HAVE_NETINET_IN_H
51 # include <netinet/in.h>
52 #endif
53 #ifdef HAVE_NETINET_TCP_H
54 # include <netinet/tcp.h>
55 #endif
56 #ifdef HAVE_ARPA_INET_H
57 # include <arpa/inet.h>
58 #endif
59 #include <ctype.h>
60 #include <fcntl.h>
61 #include <errno.h>
62 #ifdef HAVE_SYS_ERRNO_H
63 #include <sys/errno.h>
64 #endif
65 #include <netdb.h>
66 #include <unistd.h>
67 #include <stdlib.h>
68 #ifdef HAVE_ARPA_NAMESER_H
69 # include <arpa/nameser.h>
70 #endif
71 #ifdef HAVE_RESOLV_H
72 # include <resolv.h>
73 #endif
74 #ifdef HAVE_NET_IF_H
75 # include <net/if.h>
76 #endif
77
78 #include "wine/winbase16.h"
79 #include "wingdi.h"
80 #include "winuser.h"
81 #include "winsock2.h"
82 #include "wine/winsock16.h"
83 #include "winnt.h"
84 #include "heap.h"
85 #include "task.h"
86 #include "wine/port.h"
87 #include "services.h"
88 #include "server.h"
89 #include "debugtools.h"
90
91
92 DEFAULT_DEBUG_CHANNEL(winsock);
93
94 #define DEBUG_SOCKADDR 0
95 #define dump_sockaddr(a) \
96 DPRINTF("sockaddr_in: family %d, address %s, port %d\n", \
97 ((struct sockaddr_in *)a)->sin_family, \
98 inet_ntoa(((struct sockaddr_in *)a)->sin_addr), \
99 ntohs(((struct sockaddr_in *)a)->sin_port))
100
101 /* ----------------------------------- internal data */
102
103 /* ws_... struct conversion flags */
104
105 #define WS_DUP_LINEAR 0x0001
106 #define WS_DUP_NATIVE 0x0000 /* not used anymore */
107 #define WS_DUP_OFFSET 0x0002 /* internal pointers are offsets */
108 #define WS_DUP_SEGPTR 0x0004 /* internal pointers are SEGPTRs */
109 /* by default, internal pointers are linear */
110 typedef struct /* WSAAsyncSelect() control struct */
111 {
112 HANDLE service, event, sock;
113 HWND hWnd;
114 UINT uMsg;
115 LONG lEvent;
116 struct _WSINFO *pwsi;
117 } ws_select_info;
118
119 #define WS_MAX_SOCKETS_PER_PROCESS 128 /* reasonable guess */
120 #define WS_MAX_UDP_DATAGRAM 1024
121
122 #define WS_ACCEPT_QUEUE 6
123
124 #define WSI_BLOCKINGCALL 0x00000001 /* per-thread info flags */
125 #define WSI_BLOCKINGHOOK 0x00000002 /* 32-bit callback */
126
127 #define PROCFS_NETDEV_FILE "/proc/net/dev" /* Points to the file in the /proc fs
128 that lists the network devices.
129 Do we need an #ifdef LINUX for this? */
130
131 typedef struct _WSINFO
132 {
133 DWORD dwThisProcess;
134 struct _WSINFO *lpNextIData;
135
136 unsigned flags;
137 INT16 num_startup; /* reference counter */
138 INT16 num_async_rq;
139 INT16 last_free; /* entry in the socket table */
140 UINT16 buflen;
141 char* buffer; /* allocated from SEGPTR heap */
142 void *he; /* typecast for Win16/32 ws_hostent */
143 int helen;
144 void *se; /* typecast for Win16/32 ws_servent */
145 int selen;
146 void *pe; /* typecast for Win16/32 ws_protoent */
147 int pelen;
148 char* dbuffer; /* buffer for dummies (32 bytes) */
149
150 DWORD blocking_hook;
151
152 volatile HANDLE accept_old[WS_ACCEPT_QUEUE], accept_new[WS_ACCEPT_QUEUE];
153 } WSINFO, *LPWSINFO;
154
155 /* function prototypes */
156 int WS_dup_he(LPWSINFO pwsi, struct hostent* p_he, int flag);
157 int WS_dup_pe(LPWSINFO pwsi, struct protoent* p_pe, int flag);
158 int WS_dup_se(LPWSINFO pwsi, struct servent* p_se, int flag);
159
160 typedef void WIN_hostent;
161 typedef void WIN_protoent;
162 typedef void WIN_servent;
163
164 int WSAIOCTL_GetInterfaceCount(void);
165 int WSAIOCTL_GetInterfaceName(int intNumber, char *intName);
166
167 UINT16 wsaErrno(void);
168 UINT16 wsaHerrno(void);
169
170 static HANDLE _WSHeap = 0;
171
172 #define WS_ALLOC(size) \
173 HeapAlloc(_WSHeap, HEAP_ZERO_MEMORY, (size) )
174 #define WS_FREE(ptr) \
175 HeapFree(_WSHeap, 0, (ptr) )
176
177 static INT _ws_sock_ops[] =
178 { WS_SO_DEBUG, WS_SO_REUSEADDR, WS_SO_KEEPALIVE, WS_SO_DONTROUTE,
179 WS_SO_BROADCAST, WS_SO_LINGER, WS_SO_OOBINLINE, WS_SO_SNDBUF,
180 WS_SO_RCVBUF, WS_SO_ERROR, WS_SO_TYPE, WS_SO_DONTLINGER,
181 #ifdef SO_RCVTIMEO
182 WS_SO_RCVTIMEO,
183 #endif
184 0 };
185 static int _px_sock_ops[] =
186 { SO_DEBUG, SO_REUSEADDR, SO_KEEPALIVE, SO_DONTROUTE, SO_BROADCAST,
187 SO_LINGER, SO_OOBINLINE, SO_SNDBUF, SO_RCVBUF, SO_ERROR, SO_TYPE,
188 WS_SO_DONTLINGER, /* no unix equivalent */
189 #ifdef SO_RCVTIMEO
190 SO_RCVTIMEO,
191 #endif
192 };
193
194 static INT _ws_tcp_ops[] = {
195 #ifdef TCP_NODELAY
196 WS_TCP_NODELAY,
197 #endif
198 0
199 };
200 static int _px_tcp_ops[] = {
201 #ifdef TCP_NODELAY
202 TCP_NODELAY,
203 #endif
204 0
205 };
206
207 /* we need a special routine to handle WSA* errors */
208 static inline int sock_server_call( enum request req )
209 {
210 unsigned int res = server_call_noerr( req );
211 if (res)
212 {
213 /* do not map WSA errors */
214 if ((res < WSABASEERR) || (res >= 0x10000000)) res = RtlNtStatusToDosError(res);
215 SetLastError( res );
216 }
217 return res;
218 }
219
220 static int _check_ws(LPWSINFO pwsi, SOCKET s);
221 static char* _check_buffer(LPWSINFO pwsi, int size);
222
223 static int _get_sock_fd(SOCKET s)
224 {
225 struct get_read_fd_request *req = get_req_buffer();
226 int fd;
227
228 req->handle = s;
229 server_call_fd( REQ_GET_READ_FD, -1, &fd );
230 if (fd == -1)
231 FIXME("handle %d is not a socket (GLE %ld)\n",s,GetLastError());
232 return fd;
233 }
234
235 static void _enable_event(SOCKET s, unsigned int event,
236 unsigned int sstate, unsigned int cstate)
237 {
238 struct enable_socket_event_request *req = get_req_buffer();
239
240 req->handle = s;
241 req->mask = event;
242 req->sstate = sstate;
243 req->cstate = cstate;
244 sock_server_call( REQ_ENABLE_SOCKET_EVENT );
245 }
246
247 static int _is_blocking(SOCKET s)
248 {
249 struct get_socket_event_request *req = get_req_buffer();
250
251 req->handle = s;
252 req->service = FALSE;
253 req->s_event = 0;
254 req->c_event = 0;
255 sock_server_call( REQ_GET_SOCKET_EVENT );
256 return (req->state & WS_FD_NONBLOCKING) == 0;
257 }
258
259 static unsigned int _get_sock_mask(SOCKET s)
260 {
261 struct get_socket_event_request *req = get_req_buffer();
262
263 req->handle = s;
264 req->service = FALSE;
265 req->s_event = 0;
266 req->c_event = 0;
267 sock_server_call( REQ_GET_SOCKET_EVENT );
268 return req->mask;
269 }
270
271 static void _sync_sock_state(SOCKET s)
272 {
273 /* do a dummy wineserver request in order to let
274 the wineserver run through its select loop once */
275 (void)_is_blocking(s);
276 }
277
278 static int _get_sock_error(SOCKET s, unsigned int bit)
279 {
280 struct get_socket_event_request *req = get_req_buffer();
281
282 req->handle = s;
283 req->service = FALSE;
284 req->s_event = 0;
285 req->c_event = 0;
286 sock_server_call( REQ_GET_SOCKET_EVENT );
287 return req->errors[bit];
288 }
289
290 static LPWSINFO lpFirstIData = NULL;
291
292 static LPWSINFO WINSOCK_GetIData(void)
293 {
294 DWORD pid = GetCurrentProcessId();
295 LPWSINFO iData;
296
297 for (iData = lpFirstIData; iData; iData = iData->lpNextIData) {
298 if (iData->dwThisProcess == pid)
299 break;
300 }
301 return iData;
302 }
303
304 static BOOL WINSOCK_CreateIData(void)
305 {
306 LPWSINFO iData;
307
308 iData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WSINFO));
309 if (!iData)
310 return FALSE;
311 iData->dwThisProcess = GetCurrentProcessId();
312 iData->lpNextIData = lpFirstIData;
313 lpFirstIData = iData;
314 return TRUE;
315 }
316
317 static void WINSOCK_DeleteIData(void)
318 {
319 LPWSINFO iData = WINSOCK_GetIData();
320 LPWSINFO* ppid;
321 if (iData) {
322 for (ppid = &lpFirstIData; *ppid; ppid = &(*ppid)->lpNextIData) {
323 if (*ppid == iData) {
324 *ppid = iData->lpNextIData;
325 break;
326 }
327 }
328
329 if( iData->flags & WSI_BLOCKINGCALL )
330 TRACE("\tinside blocking call!\n");
331
332 /* delete scratch buffers */
333
334 if( iData->buffer ) SEGPTR_FREE(iData->buffer);
335 if( iData->dbuffer ) SEGPTR_FREE(iData->dbuffer);
336
337 HeapFree(GetProcessHeap(), 0, iData);
338 }
339 }
340
341 /***********************************************************************
342 * WSOCK32_LibMain (WSOCK32.init)
343 */
344 BOOL WINAPI WSOCK32_LibMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
345 {
346 TRACE("0x%x 0x%lx %p\n", hInstDLL, fdwReason, fImpLoad);
347 switch (fdwReason) {
348 case DLL_PROCESS_DETACH:
349 WINSOCK_DeleteIData();
350 break;
351 }
352 return TRUE;
353 }
354
355 /***********************************************************************
356 * WINSOCK_LibMain (WINSOCK.init)
357 */
358 BOOL WINAPI WINSOCK_LibMain(DWORD fdwReason, HINSTANCE hInstDLL, WORD ds,
359 WORD wHeapSize, DWORD dwReserved1, WORD wReserved2)
360 {
361 TRACE("0x%x 0x%lx\n", hInstDLL, fdwReason);
362 switch (fdwReason) {
363 case DLL_PROCESS_DETACH:
364 WINSOCK_DeleteIData();
365 break;
366 }
367 return TRUE;
368 }
369
370 /***********************************************************************
371 * convert_sockopt()
372 *
373 * Converts socket flags from Windows format.
374 */
375 static void convert_sockopt(INT *level, INT *optname)
376 {
377 int i;
378 switch (*level)
379 {
380 case WS_SOL_SOCKET:
381 *level = SOL_SOCKET;
382 for(i=0; _ws_sock_ops[i]; i++)
383 if( _ws_sock_ops[i] == *optname ) break;
384 if( _ws_sock_ops[i] ) *optname = _px_sock_ops[i];
385 else FIXME("Unknown SOL_SOCKET optname %d\n", *optname);
386 break;
387 case WS_IPPROTO_TCP:
388 *level = IPPROTO_TCP;
389 for(i=0; _ws_tcp_ops[i]; i++)
390 if ( _ws_tcp_ops[i] == *optname ) break;
391 if( _ws_tcp_ops[i] ) *optname = _px_tcp_ops[i];
392 else FIXME("Unknown IPPROTO_TCP optname %d\n", *optname);
393 break;
394 }
395 }
396
397 /* ----------------------------------- Per-thread info (or per-process?) */
398
399 static int wsi_strtolo(LPWSINFO pwsi, const char* name, const char* opt)
400 {
401 /* Stuff a lowercase copy of the string into the local buffer */
402
403 int i = strlen(name) + 2;
404 char* p = _check_buffer(pwsi, i + ((opt)?strlen(opt):0));
405
406 if( p )
407 {
408 do *p++ = tolower(*name); while(*name++);
409 i = (p - (char*)(pwsi->buffer));
410 if( opt ) do *p++ = tolower(*opt); while(*opt++);
411 return i;
412 }
413 return 0;
414 }
415
416 static fd_set* fd_set_import( fd_set* fds, LPWSINFO pwsi, void* wsfds, int* highfd, int lfd[], BOOL b32 )
417 {
418 /* translate Winsock fd set into local fd set */
419
420 if( wsfds )
421 {
422 #define wsfds16 ((ws_fd_set16*)wsfds)
423 #define wsfds32 ((ws_fd_set32*)wsfds)
424 int i, count;
425
426 FD_ZERO(fds);
427 count = b32 ? wsfds32->fd_count : wsfds16->fd_count;
428
429 for( i = 0; i < count; i++ )
430 {
431 int s = (b32) ? wsfds32->fd_array[i]
432 : wsfds16->fd_array[i];
433 if( _check_ws(pwsi, s) )
434 {
435 int fd = _get_sock_fd(s);
436 lfd[ i ] = fd;
437 if( fd > *highfd ) *highfd = fd;
438 FD_SET(fd, fds);
439 }
440 else lfd[ i ] = -1;
441 }
442 #undef wsfds32
443 #undef wsfds16
444 return fds;
445 }
446 return NULL;
447 }
448
449 inline static int sock_error_p(int s)
450 {
451 unsigned int optval, optlen;
452
453 optlen = sizeof(optval);
454 getsockopt(s, SOL_SOCKET, SO_ERROR, (void *) &optval, &optlen);
455 if (optval) WARN("\t[%i] error: %d\n", s, optval);
456 return optval != 0;
457 }
458
459 static int fd_set_export( LPWSINFO pwsi, fd_set* fds, fd_set* exceptfds, void* wsfds, int lfd[], BOOL b32 )
460 {
461 int num_err = 0;
462
463 /* translate local fd set into Winsock fd set, adding
464 * errors to exceptfds (only if app requested it) */
465
466 if( wsfds )
467 {
468 #define wsfds16 ((ws_fd_set16*)wsfds)
469 #define wsfds32 ((ws_fd_set32*)wsfds)
470 int i, j, count = (b32) ? wsfds32->fd_count : wsfds16->fd_count;
471
472 for( i = 0, j = 0; i < count; i++ )
473 {
474 if( lfd[i] >= 0 )
475 {
476 int fd = lfd[i];
477 if( FD_ISSET(fd, fds) )
478 {
479 if ( exceptfds && sock_error_p(fd) )
480 {
481 FD_SET(fd, exceptfds);
482 num_err++;
483 }
484 else if( b32 )
485 wsfds32->fd_array[j++] = wsfds32->fd_array[i];
486 else
487 wsfds16->fd_array[j++] = wsfds16->fd_array[i];
488 }
489 close(fd);
490 lfd[i] = -1;
491 }
492 }
493
494 if( b32 ) wsfds32->fd_count = j;
495 else wsfds16->fd_count = j;
496
497 TRACE("\n");
498 #undef wsfds32
499 #undef wsfds16
500 }
501 return num_err;
502 }
503
504 static void fd_set_unimport( void* wsfds, int lfd[], BOOL b32 )
505 {
506 if ( wsfds )
507 {
508 #define wsfds16 ((ws_fd_set16*)wsfds)
509 #define wsfds32 ((ws_fd_set32*)wsfds)
510 int i, count = (b32) ? wsfds32->fd_count : wsfds16->fd_count;
511
512 for( i = 0; i < count; i++ )
513 if ( lfd[i] >= 0 )
514 close(lfd[i]);
515
516 TRACE("\n");
517 #undef wsfds32
518 #undef wsfds16
519 }
520 }
521
522 static int do_block( int fd, int mask )
523 {
524 fd_set fds[3];
525 int i, r;
526
527 FD_ZERO(&fds[0]);
528 FD_ZERO(&fds[1]);
529 FD_ZERO(&fds[2]);
530 for (i=0; i<3; i++)
531 if (mask & (1<<i))
532 FD_SET(fd, &fds[i]);
533 i = select( fd+1, &fds[0], &fds[1], &fds[2], NULL );
534 if (i <= 0) return -1;
535 r = 0;
536 for (i=0; i<3; i++)
537 if (FD_ISSET(fd, &fds[i]))
538 r |= 1<<i;
539 return r;
540 }
541
542 void* __ws_memalloc( int size )
543 {
544 return WS_ALLOC(size);
545 }
546
547 void __ws_memfree(void* ptr)
548 {
549 WS_FREE(ptr);
550 }
551
552
553 /* ----------------------------------- API -----
554 *
555 * Init / cleanup / error checking.
556 */
557
558 /***********************************************************************
559 * WSAStartup16() (WINSOCK.115)
560 *
561 * Create socket control struct, attach it to the global list and
562 * update a pointer in the task struct.
563 */
564 INT16 WINAPI WSAStartup16(UINT16 wVersionRequested, LPWSADATA lpWSAData)
565 {
566 WSADATA WINSOCK_data = { 0x0101, 0x0101,
567 "WINE Sockets 1.1",
568 #ifdef linux
569 "Linux/i386",
570 #elif defined(__NetBSD__)
571 "NetBSD/i386",
572 #elif defined(sunos)
573 "SunOS",
574 #elif defined(__FreeBSD__)
575 "FreeBSD",
576 #elif defined(__OpenBSD__)
577 "OpenBSD/i386",
578 #else
579 "Unknown",
580 #endif
581 WS_MAX_SOCKETS_PER_PROCESS,
582 WS_MAX_UDP_DATAGRAM, (SEGPTR)NULL };
583 LPWSINFO pwsi;
584
585 TRACE("verReq=%x\n", wVersionRequested);
586
587 if (LOBYTE(wVersionRequested) < 1 || (LOBYTE(wVersionRequested) == 1 &&
588 HIBYTE(wVersionRequested) < 1)) return WSAVERNOTSUPPORTED;
589
590 if (!lpWSAData) return WSAEINVAL;
591
592 /* initialize socket heap */
593
594 if( !_WSHeap )
595 {
596 _WSHeap = HeapCreate(HEAP_ZERO_MEMORY, 8120, 32768);
597 if( !_WSHeap )
598 {
599 ERR("Fatal: failed to create WinSock heap\n");
600 return 0;
601 }
602 }
603 if( _WSHeap == 0 ) return WSASYSNOTREADY;
604
605 pwsi = WINSOCK_GetIData();
606 if( pwsi == NULL )
607 {
608 WINSOCK_CreateIData();
609 pwsi = WINSOCK_GetIData();
610 if (!pwsi) return WSASYSNOTREADY;
611 }
612 pwsi->num_startup++;
613
614 /* return winsock information */
615
616 memcpy(lpWSAData, &WINSOCK_data, sizeof(WINSOCK_data));
617
618 TRACE("succeeded\n");
619 return 0;
620 }
621
622 /***********************************************************************
623 * WSAStartup() (WS2_32.115)
624 */
625 INT WINAPI WSAStartup(UINT wVersionRequested, LPWSADATA lpWSAData)
626 {
627 WSADATA WINSOCK_data = { 0x0202, 0x0202,
628 "WINE Sockets 2.0",
629 #ifdef linux
630 "Linux/i386",
631 #elif defined(__NetBSD__)
632 "NetBSD/i386",
633 #elif defined(sunos)
634 "SunOS",
635 #elif defined(__FreeBSD__)
636 "FreeBSD",
637 #elif defined(__OpenBSD__)
638 "OpenBSD/i386",
639 #else
640 "Unknown",
641 #endif
642 WS_MAX_SOCKETS_PER_PROCESS,
643 WS_MAX_UDP_DATAGRAM, (SEGPTR)NULL };
644 LPWSINFO pwsi;
645
646 TRACE("verReq=%x\n", wVersionRequested);
647
648 if (LOBYTE(wVersionRequested) < 1)
649 return WSAVERNOTSUPPORTED;
650
651 if (!lpWSAData) return WSAEINVAL;
652
653 /* initialize socket heap */
654
655 if( !_WSHeap )
656 {
657 _WSHeap = HeapCreate(HEAP_ZERO_MEMORY, 8120, 32768);
658 if( !_WSHeap )
659 {
660 ERR("Fatal: failed to create WinSock heap\n");
661 return 0;
662 }
663 }
664 if( _WSHeap == 0 ) return WSASYSNOTREADY;
665
666 pwsi = WINSOCK_GetIData();
667 if( pwsi == NULL )
668 {
669 WINSOCK_CreateIData();
670 pwsi = WINSOCK_GetIData();
671 if (!pwsi) return WSASYSNOTREADY;
672 }
673 pwsi->num_startup++;
674
675 /* return winsock information */
676 memcpy(lpWSAData, &WINSOCK_data, sizeof(WINSOCK_data));
677
678 /* that's the whole of the negotiation for now */
679 lpWSAData->wVersion = wVersionRequested;
680
681 TRACE("succeeded\n");
682 return 0;
683 }
684
685
686 /***********************************************************************
687 * WSACleanup() (WINSOCK.116)
688 */
689 INT WINAPI WSACleanup(void)
690 {
691 LPWSINFO pwsi = WINSOCK_GetIData();
692 if( pwsi ) {
693 if( --pwsi->num_startup > 0 ) return 0;
694
695 WINSOCK_DeleteIData();
696 return 0;
697 }
698 SetLastError(WSANOTINITIALISED);
699 return SOCKET_ERROR;
700 }
701
702
703 /***********************************************************************
704 * WSAGetLastError() (WSOCK32.111)(WINSOCK.111)
705 */
706 INT WINAPI WSAGetLastError(void)
707 {
708 return GetLastError();
709 }
710
711 /***********************************************************************
712 * WSASetLastError() (WSOCK32.112)
713 */
714 void WINAPI WSASetLastError(INT iError) {
715 SetLastError(iError);
716 }
717
718 /***********************************************************************
719 * WSASetLastError16() (WINSOCK.112)
720 */
721 void WINAPI WSASetLastError16(INT16 iError)
722 {
723 WSASetLastError(iError);
724 }
725
726 int _check_ws(LPWSINFO pwsi, SOCKET s)
727 {
728 if( pwsi )
729 {
730 int fd;
731 if( pwsi->flags & WSI_BLOCKINGCALL ) SetLastError(WSAEINPROGRESS);
732 if ( (fd = _get_sock_fd(s)) < 0 ) {
733 SetLastError(WSAENOTSOCK);
734 return 0;
735 }
736 /* FIXME: maybe check whether fd is really a socket? */
737 close( fd );
738 return 1;
739 }
740 return 0;
741 }
742
743 char* _check_buffer(LPWSINFO pwsi, int size)
744 {
745 if( pwsi->buffer && pwsi->buflen >= size ) return pwsi->buffer;
746 else SEGPTR_FREE(pwsi->buffer);
747
748 pwsi->buffer = (char*)SEGPTR_ALLOC((pwsi->buflen = size));
749 return pwsi->buffer;
750 }
751
752 struct ws_hostent* _check_buffer_he(LPWSINFO pwsi, int size)
753 {
754 if( pwsi->he && pwsi->helen >= size ) return pwsi->he;
755 else SEGPTR_FREE(pwsi->he);
756
757 pwsi->he = SEGPTR_ALLOC((pwsi->helen = size));
758 return pwsi->he;
759 }
760
761 void* _check_buffer_se(LPWSINFO pwsi, int size)
762 {
763 if( pwsi->se && pwsi->selen >= size ) return pwsi->se;
764 else SEGPTR_FREE(pwsi->se);
765
766 pwsi->se = SEGPTR_ALLOC((pwsi->selen = size));
767 return pwsi->se;
768 }
769
770 struct ws_protoent* _check_buffer_pe(LPWSINFO pwsi, int size)
771 {
772 if( pwsi->pe && pwsi->pelen >= size ) return pwsi->pe;
773 else SEGPTR_FREE(pwsi->pe);
774
775 pwsi->pe = SEGPTR_ALLOC((pwsi->pelen = size));
776 return pwsi->pe;
777 }
778
779 /* ----------------------------------- i/o APIs */
780
781 /***********************************************************************
782 * accept() (WSOCK32.1)
783 */
784 static void WSOCK32_async_accept(LPWSINFO pwsi, SOCKET s, SOCKET as)
785 {
786 int q;
787 /* queue socket for WSAAsyncSelect */
788 for (q=0; q<WS_ACCEPT_QUEUE; q++)
789 if (InterlockedCompareExchange((PVOID*)&pwsi->accept_old[q], (PVOID)s, (PVOID)0) == (PVOID)0)
790 break;
791 if (q<WS_ACCEPT_QUEUE)
792 pwsi->accept_new[q] = as;
793 else
794 ERR("accept queue too small\n");
795 /* now signal our AsyncSelect handler */
796 _enable_event(s, WS_FD_SERVEVENT, 0, 0);
797 }
798
799 SOCKET WINAPI WSOCK32_accept(SOCKET s, struct sockaddr *addr,
800 INT *addrlen32)
801 {
802 LPWSINFO pwsi = WINSOCK_GetIData();
803 #ifdef HAVE_IPX
804 struct ws_sockaddr_ipx* addr2 = (struct ws_sockaddr_ipx *)addr;
805 #endif
806 struct accept_socket_request *req = get_req_buffer();
807
808 TRACE("(%08x): socket %04x\n",
809 (unsigned)pwsi, (UINT16)s );
810 if( _check_ws(pwsi, s) )
811 {
812 if (_is_blocking(s))
813 {
814 /* block here */
815 int fd = _get_sock_fd(s);
816 do_block(fd, 5);
817 close(fd);
818 _sync_sock_state(s); /* let wineserver notice connection */
819 /* retrieve any error codes from it */
820 SetLastError(_get_sock_error(s, FD_ACCEPT_BIT));
821 /* FIXME: care about the error? */
822 }
823 req->lhandle = s;
824 req->access = GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE;
825 req->inherit = TRUE;
826 sock_server_call( REQ_ACCEPT_SOCKET );
827 if( req->handle >= 0 )
828 {
829 SOCKET as = req->handle;
830 unsigned omask = _get_sock_mask( s );
831 int fd = _get_sock_fd( as );
832 if( getpeername(fd, addr, addrlen32) != -1 )
833 {
834 #ifdef HAVE_IPX
835 if (addr && ((struct sockaddr_ipx *)addr)->sipx_family == AF_IPX) {
836 addr = (struct sockaddr *)
837 malloc(addrlen32 ? *addrlen32 : sizeof(*addr2));
838 memcpy(addr, addr2,
839 addrlen32 ? *addrlen32 : sizeof(*addr2));
840 addr2->sipx_family = WS_AF_IPX;
841 addr2->sipx_network = ((struct sockaddr_ipx *)addr)->sipx_network;
842 addr2->sipx_port = ((struct sockaddr_ipx *)addr)->sipx_port;
843 memcpy(addr2->sipx_node,
844 ((struct sockaddr_ipx *)addr)->sipx_node, IPX_NODE_LEN);
845 free(addr);
846 }
847 #endif
848 } else SetLastError(wsaErrno());
849 close(fd);
850 if (omask & WS_FD_SERVEVENT)
851 WSOCK32_async_accept(pwsi, s, as);
852 return as;
853 }
854 }
855 return INVALID_SOCKET;
856 }
857
858 /***********************************************************************
859 * accept() (WINSOCK.1)
860 */
861 SOCKET16 WINAPI WINSOCK_accept16(SOCKET16 s, struct sockaddr* addr,
862 INT16* addrlen16 )
863 {
864 INT addrlen32 = addrlen16 ? *addrlen16 : 0;
865 SOCKET retSocket = WSOCK32_accept( s, addr, &addrlen32 );
866 if( addrlen16 ) *addrlen16 = (INT16)addrlen32;
867 return (SOCKET16)retSocket;
868 }
869
870 /***********************************************************************
871 * bind() (WSOCK32.2)
872 */
873 INT WINAPI WSOCK32_bind(SOCKET s, struct sockaddr *name, INT namelen)
874 {
875 LPWSINFO pwsi = WINSOCK_GetIData();
876 #ifdef HAVE_IPX
877 struct ws_sockaddr_ipx* name2 = (struct ws_sockaddr_ipx *)name;
878 #endif
879
880 TRACE("(%08x): socket %04x, ptr %8x, length %d\n",
881 (unsigned)pwsi, s, (int) name, namelen);
882 #if DEBUG_SOCKADDR
883 dump_sockaddr(name);
884 #endif
885
886 if ( _check_ws(pwsi, s) )
887 {
888 int fd = _get_sock_fd(s);
889 /* FIXME: what family does this really map to on the Unix side? */
890 if (name && ((struct ws_sockaddr_ipx *)name)->sipx_family == WS_AF_PUP)
891 ((struct ws_sockaddr_ipx *)name)->sipx_family = AF_UNSPEC;
892 #ifdef HAVE_IPX
893 else if (name &&
894 ((struct ws_sockaddr_ipx *)name)->sipx_family == WS_AF_IPX)
895 {
896 name = (struct sockaddr *) malloc(sizeof(struct sockaddr_ipx));
897 memset(name, '\0', sizeof(struct sockaddr_ipx));
898 ((struct sockaddr_ipx *)name)->sipx_family = AF_IPX;
899 ((struct sockaddr_ipx *)name)->sipx_port = name2->sipx_port;
900 ((struct sockaddr_ipx *)name)->sipx_network = name2->sipx_network;
901 memcpy(((struct sockaddr_ipx *)name)->sipx_node,
902 name2->sipx_node, IPX_NODE_LEN);
903 namelen = sizeof(struct sockaddr_ipx);
904 }
905 #endif
906 if ( namelen >= sizeof(*name) )
907 {
908 if ( name && (((struct ws_sockaddr_in *)name)->sin_family == AF_INET
909 #ifdef HAVE_IPX
910 || ((struct sockaddr_ipx *)name)->sipx_family == AF_IPX
911 #endif
912 ))
913 {
914 if ( bind(fd, name, namelen) < 0 )
915 {
916 int loc_errno = errno;
917 WARN("\tfailure - errno = %i\n", errno);
918 errno = loc_errno;
919 switch(errno)
920 {
921 case EBADF: SetLastError(WSAENOTSOCK); break;
922 case EADDRNOTAVAIL: SetLastError(WSAEINVAL); break;
923 default: SetLastError(wsaErrno());break;
924 }
925 }
926 else {
927 #ifdef HAVE_IPX
928 if (((struct sockaddr_ipx *)name)->sipx_family == AF_IPX)
929 free(name);
930 #endif
931 close(fd);
932 return 0; /* success */
933 }
934 } else SetLastError(WSAEAFNOSUPPORT);
935 } else SetLastError(WSAEFAULT);
936 #ifdef HAVE_IPX
937 if (name && ((struct sockaddr_ipx *)name)->sipx_family == AF_IPX)
938 free(name);
939 #endif
940 close(fd);
941 }
942 return SOCKET_ERROR;
943 }
944
945 /***********************************************************************
946 * bind() (WINSOCK.2)
947 */
948 INT16 WINAPI WINSOCK_bind16(SOCKET16 s, struct sockaddr *name, INT16 namelen)
949 {
950 return (INT16)WSOCK32_bind( s, name, namelen );
951 }
952
953 /***********************************************************************
954 * closesocket() (WSOCK32.3)
955 */
956 INT WINAPI WSOCK32_closesocket(SOCKET s)
957 {
958 LPWSINFO pwsi = WINSOCK_GetIData();
959
960 TRACE("(%08x): socket %08x\n", (unsigned)pwsi, s);
961
962 if( _check_ws(pwsi, s) )
963 {
964 if( CloseHandle(s) )
965 return 0;
966 }
967 return SOCKET_ERROR;
968 }
969
970 /***********************************************************************
971 * closesocket() (WINSOCK.3)
972 */
973 INT16 WINAPI WINSOCK_closesocket16(SOCKET16 s)
974 {
975 return (INT16)WSOCK32_closesocket(s);
976 }
977
978 /***********************************************************************
979 * connect() (WSOCK32.4)
980 */
981 INT WINAPI WSOCK32_connect(SOCKET s, struct sockaddr *name, INT namelen)
982 {
983 LPWSINFO pwsi = WINSOCK_GetIData();
984 #ifdef HAVE_IPX
985 struct ws_sockaddr_ipx* name2 = (struct ws_sockaddr_ipx *)name;
986 #endif
987
988 TRACE("(%08x): socket %04x, ptr %8x, length %d\n",
989 (unsigned)pwsi, s, (int) name, namelen);
990 #if DEBUG_SOCKADDR
991 dump_sockaddr(name);
992 #endif
993
994 if( _check_ws(pwsi, s) )
995 {
996 int fd = _get_sock_fd(s);
997 if (name && ((struct ws_sockaddr_ipx *)name)->sipx_family == WS_AF_PUP)
998 ((struct ws_sockaddr_ipx *)name)->sipx_family = AF_UNSPEC;
999 #ifdef HAVE_IPX
1000 else if (name && ((struct ws_sockaddr_ipx *)name)->sipx_family == WS_AF_IPX)
1001 {
1002 name = (struct sockaddr *) malloc(sizeof(struct sockaddr_ipx));
1003 memset(name, '\0', sizeof(struct sockaddr_ipx));
1004 ((struct sockaddr_ipx *)name)->sipx_family = AF_IPX;
1005 ((struct sockaddr_ipx *)name)->sipx_port = name2->sipx_port;
1006 ((struct sockaddr_ipx *)name)->sipx_network = name2->sipx_network;
1007 memcpy(((struct sockaddr_ipx *)name)->sipx_node,
1008 name2->sipx_node, IPX_NODE_LEN);
1009 namelen = sizeof(struct sockaddr_ipx);
1010 }
1011 #endif
1012 if (connect(fd, name, namelen) == 0) {
1013 close(fd);
1014 goto connect_success;
1015 }
1016 if (errno == EINPROGRESS)
1017 {
1018 /* tell wineserver that a connection is in progress */
1019 _enable_event(s, FD_CONNECT|FD_READ|FD_WRITE,
1020 WS_FD_CONNECT|WS_FD_READ|WS_FD_WRITE,
1021 WS_FD_CONNECTED|WS_FD_LISTENING);
1022 if (_is_blocking(s))
1023 {
1024 int result;
1025 /* block here */
1026 do_block(fd, 6);
1027 _sync_sock_state(s); /* let wineserver notice connection */
1028 /* retrieve any error codes from it */
1029 result = _get_sock_error(s, FD_CONNECT_BIT);
1030 if (result)
1031 SetLastError(result);
1032 else {
1033 close(fd);
1034 goto connect_success;
1035 }
1036 }
1037 else SetLastError(WSAEWOULDBLOCK);
1038 close(fd);
1039 }
1040 else
1041 {
1042 SetLastError(wsaErrno());
1043 close(fd);
1044 }
1045 }
1046 #ifdef HAVE_IPX
1047 if (name && ((struct sockaddr_ipx *)name)->sipx_family == AF_IPX)
1048 free(name);
1049 #endif
1050 return SOCKET_ERROR;
1051 connect_success:
1052 #ifdef HAVE_IPX
1053 if (((struct sockaddr_ipx *)name)->sipx_family == AF_IPX)
1054 free(name);
1055 #endif
1056 _enable_event(s, FD_CONNECT|FD_READ|FD_WRITE,
1057 WS_FD_CONNECTED|WS_FD_READ|WS_FD_WRITE,
1058 WS_FD_CONNECT|WS_FD_LISTENING);
1059 return 0;
1060 }
1061
1062 /***********************************************************************
1063 * connect() (WINSOCK.4)
1064 */
1065 INT16 WINAPI WINSOCK_connect16(SOCKET16 s, struct sockaddr *name, INT16 namelen)
1066 {
1067 return (INT16)WSOCK32_connect( s, name, namelen );
1068 }
1069
1070 /***********************************************************************
1071 * getpeername() (WSOCK32.5)
1072 */
1073 INT WINAPI WSOCK32_getpeername(SOCKET s, struct sockaddr *name,
1074 INT *namelen)
1075 {
1076 LPWSINFO pwsi = WINSOCK_GetIData();
1077 #ifdef HAVE_IPX
1078 struct ws_sockaddr_ipx* name2 = (struct ws_sockaddr_ipx *)name;
1079 #endif
1080
1081 TRACE("(%08x): socket: %04x, ptr %8x, ptr %8x\n",
1082 (unsigned)pwsi, s, (int) name, *namelen);
1083 if( _check_ws(pwsi, s) )
1084 {
1085 int fd = _get_sock_fd(s);
1086 if (getpeername(fd, name, namelen) == 0) {
1087 #ifdef HAVE_IPX
1088 if (((struct ws_sockaddr_ipx *)name)->sipx_family == AF_IPX) {
1089 name = (struct sockaddr *)
1090 malloc(namelen ? *namelen : sizeof(*name2));
1091 memcpy(name, name2, namelen ? *namelen : sizeof(*name2));
1092 name2->sipx_family = WS_AF_IPX;
1093 name2->sipx_network = ((struct sockaddr_ipx *)name)->sipx_network;
1094 name2->sipx_port = ((struct sockaddr_ipx *)name)->sipx_port;
1095 memcpy(name2->sipx_node,
1096 ((struct sockaddr_ipx *)name)->sipx_node, IPX_NODE_LEN);
1097 free(name);
1098 }
1099 #endif
1100 close(fd);
1101 return 0;
1102 }
1103 SetLastError(wsaErrno());
1104 close(fd);
1105 }
1106 return SOCKET_ERROR;
1107 }
1108
1109 /***********************************************************************
1110 * getpeername() (WINSOCK.5)
1111 */
1112 INT16 WINAPI WINSOCK_getpeername16(SOCKET16 s, struct sockaddr *name,
1113 INT16 *namelen16)
1114 {
1115 INT namelen32 = *namelen16;
1116 INT retVal = WSOCK32_getpeername( s, name, &namelen32 );
1117
1118 #if DEBUG_SOCKADDR
1119 dump_sockaddr(name);
1120 #endif
1121
1122 *namelen16 = namelen32;
1123 return (INT16)retVal;
1124 }
1125
1126 /***********************************************************************
1127 * getsockname() (WSOCK32.6)
1128 */
1129 INT WINAPI WSOCK32_getsockname(SOCKET s, struct sockaddr *name,
1130 INT *namelen)
1131 {
1132 LPWSINFO pwsi = WINSOCK_GetIData();
1133 #ifdef HAVE_IPX
1134 struct ws_sockaddr_ipx* name2 = (struct ws_sockaddr_ipx *)name;
1135 #endif
1136
1137 TRACE("(%08x): socket: %04x, ptr %8x, ptr %8x\n",
1138 (unsigned)pwsi, s, (int) name, (int) *namelen);
1139 if( _check_ws(pwsi, s) )
1140 {
1141 int fd = _get_sock_fd(s);
1142 if (getsockname(fd, name, namelen) == 0) {
1143 #ifdef HAVE_IPX
1144 if (((struct sockaddr_ipx *)name)->sipx_family == AF_IPX) {
1145 name = (struct sockaddr *)
1146 malloc(namelen ? *namelen : sizeof(*name2));
1147 memcpy(name, name2, namelen ? *namelen : sizeof(*name2));
1148 name2->sipx_family = WS_AF_IPX;
1149 name2->sipx_network = ((struct sockaddr_ipx *)name)->sipx_network;
1150 name2->sipx_port = ((struct sockaddr_ipx *)name)->sipx_port;
1151 memcpy(name2->sipx_node,
1152 ((struct sockaddr_ipx *)name)->sipx_node, IPX_NODE_LEN);
1153 free(name);
1154 }
1155 #endif
1156 close(fd);
1157 return 0;
1158 }
1159 SetLastError(wsaErrno());
1160 close(fd);
1161 }
1162 return SOCKET_ERROR;
1163 }
1164
1165 /***********************************************************************
1166 * getsockname() (WINSOCK.6)
1167 */
1168 INT16 WINAPI WINSOCK_getsockname16(SOCKET16 s, struct sockaddr *name,
1169 INT16 *namelen16)
1170 {
1171 INT retVal;
1172
1173 if( namelen16 )
1174 {
1175 INT namelen32 = *namelen16;
1176 retVal = WSOCK32_getsockname( s, name, &namelen32 );
1177 *namelen16 = namelen32;
1178
1179 #if DEBUG_SOCKADDR
1180 dump_sockaddr(name);
1181 #endif
1182
1183 }
1184 else retVal = SOCKET_ERROR;
1185 return (INT16)retVal;
1186 }
1187
1188
1189 /***********************************************************************
1190 * getsockopt() (WSOCK32.7)
1191 */
1192 INT WINAPI WSOCK32_getsockopt(SOCKET s, INT level,
1193 INT optname, char *optval, INT *optlen)
1194 {
1195 LPWSINFO pwsi = WINSOCK_GetIData();
1196
1197 TRACE("(%08x): socket: %04x, opt %d, ptr %8x, ptr %8x\n",
1198 (unsigned)pwsi, s, level, (int) optval, (int) *optlen);
1199 if( _check_ws(pwsi, s) )
1200 {
1201 int fd = _get_sock_fd(s);
1202 convert_sockopt(&level, &optname);
1203 if (getsockopt(fd, (int) level, optname, optval, optlen) == 0 )
1204 {
1205 close(fd);
1206 return 0;
1207 }
1208 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
1209 close(fd);
1210 }
1211 return SOCKET_ERROR;
1212 }
1213
1214 /***********************************************************************
1215 * getsockopt() (WINSOCK.7)
1216 */
1217 INT16 WINAPI WINSOCK_getsockopt16(SOCKET16 s, INT16 level,
1218 INT16 optname, char *optval, INT16 *optlen)
1219 {
1220 INT optlen32;
1221 INT *p = &optlen32;
1222 INT retVal;
1223 if( optlen ) optlen32 = *optlen; else p = NULL;
1224 retVal = WSOCK32_getsockopt( s, (UINT16)level, optname, optval, p );
1225 if( optlen ) *optlen = optlen32;
1226 return (INT16)retVal;
1227 }
1228
1229 /***********************************************************************
1230 * htonl() (WINSOCK.8)(WSOCK32.8)
1231 */
1232 u_long WINAPI WINSOCK_htonl(u_long hostlong) { return( htonl(hostlong) ); }
1233 /***********************************************************************
1234 * htons() (WINSOCK.9)(WSOCK32.9)
1235 */
1236 u_short WINAPI WINSOCK_htons(u_short hostshort) { return( htons(hostshort) ); }
1237 /***********************************************************************
1238 * inet_addr() (WINSOCK.10)(WSOCK32.10)
1239 */
1240 u_long WINAPI WINSOCK_inet_addr(char *cp) { return( inet_addr(cp) ); }
1241 /***********************************************************************
1242 * ntohl() (WINSOCK.14)(WSOCK32.14)
1243 */
1244 u_long WINAPI WINSOCK_ntohl(u_long netlong) { return( ntohl(netlong) ); }
1245 /***********************************************************************
1246 * ntohs() (WINSOCK.15)(WSOCK32.15)
1247 */
1248 u_short WINAPI WINSOCK_ntohs(u_short netshort) { return( ntohs(netshort) ); }
1249
1250 /***********************************************************************
1251 * inet_ntoa() (WINSOCK.11)(WSOCK32.11)
1252 */
1253 char* WINAPI WSOCK32_inet_ntoa(struct in_addr in)
1254 {
1255 /* use "buffer for dummies" here because some applications have
1256 * propensity to decode addresses in ws_hostent structure without
1257 * saving them first...
1258 */
1259
1260 LPWSINFO pwsi = WINSOCK_GetIData();
1261
1262 if( pwsi )
1263 {
1264 char* s = inet_ntoa(in);
1265 if( s )
1266 {
1267 if( pwsi->dbuffer == NULL ) {
1268 /* Yes, 16: 4*3 digits + 3 '.' + 1 '\0' */
1269 if((pwsi->dbuffer = (char*) SEGPTR_ALLOC(16)) == NULL )
1270 {
1271 SetLastError(WSAENOBUFS);
1272 return NULL;
1273 }
1274 }
1275 strcpy(pwsi->dbuffer, s);
1276 return pwsi->dbuffer;
1277 }
1278 SetLastError(wsaErrno());
1279 }
1280 return NULL;
1281 }
1282
1283 SEGPTR WINAPI WINSOCK_inet_ntoa16(struct in_addr in)
1284 {
1285 char* retVal = WSOCK32_inet_ntoa(in);
1286 return retVal ? SEGPTR_GET(retVal) : (SEGPTR)NULL;
1287 }
1288
1289
1290 /**********************************************************************
1291 * WSAIoctl (WS2_32)
1292 *
1293 *
1294 * FIXME: Only SIO_GET_INTERFACE_LIST option implemented.
1295 */
1296 INT WINAPI WSAIoctl (SOCKET s,
1297 DWORD dwIoControlCode,
1298 LPVOID lpvInBuffer,
1299 DWORD cbInBuffer,
1300 LPVOID lpbOutBuffer,
1301 DWORD cbOutBuffer,
1302 LPDWORD lpcbBytesReturned,
1303 LPWSAOVERLAPPED lpOverlapped,
1304 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
1305 {
1306 LPWSINFO pwsi = WINSOCK_GetIData();
1307
1308 if( _check_ws(pwsi, s) )
1309 {
1310 int fd = _get_sock_fd(s);
1311
1312 switch( dwIoControlCode )
1313 {
1314 case SIO_GET_INTERFACE_LIST:
1315 {
1316 INTERFACE_INFO* intArray = (INTERFACE_INFO*)lpbOutBuffer;
1317 int i, numInt;
1318 struct ifreq ifInfo;
1319 char ifName[512];
1320
1321
1322 TRACE ("-> SIO_GET_INTERFACE_LIST request\n");
1323
1324 numInt = WSAIOCTL_GetInterfaceCount();
1325 if (numInt < 0)
1326 {
1327 ERR ("Unable to open /proc filesystem to determine number of network interfaces!\n");
1328 close(fd);
1329 WSASetLastError(WSAEINVAL);
1330 return (SOCKET_ERROR);
1331 }
1332
1333 for (i=0; i<numInt; i++)
1334 {
1335 if (!WSAIOCTL_GetInterfaceName(i, ifName))
1336 {
1337 ERR ("Error parsing /proc filesystem!\n");
1338 close(fd);
1339 WSASetLastError(WSAEINVAL);
1340 return (SOCKET_ERROR);
1341 }
1342
1343 ifInfo.ifr_addr.sa_family = AF_INET;
1344
1345 /* IP Address */
1346 strcpy (ifInfo.ifr_name, ifName);
1347 if (ioctl(fd, SIOCGIFADDR, &ifInfo) < 0)
1348 {
1349 ERR ("Error obtaining IP address\n");
1350 close(fd);
1351 WSASetLastError(WSAEINVAL);
1352 return (SOCKET_ERROR);
1353 }
1354 else
1355 {
1356 struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_addr;
1357
1358 intArray->iiAddress.AddressIn.sin_family = AF_INET;
1359 intArray->iiAddress.AddressIn.sin_port = ipTemp->sin_port;
1360 intArray->iiAddress.AddressIn.sin_addr.ws_addr = ipTemp->sin_addr.S_un.S_addr;
1361 }
1362
1363 /* Broadcast Address */
1364 strcpy (ifInfo.ifr_name, ifName);
1365 if (ioctl(fd, SIOCGIFBRDADDR, &ifInfo) < 0)
1366 {
1367 ERR ("Error obtaining Broadcast IP address\n");
1368 close(fd);
1369 WSASetLastError(WSAEINVAL);
1370 return (SOCKET_ERROR);
1371 }
1372 else
1373 {
1374 struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_broadaddr;
1375
1376 intArray->iiBroadcastAddress.AddressIn.sin_family = AF_INET;
1377 intArray->iiBroadcastAddress.AddressIn.sin_port = ipTemp->sin_port;
1378 intArray->iiBroadcastAddress.AddressIn.sin_addr.ws_addr = ipTemp->sin_addr.S_un.S_addr;
1379 }
1380
1381 /* Subnet Mask */
1382 strcpy (ifInfo.ifr_name, ifName);
1383 if (ioctl(fd, SIOCGIFNETMASK, &ifInfo) < 0)
1384 {
1385 ERR ("Error obtaining Subnet IP address\n");
1386 close(fd);
1387 WSASetLastError(WSAEINVAL);
1388 return (SOCKET_ERROR);
1389 }
1390 else
1391 {
1392 /* Trying to avoid some compile problems across platforms.
1393 (Linux, FreeBSD, Solaris...) */
1394 #ifndef ifr_netmask
1395 #ifndef ifr_addr
1396 intArray->iiNetmask.AddressIn.sin_family = AF_INET;
1397 intArray->iiNetmask.AddressIn.sin_port = 0;
1398 intArray->iiNetmask.AddressIn.sin_addr.ws_addr = 0;
1399 ERR ("Unable to determine Netmask on your platform!\n");
1400 #else
1401 struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_addr;
1402
1403 intArray->iiNetmask.AddressIn.sin_family = AF_INET;
1404 intArray->iiNetmask.AddressIn.sin_port = ipTemp->sin_port;
1405 intArray->iiNetmask.AddressIn.sin_addr.ws_addr = ipTemp->sin_addr.S_un.S_addr;
1406 #endif
1407 #else
1408 struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_netmask;
1409
1410 intArray->iiNetmask.AddressIn.sin_family = AF_INET;
1411 intArray->iiNetmask.AddressIn.sin_port = ipTemp->sin_port;
1412 intArray->iiNetmask.AddressIn.sin_addr.ws_addr = ipTemp->sin_addr.S_un.S_addr;
1413 #endif
1414 }
1415
1416 /* Socket Status Flags */
1417 strcpy(ifInfo.ifr_name, ifName);
1418 if (ioctl(fd, SIOCGIFFLAGS, &ifInfo) < 0)
1419 {
1420 ERR ("Error obtaining status flags for socket!\n");
1421 close(fd);
1422 WSASetLastError(WSAEINVAL);
1423 return (SOCKET_ERROR);
1424 }
1425 else
1426 {
1427 /* FIXME - Is this the right flag to use? */
1428 intArray->iiFlags = ifInfo.ifr_flags;
1429 }
1430 intArray++; /* Prepare for another interface */
1431 }
1432
1433 /* Calculate the size of the array being returned */
1434 *lpcbBytesReturned = sizeof(INTERFACE_INFO) * numInt;
1435 break;
1436 }
1437
1438 default:
1439 {
1440 WARN("\tunsupported WS_IOCTL cmd (%08lx)\n", dwIoControlCode);
1441 close(fd);
1442 WSASetLastError(WSAEOPNOTSUPP);
1443 return (SOCKET_ERROR);
1444 }
1445 }
1446
1447 /* Function executed with no errors */
1448 close(fd);
1449 return (0);
1450 }
1451 else
1452 {
1453 WSASetLastError(WSAENOTSOCK);
1454 return (SOCKET_ERROR);
1455 }
1456 }
1457
1458
1459 /*
1460 Helper function for WSAIoctl - Get count of the number of interfaces
1461 by parsing /proc filesystem.
1462 */
1463 int WSAIOCTL_GetInterfaceCount(void)
1464 {
1465 FILE *procfs;
1466 char buf[512]; /* Size doesn't matter, something big */
1467 int intcnt=0;
1468
1469
1470 /* Open /proc filesystem file for network devices */
1471 procfs = fopen(PROCFS_NETDEV_FILE, "r");
1472 if (!procfs)
1473 {
1474 /* If we can't open the file, return an error */
1475 return (-1);
1476 }
1477
1478 /* Omit first two lines, they are only headers */
1479 fgets(buf, sizeof buf, procfs);
1480 fgets(buf, sizeof buf, procfs);
1481
1482 while (fgets(buf, sizeof buf, procfs))
1483 {
1484 /* Each line in the file represents a network interface */
1485 intcnt++;
1486 }
1487
1488 fclose(procfs);
1489 return(intcnt);
1490 }
1491
1492
1493 /*
1494 Helper function for WSAIoctl - Get name of device from interface number
1495 by parsing /proc filesystem.
1496 */
1497 int WSAIOCTL_GetInterfaceName(int intNumber, char *intName)
1498 {
1499 FILE *procfs;
1500 char buf[512]; /* Size doesn't matter, something big */
1501 int i;
1502
1503 /* Open /proc filesystem file for network devices */
1504 procfs = fopen(PROCFS_NETDEV_FILE, "r");
1505 if (!procfs)
1506 {
1507 /* If we can't open the file, return an error */
1508 return (-1);
1509 }
1510
1511 /* Omit first two lines, they are only headers */
1512 fgets(buf, sizeof(buf), procfs);
1513 fgets(buf, sizeof(buf), procfs);
1514
1515 for (i=0; i<intNumber; i++)
1516 {
1517 /* Skip the lines that don't interest us. */
1518 fgets(buf, sizeof(buf), procfs);
1519 }
1520 fgets(buf, sizeof(buf), procfs); /* This is the line we want */
1521
1522
1523 /* Parse out the line, grabbing only the name of the device
1524 to the intName variable
1525
1526 The Line comes in like this: (we only care about the device name)
1527 lo: 21970 377 0 0 0 0 0 0 21970 377 0 0 0 0 0 0
1528 */
1529 i=0;
1530 while (isspace(buf[i])) /* Skip initial space(s) */
1531 {
1532 i++;
1533 }
1534
1535 while (buf[i])
1536 {
1537 if (isspace(buf[i]))
1538 {
1539 break;
1540 }
1541
1542 if (buf[i] == ':') /* FIXME: Not sure if this block (alias detection) works properly */
1543 {
1544 /* This interface could be an alias... */
1545 int hold = i;
1546 char *dotname = intName;
1547 *intName++ = buf[i++];
1548
1549 while (isdigit(buf[i]))
1550 {
1551 *intName++ = buf[i++];
1552 }
1553
1554 if (buf[i] != ':')
1555 {
1556 /* ... It wasn't, so back up */
1557 i = hold;
1558 intName = dotname;
1559 }
1560
1561 if (buf[i] == '\0')
1562 {
1563 fclose(procfs);
1564 return(FALSE);
1565 }
1566
1567 i++;
1568 break;
1569 }
1570
1571 *intName++ = buf[i++];
1572 }
1573 *intName++ = '\0';
1574
1575 fclose(procfs);
1576 return(TRUE);
1577 }
1578
1579
1580 /***********************************************************************
1581 * ioctlsocket() (WSOCK32.12)
1582 */
1583 INT WINAPI WSOCK32_ioctlsocket(SOCKET s, LONG cmd, ULONG *argp)
1584 {
1585 LPWSINFO pwsi = WINSOCK_GetIData();
1586
1587 TRACE("(%08x): socket %04x, cmd %08lx, ptr %8x\n",
1588 (unsigned)pwsi, s, cmd, (unsigned) argp);
1589 if( _check_ws(pwsi, s) )
1590 {
1591 int fd = _get_sock_fd(s);
1592 long newcmd = cmd;
1593
1594 switch( cmd )
1595 {
1596 case WS_FIONREAD:
1597 newcmd=FIONREAD;
1598 break;
1599
1600 case WS_FIONBIO:
1601 newcmd=FIONBIO;
1602 if( _get_sock_mask(s) )
1603 {
1604 /* AsyncSelect()'ed sockets are always nonblocking */
1605 if (*argp) {
1606 close(fd);
1607 return 0;
1608 }
1609 SetLastError(WSAEINVAL);
1610 close(fd);
1611 return SOCKET_ERROR;
1612 }
1613 close(fd);
1614 if (*argp)
1615 _enable_event(s, 0, WS_FD_NONBLOCKING, 0);
1616 else
1617 _enable_event(s, 0, 0, WS_FD_NONBLOCKING);
1618 return 0;
1619
1620 case WS_SIOCATMARK:
1621 newcmd=SIOCATMARK;
1622 break;
1623
1624 case WS_IOW('f',125,u_long):
1625 WARN("Warning: WS1.1 shouldn't be using async I/O\n");
1626 SetLastError(WSAEINVAL);
1627 return SOCKET_ERROR;
1628
1629 default:
1630 /* Netscape tries hard to use bogus ioctl 0x667e */
1631 WARN("\tunknown WS_IOCTL cmd (%08lx)\n", cmd);
1632 }
1633 if( ioctl(fd, newcmd, (char*)argp ) == 0 )
1634 {
1635 close(fd);
1636 return 0;
1637 }
1638 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
1639 close(fd);
1640 }
1641 return SOCKET_ERROR;
1642 }
1643
1644 /***********************************************************************
1645 * ioctlsocket() (WINSOCK.12)
1646 */
1647 INT16 WINAPI WINSOCK_ioctlsocket16(SOCKET16 s, LONG cmd, ULONG *argp)
1648 {
1649 return (INT16)WSOCK32_ioctlsocket( s, cmd, argp );
1650 }
1651
1652
1653 /***********************************************************************
1654 * listen() (WSOCK32.13)
1655 */
1656 INT WINAPI WSOCK32_listen(SOCKET s, INT backlog)
1657 {
1658 LPWSINFO pwsi = WINSOCK_GetIData();
1659
1660 TRACE("(%08x): socket %04x, backlog %d\n",
1661 (unsigned)pwsi, s, backlog);
1662 if( _check_ws(pwsi, s) )
1663 {
1664 int fd = _get_sock_fd(s);
1665 if (listen(fd, backlog) == 0)
1666 {
1667 close(fd);
1668 _enable_event(s, FD_ACCEPT,
1669 WS_FD_LISTENING,
1670 WS_FD_CONNECT|WS_FD_CONNECTED);
1671 return 0;
1672 }
1673 SetLastError(wsaErrno());
1674 }
1675 else SetLastError(WSAENOTSOCK);
1676 return SOCKET_ERROR;
1677 }
1678
1679 /***********************************************************************
1680 * listen() (WINSOCK.13)
1681 */
1682 INT16 WINAPI WINSOCK_listen16(SOCKET16 s, INT16 backlog)
1683 {
1684 return (INT16)WSOCK32_listen( s, backlog );
1685 }
1686
1687
1688 /***********************************************************************
1689 * recv() (WSOCK32.16)
1690 */
1691 INT WINAPI WSOCK32_recv(SOCKET s, char *buf, INT len, INT flags)
1692 {
1693 LPWSINFO pwsi = WINSOCK_GetIData();
1694
1695 TRACE("(%08x): socket %04x, buf %8x, len %d, "
1696 "flags %d\n", (unsigned)pwsi, s, (unsigned)buf,
1697 len, flags);
1698 if( _check_ws(pwsi, s) )
1699 {
1700 int fd = _get_sock_fd(s);
1701 INT length;
1702
1703 if (_is_blocking(s))
1704 {
1705 /* block here */
1706 /* FIXME: OOB and exceptfds? */
1707 do_block(fd, 1);
1708 }
1709 if ((length = recv(fd, buf, len, flags)) >= 0)
1710 {
1711 TRACE(" -> %i bytes\n", length);
1712
1713 close(fd);
1714 _enable_event(s, FD_READ, 0, 0);
1715 return length;
1716 }
1717 SetLastError(wsaErrno());
1718 close(fd);
1719 }
1720 else SetLastError(WSAENOTSOCK);
1721 WARN(" -> ERROR\n");
1722 return SOCKET_ERROR;
1723 }
1724
1725 /***********************************************************************
1726 * recv() (WINSOCK.16)
1727 */
1728 INT16 WINAPI WINSOCK_recv16(SOCKET16 s, char *buf, INT16 len, INT16 flags)
1729 {
1730 return (INT16)WSOCK32_recv( s, buf, len, flags );
1731 }
1732
1733
1734 /***********************************************************************
1735 * recvfrom() (WSOCK32.17)
1736 */
1737 INT WINAPI WSOCK32_recvfrom(SOCKET s, char *buf, INT len, INT flags,
1738 struct sockaddr *from, INT *fromlen32)
1739 {
1740 LPWSINFO pwsi = WINSOCK_GetIData();
1741 #ifdef HAVE_IPX
1742 struct ws_sockaddr_ipx* from2 = (struct ws_sockaddr_ipx *)from;
1743 #endif
1744
1745 TRACE("(%08x): socket %04x, ptr %08x, "
1746 "len %d, flags %d\n", (unsigned)pwsi, s, (unsigned)buf,
1747 len, flags);
1748 #if DEBUG_SOCKADDR
1749 if( from ) dump_sockaddr(from);
1750 else DPRINTF("from = NULL\n");
1751 #endif
1752
1753 if( _check_ws(pwsi, s) )
1754 {
1755 int fd = _get_sock_fd(s);
1756 int length;
1757
1758 if (_is_blocking(s))
1759 {
1760 /* block here */
1761 /* FIXME: OOB and exceptfds */
1762 do_block(fd, 1);
1763 }
1764 if ((length = recvfrom(fd, buf, len, flags, from, fromlen32)) >= 0)
1765 {
1766 TRACE(" -> %i bytes\n", length);
1767
1768 #ifdef HAVE_IPX
1769 if (from && ((struct sockaddr_ipx *)from)->sipx_family == AF_IPX) {
1770 from = (struct sockaddr *)
1771 malloc(fromlen32 ? *fromlen32 : sizeof(*from2));
1772 memcpy(from, from2, fromlen32 ? *fromlen32 : sizeof(*from2));
1773 from2->sipx_family = WS_AF_IPX;
1774 from2->sipx_network = ((struct sockaddr_ipx *)from)->sipx_network;
1775 from2->sipx_port = ((struct sockaddr_ipx *)from)->sipx_port;
1776 memcpy(from2->sipx_node,
1777 ((struct sockaddr_ipx *)from)->sipx_node, IPX_NODE_LEN);
1778 free(from);
1779 }
1780 #endif
1781 close(fd);
1782 _enable_event(s, FD_READ, 0, 0);
1783 return (INT16)length;
1784 }
1785 SetLastError(wsaErrno());
1786 close(fd);
1787 }
1788 else SetLastError(WSAENOTSOCK);
1789 WARN(" -> ERROR\n");
1790 #ifdef HAVE_IPX
1791 if (from && ((struct sockaddr_ipx *)from)->sipx_family == AF_IPX) {
1792 from = (struct sockaddr *)
1793 malloc(fromlen32 ? *fromlen32 : sizeof(*from2));
1794 memcpy(from, from2, fromlen32 ? *fromlen32 : sizeof(*from2));
1795 from2->sipx_family = WS_AF_IPX;
1796 from2->sipx_network = ((struct sockaddr_ipx *)from)->sipx_network;
1797 from2->sipx_port = ((struct sockaddr_ipx *)from)->sipx_port;
1798 memcpy(from2->sipx_node,
1799 ((struct sockaddr_ipx *)from)->sipx_node, IPX_NODE_LEN);
1800 free(from);
1801 }
1802 #endif
1803 return SOCKET_ERROR;
1804 }
1805
1806 /***********************************************************************
1807 * recvfrom() (WINSOCK.17)
1808 */
1809 INT16 WINAPI WINSOCK_recvfrom16(SOCKET16 s, char *buf, INT16 len, INT16 flags,
1810 struct sockaddr *from, INT16 *fromlen16)
1811 {
1812 INT fromlen32;
1813 INT *p = &fromlen32;
1814 INT retVal;
1815
1816 if( fromlen16 ) fromlen32 = *fromlen16; else p = NULL;
1817 retVal = WSOCK32_recvfrom( s, buf, len, flags, from, p );
1818 if( fromlen16 ) *fromlen16 = fromlen32;
1819 return (INT16)retVal;
1820 }
1821
1822 /***********************************************************************
1823 * select() (WINSOCK.18)(WSOCK32.18)
1824 */
1825 static INT __ws_select( BOOL b32, void *ws_readfds, void *ws_writefds, void *ws_exceptfds,
1826 struct timeval *timeout )
1827 {
1828 LPWSINFO pwsi = WINSOCK_GetIData();
1829
1830 TRACE("(%08x): read %8x, write %8x, excp %8x\n",
1831 (unsigned) pwsi, (unsigned) ws_readfds, (unsigned) ws_writefds, (unsigned) ws_exceptfds);
1832
1833 if( pwsi )
1834 {
1835 int highfd = 0;
1836 fd_set readfds, writefds, exceptfds;
1837 fd_set *p_read, *p_write, *p_except;
1838 int readfd[FD_SETSIZE], writefd[FD_SETSIZE], exceptfd[FD_SETSIZE];
1839
1840 p_read = fd_set_import(&readfds, pwsi, ws_readfds, &highfd, readfd, b32);
1841 p_write = fd_set_import(&writefds, pwsi, ws_writefds, &highfd, writefd, b32);
1842 p_except = fd_set_import(&exceptfds, pwsi, ws_exceptfds, &highfd, exceptfd, b32);
1843
1844 if( (highfd = select(highfd + 1, p_read, p_write, p_except, timeout)) > 0 )
1845 {
1846 fd_set_export(pwsi, &readfds, p_except, ws_readfds, readfd, b32);
1847 fd_set_export(pwsi, &writefds, p_except, ws_writefds, writefd, b32);
1848
1849 if (p_except && ws_exceptfds)
1850 {
1851 #define wsfds16 ((ws_fd_set16*)ws_exceptfds)
1852 #define wsfds32 ((ws_fd_set32*)ws_exceptfds)
1853 int i, j, count = (b32) ? wsfds32->fd_count : wsfds16->fd_count;
1854
1855 for (i = j = 0; i < count; i++)
1856 {
1857 int fd = exceptfd[i];
1858 if( fd >= 0 && FD_ISSET(fd, &exceptfds) )
1859 {
1860 if( b32 )
1861 wsfds32->fd_array[j++] = wsfds32->fd_array[i];
1862 else
1863 wsfds16->fd_array[j++] = wsfds16->fd_array[i];
1864 }
1865 if( fd >= 0 ) close(fd);
1866 exceptfd[i] = -1;
1867 }
1868 if( b32 )
1869 wsfds32->fd_count = j;
1870 else
1871 wsfds16->fd_count = j;
1872 #undef wsfds32
1873 #undef wsfds16
1874 }
1875 return highfd;
1876 }
1877 fd_set_unimport(ws_readfds, readfd, b32);
1878 fd_set_unimport(ws_writefds, writefd, b32);
1879 fd_set_unimport(ws_exceptfds, exceptfd, b32);
1880 if( ws_readfds ) ((ws_fd_set32*)ws_readfds)->fd_count = 0;
1881 if( ws_writefds ) ((ws_fd_set32*)ws_writefds)->fd_count = 0;
1882 if( ws_exceptfds ) ((ws_fd_set32*)ws_exceptfds)->fd_count = 0;
1883
1884 if( highfd == 0 ) return 0;
1885 SetLastError(wsaErrno());
1886 }
1887 return SOCKET_ERROR;
1888 }
1889
1890 INT16 WINAPI WINSOCK_select16(INT16 nfds, ws_fd_set16 *ws_readfds,
1891 ws_fd_set16 *ws_writefds, ws_fd_set16 *ws_exceptfds,
1892 struct timeval *timeout)
1893 {
1894 return (INT16)__ws_select( FALSE, ws_readfds, ws_writefds, ws_exceptfds, timeout );
1895 }
1896
1897 INT WINAPI WSOCK32_select(INT nfds, ws_fd_set32 *ws_readfds,
1898 ws_fd_set32 *ws_writefds, ws_fd_set32 *ws_exceptfds,
1899 struct timeval *timeout)
1900 {
1901 /* struct timeval is the same for both 32- and 16-bit code */
1902 return (INT)__ws_select( TRUE, ws_readfds, ws_writefds, ws_exceptfds, timeout );
1903 }
1904
1905
1906 /***********************************************************************
1907 * send() (WSOCK32.19)
1908 */
1909 INT WINAPI WSOCK32_send(SOCKET s, char *buf, INT len, INT flags)
1910 {
1911 LPWSINFO pwsi = WINSOCK_GetIData();
1912
1913 TRACE("(%08x): socket %04x, ptr %08x, length %d, flags %d\n",
1914 (unsigned)pwsi, s, (unsigned) buf, len, flags);
1915 if( _check_ws(pwsi, s) )
1916 {
1917 int fd = _get_sock_fd(s);
1918 int length;
1919
1920 if (_is_blocking(s))
1921 {
1922 /* block here */
1923 /* FIXME: exceptfds */
1924 do_block(fd, 2);
1925 }
1926 if ((length = send(fd, buf, len, flags)) < 0 )
1927 {
1928 SetLastError(wsaErrno());
1929 if( GetLastError() == WSAEWOULDBLOCK )
1930 _enable_event(s, FD_WRITE, 0, 0);
1931 }
1932 else
1933 {
1934 close(fd);
1935 return (INT16)length;
1936 }
1937 close(fd);
1938 }
1939 else SetLastError(WSAENOTSOCK);
1940 return SOCKET_ERROR;
1941 }
1942
1943 /***********************************************************************
1944 * send() (WINSOCK.19)
1945 */
1946 INT16 WINAPI WINSOCK_send16(SOCKET16 s, char *buf, INT16 len, INT16 flags)
1947 {
1948 return WSOCK32_send( s, buf, len, flags );
1949 }
1950
1951 /***********************************************************************
1952 * sendto() (WSOCK32.20)
1953 */
1954 INT WINAPI WSOCK32_sendto(SOCKET s, char *buf, INT len, INT flags,
1955 struct sockaddr *to, INT tolen)
1956 {
1957 LPWSINFO pwsi = WINSOCK_GetIData();
1958 #ifdef HAVE_IPX
1959 struct ws_sockaddr_ipx* to2 = (struct ws_sockaddr_ipx *)to;
1960 #endif
1961
1962 TRACE("(%08x): socket %04x, ptr %08x, length %d, flags %d\n",
1963 (unsigned)pwsi, s, (unsigned) buf, len, flags);
1964 if( _check_ws(pwsi, s) )
1965 {
1966 int fd = _get_sock_fd(s);
1967 INT length;
1968
1969 if (to && ((struct ws_sockaddr_ipx *)to)->sipx_family == WS_AF_PUP)
1970 ((struct ws_sockaddr_ipx *)to)->sipx_family = AF_UNSPEC;
1971 #ifdef HAVE_IPX
1972 else if (to &&
1973 ((struct ws_sockaddr_ipx *)to)->sipx_family == WS_AF_IPX)
1974 {
1975 to = (struct sockaddr *) malloc(sizeof(struct sockaddr_ipx));
1976 memset(to, '\0', sizeof(struct sockaddr_ipx));
1977 ((struct sockaddr_ipx *)to)->sipx_family = AF_IPX;
1978 ((struct sockaddr_ipx *)to)->sipx_port = to2->sipx_port;
1979 ((struct sockaddr_ipx *)to)->sipx_network = to2->sipx_network;
1980 memcpy(((struct sockaddr_ipx *)to)->sipx_node,
1981 to2->sipx_node, IPX_NODE_LEN);
1982 tolen = sizeof(struct sockaddr_ipx);
1983 }
1984 #endif
1985 if (_is_blocking(s))
1986 {
1987 /* block here */
1988 /* FIXME: exceptfds */
1989 do_block(fd, 2);
1990 }
1991 if ((length = sendto(fd, buf, len, flags, to, tolen)) < 0 )
1992 {
1993 SetLastError(wsaErrno());
1994 if( GetLastError() == WSAEWOULDBLOCK )
1995 _enable_event(s, FD_WRITE, 0, 0);
1996 }
1997 else {
1998 #ifdef HAVE_IPX
1999 if (to && ((struct sockaddr_ipx *)to)->sipx_family == AF_IPX) {
2000 free(to);
2001 }
2002 #endif
2003 close(fd);
2004 return length;
2005 }
2006 close(fd);
2007 }
2008 else SetLastError(WSAENOTSOCK);
2009 #ifdef HAVE_IPX
2010 if (to && ((struct sockaddr_ipx *)to)->sipx_family == AF_IPX) {
2011 free(to);
2012 }
2013 #endif
2014 return SOCKET_ERROR;
2015 }
2016
2017 /***********************************************************************
2018 * sendto() (WINSOCK.20)
2019 */
2020 INT16 WINAPI WINSOCK_sendto16(SOCKET16 s, char *buf, INT16 len, INT16 flags,
2021 struct sockaddr *to, INT16 tolen)
2022 {
2023 return (INT16)WSOCK32_sendto( s, buf, len, flags, to, tolen );
2024 }
2025
2026 /***********************************************************************
2027 * setsockopt() (WSOCK32.21)
2028 */
2029 INT WINAPI WSOCK32_setsockopt(SOCKET16 s, INT level, INT optname,
2030 char *optval, INT optlen)
2031 {
2032 LPWSINFO pwsi = WINSOCK_GetIData();
2033
2034 TRACE("(%08x): socket %04x, lev %d, opt %d, ptr %08x, len %d\n",
2035 (unsigned)pwsi, s, level, optname, (int) optval, optlen);
2036 if( _check_ws(pwsi, s) )
2037 {
2038 struct linger linger;
2039 int fd = _get_sock_fd(s);
2040 int woptval;
2041
2042 convert_sockopt(&level, &optname);
2043 if(optname == WS_SO_DONTLINGER) {
2044 linger.l_onoff = *((int*)optval) ? 0: 1;
2045 linger.l_linger = 0;
2046 optname=SO_LINGER;
2047 optval = (char*)&linger;
2048 optlen = sizeof(struct linger);
2049 }else{
2050 if (optname == SO_LINGER && optval) {
2051 /* yes, uses unsigned short in both win16/win32 */
2052 linger.l_onoff = ((UINT16*)optval)[0];
2053 linger.l_linger = ((UINT16*)optval)[1];
2054 /* FIXME: what is documented behavior if SO_LINGER optval
2055 is null?? */
2056 optval = (char*)&linger;
2057 optlen = sizeof(struct linger);
2058 } else if (optlen < sizeof(int)){
2059 woptval= *((INT16 *) optval);
2060 optval= (char*) &woptval;
2061 optlen=sizeof(int);
2062 }
2063 }
2064 if (setsockopt(fd, level, optname, optval, optlen) == 0)
2065 {
2066 close(fd);
2067 return 0;
2068 }
2069 SetLastError(wsaErrno());
2070 close(fd);
2071 }
2072 else SetLastError(WSAENOTSOCK);
2073 return SOCKET_ERROR;
2074 }
2075
2076 /***********************************************************************
2077 * setsockopt() (WINSOCK.21)
2078 */
2079 INT16 WINAPI WINSOCK_setsockopt16(SOCKET16 s, INT16 level, INT16 optname,
2080 char *optval, INT16 optlen)
2081 {
2082 if( !optval ) return SOCKET_ERROR;
2083 return (INT16)WSOCK32_setsockopt( s, (UINT16)level, optname, optval, optlen );
2084 }
2085
2086
2087 /***********************************************************************
2088 * shutdown() (WSOCK32.22)
2089 */
2090 INT WINAPI WSOCK32_shutdown(SOCKET s, INT how)
2091 {
2092 LPWSINFO pwsi = WINSOCK_GetIData();
2093
2094 TRACE("(%08x): socket %04x, how %i\n",
2095 (unsigned)pwsi, s, how );
2096 if( _check_ws(pwsi, s) )
2097 {
2098 int fd = _get_sock_fd(s);
2099 switch( how )
2100 {
2101 case 0: /* drop receives */
2102 _enable_event(s, 0, 0, WS_FD_READ);
2103 #ifdef SHUT_RD
2104 how = SHUT_RD;
2105 #endif
2106 break;
2107
2108 case 1: /* drop sends */
2109 _enable_event(s, 0, 0, WS_FD_WRITE);
2110 #ifdef SHUT_WR
2111 how = SHUT_WR;
2112 #endif
2113 break;
2114
2115 case 2: /* drop all */
2116 #ifdef SHUT_RDWR
2117 how = SHUT_RDWR;
2118 #endif
2119 default:
2120 WSAAsyncSelect( s, 0, 0, 0 );
2121 break;
2122 }
2123
2124 if (shutdown(fd, how) == 0)
2125 {
2126 if( how > 1 )
2127 {
2128 _enable_event(s, 0, 0, WS_FD_CONNECTED|WS_FD_LISTENING);
2129 }
2130 close(fd);
2131 return 0;
2132 }
2133 SetLastError(wsaErrno());
2134 close(fd);
2135 }
2136 else SetLastError(WSAENOTSOCK);
2137 return SOCKET_ERROR;
2138 }
2139
2140 /***********************************************************************
2141 * shutdown() (WINSOCK.22)
2142 */
2143 INT16 WINAPI WINSOCK_shutdown16(SOCKET16 s, INT16 how)
2144 {
2145 return (INT16)WSOCK32_shutdown( s, how );
2146 }
2147
2148
2149 /***********************************************************************
2150 * socket() (WSOCK32.23)
2151 */
2152 SOCKET WINAPI WSOCK32_socket(INT af, INT type, INT protocol)
2153 {
2154 LPWSINFO pwsi = WINSOCK_GetIData();
2155 struct create_socket_request *req = get_req_buffer();
2156
2157 TRACE("(%08x): af=%d type=%d protocol=%d\n",
2158 (unsigned)pwsi, af, type, protocol);
2159
2160 if( pwsi )
2161 {
2162 /* check the socket family */
2163 switch(af)
2164 {
2165 #ifdef HAVE_IPX
2166 case WS_AF_IPX: af = AF_IPX;
2167 #endif
2168 case AF_INET:
2169 case AF_UNSPEC: break;
2170 default: SetLastError(WSAEAFNOSUPPORT);
2171 return INVALID_SOCKET;
2172 }
2173
2174 /* check the socket type */
2175 switch(type)
2176 {
2177 case SOCK_STREAM:
2178 case SOCK_DGRAM:
2179 case SOCK_RAW: break;
2180 default: SetLastError(WSAESOCKTNOSUPPORT);
2181 return INVALID_SOCKET;
2182 }
2183
2184 /* check the protocol type */
2185 if ( protocol < 0 ) /* don't support negative values */
2186 { SetLastError(WSAEPROTONOSUPPORT); return INVALID_SOCKET; }
2187
2188 if ( af == AF_UNSPEC) /* did they not specify the address family? */
2189 switch(protocol)
2190 {
2191 case IPPROTO_TCP:
2192 if (type == SOCK_STREAM) { af = AF_INET; break; }
2193 case IPPROTO_UDP:
2194 if (type == SOCK_DGRAM) { af = AF_INET; break; }
2195 default: SetLastError(WSAEPROTOTYPE); return INVALID_SOCKET;
2196 }
2197
2198 req->family = af;
2199 req->type = type;
2200 req->protocol = protocol;
2201 req->access = GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE;
2202 req->inherit = TRUE;
2203 sock_server_call( REQ_CREATE_SOCKET );
2204 if ( req->handle >= 0)
2205 {
2206 TRACE("\tcreated %04x\n", req->handle);
2207
2208 return req->handle;
2209 }
2210
2211 if (GetLastError() == WSAEACCES) /* raw socket denied */
2212 {
2213 if (type == SOCK_RAW)
2214 MESSAGE("WARNING: Trying to create a socket of type SOCK_RAW, will fail unless running as root\n");
2215 else
2216 MESSAGE("WS_SOCKET: not enough privileges to create socket, try running as root\n");
2217 SetLastError(WSAESOCKTNOSUPPORT);
2218 }
2219 }
2220
2221 WARN("\t\tfailed!\n");
2222 return INVALID_SOCKET;
2223 }
2224
2225 /***********************************************************************
2226 * socket() (WINSOCK.23)
2227 */
2228 SOCKET16 WINAPI WINSOCK_socket16(INT16 af, INT16 type, INT16 protocol)
2229 {
2230 return (SOCKET16)WSOCK32_socket( af, type, protocol );
2231 }
2232
2233
2234 /* ----------------------------------- DNS services
2235 *
2236 * IMPORTANT: 16-bit API structures have SEGPTR pointers inside them.
2237 * Also, we have to use wsock32 stubs to convert structures and
2238 * error codes from Unix to WSA, hence there is no direct mapping in
2239 * the relay32/wsock32.spec.
2240 */
2241
2242 static char* NULL_STRING = "NULL";
2243
2244 /***********************************************************************
2245 * gethostbyaddr() (WINSOCK.51)(WSOCK32.51)
2246 */
2247 static WIN_hostent* __ws_gethostbyaddr(const char *addr, int len, int type, int dup_flag)
2248 {
2249 LPWSINFO pwsi = WINSOCK_GetIData();
2250
2251 if( pwsi )
2252 {
2253 struct hostent* host;
2254 if( (host = gethostbyaddr(addr, len, type)) != NULL )
2255 if( WS_dup_he(pwsi, host, dup_flag) )
2256 return (WIN_hostent*)(pwsi->he);
2257 else
2258 SetLastError(WSAENOBUFS);
2259 else
2260 SetLastError((h_errno < 0) ? wsaErrno() : wsaHerrno());
2261 }
2262 return NULL;
2263 }
2264
2265 SEGPTR WINAPI WINSOCK_gethostbyaddr16(const char *addr, INT16 len, INT16 type)
2266 {
2267 WIN_hostent* retval;
2268 TRACE("ptr %08x, len %d, type %d\n",
2269 (unsigned) addr, len, type);
2270 retval = __ws_gethostbyaddr( addr, len, type, WS_DUP_SEGPTR );
2271 return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
2272 }
2273
2274 WIN_hostent* WINAPI WSOCK32_gethostbyaddr(const char *addr, INT len,
2275 INT type)
2276 {
2277 TRACE("ptr %08x, len %d, type %d\n",
2278 (unsigned) addr, len, type);
2279 return __ws_gethostbyaddr(addr, len, type, WS_DUP_LINEAR);
2280 }
2281
2282 /***********************************************************************
2283 * gethostbyname() (WINSOCK.52)(WSOCK32.52)
2284 */
2285 static WIN_hostent * __ws_gethostbyname(const char *name, int dup_flag)
2286 {
2287 LPWSINFO pwsi = WINSOCK_GetIData();
2288
2289 if( pwsi )
2290 {
2291 struct hostent* host;
2292 if( (host = gethostbyname(name)) != NULL )
2293 if( WS_dup_he(pwsi, host, dup_flag) )
2294 return (WIN_hostent*)(pwsi->he);
2295 else SetLastError(WSAENOBUFS);
2296 else SetLastError((h_errno < 0) ? wsaErrno() : wsaHerrno());
2297 }
2298 return NULL;
2299 }
2300
2301 SEGPTR WINAPI WINSOCK_gethostbyname16(const char *name)
2302 {
2303 WIN_hostent* retval;
2304 TRACE("%s\n", (name)?name:NULL_STRING);
2305 retval = __ws_gethostbyname( name, WS_DUP_SEGPTR );
2306 return (retval)? SEGPTR_GET(retval) : ((SEGPTR)NULL) ;
2307 }
2308
2309 WIN_hostent* WINAPI WSOCK32_gethostbyname(const char* name)
2310 {
2311 TRACE("%s\n", (name)?name:NULL_STRING);
2312 return __ws_gethostbyname( name, WS_DUP_LINEAR );
2313 }
2314
2315
2316 /***********************************************************************
2317 * getprotobyname() (WINSOCK.53)(WSOCK32.53)
2318 */
2319 static WIN_protoent* __ws_getprotobyname(const char *name, int dup_flag)
2320 {
2321 LPWSINFO pwsi = WINSOCK_GetIData();
2322
2323 if( pwsi )
2324 {
2325 struct protoent* proto;
2326 if( (proto = getprotobyname(name)) != NULL )
2327 if( WS_dup_pe(pwsi, proto, dup_flag) )
2328 return (WIN_protoent*)(pwsi->pe);
2329 else SetLastError(WSAENOBUFS);
2330 else {
2331 MESSAGE("protocol %s not found; You might want to add "
2332 "this to /etc/protocols\n", debugstr_a(name) );
2333 SetLastError(WSANO_DATA);
2334 }
2335 } else SetLastError(WSANOTINITIALISED);
2336 return NULL;
2337 }
2338
2339 SEGPTR WINAPI WINSOCK_getprotobyname16(const char *name)
2340 {
2341 WIN_protoent* retval;
2342 TRACE("%s\n", (name)?name:NULL_STRING);
2343 retval = __ws_getprotobyname(name, WS_DUP_SEGPTR);
2344 return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
2345 }
2346
2347 WIN_protoent* WINAPI WSOCK32_getprotobyname(const char* name)
2348 {
2349 TRACE("%s\n", (name)?name:NULL_STRING);
2350 return __ws_getprotobyname(name, WS_DUP_LINEAR);
2351 }
2352
2353
2354 /***********************************************************************
2355 * getprotobynumber() (WINSOCK.54)(WSOCK32.54)
2356 */
2357 static WIN_protoent* __ws_getprotobynumber(int number, int dup_flag)
2358 {
2359 LPWSINFO pwsi = WINSOCK_GetIData();
2360
2361 if( pwsi )
2362 {
2363 struct protoent* proto;
2364 if( (proto = getprotobynumber(number)) != NULL )
2365 if( WS_dup_pe(pwsi, proto, dup_flag) )
2366 return (WIN_protoent*)(pwsi->pe);
2367 else SetLastError(WSAENOBUFS);
2368 else {
2369 MESSAGE("protocol number %d not found; You might want to add "
2370 "this to /etc/protocols\n", number );
2371 SetLastError(WSANO_DATA);
2372 }
2373 } else SetLastError(WSANOTINITIALISED);
2374 return NULL;
2375 }
2376
2377 SEGPTR WINAPI WINSOCK_getprotobynumber16(INT16 number)
2378 {
2379 WIN_protoent* retval;
2380 TRACE("%i\n", number);
2381 retval = __ws_getprotobynumber(number, WS_DUP_SEGPTR);
2382 return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
2383 }
2384
2385 WIN_protoent* WINAPI WSOCK32_getprotobynumber(INT number)
2386 {
2387 TRACE("%i\n", number);
2388 return __ws_getprotobynumber(number, WS_DUP_LINEAR);
2389 }
2390
2391
2392 /***********************************************************************
2393 * getservbyname() (WINSOCK.55)(WSOCK32.55)
2394 */
2395 static WIN_servent* __ws_getservbyname(const char *name, const char *proto, int dup_flag)
2396 {
2397 LPWSINFO pwsi = WINSOCK_GetIData();
2398
2399 if( pwsi )
2400 {
2401 struct servent* serv;
2402 int i = wsi_strtolo( pwsi, name, proto );
2403
2404 if( i ) {
2405 serv = getservbyname(pwsi->buffer,
2406 proto ? (pwsi->buffer + i) : NULL);
2407 if( serv != NULL )
2408 if( WS_dup_se(pwsi, serv, dup_flag) )
2409 return (WIN_servent*)(pwsi->se);
2410 else SetLastError(WSAENOBUFS);
2411 else {
2412 MESSAGE("service %s protocol %s not found; You might want to add "
2413 "this to /etc/services\n", debugstr_a(pwsi->buffer),
2414 proto ? debugstr_a(pwsi->buffer+i):"*");
2415 SetLastError(WSANO_DATA);
2416 }
2417 }
2418 else SetLastError(WSAENOBUFS);
2419 } else SetLastError(WSANOTINITIALISED);
2420 return NULL;
2421 }
2422
2423 SEGPTR WINAPI WINSOCK_getservbyname16(const char *name, const char *proto)
2424 {
2425 WIN_servent* retval;
2426 TRACE("'%s', '%s'\n",
2427 (name)?name:NULL_STRING, (proto)?proto:NULL_STRING);
2428 retval = __ws_getservbyname(name, proto, WS_DUP_SEGPTR);
2429 return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
2430 }
2431
2432 WIN_servent* WINAPI WSOCK32_getservbyname(const char *name, const char *proto)
2433 {
2434 TRACE("'%s', '%s'\n",
2435 (name)?name:NULL_STRING, (proto)?proto:NULL_STRING);
2436 return __ws_getservbyname(name, proto, WS_DUP_LINEAR);
2437 }
2438
2439
2440 /***********************************************************************
2441 * getservbyport() (WINSOCK.56)(WSOCK32.56)
2442 */
2443 static WIN_servent* __ws_getservbyport(int port, const char* proto, int dup_flag)
2444 {
2445 LPWSINFO pwsi = WINSOCK_GetIData();
2446
2447 if( pwsi )
2448 {
2449 struct servent* serv;
2450 if (!proto || wsi_strtolo( pwsi, proto, NULL )) {
2451 if( (serv = getservbyport(port, (proto) ? pwsi->buffer : NULL)) != NULL ) {
2452 if( WS_dup_se(pwsi, serv, dup_flag) )
2453 return (WIN_servent*)(pwsi->se);
2454 else SetLastError(WSAENOBUFS);
2455 }
2456 else {
2457 MESSAGE("service on port %lu protocol %s not found; You might want to add "
2458 "this to /etc/services\n", (unsigned long)ntohl(port),
2459 proto ? debugstr_a(pwsi->buffer) : "*");
2460 SetLastError(WSANO_DATA);
2461 }
2462 }
2463 else SetLastError(WSAENOBUFS);
2464 } else SetLastError(WSANOTINITIALISED);
2465 return NULL;
2466 }
2467
2468 SEGPTR WINAPI WINSOCK_getservbyport16(INT16 port, const char *proto)
2469 {
2470 WIN_servent* retval;
2471 TRACE("%d (i.e. port %d), '%s'\n",
2472 (int)port, (int)ntohl(port), (proto)?proto:NULL_STRING);
2473 retval = __ws_getservbyport(port, proto, WS_DUP_SEGPTR);
2474 return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
2475 }
2476
2477 WIN_servent* WINAPI WSOCK32_getservbyport(INT port, const char *proto)
2478 {
2479 TRACE("%d (i.e. port %d), '%s'\n",
2480 (int)port, (int)ntohl(port), (proto)?proto:NULL_STRING);
2481 return __ws_getservbyport(port, proto, WS_DUP_LINEAR);
2482 }
2483
2484
2485 /***********************************************************************
2486 * gethostname() (WSOCK32.57)
2487 */
2488 INT WINAPI WSOCK32_gethostname(char *name, INT namelen)
2489 {
2490 LPWSINFO pwsi = WINSOCK_GetIData();
2491
2492 TRACE("(%08x): name %s, len %d\n",
2493 (unsigned)pwsi, (name)?name:NULL_STRING, namelen);
2494 if( pwsi )
2495 {
2496 if (gethostname(name, namelen) == 0) return 0;
2497 SetLastError((errno == EINVAL) ? WSAEFAULT : wsaErrno());
2498 }
2499 return SOCKET_ERROR;
2500 }
2501
2502 /***********************************************************************
2503 * gethostname() (WINSOCK.57)
2504 */
2505 INT16 WINAPI WINSOCK_gethostname16(char *name, INT16 namelen)
2506 {
2507 return (INT16)WSOCK32_gethostname(name, namelen);
2508 }
2509
2510
2511 /* ------------------------------------- Windows sockets extensions -- *
2512 * *
2513 * ------------------------------------------------------------------- */
2514
2515 /***********************************************************************
2516 * WSAEnumNetworkEvents
2517 */
2518 int WINAPI WSAEnumNetworkEvents(SOCKET s, WSAEVENT hEvent, LPWSANETWORKEVENTS lpEvent)
2519 {
2520 LPWSINFO pwsi = WINSOCK_GetIData();
2521 struct get_socket_event_request *req = get_req_buffer();
2522
2523 TRACE("(%08x): %08x, hEvent %08x, lpEvent %08x\n",
2524 (unsigned)pwsi, s, hEvent, (unsigned)lpEvent );
2525 if( _check_ws(pwsi, s) )
2526 {
2527 req->handle = s;
2528 req->service = TRUE;
2529 req->s_event = 0;
2530 req->c_event = hEvent;
2531 sock_server_call( REQ_GET_SOCKET_EVENT );
2532 lpEvent->lNetworkEvents = req->pmask;
2533 memcpy(lpEvent->iErrorCode, req->errors, sizeof(lpEvent->iErrorCode));
2534 return 0;
2535 }
2536 else SetLastError(WSAEINVAL);
2537 return SOCKET_ERROR;
2538 }
2539
2540 /***********************************************************************
2541 * WSAEventSelect
2542 */
2543 int WINAPI WSAEventSelect(SOCKET s, WSAEVENT hEvent, LONG lEvent)
2544 {
2545 LPWSINFO pwsi = WINSOCK_GetIData();
2546 struct set_socket_event_request *req = get_req_buffer();
2547
2548 TRACE("(%08x): %08x, hEvent %08x, event %08x\n",
2549 (unsigned)pwsi, s, hEvent, (unsigned)lEvent );
2550 if( _check_ws(pwsi, s) )
2551 {
2552 req->handle = s;
2553 req->mask = lEvent;
2554 req->event = hEvent;
2555 sock_server_call( REQ_SET_SOCKET_EVENT );
2556 return 0;
2557 }
2558 else SetLastError(WSAEINVAL);
2559 return SOCKET_ERROR;
2560 }
2561
2562 /***********************************************************************
2563 * WSAAsyncSelect() (WINSOCK.101)(WSOCK32.101)
2564 */
2565
2566 VOID CALLBACK WINSOCK_DoAsyncEvent( ULONG_PTR ptr )
2567 {
2568 ws_select_info *info = (ws_select_info*)ptr;
2569 LPWSINFO pwsi = info->pwsi;
2570 struct get_socket_event_request *req = get_req_buffer();
2571 unsigned int i, pmask, orphan = FALSE;
2572
2573 TRACE("socket %08x, event %08x\n", info->sock, info->event);
2574 SetLastError(0);
2575 req->handle = info->sock;
2576 req->service = TRUE;
2577 req->s_event = info->event; /* <== avoid race conditions */
2578 req->c_event = info->event;
2579 sock_server_call( REQ_GET_SOCKET_EVENT );
2580 if ( (GetLastError() == WSAENOTSOCK) || (GetLastError() == WSAEINVAL) )
2581 {
2582 /* orphaned event (socket closed or something) */
2583 pmask = WS_FD_SERVEVENT;
2584 orphan = TRUE;
2585 } else
2586 pmask = req->pmask;
2587 /* check for accepted sockets that needs to inherit WSAAsyncSelect */
2588 if (pmask & WS_FD_SERVEVENT) {
2589 int q;
2590 for (q=0; q<WS_ACCEPT_QUEUE; q++)
2591 if (pwsi->accept_old[q] == info->sock) {
2592 /* there's only one service thread per pwsi, no lock necessary */
2593 HANDLE as = pwsi->accept_new[q];
2594 if (as) {
2595 pwsi->accept_new[q] = 0;
2596 pwsi->accept_old[q] = 0;
2597 WSAAsyncSelect(as, info->hWnd, info->uMsg, info->lEvent);
2598 }
2599 }
2600 pmask &= ~WS_FD_SERVEVENT;
2601 }
2602 /* dispatch network events */
2603 for (i=0; i<FD_MAX_EVENTS; i++)
2604 if (pmask & (1<<i)) {
2605 TRACE("post: event bit %d, error %d\n", i, req->errors[i]);
2606 PostMessageA(info->hWnd, info->uMsg, info->sock,
2607 WSAMAKESELECTREPLY(1<<i, req->errors[i]));
2608 }
2609 /* cleanup */
2610 if (orphan)
2611 {
2612 TRACE("orphaned event, self-destructing\n");
2613 /* SERVICE_Delete closes the event object */
2614 SERVICE_Delete( info->service );
2615 WS_FREE(info);
2616 }
2617 }
2618
2619 INT WINAPI WSAAsyncSelect(SOCKET s, HWND hWnd, UINT uMsg, LONG lEvent)
2620 {
2621 LPWSINFO pwsi = WINSOCK_GetIData();
2622
2623 TRACE("(%08x): %04x, hWnd %04x, uMsg %08x, event %08x\n",
2624 (unsigned)pwsi, (SOCKET16)s, (HWND16)hWnd, uMsg, (unsigned)lEvent );
2625 if( _check_ws(pwsi, s) )
2626 {
2627 if( lEvent )
2628 {
2629 ws_select_info *info = (ws_select_info*)WS_ALLOC(sizeof(ws_select_info));
2630 if( info )
2631 {
2632 HANDLE hObj = CreateEventA( NULL, TRUE, FALSE, NULL );
2633 INT err;
2634
2635 info->sock = s;
2636 info->event = hObj;
2637 info->hWnd = hWnd;
2638 info->uMsg = uMsg;
2639 info->lEvent = lEvent;
2640 info->pwsi = pwsi;
2641 info->service = SERVICE_AddObject( hObj, WINSOCK_DoAsyncEvent, (ULONG_PTR)info );
2642
2643 err = WSAEventSelect( s, hObj, lEvent | WS_FD_SERVEVENT );
2644 if (err) {
2645 /* SERVICE_Delete closes the event object */
2646 SERVICE_Delete( info->service );
2647 WS_FREE(info);
2648 return err;
2649 }
2650
2651 return 0; /* success */
2652 }
2653 else SetLastError(WSAENOBUFS);
2654 }
2655 else
2656 {
2657 WSAEventSelect(s, 0, 0);
2658 return 0;
2659 }
2660 }
2661 else SetLastError(WSAEINVAL);
2662 return SOCKET_ERROR;
2663 }
2664
2665 INT16 WINAPI WSAAsyncSelect16(SOCKET16 s, HWND16 hWnd, UINT16 wMsg, LONG lEvent)
2666 {
2667 return (INT16)WSAAsyncSelect( s, hWnd, wMsg, lEvent );
2668 }
2669
2670 /***********************************************************************
2671 * WSARecvEx() (WSOCK32.1107)
2672 *
2673 * WSARecvEx is a Microsoft specific extension to winsock that is identical to recv
2674 * except that has an in/out argument call flags that has the value MSG_PARTIAL ored
2675 * into the flags parameter when a partial packet is read. This only applies to
2676 * sockets using the datagram protocol. This method does not seem to be implemented
2677 * correctly by microsoft as the winsock implementation does not set the MSG_PARTIAL
2678 * flag when a fragmented packet arrives.
2679 */
2680 INT WINAPI WSARecvEx(SOCKET s, char *buf, INT len, INT *flags) {
2681 FIXME("(WSARecvEx) partial packet return value not set \n");
2682
2683 return WSOCK32_recv(s, buf, len, *flags);
2684 }
2685
2686
2687 /***********************************************************************
2688 * WSARecvEx16() (WINSOCK.1107)
2689 *
2690 * See description for WSARecvEx()
2691 */
2692 INT16 WINAPI WSARecvEx16(SOCKET16 s, char *buf, INT16 len, INT16 *flags) {
2693 FIXME("(WSARecvEx16) partial packet return value not set \n");
2694
2695 return WINSOCK_recv16(s, buf, len, *flags);
2696 }
2697
2698
2699 /***********************************************************************
2700 * WSACreateEvent() (WS2_32.???)
2701 *
2702 */
2703 WSAEVENT WINAPI WSACreateEvent(void)
2704 {
2705 /* Create a manual-reset event, with initial state: unsignealed */
2706 TRACE("\n");
2707
2708 return CreateEventA(NULL, TRUE, FALSE, NULL);
2709 }
2710
2711 /***********************************************************************
2712 * WSACloseEvent() (WS2_32.???)
2713 *
2714 */
2715 BOOL WINAPI WSACloseEvent(WSAEVENT event)
2716 {
2717 TRACE ("event=0x%x\n", event);
2718
2719 return CloseHandle(event);
2720 }
2721
2722 /***********************************************************************
2723 * WSASocketA() (WS2_32.???)
2724 *
2725 */
2726 SOCKET WINAPI WSASocketA(int af, int type, int protocol,
2727 LPWSAPROTOCOL_INFOA lpProtocolInfo,
2728 GROUP g, DWORD dwFlags)
2729 {
2730 /*
2731 FIXME: The "advanced" parameters of WSASocketA (lpProtocolInfo,
2732 g, dwFlags) are ignored.
2733 */
2734
2735 TRACE("af=%d type=%d protocol=%d protocol_info=%p group=%d flags=0x%lx\n",
2736 af, type, protocol, lpProtocolInfo, g, dwFlags );
2737
2738 return ( WSOCK32_socket (af, type, protocol) );
2739 }
2740
2741
2742 /***********************************************************************
2743 * __WSAFDIsSet() (WINSOCK.151)
2744 */
2745 INT16 WINAPI __WSAFDIsSet16(SOCKET16 s, ws_fd_set16 *set)
2746 {
2747 int i = set->fd_count;
2748
2749 TRACE("(%d,%8lx(%i))\n", s,(unsigned long)set, i);
2750
2751 while (i--)
2752 if (set->fd_array[i] == s) return 1;
2753 return 0;
2754 }
2755
2756 /***********************************************************************
2757 * __WSAFDIsSet() (WSOCK32.151)
2758 */
2759 INT WINAPI __WSAFDIsSet(SOCKET s, ws_fd_set32 *set)
2760 {
2761 int i = set->fd_count;
2762
2763 TRACE("(%d,%8lx(%i))\n", s,(unsigned long)set, i);
2764
2765 while (i--)
2766 if (set->fd_array[i] == s) return 1;
2767 return 0;
2768 }
2769
2770 /***********************************************************************
2771 * WSAIsBlocking() (WINSOCK.114)(WSOCK32.114)
2772 */
2773 BOOL WINAPI WSAIsBlocking(void)
2774 {
2775 /* By default WinSock should set all its sockets to non-blocking mode
2776 * and poll in PeekMessage loop when processing "blocking" ones. This
2777 * function is supposed to tell if the program is in this loop. Our
2778 * blocking calls are truly blocking so we always return FALSE.
2779 *
2780 * Note: It is allowed to call this function without prior WSAStartup().
2781 */
2782
2783 TRACE("\n");
2784 return FALSE;
2785 }
2786
2787 /***********************************************************************
2788 * WSACancelBlockingCall() (WINSOCK.113)(WSOCK32.113)
2789 */
2790 INT WINAPI WSACancelBlockingCall(void)
2791 {
2792 LPWSINFO pwsi = WINSOCK_GetIData();
2793
2794 TRACE("(%08x)\n", (unsigned)pwsi);
2795
2796 if( pwsi ) return 0;
2797 return SOCKET_ERROR;
2798 }
2799
2800
2801 /***********************************************************************
2802 * WSASetBlockingHook16() (WINSOCK.109)
2803 */
2804 FARPROC16 WINAPI WSASetBlockingHook16(FARPROC16 lpBlockFunc)
2805 {
2806 FARPROC16 prev;
2807 LPWSINFO pwsi = WINSOCK_GetIData();
2808
2809 TRACE("(%08x): hook %08x\n",
2810 (unsigned)pwsi, (unsigned) lpBlockFunc);
2811 if( pwsi )
2812 {
2813 prev = (FARPROC16)pwsi->blocking_hook;
2814 pwsi->blocking_hook = (DWORD)lpBlockFunc;
2815 pwsi->flags &= ~WSI_BLOCKINGHOOK;
2816 return prev;
2817 }
2818 return 0;
2819 }
2820
2821
2822 /***********************************************************************
2823 * WSASetBlockingHook()
2824 */
2825 FARPROC WINAPI WSASetBlockingHook(FARPROC lpBlockFunc)
2826 {
2827 FARPROC prev;
2828 LPWSINFO pwsi = WINSOCK_GetIData();
2829
2830 TRACE("(%08x): hook %08x\n",
2831 (unsigned)pwsi, (unsigned) lpBlockFunc);
2832 if( pwsi ) {
2833 prev = (FARPROC)pwsi->blocking_hook;
2834 pwsi->blocking_hook = (DWORD)lpBlockFunc;
2835 pwsi->flags |= WSI_BLOCKINGHOOK;
2836 return prev;
2837 }
2838 return NULL;
2839 }
2840
2841
2842 /***********************************************************************
2843 * WSAUnhookBlockingHook16() (WINSOCK.110)
2844 */
2845 INT16 WINAPI WSAUnhookBlockingHook16(void)
2846 {
2847 LPWSINFO pwsi = WINSOCK_GetIData();
2848
2849 TRACE("(%08x)\n", (unsigned)pwsi);
2850 if( pwsi ) return (INT16)(pwsi->blocking_hook = 0);
2851 return SOCKET_ERROR;
2852 }
2853
2854
2855 /***********************************************************************
2856 * WSAUnhookBlockingHook()
2857 */
2858 INT WINAPI WSAUnhookBlockingHook(void)
2859 {
2860 LPWSINFO pwsi = WINSOCK_GetIData();
2861
2862 TRACE("(%08x)\n", (unsigned)pwsi);
2863 if( pwsi )
2864 {
2865 pwsi->blocking_hook = 0;
2866 pwsi->flags &= ~WSI_BLOCKINGHOOK;
2867 return 0;
2868 }
2869 return SOCKET_ERROR;
2870 }
2871
2872
2873 /* ----------------------------------- end of API stuff */
2874
2875 /* ----------------------------------- helper functions -
2876 *
2877 * TODO: Merge WS_dup_..() stuff into one function that
2878 * would operate with a generic structure containing internal
2879 * pointers (via a template of some kind).
2880 */
2881
2882 static int list_size(char** l, int item_size)
2883 {
2884 int i,j = 0;
2885 if(l)
2886 { for(i=0;l[i];i++)
2887 j += (item_size) ? item_size : strlen(l[i]) + 1;
2888 j += (i + 1) * sizeof(char*); }
2889 return j;
2890 }
2891
2892 static int list_dup(char** l_src, char* ref, char* base, int item_size)
2893 {
2894 /* base is either either equal to ref or 0 or SEGPTR */
2895
2896 char* p = ref;
2897 char** l_to = (char**)ref;
2898 int i,j,k;
2899
2900 for(j=0;l_src[j];j++) ;
2901 p += (j + 1) * sizeof(char*);
2902 for(i=0;i<j;i++)
2903 { l_to[i] = base + (p - ref);
2904 k = ( item_size ) ? item_size : strlen(l_src[i]) + 1;
2905 memcpy(p, l_src[i], k); p += k; }
2906 l_to[i] = NULL;
2907 return (p - ref);
2908 }
2909
2910 /* ----- hostent */
2911
2912 static int hostent_size(struct hostent* p_he)
2913 {
2914 int size = 0;
2915 if( p_he )
2916 { size = sizeof(struct hostent);
2917 size += strlen(p_he->h_name) + 1;
2918 size += list_size(p_he->h_aliases, 0);
2919 size += list_size(p_he->h_addr_list, p_he->h_length ); }
2920 return size;
2921 }
2922
2923 /* duplicate hostent entry
2924 * and handle all Win16/Win32 dependent things (struct size, ...) *correctly*.
2925 * Dito for protoent and servent.
2926 */
2927 int WS_dup_he(LPWSINFO pwsi, struct hostent* p_he, int flag)
2928 {
2929 /* Convert hostent structure into ws_hostent so that the data fits
2930 * into pwsi->buffer. Internal pointers can be linear, SEGPTR, or
2931 * relative to pwsi->buffer depending on "flag" value. Returns size
2932 * of the data copied (also in the pwsi->buflen).
2933 */
2934
2935 int size = hostent_size(p_he);
2936 if( size )
2937 {
2938 char *p_name,*p_aliases,*p_addr,*p_base,*p;
2939 char *p_to;
2940 struct ws_hostent16 *p_to16;
2941 struct ws_hostent32 *p_to32;
2942
2943 _check_buffer_he(pwsi, size);
2944 p_to = (char *)pwsi->he;
2945 p_to16 = (struct ws_hostent16*)pwsi->he;
2946 p_to32 = (struct ws_hostent32*)pwsi->he;
2947
2948 p = p_to;
2949 p_base = (flag & WS_DUP_OFFSET) ? NULL
2950 : ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
2951 p += (flag & WS_DUP_SEGPTR) ?
2952 sizeof(struct ws_hostent16) : sizeof(struct ws_hostent32);
2953 p_name = p;
2954 strcpy(p, p_he->h_name); p += strlen(p) + 1;
2955 p_aliases = p;
2956 p += list_dup(p_he->h_aliases, p, p_base + (p - p_to), 0);
2957 p_addr = p;
2958 list_dup(p_he->h_addr_list, p, p_base + (p - p_to), p_he->h_length);
2959
2960 if (flag & WS_DUP_SEGPTR) /* Win16 */
2961 {
2962 p_to16->h_addrtype = (INT16)p_he->h_addrtype;
2963 p_to16->h_length = (INT16)p_he->h_length;
2964 p_to16->h_name = (SEGPTR)(p_base + (p_name - p_to));
2965 p_to16->h_aliases = (SEGPTR)(p_base + (p_aliases - p_to));
2966 p_to16->h_addr_list = (SEGPTR)(p_base + (p_addr - p_to));
2967 size += (sizeof(struct ws_hostent16) - sizeof(struct hostent));
2968 }
2969 else /* Win32 */
2970 {
2971 p_to32->h_addrtype = p_he->h_addrtype;
2972 p_to32->h_length = p_he->h_length;
2973 p_to32->h_name = (p_base + (p_name - p_to));
2974 p_to32->h_aliases = (char **)(p_base + (p_aliases - p_to));
2975 p_to32->h_addr_list = (char **)(p_base + (p_addr - p_to));
2976 size += (sizeof(struct ws_hostent32) - sizeof(struct hostent));
2977 }
2978 }
2979 return size;
2980 }
2981
2982 /* ----- protoent */
2983
2984 static int protoent_size(struct protoent* p_pe)
2985 {
2986 int size = 0;
2987 if( p_pe )
2988 { size = sizeof(struct protoent);
2989 size += strlen(p_pe->p_name) + 1;
2990 size += list_size(p_pe->p_aliases, 0); }
2991 return size;
2992 }
2993
2994 int WS_dup_pe(LPWSINFO pwsi, struct protoent* p_pe, int flag)
2995 {
2996 int size = protoent_size(p_pe);
2997 if( size )
2998 {
2999 char *p_to;
3000 struct ws_protoent16 *p_to16;
3001 struct ws_protoent32 *p_to32;
3002 char *p_name,*p_aliases,*p_base,*p;
3003
3004 _check_buffer_pe(pwsi, size);
3005 p_to = (char *)pwsi->pe;
3006 p_to16 = (struct ws_protoent16*)pwsi->pe;
3007 p_to32 = (struct ws_protoent32*)pwsi->pe;
3008 p = p_to;
3009 p_base = (flag & WS_DUP_OFFSET) ? NULL
3010 : ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
3011 p += (flag & WS_DUP_SEGPTR) ?
3012 sizeof(struct ws_protoent16) : sizeof(struct ws_protoent32);
3013 p_name = p;
3014 strcpy(p, p_pe->p_name); p += strlen(p) + 1;
3015 p_aliases = p;
3016 list_dup(p_pe->p_aliases, p, p_base + (p - p_to), 0);
3017
3018 if (flag & WS_DUP_SEGPTR) /* Win16 */
3019 {
3020 p_to16->p_proto = (INT16)p_pe->p_proto;
3021 p_to16->p_name = (SEGPTR)(p_base) + (p_name - p_to);
3022 p_to16->p_aliases = (SEGPTR)((p_base) + (p_aliases - p_to));
3023 size += (sizeof(struct ws_protoent16) - sizeof(struct protoent));
3024 }
3025 else /* Win32 */
3026 {
3027 p_to32->p_proto = p_pe->p_proto;
3028 p_to32->p_name = (p_base) + (p_name - p_to);
3029 p_to32->p_aliases = (char **)((p_base) + (p_aliases - p_to));
3030 size += (sizeof(struct ws_protoent32) - sizeof(struct protoent));
3031 }
3032 }
3033 return size;
3034 }
3035
3036 /* ----- servent */
3037
3038 static int servent_size(struct servent* p_se)
3039 {
3040 int size = 0;
3041 if( p_se )
3042 { size += sizeof(struct servent);
3043 size += strlen(p_se->s_proto) + strlen(p_se->s_name) + 2;
3044 size += list_size(p_se->s_aliases, 0); }
3045 return size;
3046 }
3047
3048 int WS_dup_se(LPWSINFO pwsi, struct servent* p_se, int flag)
3049 {
3050 int size = servent_size(p_se);
3051 if( size )
3052 {
3053 char *p_name,*p_aliases,*p_proto,*p_base,*p;
3054 char *p_to;
3055 struct ws_servent16 *p_to16;
3056 struct ws_servent32 *p_to32;
3057
3058 _check_buffer_se(pwsi, size);
3059 p_to = (char *)pwsi->se;
3060 p_to16 = (struct ws_servent16*)pwsi->se;
3061 p_to32 = (struct ws_servent32*)pwsi->se;
3062 p = p_to;
3063 p_base = (flag & WS_DUP_OFFSET) ? NULL
3064 : ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
3065 p += (flag & WS_DUP_SEGPTR) ?
3066 sizeof(struct ws_servent16) : sizeof(struct ws_servent32);
3067 p_name = p;
3068 strcpy(p, p_se->s_name); p += strlen(p) + 1;
3069 p_proto = p;
3070 strcpy(p, p_se->s_proto); p += strlen(p) + 1;
3071 p_aliases = p;
3072 list_dup(p_se->s_aliases, p, p_base + (p - p_to), 0);
3073
3074 if (flag & WS_DUP_SEGPTR) /* Win16 */
3075 {
3076 p_to16->s_port = (INT16)p_se->s_port;
3077 p_to16->s_name = (SEGPTR)(p_base + (p_name - p_to));
3078 p_to16->s_proto = (SEGPTR)(p_base + (p_proto - p_to));
3079 p_to16->s_aliases = (SEGPTR)(p_base + (p_aliases - p_to));
3080 size += (sizeof(struct ws_servent16) - sizeof(struct servent));
3081 }
3082 else /* Win32 */
3083 {
3084 p_to32->s_port = p_se->s_port;
3085 p_to32->s_name = (p_base + (p_name - p_to));
3086 p_to32->s_proto = (p_base + (p_proto - p_to));
3087 p_to32->s_aliases = (char **)(p_base + (p_aliases - p_to));
3088 size += (sizeof(struct ws_servent32) - sizeof(struct servent));
3089 }
3090 }
3091 return size;
3092 }
3093
3094 /* ----------------------------------- error handling */
3095
3096 UINT16 wsaErrno(void)
3097 {
3098 int loc_errno = errno;
3099 WARN("errno %d, (%s).\n", loc_errno, strerror(loc_errno));
3100
3101 switch(loc_errno)
3102 {
3103 case EINTR: return WSAEINTR;
3104 case EBADF: return WSAEBADF;
3105 case EPERM:
3106 case EACCES: return WSAEACCES;
3107 case EFAULT: return WSAEFAULT;
3108 case EINVAL: return WSAEINVAL;
3109 case EMFILE: return WSAEMFILE;
3110 case EWOULDBLOCK: return WSAEWOULDBLOCK;
3111 case EINPROGRESS: return WSAEINPROGRESS;
3112 case EALREADY: return WSAEALREADY;
3113 case ENOTSOCK: return WSAENOTSOCK;
3114 case EDESTADDRREQ: return WSAEDESTADDRREQ;
3115 case EMSGSIZE: return WSAEMSGSIZE;
3116 case EPROTOTYPE: return WSAEPROTOTYPE;
3117 case ENOPROTOOPT: return WSAENOPROTOOPT;
3118 case EPROTONOSUPPORT: return WSAEPROTONOSUPPORT;
3119 case ESOCKTNOSUPPORT: return WSAESOCKTNOSUPPORT;
3120 case EOPNOTSUPP: return WSAEOPNOTSUPP;
3121 case EPFNOSUPPORT: return WSAEPFNOSUPPORT;
3122 case EAFNOSUPPORT: return WSAEAFNOSUPPORT;
3123 case EADDRINUSE: return WSAEADDRINUSE;
3124 case EADDRNOTAVAIL: return WSAEADDRNOTAVAIL;
3125 case ENETDOWN: return WSAENETDOWN;
3126 case ENETUNREACH: return WSAENETUNREACH;
3127 case ENETRESET: return WSAENETRESET;
3128 case ECONNABORTED: return WSAECONNABORTED;
3129 case EPIPE:
3130 case ECONNRESET: return WSAECONNRESET;
3131 case ENOBUFS: return WSAENOBUFS;
3132 case EISCONN: return WSAEISCONN;
3133 case ENOTCONN: return WSAENOTCONN;
3134 case ESHUTDOWN: return WSAESHUTDOWN;
3135 case ETOOMANYREFS: return WSAETOOMANYREFS;
3136 case ETIMEDOUT: return WSAETIMEDOUT;
3137 case ECONNREFUSED: return WSAECONNREFUSED;
3138 case ELOOP: return WSAELOOP;
3139 case ENAMETOOLONG: return WSAENAMETOOLONG;
3140 case EHOSTDOWN: return WSAEHOSTDOWN;
3141 case EHOSTUNREACH: return WSAEHOSTUNREACH;
3142 case ENOTEMPTY: return WSAENOTEMPTY;
3143 #ifdef EPROCLIM
3144 case EPROCLIM: return WSAEPROCLIM;
3145 #endif
3146 #ifdef EUSERS
3147 case EUSERS: return WSAEUSERS;
3148 #endif
3149 #ifdef EDQUOT
3150 case EDQUOT: return WSAEDQUOT;
3151 #endif
3152 #ifdef ESTALE
3153 case ESTALE: return WSAESTALE;
3154 #endif
3155 #ifdef EREMOTE
3156 case EREMOTE: return WSAEREMOTE;
3157 #endif
3158
3159 /* just in case we ever get here and there are no problems */
3160 case 0: return 0;
3161 default:
3162 WARN("Unknown errno %d!\n", loc_errno);
3163 return WSAEOPNOTSUPP;
3164 }
3165 }
3166
3167 UINT16 wsaHerrno(void)
3168 {
3169 int loc_errno = h_errno;
3170
3171 WARN("h_errno %d.\n", loc_errno);
3172
3173 switch(loc_errno)
3174 {
3175 case HOST_NOT_FOUND: return WSAHOST_NOT_FOUND;
3176 case TRY_AGAIN: return WSATRY_AGAIN;
3177 case NO_RECOVERY: return WSANO_RECOVERY;
3178 case NO_DATA: return WSANO_DATA;
3179
3180 case 0: return 0;
3181 default:
3182 WARN("Unknown h_errno %d!\n", loc_errno);
3183 return WSAEOPNOTSUPP;
3184 }
3185 }
Maarten's multimedia branch