?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Large-scale renaming of all Win32 functions and types to use the
[wine.git] / misc / winsock.c
blobc75900ae95be85f5c71cf29b6a30d7a11f76f105
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 */
12
13 #include "config.h"
14
15 #include <string.h>
16 #include <sys/types.h>
17 #include <sys/ipc.h>
18 #include <sys/ioctl.h>
19 #ifdef HAVE_SYS_FILIO_H
20 # include <sys/filio.h>
21 #endif
22 #if defined(__svr4__)
23 #include <sys/ioccom.h>
24 #include <sys/sockio.h>
25 #endif
26
27 #if defined(__EMX__)
28 # include <sys/so_ioctl.h>
29 #endif
30
31 #ifdef HAVE_SYS_PARAM_H
32 # include <sys/param.h>
33 #endif
34
35 #include <sys/msg.h>
36 #include <sys/wait.h>
37 #include <sys/socket.h>
38 #include <netinet/in.h>
39 #include <arpa/inet.h>
40 #include <ctype.h>
41 #include <fcntl.h>
42 #include <errno.h>
43 #include <sys/errno.h>
44 #include <netdb.h>
45 #include <unistd.h>
46 #include <stdlib.h>
47 #ifdef HAVE_RESOLV_H
48 # include <resolv.h>
49 #endif
50
51 #include "wine/winbase16.h"
52 #include "winsock.h"
53 #include "winnt.h"
54 #include "heap.h"
55 #include "ldt.h"
56 #include "task.h"
57 #include "message.h"
58 #include "miscemu.h"
59 #include "debug.h"
60
61 #define DEBUG_SOCKADDR 0
62 #define dump_sockaddr(a) \
63 DUMP("sockaddr_in: family %d, address %s, port %d\n", \
64 ((struct sockaddr_in *)a)->sin_family, \
65 inet_ntoa(((struct sockaddr_in *)a)->sin_addr), \
66 ntohs(((struct sockaddr_in *)a)->sin_port))
67
68 #pragma pack(4)
69
70 /* ----------------------------------- internal data */
71
72 static HANDLE _WSHeap = 0;
73 static unsigned char* _ws_stub = NULL;
74 static LPWSINFO _wsi_list = NULL;
75
76 #define WS_ALLOC(size) \
77 HeapAlloc(_WSHeap, HEAP_ZERO_MEMORY, (size) )
78 #define WS_FREE(ptr) \
79 HeapFree(_WSHeap, 0, (ptr) )
80
81 #define WS_PTR2HANDLE(ptr) \
82 ((short)((int)(ptr) - (int)_ws_stub))
83 #define WS_HANDLE2PTR(handle) \
84 ((unsigned)((int)_ws_stub + (int)(handle)))
85
86 #define WSI_CHECK_RANGE(pwsi, pws) \
87 ( ((unsigned)(pws) > (unsigned)(pwsi)) && \
88 ((unsigned)(pws) < ((unsigned)(pwsi) + sizeof(WSINFO))) )
89
90 static INT _ws_sock_ops[] =
91 { WS_SO_DEBUG, WS_SO_REUSEADDR, WS_SO_KEEPALIVE, WS_SO_DONTROUTE,
92 WS_SO_BROADCAST, WS_SO_LINGER, WS_SO_OOBINLINE, WS_SO_SNDBUF,
93 WS_SO_RCVBUF, WS_SO_ERROR, WS_SO_TYPE, WS_SO_DONTLINGER, 0 };
94 static int _px_sock_ops[] =
95 { SO_DEBUG, SO_REUSEADDR, SO_KEEPALIVE, SO_DONTROUTE, SO_BROADCAST,
96 SO_LINGER, SO_OOBINLINE, SO_SNDBUF, SO_RCVBUF, SO_ERROR, SO_TYPE,
97 SO_LINGER };
98
99 static int _check_ws(LPWSINFO pwsi, ws_socket* pws);
100 static char* _check_buffer(LPWSINFO pwsi, int size);
101
102 /***********************************************************************
103 * convert_sockopt()
104 *
105 * Converts socket flags from Windows format.
106 */
107 static void convert_sockopt(INT *level, INT *optname)
108 {
109 int i;
110 switch (*level)
111 {
112 case WS_SOL_SOCKET:
113 *level = SOL_SOCKET;
114 for(i=0; _ws_sock_ops[i]; i++)
115 if( _ws_sock_ops[i] == *optname ) break;
116 if( _ws_sock_ops[i] ) *optname = _px_sock_ops[i];
117 else WARN(winsock, "Unknown optname %d\n", *optname);
118 break;
119 case WS_IPPROTO_TCP:
120 *optname = IPPROTO_TCP;
121 }
122 }
123
124 /* ----------------------------------- Per-thread info (or per-process?) */
125
126 static LPWSINFO wsi_find(HTASK16 hTask)
127 {
128 TDB* pTask = (TDB*)GlobalLock16(hTask);
129 if( pTask )
130 {
131 if( pTask->pwsi ) return pTask->pwsi;
132 else
133 {
134 LPWSINFO pwsi = _wsi_list;
135 while( pwsi && pwsi->tid != hTask ) pwsi = pwsi->next;
136 if( pwsi )
137 WARN(winsock,"(pwsi=0x%08x,task=0x%04x):Loose wsi struct! \n",
138 (unsigned)pwsi, hTask );
139 return pwsi;
140 }
141 }
142 return NULL;
143 }
144
145 static ws_socket* wsi_alloc_socket(LPWSINFO pwsi, int fd)
146 {
147 /* Initialize a new entry in the socket table */
148
149 if( pwsi->last_free >= 0 )
150 {
151 int i = pwsi->last_free;
152
153 pwsi->last_free = pwsi->sock[i].flags; /* free list */
154 pwsi->sock[i].fd = fd;
155 pwsi->sock[i].flags = 0;
156 return &pwsi->sock[i];
157 }
158 return NULL;
159 }
160
161 static int wsi_strtolo(LPWSINFO pwsi, const char* name, const char* opt)
162 {
163 /* Stuff a lowercase copy of the string into the local buffer */
164
165 int i = strlen(name) + 2;
166 char* p = _check_buffer(pwsi, i + ((opt)?strlen(opt):0));
167
168 if( p )
169 {
170 do *p++ = tolower(*name); while(*name++);
171 i = (p - (char*)(pwsi->buffer));
172 if( opt ) do *p++ = tolower(*opt); while(*opt++);
173 return i;
174 }
175 return 0;
176 }
177
178 static fd_set* fd_set_import( fd_set* fds, LPWSINFO pwsi, void* wsfds, int* highfd, BOOL b32 )
179 {
180 /* translate Winsock fd set into local fd set */
181
182 if( wsfds )
183 {
184 #define wsfds16 ((ws_fd_set16*)wsfds)
185 #define wsfds32 ((ws_fd_set32*)wsfds)
186 ws_socket* pws;
187 int i, count;
188
189 FD_ZERO(fds);
190 count = b32 ? wsfds32->fd_count : wsfds16->fd_count;
191
192 for( i = 0; i < count; i++ )
193 {
194 pws = (b32) ? (ws_socket*)WS_HANDLE2PTR(wsfds32->fd_array[i])
195 : (ws_socket*)WS_HANDLE2PTR(wsfds16->fd_array[i]);
196 if( _check_ws(pwsi, pws) )
197 {
198 if( pws->fd > *highfd ) *highfd = pws->fd;
199 FD_SET(pws->fd, fds);
200 }
201 }
202 #undef wsfds32
203 #undef wsfds16
204 return fds;
205 }
206 return NULL;
207 }
208
209 __inline__ static int sock_error_p(int s)
210 {
211 unsigned int optval, optlen;
212
213 optlen = sizeof(optval);
214 getsockopt(s, SOL_SOCKET, SO_ERROR, &optval, &optlen);
215 if (optval) WARN(winsock, "\t[%i] error: %d\n", s, optval);
216 return optval != 0;
217 }
218
219 static int fd_set_export( LPWSINFO pwsi, fd_set* fds, fd_set* exceptfds, void* wsfds, BOOL b32 )
220 {
221 int num_err = 0;
222
223 /* translate local fd set into Winsock fd set, adding
224 * errors to exceptfds (only if app requested it) */
225
226 if( wsfds )
227 {
228 #define wsfds16 ((ws_fd_set16*)wsfds)
229 #define wsfds32 ((ws_fd_set32*)wsfds)
230 int i, j, count = (b32) ? wsfds32->fd_count : wsfds16->fd_count;
231
232 for( i = 0, j = 0; i < count; i++ )
233 {
234 ws_socket *pws = (b32) ? (ws_socket*)WS_HANDLE2PTR(wsfds32->fd_array[i])
235 : (ws_socket*)WS_HANDLE2PTR(wsfds16->fd_array[i]);
236 if( _check_ws(pwsi, pws) )
237 {
238 int fd = pws->fd;
239
240 if( FD_ISSET(fd, fds) )
241 {
242 if ( exceptfds && sock_error_p(fd) )
243 {
244 FD_SET(fd, exceptfds);
245 num_err++;
246 }
247 else if( b32 )
248 wsfds32->fd_array[j++] = wsfds32->fd_array[i];
249 else
250 wsfds16->fd_array[j++] = wsfds16->fd_array[i];
251 }
252 }
253 }
254
255 if( b32 ) wsfds32->fd_count = j;
256 else wsfds16->fd_count = j;
257
258 TRACE(winsock, "\n");
259 #undef wsfds32
260 #undef wsfds16
261 }
262 return num_err;
263 }
264
265 HANDLE16 __ws_gethandle( void* ptr )
266 {
267 return (HANDLE16)WS_PTR2HANDLE(ptr);
268 }
269
270 void* __ws_memalloc( int size )
271 {
272 return WS_ALLOC(size);
273 }
274
275 void __ws_memfree(void* ptr)
276 {
277 WS_FREE(ptr);
278 }
279
280 /* ----------------------------------- API -----
281 *
282 * Init / cleanup / error checking.
283 */
284
285 /***********************************************************************
286 * WSAStartup16() (WINSOCK.115)
287 *
288 * Create socket control struct, attach it to the global list and
289 * update a pointer in the task struct.
290 */
291 INT16 WINAPI WSAStartup16(UINT16 wVersionRequested, LPWSADATA lpWSAData)
292 {
293 WSADATA WINSOCK_data = { 0x0101, 0x0101,
294 "WINE Sockets 1.1",
295 #ifdef linux
296 "Linux/i386",
297 #elif defined(__NetBSD__)
298 "NetBSD/i386",
299 #elif defined(sunos)
300 "SunOS",
301 #elif defined(__FreeBSD__)
302 "FreeBSD",
303 #elif defined(__OpenBSD__)
304 "OpenBSD/i386",
305 #else
306 "Unknown",
307 #endif
308 WS_MAX_SOCKETS_PER_PROCESS,
309 WS_MAX_UDP_DATAGRAM, (SEGPTR)NULL };
310 HTASK16 tid = GetCurrentTask();
311 LPWSINFO pwsi;
312
313 TRACE(winsock, "verReq=%x\n", wVersionRequested);
314
315 if (LOBYTE(wVersionRequested) < 1 || (LOBYTE(wVersionRequested) == 1 &&
316 HIBYTE(wVersionRequested) < 1)) return WSAVERNOTSUPPORTED;
317
318 if (!lpWSAData) return WSAEINVAL;
319
320 /* initialize socket heap */
321
322 if( !_ws_stub )
323 {
324 _WSHeap = HeapCreate(HEAP_ZERO_MEMORY, 8120, 32768);
325 if( !(_ws_stub = WS_ALLOC(0x10)) )
326 {
327 ERR(winsock,"Fatal: failed to create WinSock heap\n");
328 return 0;
329 }
330 }
331 if( _WSHeap == 0 ) return WSASYSNOTREADY;
332
333 /* create socket array for this task */
334
335 pwsi = wsi_find(GetCurrentTask());
336 if( pwsi == NULL )
337 {
338 TDB* pTask = (TDB*)GlobalLock16( tid );
339
340 if( (pwsi = (LPWSINFO)WS_ALLOC( sizeof(WSINFO))) )
341 {
342 int i = 0;
343 pwsi->tid = tid;
344 for( i = 0; i < WS_MAX_SOCKETS_PER_PROCESS; i++ )
345 {
346 pwsi->sock[i].fd = -1;
347 pwsi->sock[i].flags = i + 1;
348 }
349 pwsi->sock[WS_MAX_SOCKETS_PER_PROCESS - 1].flags = -1;
350 }
351 else return WSASYSNOTREADY;
352
353 /* add this control struct to the global list */
354
355 pwsi->prev = NULL;
356 if( _wsi_list )
357 _wsi_list->prev = pwsi;
358 pwsi->next = _wsi_list;
359 _wsi_list = pwsi;
360 pTask->pwsi = pwsi;
361 }
362 else pwsi->num_startup++;
363
364 /* return winsock information */
365
366 memcpy(lpWSAData, &WINSOCK_data, sizeof(WINSOCK_data));
367
368 TRACE(winsock, "succeeded\n");
369 return 0;
370 }
371
372 /***********************************************************************
373 * WSAStartup32() (WSOCK32.115)
374 */
375 INT WINAPI WSAStartup(UINT wVersionRequested, LPWSADATA lpWSAData)
376 {
377 return WSAStartup16( wVersionRequested, lpWSAData );
378 }
379
380 /***********************************************************************
381 * WSACleanup() (WINSOCK.116)
382 *
383 * Cleanup functions of varying impact.
384 */
385 void WINSOCK_Shutdown()
386 {
387 /* Called on exit(), has to remove all outstanding async DNS processes. */
388
389 WINSOCK_cancel_task_aops( 0, __ws_memfree );
390 }
391
392 INT WINSOCK_DeleteTaskWSI( TDB* pTask, LPWSINFO pwsi )
393 {
394 /* WSACleanup() backend, called on task termination as well.
395 * Real DLL would have registered its own signal handler with
396 * TaskSetSignalHandler() and waited until USIG_TERMINATION/USIG_GPF
397 * but this scheme is much more straightforward.
398 */
399
400 int i, j, n;
401
402 if( --pwsi->num_startup > 0 ) return 0;
403
404 SIGNAL_MaskAsyncEvents( TRUE );
405 WINSOCK_cancel_task_aops( pTask->hSelf, __ws_memfree );
406 SIGNAL_MaskAsyncEvents( FALSE );
407
408 /* unlink socket control struct */
409
410 if( pwsi == _wsi_list )
411 _wsi_list = pwsi->next;
412 else
413 pwsi->prev->next = pwsi->next;
414 if( pwsi->next ) pwsi->next->prev = pwsi->prev;
415
416 if( _wsi_list == NULL )
417 WINSOCK_Shutdown(); /* just in case */
418
419 if( pwsi->flags & WSI_BLOCKINGCALL )
420 TRACE(winsock,"\tinside blocking call!\n");
421
422 /* FIXME: aop_control() doesn't decrement pwsi->num_async_rq
423 *
424 * if( pwsi->num_async_rq )
425 * WARN(winsock,"\thave %i outstanding async ops!\n", pwsi->num_async_rq );
426 */
427
428 for(i = 0, j = 0, n = 0; i < WS_MAX_SOCKETS_PER_PROCESS; i++)
429 if( pwsi->sock[i].fd != -1 )
430 {
431 if( pwsi->sock[i].psop )
432 {
433 n++;
434 WSAAsyncSelect( (SOCKET16)WS_PTR2HANDLE(pwsi->sock + i), 0, 0, 0 );
435 }
436 close(pwsi->sock[i].fd); j++;
437 }
438 if( j )
439 TRACE(winsock,"\tclosed %i sockets, killed %i async selects!\n", j, n);
440
441 /* delete scratch buffers */
442
443 if( pwsi->buffer ) SEGPTR_FREE(pwsi->buffer);
444 if( pwsi->dbuffer ) SEGPTR_FREE(pwsi->dbuffer);
445
446 if( pTask )
447 pTask->pwsi = NULL;
448 memset( pwsi, 0, sizeof(WSINFO) );
449 WS_FREE(pwsi);
450 return 0;
451 }
452
453 INT WINAPI WSACleanup(void)
454 {
455 HTASK16 hTask = GetCurrentTask();
456
457 TRACE(winsock, "(%04x)\n", hTask );
458 if( hTask )
459 {
460 LPWSINFO pwsi = wsi_find(hTask);
461 if( pwsi )
462 return WINSOCK_DeleteTaskWSI( (TDB*)GlobalLock16(hTask), pwsi );
463 return SOCKET_ERROR;
464 }
465 else
466 WINSOCK_Shutdown(); /* remove all outstanding DNS requests */
467 return 0;
468 }
469
470
471 /***********************************************************************
472 * WSAGetLastError() (WSOCK32.111)(WINSOCK.111)
473 */
474 INT WINAPI WSAGetLastError(void)
475 {
476 LPWSINFO pwsi = wsi_find(GetCurrentTask());
477 INT16 ret = (pwsi) ? pwsi->err : WSANOTINITIALISED;
478
479 TRACE(winsock, "(%08x) = %i\n",
480 (unsigned)pwsi, (int)ret);
481 return ret;
482 }
483
484 /***********************************************************************
485 * WSASetLastError32() (WSOCK32.112)
486 */
487 void WINAPI WSASetLastError(INT iError)
488 {
489 LPWSINFO pwsi = wsi_find(GetCurrentTask());
490
491 TRACE(winsock, "(%08x): %d\n", (unsigned)pwsi, (int)iError);
492 if( pwsi ) pwsi->err = iError;
493 }
494
495 /***********************************************************************
496 * WSASetLastError16() (WINSOCK.112)
497 */
498 void WINAPI WSASetLastError16(INT16 iError)
499 {
500 WSASetLastError(iError);
501 }
502
503 int _check_ws(LPWSINFO pwsi, ws_socket* pws)
504 {
505 if( pwsi )
506 {
507 if( pwsi->flags & WSI_BLOCKINGCALL ) pwsi->err = WSAEINPROGRESS;
508 else if( WSI_CHECK_RANGE(pwsi, pws) ) return 1;
509 else pwsi->err = WSAENOTSOCK;
510 }
511 return 0;
512 }
513
514 char* _check_buffer(LPWSINFO pwsi, int size)
515 {
516 if( pwsi->buffer && pwsi->buflen >= size ) return pwsi->buffer;
517 else SEGPTR_FREE(pwsi->buffer);
518
519 pwsi->buffer = (char*)SEGPTR_ALLOC((pwsi->buflen = size));
520 return pwsi->buffer;
521 }
522
523 struct ws_hostent* _check_buffer_he(LPWSINFO pwsi, int size)
524 {
525 if( pwsi->he && pwsi->helen >= size ) return pwsi->he;
526 else SEGPTR_FREE(pwsi->he);
527
528 pwsi->he = (struct ws_hostent*)SEGPTR_ALLOC((pwsi->helen = size));
529 return pwsi->he;
530 }
531
532 struct ws_servent* _check_buffer_se(LPWSINFO pwsi, int size)
533 {
534 if( pwsi->se && pwsi->selen >= size ) return pwsi->se;
535 else SEGPTR_FREE(pwsi->se);
536
537 pwsi->se = (struct ws_servent*)SEGPTR_ALLOC((pwsi->selen = size));
538 return pwsi->se;
539 }
540
541 struct ws_protoent* _check_buffer_pe(LPWSINFO pwsi, int size)
542 {
543 if( pwsi->pe && pwsi->pelen >= size ) return pwsi->pe;
544 else SEGPTR_FREE(pwsi->pe);
545
546 pwsi->pe = (struct ws_protoent*)SEGPTR_ALLOC((pwsi->pelen = size));
547 return pwsi->pe;
548 }
549
550 /* ----------------------------------- i/o APIs */
551
552 /***********************************************************************
553 * accept() (WSOCK32.1)
554 */
555 SOCKET WINAPI WINSOCK_accept(SOCKET s, struct sockaddr *addr,
556 INT *addrlen32)
557 {
558 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR((SOCKET16)s);
559 LPWSINFO pwsi = wsi_find(GetCurrentTask());
560 #ifdef HAVE_IPX
561 struct ws_sockaddr_ipx* addr2 = (struct ws_sockaddr_ipx *)addr;
562 #endif
563
564 TRACE(winsock, "(%08x): socket %04x\n",
565 (unsigned)pwsi, (UINT16)s );
566 if( _check_ws(pwsi, pws) )
567 {
568 int sock, fd_flags;
569
570 fd_flags = fcntl(pws->fd, F_GETFL, 0);
571
572 if( (sock = accept(pws->fd, addr, addrlen32)) >= 0 )
573 {
574 ws_socket* pnew = wsi_alloc_socket(pwsi, sock);
575 if( pnew )
576 {
577 s = (SOCKET)WS_PTR2HANDLE(pnew);
578 if( pws->psop && pws->flags & WS_FD_ACCEPT )
579 {
580 EVENT_AddIO( pws->fd, EVENT_IO_READ ); /* reenabler */
581
582 /* async select the accept()'ed socket */
583 WSAAsyncSelect( s, pws->psop->hWnd, pws->psop->uMsg,
584 pws->flags & ~WS_FD_ACCEPT );
585 }
586 #ifdef HAVE_IPX
587 if (addr && ((struct sockaddr_ipx *)addr)->sipx_family == AF_IPX) {
588 addr = (struct sockaddr *)
589 malloc(addrlen32 ? *addrlen32 : sizeof(*addr2));
590 memcpy(addr, addr2,
591 addrlen32 ? *addrlen32 : sizeof(*addr2));
592 addr2->sipx_family = WS_AF_IPX;
593 addr2->sipx_network = ((struct sockaddr_ipx *)addr)->sipx_network;
594 addr2->sipx_port = ((struct sockaddr_ipx *)addr)->sipx_port;
595 memcpy(addr2->sipx_node,
596 ((struct sockaddr_ipx *)addr)->sipx_node, IPX_NODE_LEN);
597 free(addr);
598 }
599 #endif
600 return s;
601 }
602 else pwsi->err = WSAENOBUFS;
603 }
604 else pwsi->err = wsaErrno();
605 }
606 #ifdef HAVE_IPX
607 if (addr && ((struct sockaddr_ipx *)addr)->sipx_family == AF_IPX) {
608 addr = (struct sockaddr *)
609 malloc(addrlen32 ? *addrlen32 : sizeof(*addr2));
610 memcpy(addr, addr2, addrlen32 ? *addrlen32 : sizeof(*addr2));
611 addr2->sipx_family = WS_AF_IPX;
612 addr2->sipx_network = ((struct sockaddr_ipx *)addr)->sipx_network;
613 addr2->sipx_port = ((struct sockaddr_ipx *)addr)->sipx_port;
614 memcpy(addr2->sipx_node,
615 ((struct sockaddr_ipx *)addr)->sipx_node, IPX_NODE_LEN);
616 free(addr);
617 }
618 #endif
619 return INVALID_SOCKET;
620 }
621
622 /***********************************************************************
623 * accept() (WINSOCK.1)
624 */
625 SOCKET16 WINAPI WINSOCK_accept16(SOCKET16 s, struct sockaddr* addr,
626 INT16* addrlen16 )
627 {
628 INT addrlen32 = addrlen16 ? *addrlen16 : 0;
629 SOCKET retSocket = WINSOCK_accept( s, addr, &addrlen32 );
630 if( addrlen16 ) *addrlen16 = (INT16)addrlen32;
631 return (SOCKET16)retSocket;
632 }
633
634 /***********************************************************************
635 * bind() (WSOCK32.2)
636 */
637 INT WINAPI WINSOCK_bind(SOCKET s, struct sockaddr *name, INT namelen)
638 {
639 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
640 LPWSINFO pwsi = wsi_find(GetCurrentTask());
641 #ifdef HAVE_IPX
642 struct ws_sockaddr_ipx* name2 = (struct ws_sockaddr_ipx *)name;
643 #endif
644
645 TRACE(winsock, "(%08x): socket %04x, ptr %8x, length %d\n",
646 (unsigned)pwsi, s, (int) name, namelen);
647 #if DEBUG_SOCKADDR
648 dump_sockaddr(name);
649 #endif
650
651 if ( _check_ws(pwsi, pws) )
652 {
653 /* FIXME: what family does this really map to on the Unix side? */
654 if (name && ((struct ws_sockaddr_ipx *)name)->sipx_family == WS_AF_PUP)
655 ((struct ws_sockaddr_ipx *)name)->sipx_family = AF_UNSPEC;
656 #ifdef HAVE_IPX
657 else if (name &&
658 ((struct ws_sockaddr_ipx *)name)->sipx_family == WS_AF_IPX)
659 {
660 name = (struct sockaddr *) malloc(sizeof(struct sockaddr_ipx));
661 memset(name, '\0', sizeof(struct sockaddr_ipx));
662 ((struct sockaddr_ipx *)name)->sipx_family = AF_IPX;
663 ((struct sockaddr_ipx *)name)->sipx_port = name2->sipx_port;
664 ((struct sockaddr_ipx *)name)->sipx_network = name2->sipx_network;
665 memcpy(((struct sockaddr_ipx *)name)->sipx_node,
666 name2->sipx_node, IPX_NODE_LEN);
667 namelen = sizeof(struct sockaddr_ipx);
668 }
669 #endif
670 if ( namelen >= sizeof(*name) )
671 {
672 if ( name && (((struct ws_sockaddr_in *)name)->sin_family == AF_INET
673 #ifdef HAVE_IPX
674 || ((struct sockaddr_ipx *)name)->sipx_family == AF_IPX
675 #endif
676 ))
677 {
678 if ( bind(pws->fd, name, namelen) < 0 )
679 {
680 int loc_errno = errno;
681 WARN(winsock, "\tfailure - errno = %i\n", errno);
682 errno = loc_errno;
683 switch(errno)
684 {
685 case EBADF: pwsi->err = WSAENOTSOCK; break;
686 case EADDRNOTAVAIL: pwsi->err = WSAEINVAL; break;
687 default: pwsi->err = wsaErrno();
688 }
689 }
690 else {
691 #ifdef HAVE_IPX
692 if (((struct sockaddr_ipx *)name)->sipx_family == AF_IPX)
693 free(name);
694 #endif
695 return 0; /* success */
696 }
697 }
698 else pwsi->err = WSAEAFNOSUPPORT;
699 }
700 else pwsi->err = WSAEFAULT;
701 #ifdef HAVE_IPX
702 if (name && ((struct sockaddr_ipx *)name)->sipx_family == AF_IPX)
703 free(name);
704 #endif
705 }
706 return SOCKET_ERROR;
707 }
708
709 /***********************************************************************
710 * bind() (WINSOCK.2)
711 */
712 INT16 WINAPI WINSOCK_bind16(SOCKET16 s, struct sockaddr *name, INT16 namelen)
713 {
714 return (INT16)WINSOCK_bind( s, name, namelen );
715 }
716
717 /***********************************************************************
718 * closesocket() (WSOCK32.3)
719 */
720 INT WINAPI WINSOCK_closesocket(SOCKET s)
721 {
722 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
723 LPWSINFO pwsi = wsi_find(GetCurrentTask());
724
725 TRACE(winsock, "(%08x): socket %08x\n", (unsigned)pwsi, s);
726
727 if( _check_ws(pwsi, pws) )
728 {
729 int fd = pws->fd;
730
731 if( pws->psop ) WSAAsyncSelect( s, 0, 0, 0 );
732
733 pws->fd = -1;
734 pws->flags = (unsigned)pwsi->last_free;
735 pwsi->last_free = pws - &pwsi->sock[0]; /* add to free list */
736
737 if( close(fd) == 0 )
738 return 0;
739 pwsi->err = (errno == EBADF) ? WSAENOTSOCK : wsaErrno();
740 }
741 return SOCKET_ERROR;
742 }
743
744 /***********************************************************************
745 * closesocket() (WINSOCK.3)
746 */
747 INT16 WINAPI WINSOCK_closesocket16(SOCKET16 s)
748 {
749 return (INT16)WINSOCK_closesocket(s);
750 }
751
752 /***********************************************************************
753 * connect() (WSOCK32.4)
754 */
755 INT WINAPI WINSOCK_connect(SOCKET s, struct sockaddr *name, INT namelen)
756 {
757 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
758 LPWSINFO pwsi = wsi_find(GetCurrentTask());
759 #ifdef HAVE_IPX
760 struct ws_sockaddr_ipx* name2 = (struct ws_sockaddr_ipx *)name;
761 #endif
762
763 TRACE(winsock, "(%08x): socket %04x, ptr %8x, length %d\n",
764 (unsigned)pwsi, s, (int) name, namelen);
765 #if DEBUG_SOCKADDR
766 dump_sockaddr(name);
767 #endif
768
769 if( _check_ws(pwsi, pws) )
770 {
771 if (name && ((struct ws_sockaddr_ipx *)name)->sipx_family == WS_AF_PUP)
772 ((struct ws_sockaddr_ipx *)name)->sipx_family = AF_UNSPEC;
773 #ifdef HAVE_IPX
774 else if (name && ((struct ws_sockaddr_ipx *)name)->sipx_family == WS_AF_IPX)
775 {
776 name = (struct sockaddr *) malloc(sizeof(struct sockaddr_ipx));
777 memset(name, '\0', sizeof(struct sockaddr_ipx));
778 ((struct sockaddr_ipx *)name)->sipx_family = AF_IPX;
779 ((struct sockaddr_ipx *)name)->sipx_port = name2->sipx_port;
780 ((struct sockaddr_ipx *)name)->sipx_network = name2->sipx_network;
781 memcpy(((struct sockaddr_ipx *)name)->sipx_node,
782 name2->sipx_node, IPX_NODE_LEN);
783 namelen = sizeof(struct sockaddr_ipx);
784 }
785 #endif
786 if (connect(pws->fd, name, namelen) == 0)
787 {
788 if( pws->psop && (pws->flags & WS_FD_CONNECT) )
789 {
790 /* application did AsyncSelect() but then went
791 * ahead and called connect() without waiting for
792 * notification.
793 *
794 * FIXME: Do we have to post a notification message
795 * in this case?
796 */
797
798 if( !(pws->flags & WS_FD_CONNECTED) )
799 {
800 if( pws->flags & (WS_FD_READ | WS_FD_CLOSE) )
801 EVENT_AddIO( pws->fd, EVENT_IO_READ );
802 else
803 EVENT_DeleteIO( pws->fd, EVENT_IO_READ );
804 if( pws->flags & WS_FD_WRITE )
805 EVENT_AddIO( pws->fd, EVENT_IO_WRITE );
806 else
807 EVENT_DeleteIO( pws->fd, EVENT_IO_WRITE );
808 }
809 }
810 pws->flags |= WS_FD_CONNECTED;
811 pws->flags &= ~(WS_FD_INACTIVE | WS_FD_CONNECT | WS_FD_LISTENING);
812 #ifdef HAVE_IPX
813 if (((struct sockaddr_ipx *)name)->sipx_family == AF_IPX)
814 free(name);
815 #endif
816 return 0;
817 }
818 pwsi->err = (errno == EINPROGRESS) ? WSAEWOULDBLOCK : wsaErrno();
819 }
820 #ifdef HAVE_IPX
821 if (name && ((struct sockaddr_ipx *)name)->sipx_family == AF_IPX)
822 free(name);
823 #endif
824 return SOCKET_ERROR;
825 }
826
827 /***********************************************************************
828 * connect() (WINSOCK.4)
829 */
830 INT16 WINAPI WINSOCK_connect16(SOCKET16 s, struct sockaddr *name, INT16 namelen)
831 {
832 return (INT16)WINSOCK_connect( s, name, namelen );
833 }
834
835 /***********************************************************************
836 * getpeername() (WSOCK32.5)
837 */
838 INT WINAPI WINSOCK_getpeername(SOCKET s, struct sockaddr *name,
839 INT *namelen)
840 {
841 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
842 LPWSINFO pwsi = wsi_find(GetCurrentTask());
843 #ifdef HAVE_IPX
844 struct ws_sockaddr_ipx* name2 = (struct ws_sockaddr_ipx *)name;
845 #endif
846
847 TRACE(winsock, "(%08x): socket: %04x, ptr %8x, ptr %8x\n",
848 (unsigned)pwsi, s, (int) name, *namelen);
849 if( _check_ws(pwsi, pws) )
850 {
851 if (getpeername(pws->fd, name, namelen) == 0) {
852 #ifdef HAVE_IPX
853 if (((struct ws_sockaddr_ipx *)name)->sipx_family == AF_IPX) {
854 name = (struct sockaddr *)
855 malloc(namelen ? *namelen : sizeof(*name2));
856 memcpy(name, name2, namelen ? *namelen : sizeof(*name2));
857 name2->sipx_family = WS_AF_IPX;
858 name2->sipx_network = ((struct sockaddr_ipx *)name)->sipx_network;
859 name2->sipx_port = ((struct sockaddr_ipx *)name)->sipx_port;
860 memcpy(name2->sipx_node,
861 ((struct sockaddr_ipx *)name)->sipx_node, IPX_NODE_LEN);
862 free(name);
863 }
864 #endif
865 return 0;
866 }
867 pwsi->err = (h_errno < 0) ? wsaErrno() : wsaHerrno();
868 }
869 #ifdef HAVE_IPX
870 if (name && ((struct ws_sockaddr_ipx *)name)->sipx_family == AF_IPX) {
871 name = (struct sockaddr *) malloc(namelen ? *namelen : sizeof(*name2));
872 memcpy(name, name2, namelen ? *namelen : sizeof(*name2));
873 name2->sipx_family = WS_AF_IPX;
874 name2->sipx_network = ((struct sockaddr_ipx *)name)->sipx_network;
875 name2->sipx_port = ((struct sockaddr_ipx *)name)->sipx_port;
876 memcpy(name2->sipx_node,
877 ((struct sockaddr_ipx *)name)->sipx_node, IPX_NODE_LEN);
878 free(name);
879 }
880 #endif
881 return SOCKET_ERROR;
882 }
883
884 /***********************************************************************
885 * getpeername() (WINSOCK.5)
886 */
887 INT16 WINAPI WINSOCK_getpeername16(SOCKET16 s, struct sockaddr *name,
888 INT16 *namelen16)
889 {
890 INT namelen32 = *namelen16;
891 INT retVal = WINSOCK_getpeername( s, name, &namelen32 );
892
893 #if DEBUG_SOCKADDR
894 dump_sockaddr(name);
895 #endif
896
897 *namelen16 = namelen32;
898 return (INT16)retVal;
899 }
900
901 /***********************************************************************
902 * getsockname() (WSOCK32.6)
903 */
904 INT WINAPI WINSOCK_getsockname(SOCKET s, struct sockaddr *name,
905 INT *namelen)
906 {
907 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
908 LPWSINFO pwsi = wsi_find(GetCurrentTask());
909 #ifdef HAVE_IPX
910 struct ws_sockaddr_ipx* name2 = (struct ws_sockaddr_ipx *)name;
911 #endif
912
913 TRACE(winsock, "(%08x): socket: %04x, ptr %8x, ptr %8x\n",
914 (unsigned)pwsi, s, (int) name, (int) *namelen);
915 if( _check_ws(pwsi, pws) )
916 {
917 if (getsockname(pws->fd, name, namelen) == 0) {
918 #ifdef HAVE_IPX
919 if (((struct sockaddr_ipx *)name)->sipx_family == AF_IPX) {
920 name = (struct sockaddr *)
921 malloc(namelen ? *namelen : sizeof(*name2));
922 memcpy(name, name2, namelen ? *namelen : sizeof(*name2));
923 name2->sipx_family = WS_AF_IPX;
924 name2->sipx_network = ((struct sockaddr_ipx *)name)->sipx_network;
925 name2->sipx_port = ((struct sockaddr_ipx *)name)->sipx_port;
926 memcpy(name2->sipx_node,
927 ((struct sockaddr_ipx *)name)->sipx_node, IPX_NODE_LEN);
928 free(name);
929 }
930 #endif
931 return 0;
932 }
933 pwsi->err = (h_errno < 0) ? wsaErrno() : wsaHerrno();
934 }
935 #ifdef HAVE_IPX
936 if (name && ((struct ws_sockaddr_ipx *)name)->sipx_family == AF_IPX) {
937 name = (struct sockaddr *) malloc(namelen ? *namelen : sizeof(*name2));
938 memcpy(name, name2, namelen ? *namelen : sizeof(*name2));
939 name2->sipx_family = WS_AF_IPX;
940 name2->sipx_network = ((struct sockaddr_ipx *)name)->sipx_network;
941 name2->sipx_port = ((struct sockaddr_ipx *)name)->sipx_port;
942 memcpy(name2->sipx_node,
943 ((struct sockaddr_ipx *)name)->sipx_node, IPX_NODE_LEN);
944 free(name);
945 }
946 #endif
947 return SOCKET_ERROR;
948 }
949
950 /***********************************************************************
951 * getsockname() (WINSOCK.6)
952 */
953 INT16 WINAPI WINSOCK_getsockname16(SOCKET16 s, struct sockaddr *name,
954 INT16 *namelen16)
955 {
956 INT retVal;
957
958 if( namelen16 )
959 {
960 INT namelen32 = *namelen16;
961 retVal = WINSOCK_getsockname( s, name, &namelen32 );
962 *namelen16 = namelen32;
963
964 #if DEBUG_SOCKADDR
965 dump_sockaddr(name);
966 #endif
967
968 }
969 else retVal = SOCKET_ERROR;
970 return (INT16)retVal;
971 }
972
973
974 /***********************************************************************
975 * getsockopt() (WSOCK32.7)
976 */
977 INT WINAPI WINSOCK_getsockopt(SOCKET s, INT level,
978 INT optname, char *optval, INT *optlen)
979 {
980 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
981 LPWSINFO pwsi = wsi_find(GetCurrentTask());
982
983 TRACE(winsock, "(%08x): socket: %04x, opt %d, ptr %8x, ptr %8x\n",
984 (unsigned)pwsi, s, level, (int) optval, (int) *optlen);
985 if( _check_ws(pwsi, pws) )
986 {
987 convert_sockopt(&level, &optname);
988 if (getsockopt(pws->fd, (int) level, optname, optval, optlen) == 0 )
989 return 0;
990 pwsi->err = (errno == EBADF) ? WSAENOTSOCK : wsaErrno();
991 }
992 return SOCKET_ERROR;
993 }
994
995 /***********************************************************************
996 * getsockopt() (WINSOCK.7)
997 */
998 INT16 WINAPI WINSOCK_getsockopt16(SOCKET16 s, INT16 level,
999 INT16 optname, char *optval, INT16 *optlen)
1000 {
1001 INT optlen32;
1002 INT *p = &optlen32;
1003 INT retVal;
1004 if( optlen ) optlen32 = *optlen; else p = NULL;
1005 retVal = WINSOCK_getsockopt( s, (UINT16)level, optname, optval, p );
1006 if( optlen ) *optlen = optlen32;
1007 return (INT16)retVal;
1008 }
1009
1010 /***********************************************************************
1011 * htonl() (WINSOCK.8)(WSOCK32.8)
1012 */
1013 u_long WINAPI WINSOCK_htonl(u_long hostlong) { return( htonl(hostlong) ); }
1014 /***********************************************************************
1015 * htons() (WINSOCK.9)(WSOCK32.9)
1016 */
1017 u_short WINAPI WINSOCK_htons(u_short hostshort) { return( htons(hostshort) ); }
1018 /***********************************************************************
1019 * inet_addr() (WINSOCK.10)(WSOCK32.10)
1020 */
1021 u_long WINAPI WINSOCK_inet_addr(char *cp) { return( inet_addr(cp) ); }
1022 /***********************************************************************
1023 * htohl() (WINSOCK.14)(WSOCK32.14)
1024 */
1025 u_long WINAPI WINSOCK_ntohl(u_long netlong) { return( ntohl(netlong) ); }
1026 /***********************************************************************
1027 * ntohs() (WINSOCK.15)(WSOCK32.15)
1028 */
1029 u_short WINAPI WINSOCK_ntohs(u_short netshort) { return( ntohs(netshort) ); }
1030
1031 /***********************************************************************
1032 * inet_ntoa() (WINSOCK.11)(WSOCK32.11)
1033 */
1034 char* WINAPI WINSOCK_inet_ntoa(struct in_addr in)
1035 {
1036 /* use "buffer for dummies" here because some applications have
1037 * propensity to decode addresses in ws_hostent structure without
1038 * saving them first...
1039 */
1040
1041 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1042
1043 if( pwsi )
1044 {
1045 char* s = inet_ntoa(in);
1046 if( s )
1047 {
1048 if( pwsi->dbuffer == NULL )
1049 if((pwsi->dbuffer = (char*) SEGPTR_ALLOC(32)) == NULL )
1050 {
1051 pwsi->err = WSAENOBUFS;
1052 return NULL;
1053 }
1054 strncpy(pwsi->dbuffer, s, 32 );
1055 return pwsi->dbuffer;
1056 }
1057 pwsi->err = wsaErrno();
1058 }
1059 return NULL;
1060 }
1061
1062 SEGPTR WINAPI WINSOCK_inet_ntoa16(struct in_addr in)
1063 {
1064 char* retVal = WINSOCK_inet_ntoa(in);
1065 return retVal ? SEGPTR_GET(retVal) : (SEGPTR)NULL;
1066 }
1067
1068 /***********************************************************************
1069 * ioctlsocket() (WSOCK32.12)
1070 */
1071 INT WINAPI WINSOCK_ioctlsocket(SOCKET s, UINT cmd, UINT *argp)
1072 {
1073 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
1074 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1075
1076 TRACE(winsock, "(%08x): socket %04x, cmd %08x, ptr %8x\n",
1077 (unsigned)pwsi, s, cmd, (unsigned) argp);
1078 if( _check_ws(pwsi, pws) )
1079 {
1080 long newcmd = cmd;
1081
1082 switch( cmd )
1083 {
1084 case WS_FIONREAD:
1085 newcmd=FIONREAD;
1086 break;
1087
1088 case WS_FIONBIO:
1089 newcmd=FIONBIO;
1090 if( pws->psop && *argp == 0 )
1091 {
1092 /* AsyncSelect()'ed sockets are always nonblocking */
1093 pwsi->err = WSAEINVAL;
1094 return SOCKET_ERROR;
1095 }
1096 break;
1097
1098 case WS_SIOCATMARK:
1099 newcmd=SIOCATMARK;
1100 break;
1101
1102 case WS_IOW('f',125,u_long):
1103 WARN(winsock,"Warning: WS1.1 shouldn't be using async I/O\n");
1104 pwsi->err = WSAEINVAL;
1105 return SOCKET_ERROR;
1106
1107 default:
1108 /* Netscape tries hard to use bogus ioctl 0x667e */
1109 WARN(winsock, "\tunknown WS_IOCTL cmd (%08x)\n", cmd);
1110 }
1111 if( ioctl(pws->fd, newcmd, (char*)argp ) == 0 ) return 0;
1112 pwsi->err = (errno == EBADF) ? WSAENOTSOCK : wsaErrno();
1113 }
1114 return SOCKET_ERROR;
1115 }
1116
1117 /***********************************************************************
1118 * ioctlsocket() (WINSOCK.12)
1119 */
1120 INT16 WINAPI WINSOCK_ioctlsocket16(SOCKET16 s, UINT cmd, UINT *argp)
1121 {
1122 return (INT16)WINSOCK_ioctlsocket( s, cmd, argp );
1123 }
1124
1125
1126 /***********************************************************************
1127 * listen() (WSOCK32.13)
1128 */
1129 INT WINAPI WINSOCK_listen(SOCKET s, INT backlog)
1130 {
1131 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
1132 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1133
1134 TRACE(winsock, "(%08x): socket %04x, backlog %d\n",
1135 (unsigned)pwsi, s, backlog);
1136 if( _check_ws(pwsi, pws) )
1137 {
1138 if (listen(pws->fd, backlog) == 0)
1139 {
1140 if( !pws->psop )
1141 {
1142 int fd_flags = fcntl(pws->fd, F_GETFL, 0);
1143 if( !(fd_flags & O_NONBLOCK) ) pws->flags |= WS_FD_ACCEPT;
1144 }
1145 pws->flags |= WS_FD_LISTENING;
1146 pws->flags &= ~(WS_FD_INACTIVE | WS_FD_CONNECT | WS_FD_CONNECTED); /* just in case */
1147 return 0;
1148 }
1149 pwsi->err = wsaErrno();
1150 }
1151 else if( pwsi ) pwsi->err = WSAENOTSOCK;
1152 return SOCKET_ERROR;
1153 }
1154
1155 /***********************************************************************
1156 * listen() (WINSOCK.13)
1157 */
1158 INT16 WINAPI WINSOCK_listen16(SOCKET16 s, INT16 backlog)
1159 {
1160 return (INT16)WINSOCK_listen( s, backlog );
1161 }
1162
1163
1164 /***********************************************************************
1165 * recv() (WSOCK32.16)
1166 */
1167 INT WINAPI WINSOCK_recv(SOCKET s, char *buf, INT len, INT flags)
1168 {
1169 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
1170 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1171
1172 TRACE(winsock, "(%08x): socket %04x, buf %8x, len %d, "
1173 "flags %d\n", (unsigned)pwsi, s, (unsigned)buf,
1174 len, flags);
1175 if( _check_ws(pwsi, pws) )
1176 {
1177 INT length;
1178 if ((length = recv(pws->fd, buf, len, flags)) >= 0)
1179 {
1180 TRACE(winsock, " -> %i bytes\n", length);
1181
1182 if( pws->psop && (pws->flags & (WS_FD_READ | WS_FD_CLOSE)) )
1183 EVENT_AddIO( pws->fd, EVENT_IO_READ ); /* reenabler */
1184
1185 return length;
1186 }
1187 pwsi->err = wsaErrno();
1188 }
1189 else if( pwsi ) pwsi->err = WSAENOTSOCK;
1190 WARN(winsock, " -> ERROR\n");
1191 return SOCKET_ERROR;
1192 }
1193
1194 /***********************************************************************
1195 * recv() (WINSOCK.16)
1196 */
1197 INT16 WINAPI WINSOCK_recv16(SOCKET16 s, char *buf, INT16 len, INT16 flags)
1198 {
1199 return (INT16)WINSOCK_recv( s, buf, len, flags );
1200 }
1201
1202
1203 /***********************************************************************
1204 * recvfrom() (WSOCK32.17)
1205 */
1206 INT WINAPI WINSOCK_recvfrom(SOCKET s, char *buf, INT len, INT flags,
1207 struct sockaddr *from, INT *fromlen32)
1208 {
1209 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
1210 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1211 #ifdef HAVE_IPX
1212 struct ws_sockaddr_ipx* from2 = (struct ws_sockaddr_ipx *)from;
1213 #endif
1214
1215 TRACE(winsock, "(%08x): socket %04x, ptr %08x, "
1216 "len %d, flags %d\n", (unsigned)pwsi, s, (unsigned)buf,
1217 len, flags);
1218 #if DEBUG_SOCKADDR
1219 if( from ) dump_sockaddr(from);
1220 else DUMP("from = NULL\n");
1221 #endif
1222
1223 if( _check_ws(pwsi, pws) )
1224 {
1225 int length;
1226
1227 if ((length = recvfrom(pws->fd, buf, len, flags, from, fromlen32)) >= 0)
1228 {
1229 TRACE(winsock, " -> %i bytes\n", length);
1230
1231 if( pws->psop && (pws->flags & (WS_FD_READ | WS_FD_CLOSE)) )
1232 EVENT_AddIO( pws->fd, EVENT_IO_READ ); /* reenabler */
1233
1234 #ifdef HAVE_IPX
1235 if (from && ((struct sockaddr_ipx *)from)->sipx_family == AF_IPX) {
1236 from = (struct sockaddr *)
1237 malloc(fromlen32 ? *fromlen32 : sizeof(*from2));
1238 memcpy(from, from2, fromlen32 ? *fromlen32 : sizeof(*from2));
1239 from2->sipx_family = WS_AF_IPX;
1240 from2->sipx_network = ((struct sockaddr_ipx *)from)->sipx_network;
1241 from2->sipx_port = ((struct sockaddr_ipx *)from)->sipx_port;
1242 memcpy(from2->sipx_node,
1243 ((struct sockaddr_ipx *)from)->sipx_node, IPX_NODE_LEN);
1244 free(from);
1245 }
1246 #endif
1247 return (INT16)length;
1248 }
1249 pwsi->err = wsaErrno();
1250 }
1251 else if( pwsi ) pwsi->err = WSAENOTSOCK;
1252 WARN(winsock, " -> ERROR\n");
1253 #ifdef HAVE_IPX
1254 if (from && ((struct sockaddr_ipx *)from)->sipx_family == AF_IPX) {
1255 from = (struct sockaddr *)
1256 malloc(fromlen32 ? *fromlen32 : sizeof(*from2));
1257 memcpy(from, from2, fromlen32 ? *fromlen32 : sizeof(*from2));
1258 from2->sipx_family = WS_AF_IPX;
1259 from2->sipx_network = ((struct sockaddr_ipx *)from)->sipx_network;
1260 from2->sipx_port = ((struct sockaddr_ipx *)from)->sipx_port;
1261 memcpy(from2->sipx_node,
1262 ((struct sockaddr_ipx *)from)->sipx_node, IPX_NODE_LEN);
1263 free(from);
1264 }
1265 #endif
1266 return SOCKET_ERROR;
1267 }
1268
1269 /***********************************************************************
1270 * recvfrom() (WINSOCK.17)
1271 */
1272 INT16 WINAPI WINSOCK_recvfrom16(SOCKET16 s, char *buf, INT16 len, INT16 flags,
1273 struct sockaddr *from, INT16 *fromlen16)
1274 {
1275 INT fromlen32;
1276 INT *p = &fromlen32;
1277 INT retVal;
1278
1279 if( fromlen16 ) fromlen32 = *fromlen16; else p = NULL;
1280 retVal = WINSOCK_recvfrom( s, buf, len, flags, from, p );
1281 if( fromlen16 ) *fromlen16 = fromlen32;
1282 return (INT16)retVal;
1283 }
1284
1285 /***********************************************************************
1286 * select() (WINSOCK.18)(WSOCK32.18)
1287 */
1288 static INT __ws_select( BOOL b32, void *ws_readfds, void *ws_writefds, void *ws_exceptfds,
1289 struct timeval *timeout )
1290 {
1291 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1292
1293 TRACE(winsock, "(%08x): read %8x, write %8x, excp %8x\n",
1294 (unsigned) pwsi, (unsigned) ws_readfds, (unsigned) ws_writefds, (unsigned) ws_exceptfds);
1295
1296 if( pwsi )
1297 {
1298 int highfd = 0;
1299 fd_set readfds, writefds, exceptfds;
1300 fd_set *p_read, *p_write, *p_except;
1301
1302 p_read = fd_set_import(&readfds, pwsi, ws_readfds, &highfd, b32);
1303 p_write = fd_set_import(&writefds, pwsi, ws_writefds, &highfd, b32);
1304 p_except = fd_set_import(&exceptfds, pwsi, ws_exceptfds, &highfd, b32);
1305
1306 if( (highfd = select(highfd + 1, p_read, p_write, p_except, timeout)) > 0 )
1307 {
1308 fd_set_export(pwsi, &readfds, p_except, ws_readfds, b32);
1309 fd_set_export(pwsi, &writefds, p_except, ws_writefds, b32);
1310
1311 if (p_except && ws_exceptfds)
1312 {
1313 #define wsfds16 ((ws_fd_set16*)ws_exceptfds)
1314 #define wsfds32 ((ws_fd_set32*)ws_exceptfds)
1315 int i, j, count = (b32) ? wsfds32->fd_count : wsfds16->fd_count;
1316
1317 for (i = j = 0; i < count; i++)
1318 {
1319 ws_socket *pws = (b32) ? (ws_socket *)WS_HANDLE2PTR(wsfds32->fd_array[i])
1320 : (ws_socket *)WS_HANDLE2PTR(wsfds16->fd_array[i]);
1321 if( _check_ws(pwsi, pws) && FD_ISSET(pws->fd, &exceptfds) )
1322 {
1323 if( b32 )
1324 wsfds32->fd_array[j++] = wsfds32->fd_array[i];
1325 else
1326 wsfds16->fd_array[j++] = wsfds16->fd_array[i];
1327 }
1328 }
1329 if( b32 )
1330 wsfds32->fd_count = j;
1331 else
1332 wsfds16->fd_count = j;
1333 #undef wsfds32
1334 #undef wsfds16
1335 }
1336 return highfd;
1337 }
1338 if( ws_readfds ) ((ws_fd_set32*)ws_readfds)->fd_count = 0;
1339 if( ws_writefds ) ((ws_fd_set32*)ws_writefds)->fd_count = 0;
1340 if( ws_exceptfds ) ((ws_fd_set32*)ws_exceptfds)->fd_count = 0;
1341
1342 if( highfd == 0 ) return 0;
1343 pwsi->err = wsaErrno();
1344 }
1345 return SOCKET_ERROR;
1346 }
1347
1348 INT16 WINAPI WINSOCK_select16(INT16 nfds, ws_fd_set16 *ws_readfds,
1349 ws_fd_set16 *ws_writefds, ws_fd_set16 *ws_exceptfds,
1350 struct timeval *timeout)
1351 {
1352 return (INT16)__ws_select( FALSE, ws_readfds, ws_writefds, ws_exceptfds, timeout );
1353 }
1354
1355 INT WINAPI WINSOCK_select(INT nfds, ws_fd_set32 *ws_readfds,
1356 ws_fd_set32 *ws_writefds, ws_fd_set32 *ws_exceptfds,
1357 struct timeval *timeout)
1358 {
1359 /* struct timeval is the same for both 32- and 16-bit code */
1360 return (INT)__ws_select( TRUE, ws_readfds, ws_writefds, ws_exceptfds, timeout );
1361 }
1362
1363
1364 /***********************************************************************
1365 * send() (WSOCK32.19)
1366 */
1367 INT WINAPI WINSOCK_send(SOCKET s, char *buf, INT len, INT flags)
1368 {
1369 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
1370 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1371
1372 TRACE(winsock, "(%08x): socket %04x, ptr %08x, length %d, flags %d\n",
1373 (unsigned)pwsi, s, (unsigned) buf, len, flags);
1374 if( _check_ws(pwsi, pws) )
1375 {
1376 int length;
1377
1378 if ((length = send(pws->fd, buf, len, flags)) < 0 )
1379 {
1380 pwsi->err = wsaErrno();
1381 if( pwsi->err == WSAEWOULDBLOCK &&
1382 pws->psop && pws->flags & WS_FD_WRITE )
1383 EVENT_AddIO( pws->fd, EVENT_IO_WRITE ); /* reenabler */
1384 }
1385 else return (INT16)length;
1386 }
1387 else if( pwsi ) pwsi->err = WSAENOTSOCK;
1388 return SOCKET_ERROR;
1389 }
1390
1391 /***********************************************************************
1392 * send() (WINSOCK.19)
1393 */
1394 INT16 WINAPI WINSOCK_send16(SOCKET16 s, char *buf, INT16 len, INT16 flags)
1395 {
1396 return WINSOCK_send( s, buf, len, flags );
1397 }
1398
1399 /***********************************************************************
1400 * sendto() (WSOCK32.20)
1401 */
1402 INT WINAPI WINSOCK_sendto(SOCKET s, char *buf, INT len, INT flags,
1403 struct sockaddr *to, INT tolen)
1404 {
1405 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
1406 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1407 #ifdef HAVE_IPX
1408 struct ws_sockaddr_ipx* to2 = (struct ws_sockaddr_ipx *)to;
1409 #endif
1410
1411 TRACE(winsock, "(%08x): socket %04x, ptr %08x, length %d, flags %d\n",
1412 (unsigned)pwsi, s, (unsigned) buf, len, flags);
1413 if( _check_ws(pwsi, pws) )
1414 {
1415 INT length;
1416
1417 if (to && ((struct ws_sockaddr_ipx *)to)->sipx_family == WS_AF_PUP)
1418 ((struct ws_sockaddr_ipx *)to)->sipx_family = AF_UNSPEC;
1419 #ifdef HAVE_IPX
1420 else if (to &&
1421 ((struct ws_sockaddr_ipx *)to)->sipx_family == WS_AF_IPX)
1422 {
1423 to = (struct sockaddr *) malloc(sizeof(struct sockaddr_ipx));
1424 memset(to, '\0', sizeof(struct sockaddr_ipx));
1425 ((struct sockaddr_ipx *)to)->sipx_family = AF_IPX;
1426 ((struct sockaddr_ipx *)to)->sipx_port = to2->sipx_port;
1427 ((struct sockaddr_ipx *)to)->sipx_network = to2->sipx_network;
1428 memcpy(((struct sockaddr_ipx *)to)->sipx_node,
1429 to2->sipx_node, IPX_NODE_LEN);
1430 tolen = sizeof(struct sockaddr_ipx);
1431 }
1432 #endif
1433 if ((length = sendto(pws->fd, buf, len, flags, to, tolen)) < 0 )
1434 {
1435 pwsi->err = wsaErrno();
1436 if( pwsi->err == WSAEWOULDBLOCK &&
1437 pws->psop && pws->flags & WS_FD_WRITE )
1438 EVENT_AddIO( pws->fd, EVENT_IO_WRITE ); /* reenabler */
1439 }
1440 else {
1441 #ifdef HAVE_IPX
1442 if (to && ((struct sockaddr_ipx *)to)->sipx_family == AF_IPX) {
1443 free(to);
1444 }
1445 #endif
1446 return length;
1447 }
1448 }
1449 else if( pwsi ) pwsi->err = WSAENOTSOCK;
1450 #ifdef HAVE_IPX
1451 if (to && ((struct sockaddr_ipx *)to)->sipx_family == AF_IPX) {
1452 free(to);
1453 }
1454 #endif
1455 return SOCKET_ERROR;
1456 }
1457
1458 /***********************************************************************
1459 * sendto() (WINSOCK.20)
1460 */
1461 INT16 WINAPI WINSOCK_sendto16(SOCKET16 s, char *buf, INT16 len, INT16 flags,
1462 struct sockaddr *to, INT16 tolen)
1463 {
1464 return (INT16)WINSOCK_sendto( s, buf, len, flags, to, tolen );
1465 }
1466
1467 /***********************************************************************
1468 * setsockopt() (WSOCK32.21)
1469 */
1470 INT WINAPI WINSOCK_setsockopt(SOCKET16 s, INT level, INT optname,
1471 char *optval, INT optlen)
1472 {
1473 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
1474 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1475
1476 TRACE(winsock, "(%08x): socket %04x, lev %d, opt %d, ptr %08x, len %d\n",
1477 (unsigned)pwsi, s, level, optname, (int) optval, optlen);
1478 if( _check_ws(pwsi, pws) )
1479 {
1480 struct linger linger;
1481
1482 convert_sockopt(&level, &optname);
1483 if (optname == SO_LINGER && optval) {
1484 /* yes, uses unsigned short in both win16/win32 */
1485 linger.l_onoff = ((UINT16*)optval)[0];
1486 linger.l_linger = ((UINT16*)optval)[1];
1487 /* FIXME: what is documented behavior if SO_LINGER optval
1488 is null?? */
1489 optval = (char*)&linger;
1490 optlen = sizeof(struct linger);
1491 }
1492 if (setsockopt(pws->fd, level, optname, optval, optlen) == 0) return 0;
1493 pwsi->err = wsaErrno();
1494 }
1495 else if( pwsi ) pwsi->err = WSAENOTSOCK;
1496 return SOCKET_ERROR;
1497 }
1498
1499 /***********************************************************************
1500 * setsockopt() (WINSOCK.21)
1501 */
1502 INT16 WINAPI WINSOCK_setsockopt16(SOCKET16 s, INT16 level, INT16 optname,
1503 char *optval, INT16 optlen)
1504 {
1505 if( !optval ) return SOCKET_ERROR;
1506 return (INT16)WINSOCK_setsockopt( s, (UINT16)level, optname, optval, optlen );
1507 }
1508
1509
1510 /***********************************************************************
1511 * shutdown() (WSOCK32.22)
1512 */
1513 INT WINAPI WINSOCK_shutdown(SOCKET s, INT how)
1514 {
1515 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
1516 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1517
1518 TRACE(winsock, "(%08x): socket %04x, how %i\n",
1519 (unsigned)pwsi, s, how );
1520 if( _check_ws(pwsi, pws) )
1521 {
1522 if( pws->psop )
1523 switch( how )
1524 {
1525 case 0: /* drop receives */
1526 if( pws->flags & (WS_FD_READ | WS_FD_CLOSE) )
1527 EVENT_DeleteIO( pws->fd, EVENT_IO_READ );
1528 pws->flags &= ~(WS_FD_READ | WS_FD_CLOSE);
1529 #ifdef SHUT_RD
1530 how = SHUT_RD;
1531 #endif
1532 break;
1533
1534 case 1: /* drop sends */
1535 if( pws->flags & WS_FD_WRITE )
1536 EVENT_DeleteIO( pws->fd, EVENT_IO_WRITE );
1537 pws->flags &= ~WS_FD_WRITE;
1538 #ifdef SHUT_WR
1539 how = SHUT_WR;
1540 #endif
1541 break;
1542
1543 case 2: /* drop all */
1544 #ifdef SHUT_RDWR
1545 how = SHUT_RDWR;
1546 #endif
1547 default:
1548 WSAAsyncSelect( s, 0, 0, 0 );
1549 break;
1550 }
1551
1552 if (shutdown(pws->fd, how) == 0)
1553 {
1554 if( how > 1 )
1555 {
1556 pws->flags &= ~(WS_FD_CONNECTED | WS_FD_LISTENING);
1557 pws->flags |= WS_FD_INACTIVE;
1558 }
1559 return 0;
1560 }
1561 pwsi->err = wsaErrno();
1562 }
1563 else if( pwsi ) pwsi->err = WSAENOTSOCK;
1564 return SOCKET_ERROR;
1565 }
1566
1567 /***********************************************************************
1568 * shutdown() (WINSOCK.22)
1569 */
1570 INT16 WINAPI WINSOCK_shutdown16(SOCKET16 s, INT16 how)
1571 {
1572 return (INT16)WINSOCK_shutdown( s, how );
1573 }
1574
1575
1576 /***********************************************************************
1577 * socket() (WSOCK32.23)
1578 */
1579 SOCKET WINAPI WINSOCK_socket(INT af, INT type, INT protocol)
1580 {
1581 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1582
1583 TRACE(winsock, "(%08x): af=%d type=%d protocol=%d\n",
1584 (unsigned)pwsi, af, type, protocol);
1585
1586 if( pwsi )
1587 {
1588 int sock;
1589
1590 /* check the socket family */
1591 switch(af)
1592 {
1593 #ifdef HAVE_IPX
1594 case WS_AF_IPX: af = AF_IPX;
1595 #endif
1596 case AF_INET:
1597 case AF_UNSPEC: break;
1598 default: pwsi->err = WSAEAFNOSUPPORT;
1599 return INVALID_SOCKET;
1600 }
1601
1602 /* check the socket type */
1603 switch(type)
1604 {
1605 case SOCK_STREAM:
1606 case SOCK_DGRAM:
1607 case SOCK_RAW: break;
1608 default: pwsi->err = WSAESOCKTNOSUPPORT;
1609 return INVALID_SOCKET;
1610 }
1611
1612 /* check the protocol type */
1613 if ( protocol < 0 ) /* don't support negative values */
1614 { pwsi->err = WSAEPROTONOSUPPORT; return INVALID_SOCKET; }
1615
1616 if ( af == AF_UNSPEC) /* did they not specify the address family? */
1617 switch(protocol)
1618 {
1619 case IPPROTO_TCP:
1620 if (type == SOCK_STREAM) { af = AF_INET; break; }
1621 case IPPROTO_UDP:
1622 if (type == SOCK_DGRAM) { af = AF_INET; break; }
1623 default: pwsi->err = WSAEPROTOTYPE; return INVALID_SOCKET;
1624 }
1625
1626 if ((sock = socket(af, type, protocol)) >= 0)
1627 {
1628 ws_socket* pnew = wsi_alloc_socket(pwsi, sock);
1629
1630 TRACE(winsock,"\tcreated %i (handle %04x)\n", sock, (UINT16)WS_PTR2HANDLE(pnew));
1631
1632 if( pnew )
1633 {
1634 pnew->flags |= WS_FD_INACTIVE;
1635 return (SOCKET16)WS_PTR2HANDLE(pnew);
1636 }
1637
1638 close(sock);
1639 pwsi->err = WSAENOBUFS;
1640 return INVALID_SOCKET;
1641 }
1642
1643 if (errno == EPERM) /* raw socket denied */
1644 {
1645 WARN(winsock, "WS_SOCKET: not enough privileges\n");
1646 pwsi->err = WSAESOCKTNOSUPPORT;
1647 } else pwsi->err = wsaErrno();
1648 }
1649
1650 WARN(winsock, "\t\tfailed!\n");
1651 return INVALID_SOCKET;
1652 }
1653
1654 /***********************************************************************
1655 * socket() (WINSOCK.23)
1656 */
1657 SOCKET16 WINAPI WINSOCK_socket16(INT16 af, INT16 type, INT16 protocol)
1658 {
1659 return (SOCKET16)WINSOCK_socket( af, type, protocol );
1660 }
1661
1662
1663 /* ----------------------------------- DNS services
1664 *
1665 * IMPORTANT: 16-bit API structures have SEGPTR pointers inside them.
1666 * Also, we have to use wsock32 stubs to convert structures and
1667 * error codes from Unix to WSA, hence there is no direct mapping in
1668 * the relay32/wsock32.spec.
1669 */
1670
1671 static char* NULL_STRING = "NULL";
1672
1673 /***********************************************************************
1674 * gethostbyaddr() (WINSOCK.51)(WSOCK32.51)
1675 */
1676 static struct WIN_hostent* __ws_gethostbyaddr(const char *addr, int len, int type, int dup_flag)
1677 {
1678 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1679
1680 if( pwsi )
1681 {
1682 struct hostent* host;
1683 if( (host = gethostbyaddr(addr, len, type)) != NULL )
1684 if( WS_dup_he(pwsi, host, dup_flag) )
1685 return (struct WIN_hostent*)(pwsi->he);
1686 else
1687 pwsi->err = WSAENOBUFS;
1688 else
1689 pwsi->err = (h_errno < 0) ? wsaErrno() : wsaHerrno();
1690 }
1691 return NULL;
1692 }
1693
1694 SEGPTR WINAPI WINSOCK_gethostbyaddr16(const char *addr, INT16 len, INT16 type)
1695 {
1696 struct WIN_hostent* retval;
1697 TRACE(winsock, "ptr %08x, len %d, type %d\n",
1698 (unsigned) addr, len, type);
1699 retval = __ws_gethostbyaddr( addr, len, type, WS_DUP_SEGPTR );
1700 return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
1701 }
1702
1703 struct WIN_hostent* WINAPI WINSOCK_gethostbyaddr(const char *addr, INT len,
1704 INT type)
1705 {
1706 TRACE(winsock, "ptr %08x, len %d, type %d\n",
1707 (unsigned) addr, len, type);
1708 return __ws_gethostbyaddr(addr, len, type, WS_DUP_LINEAR);
1709 }
1710
1711 /***********************************************************************
1712 * gethostbyname() (WINSOCK.52)(WSOCK32.52)
1713 */
1714 static struct WIN_hostent * __ws_gethostbyname(const char *name, int dup_flag)
1715 {
1716 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1717
1718 if( pwsi )
1719 {
1720 struct hostent* host;
1721 if( (host = gethostbyname(name)) != NULL )
1722 if( WS_dup_he(pwsi, host, dup_flag) )
1723 return (struct WIN_hostent*)(pwsi->he);
1724 else pwsi->err = WSAENOBUFS;
1725 else pwsi->err = (h_errno < 0) ? wsaErrno() : wsaHerrno();
1726 }
1727 return NULL;
1728 }
1729
1730 SEGPTR WINAPI WINSOCK_gethostbyname16(const char *name)
1731 {
1732 struct WIN_hostent* retval;
1733 TRACE(winsock, "%s\n", (name)?name:NULL_STRING);
1734 retval = __ws_gethostbyname( name, WS_DUP_SEGPTR );
1735 return (retval)? SEGPTR_GET(retval) : ((SEGPTR)NULL) ;
1736 }
1737
1738 struct WIN_hostent* WINAPI WINSOCK_gethostbyname(const char* name)
1739 {
1740 TRACE(winsock, "%s\n", (name)?name:NULL_STRING);
1741 return __ws_gethostbyname( name, WS_DUP_LINEAR );
1742 }
1743
1744
1745 /***********************************************************************
1746 * getprotobyname() (WINSOCK.53)(WSOCK32.53)
1747 */
1748 static struct WIN_protoent* __ws_getprotobyname(const char *name, int dup_flag)
1749 {
1750 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1751
1752 if( pwsi )
1753 {
1754 struct protoent* proto;
1755 if( (proto = getprotobyname(name)) != NULL )
1756 if( WS_dup_pe(pwsi, proto, dup_flag) )
1757 return (struct WIN_protoent*)(pwsi->pe);
1758 else pwsi->err = WSAENOBUFS;
1759 else pwsi->err = (h_errno < 0) ? wsaErrno() : wsaHerrno();
1760 }
1761 return NULL;
1762 }
1763
1764 SEGPTR WINAPI WINSOCK_getprotobyname16(const char *name)
1765 {
1766 struct WIN_protoent* retval;
1767 TRACE(winsock, "%s\n", (name)?name:NULL_STRING);
1768 retval = __ws_getprotobyname(name, WS_DUP_SEGPTR);
1769 return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
1770 }
1771
1772 struct WIN_protoent* WINAPI WINSOCK_getprotobyname(const char* name)
1773 {
1774 TRACE(winsock, "%s\n", (name)?name:NULL_STRING);
1775 return __ws_getprotobyname(name, WS_DUP_LINEAR);
1776 }
1777
1778
1779 /***********************************************************************
1780 * getprotobynumber() (WINSOCK.54)(WSOCK32.54)
1781 */
1782 static struct WIN_protoent* __ws_getprotobynumber(int number, int dup_flag)
1783 {
1784 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1785
1786 if( pwsi )
1787 {
1788 struct protoent* proto;
1789 if( (proto = getprotobynumber(number)) != NULL )
1790 if( WS_dup_pe(pwsi, proto, dup_flag) )
1791 return (struct WIN_protoent*)(pwsi->pe);
1792 else pwsi->err = WSAENOBUFS;
1793 else pwsi->err = WSANO_DATA;
1794 }
1795 return NULL;
1796 }
1797
1798 SEGPTR WINAPI WINSOCK_getprotobynumber16(INT16 number)
1799 {
1800 struct WIN_protoent* retval;
1801 TRACE(winsock, "%i\n", number);
1802 retval = __ws_getprotobynumber(number, WS_DUP_SEGPTR);
1803 return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
1804 }
1805
1806 struct WIN_protoent* WINAPI WINSOCK_getprotobynumber(INT number)
1807 {
1808 TRACE(winsock, "%i\n", number);
1809 return __ws_getprotobynumber(number, WS_DUP_LINEAR);
1810 }
1811
1812
1813 /***********************************************************************
1814 * getservbyname() (WINSOCK.55)(WSOCK32.55)
1815 */
1816 struct WIN_servent* __ws_getservbyname(const char *name, const char *proto, int dup_flag)
1817 {
1818 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1819
1820 if( pwsi )
1821 {
1822 struct servent* serv;
1823 int i = wsi_strtolo( pwsi, name, proto );
1824
1825 if( i )
1826 if( (serv = getservbyname(pwsi->buffer, pwsi->buffer + i)) != NULL )
1827 if( WS_dup_se(pwsi, serv, dup_flag) )
1828 return (struct WIN_servent*)(pwsi->se);
1829 else pwsi->err = WSAENOBUFS;
1830 else pwsi->err = (h_errno < 0) ? wsaErrno() : wsaHerrno();
1831 else pwsi->err = WSAENOBUFS;
1832 }
1833 return NULL;
1834 }
1835
1836 SEGPTR WINAPI WINSOCK_getservbyname16(const char *name, const char *proto)
1837 {
1838 struct WIN_servent* retval;
1839 TRACE(winsock, "'%s', '%s'\n",
1840 (name)?name:NULL_STRING, (proto)?proto:NULL_STRING);
1841 retval = __ws_getservbyname(name, proto, WS_DUP_SEGPTR);
1842 return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
1843 }
1844
1845 struct WIN_servent* WINAPI WINSOCK_getservbyname(const char *name, const char *proto)
1846 {
1847 TRACE(winsock, "'%s', '%s'\n",
1848 (name)?name:NULL_STRING, (proto)?proto:NULL_STRING);
1849 return __ws_getservbyname(name, proto, WS_DUP_LINEAR);
1850 }
1851
1852
1853 /***********************************************************************
1854 * getservbyport() (WINSOCK.56)(WSOCK32.56)
1855 */
1856 static struct WIN_servent* __ws_getservbyport(int port, const char* proto, int dup_flag)
1857 {
1858 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1859
1860 if( pwsi )
1861 {
1862 struct servent* serv;
1863 int i = wsi_strtolo( pwsi, proto, NULL );
1864
1865 if( i )
1866 if( (serv = getservbyport(port, pwsi->buffer)) != NULL )
1867 if( WS_dup_se(pwsi, serv, dup_flag) )
1868 return (struct WIN_servent*)(pwsi->se);
1869 else pwsi->err = WSAENOBUFS;
1870 else pwsi->err = (h_errno < 0) ? wsaErrno() : wsaHerrno();
1871 else pwsi->err = WSAENOBUFS;
1872 }
1873 return NULL;
1874 }
1875
1876 SEGPTR WINAPI WINSOCK_getservbyport16(INT16 port, const char *proto)
1877 {
1878 struct WIN_servent* retval;
1879 TRACE(winsock, "%i, '%s'\n",
1880 (int)port, (proto)?proto:NULL_STRING);
1881 retval = __ws_getservbyport(port, proto, WS_DUP_SEGPTR);
1882 return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
1883 }
1884
1885 struct WIN_servent* WINAPI WINSOCK_getservbyport(INT port, const char *proto)
1886 {
1887 TRACE(winsock, "%i, '%s'\n",
1888 (int)port, (proto)?proto:NULL_STRING);
1889 return __ws_getservbyport(port, proto, WS_DUP_LINEAR);
1890 }
1891
1892
1893 /***********************************************************************
1894 * gethostname() (WSOCK32.57)
1895 */
1896 INT WINAPI WINSOCK_gethostname(char *name, INT namelen)
1897 {
1898 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1899
1900 TRACE(winsock, "(%08x): name %s, len %d\n",
1901 (unsigned)pwsi, (name)?name:NULL_STRING, namelen);
1902 if( pwsi )
1903 {
1904 if (gethostname(name, namelen) == 0) return 0;
1905 pwsi->err = (errno == EINVAL) ? WSAEFAULT : wsaErrno();
1906 }
1907 return SOCKET_ERROR;
1908 }
1909
1910 /***********************************************************************
1911 * gethostname() (WINSOCK.57)
1912 */
1913 INT16 WINAPI WINSOCK_gethostname16(char *name, INT16 namelen)
1914 {
1915 return (INT16)WINSOCK_gethostname(name, namelen);
1916 }
1917
1918
1919 /* ------------------------------------- Windows sockets extensions -- *
1920 * *
1921 * ------------------------------------------------------------------- */
1922
1923
1924 /***********************************************************************
1925 * WSAAsyncGetHostByAddr() (WINSOCK.102)
1926 */
1927 HANDLE16 WINAPI WSAAsyncGetHostByAddr16(HWND16 hWnd, UINT16 uMsg, LPCSTR addr,
1928 INT16 len, INT16 type, SEGPTR sbuf, INT16 buflen)
1929 {
1930 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1931
1932 TRACE(winsock, "(%08x): hwnd %04x, msg %04x, addr %08x[%i]\n",
1933 (unsigned)pwsi, hWnd, uMsg, (unsigned)addr , len );
1934
1935 if( pwsi )
1936 return __WSAsyncDBQuery(pwsi, hWnd, uMsg, type, addr, len,
1937 NULL, (void*)sbuf, buflen, WSMSG_ASYNC_HOSTBYADDR );
1938 return 0;
1939 }
1940
1941 /***********************************************************************
1942 * WSAAsyncGetHostByAddr() (WSOCK32.102)
1943 */
1944 HANDLE WINAPI WSAAsyncGetHostByAddr(HWND hWnd, UINT uMsg, LPCSTR addr,
1945 INT len, INT type, LPSTR sbuf, INT buflen)
1946 {
1947 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1948
1949 TRACE(winsock, "(%08x): hwnd %04x, msg %08x, addr %08x[%i]\n",
1950 (unsigned)pwsi, (HWND16)hWnd, uMsg, (unsigned)addr , len );
1951
1952 if( pwsi )
1953 return __WSAsyncDBQuery(pwsi, hWnd, uMsg, type, addr, len,
1954 NULL, (void*)sbuf, buflen, WSMSG_ASYNC_HOSTBYADDR | WSMSG_WIN32_AOP);
1955 return 0;
1956 }
1957
1958
1959 /***********************************************************************
1960 * WSAAsyncGetHostByName() (WINSOCK.103)
1961 */
1962 HANDLE16 WINAPI WSAAsyncGetHostByName16(HWND16 hWnd, UINT16 uMsg, LPCSTR name,
1963 SEGPTR sbuf, INT16 buflen)
1964 {
1965 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1966
1967 TRACE(winsock, "(%08x): hwnd %04x, msg %04x, host %s,
1968 buffer %i\n", (unsigned)pwsi, hWnd, uMsg, (name)?name:NULL_STRING, (int)buflen );
1969
1970 if( pwsi )
1971 return __WSAsyncDBQuery(pwsi, hWnd, uMsg, 0, name, 0,
1972 NULL, (void*)sbuf, buflen, WSMSG_ASYNC_HOSTBYNAME );
1973 return 0;
1974 }
1975
1976 /***********************************************************************
1977 * WSAAsyncGetHostByName32() (WSOCK32.103)
1978 */
1979 HANDLE WINAPI WSAAsyncGetHostByName(HWND hWnd, UINT uMsg, LPCSTR name,
1980 LPSTR sbuf, INT buflen)
1981 {
1982 LPWSINFO pwsi = wsi_find(GetCurrentTask());
1983 TRACE(winsock, "(%08x): hwnd %04x, msg %08x, host %s, buffer %i\n",
1984 (unsigned)pwsi, (HWND16)hWnd, uMsg,
1985 (name)?name:NULL_STRING, (int)buflen );
1986 if( pwsi )
1987 return __WSAsyncDBQuery(pwsi, hWnd, uMsg, 0, name, 0,
1988 NULL, (void*)sbuf, buflen, WSMSG_ASYNC_HOSTBYNAME | WSMSG_WIN32_AOP);
1989 return 0;
1990 }
1991
1992
1993 /***********************************************************************
1994 * WSAAsyncGetProtoByName() (WINSOCK.105)
1995 */
1996 HANDLE16 WINAPI WSAAsyncGetProtoByName16(HWND16 hWnd, UINT16 uMsg, LPCSTR name,
1997 SEGPTR sbuf, INT16 buflen)
1998 {
1999 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2000
2001 TRACE(winsock, "(%08x): hwnd %04x, msg %08x, protocol %s\n",
2002 (unsigned)pwsi, (HWND16)hWnd, uMsg, (name)?name:NULL_STRING );
2003
2004 if( pwsi )
2005 return __WSAsyncDBQuery(pwsi, hWnd, uMsg, 0, name, 0,
2006 NULL, (void*)sbuf, buflen, WSMSG_ASYNC_PROTOBYNAME );
2007 return 0;
2008 }
2009
2010 /***********************************************************************
2011 * WSAAsyncGetProtoByName() (WSOCK32.105)
2012 */
2013 HANDLE WINAPI WSAAsyncGetProtoByName(HWND hWnd, UINT uMsg, LPCSTR name,
2014 LPSTR sbuf, INT buflen)
2015 {
2016 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2017
2018 TRACE(winsock, "(%08x): hwnd %04x, msg %08x, protocol %s\n",
2019 (unsigned)pwsi, (HWND16)hWnd, uMsg, (name)?name:NULL_STRING );
2020
2021 if( pwsi )
2022 return __WSAsyncDBQuery(pwsi, hWnd, uMsg, 0, name, 0,
2023 NULL, (void*)sbuf, buflen, WSMSG_ASYNC_PROTOBYNAME | WSMSG_WIN32_AOP);
2024 return 0;
2025 }
2026
2027
2028 /***********************************************************************
2029 * WSAAsyncGetProtoByNumber() (WINSOCK.104)
2030 */
2031 HANDLE16 WINAPI WSAAsyncGetProtoByNumber16(HWND16 hWnd, UINT16 uMsg, INT16 number,
2032 SEGPTR sbuf, INT16 buflen)
2033 {
2034 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2035
2036 TRACE(winsock, "(%08x): hwnd %04x, msg %04x, num %i\n",
2037 (unsigned)pwsi, hWnd, uMsg, number );
2038
2039 if( pwsi )
2040 return __WSAsyncDBQuery(pwsi, hWnd, uMsg, number, NULL, 0,
2041 NULL, (void*)sbuf, buflen, WSMSG_ASYNC_PROTOBYNUM );
2042 return 0;
2043 }
2044
2045 /***********************************************************************
2046 * WSAAsyncGetProtoByNumber() (WSOCK32.104)
2047 */
2048 HANDLE WINAPI WSAAsyncGetProtoByNumber(HWND hWnd, UINT uMsg, INT number,
2049 LPSTR sbuf, INT buflen)
2050 {
2051 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2052
2053 TRACE(winsock, "(%08x): hwnd %04x, msg %08x, num %i\n",
2054 (unsigned)pwsi, (HWND16)hWnd, uMsg, number );
2055
2056 if( pwsi )
2057 return __WSAsyncDBQuery(pwsi, hWnd, uMsg, number, NULL, 0,
2058 NULL, (void*)sbuf, buflen, WSMSG_ASYNC_PROTOBYNUM | WSMSG_WIN32_AOP);
2059 return 0;
2060 }
2061
2062
2063 /***********************************************************************
2064 * WSAAsyncGetServByName() (WINSOCK.107)
2065 */
2066 HANDLE16 WINAPI WSAAsyncGetServByName16(HWND16 hWnd, UINT16 uMsg, LPCSTR name,
2067 LPCSTR proto, SEGPTR sbuf, INT16 buflen)
2068 {
2069 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2070
2071 TRACE(winsock, "(%08x): hwnd %04x, msg %04x, name %s, proto %s\n",
2072 (unsigned)pwsi, hWnd, uMsg,
2073 (name)?name:NULL_STRING, (proto)?proto:NULL_STRING );
2074
2075 if( pwsi )
2076 {
2077 int i = wsi_strtolo( pwsi, name, proto );
2078
2079 if( i )
2080 return __WSAsyncDBQuery(pwsi, hWnd, uMsg, 0, pwsi->buffer, 0,
2081 pwsi->buffer + i, (void*)sbuf, buflen, WSMSG_ASYNC_SERVBYNAME );
2082 }
2083 return 0;
2084 }
2085
2086 /***********************************************************************
2087 * WSAAsyncGetServByName() (WSOCK32.107)
2088 */
2089 HANDLE WINAPI WSAAsyncGetServByName(HWND hWnd, UINT uMsg, LPCSTR name,
2090 LPCSTR proto, LPSTR sbuf, INT buflen)
2091 {
2092 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2093
2094 TRACE(winsock, "(%08x): hwnd %04x, msg %08x, name %s, proto %s\n",
2095 (unsigned)pwsi, (HWND16)hWnd, uMsg,
2096 (name)?name:NULL_STRING, (proto)?proto:NULL_STRING );
2097 if( pwsi )
2098 {
2099 int i = wsi_strtolo( pwsi, name, proto );
2100
2101 if( i )
2102 return __WSAsyncDBQuery(pwsi, hWnd, uMsg, 0, pwsi->buffer, 0,
2103 pwsi->buffer + i, (void*)sbuf, buflen, WSMSG_ASYNC_SERVBYNAME | WSMSG_WIN32_AOP);
2104 }
2105 return 0;
2106 }
2107
2108
2109 /***********************************************************************
2110 * WSAAsyncGetServByPort() (WINSOCK.106)
2111 */
2112 HANDLE16 WINAPI WSAAsyncGetServByPort16(HWND16 hWnd, UINT16 uMsg, INT16 port,
2113 LPCSTR proto, SEGPTR sbuf, INT16 buflen)
2114 {
2115 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2116
2117 TRACE(winsock, "(%08x): hwnd %04x, msg %04x, port %i, proto %s\n",
2118 (unsigned)pwsi, hWnd, uMsg, port, (proto)?proto:NULL_STRING );
2119
2120 if( pwsi )
2121 {
2122 int i = wsi_strtolo( pwsi, proto, NULL );
2123
2124 if( i )
2125 return __WSAsyncDBQuery(pwsi, hWnd, uMsg, port, pwsi->buffer, 0,
2126 NULL, (void*)sbuf, buflen, WSMSG_ASYNC_SERVBYPORT );
2127 }
2128 return 0;
2129 }
2130
2131 /***********************************************************************
2132 * WSAAsyncGetServByPort() (WSOCK32.106)
2133 */
2134 HANDLE WINAPI WSAAsyncGetServByPort(HWND hWnd, UINT uMsg, INT port,
2135 LPCSTR proto, LPSTR sbuf, INT buflen)
2136 {
2137 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2138
2139 TRACE(winsock, "(%08x): hwnd %04x, msg %08x, port %i, proto %s\n",
2140 (unsigned)pwsi, (HWND16)hWnd, uMsg, port, (proto)?proto:NULL_STRING );
2141
2142 if( pwsi )
2143 {
2144 int i = wsi_strtolo( pwsi, proto, NULL );
2145
2146 if( i )
2147 return __WSAsyncDBQuery(pwsi, hWnd, uMsg, port, pwsi->buffer, 0,
2148 NULL, (void*)sbuf, buflen, WSMSG_ASYNC_SERVBYPORT | WSMSG_WIN32_AOP);
2149 }
2150 return 0;
2151 }
2152
2153
2154 /***********************************************************************
2155 * WSACancelAsyncRequest() (WINSOCK.108)(WSOCK32.109)
2156 */
2157 INT WINAPI WSACancelAsyncRequest(HANDLE hAsyncTaskHandle)
2158 {
2159 INT retVal = SOCKET_ERROR;
2160 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2161 ws_async_op* p_aop = (ws_async_op*)WS_HANDLE2PTR(hAsyncTaskHandle);
2162
2163 TRACE(winsock, "(%08x): handle %08x\n",
2164 (unsigned)pwsi, hAsyncTaskHandle);
2165 if( pwsi )
2166 {
2167 SIGNAL_MaskAsyncEvents( TRUE ); /* block SIGIO */
2168 if( WINSOCK_cancel_async_op(p_aop) )
2169 {
2170 WS_FREE(p_aop);
2171 pwsi->num_async_rq--;
2172 retVal = 0;
2173 }
2174 else pwsi->err = WSAEINVAL;
2175 SIGNAL_MaskAsyncEvents( FALSE );
2176 }
2177 return retVal;
2178 }
2179
2180 INT16 WINAPI WSACancelAsyncRequest16(HANDLE16 hAsyncTaskHandle)
2181 {
2182 return (HANDLE16)WSACancelAsyncRequest((HANDLE)hAsyncTaskHandle);
2183 }
2184
2185 /***********************************************************************
2186 * WSAAsyncSelect() (WINSOCK.101)(WSOCK32.101)
2187 */
2188
2189 static ws_select_op* __ws_select_list = NULL;
2190
2191 BOOL WINSOCK_HandleIO( int* max_fd, int num_pending,
2192 fd_set pending_set[3], fd_set event_set[3] )
2193 {
2194 /* This function is called by the event dispatcher
2195 * with the pending_set[] containing the result of select() and
2196 * the event_set[] containing all fd that are being watched */
2197
2198 ws_select_op* psop = __ws_select_list;
2199 BOOL bPost = FALSE;
2200 DWORD dwEvent, dwErrBytes;
2201 int num_posted;
2202
2203 TRACE(winsock,"%i pending descriptors\n", num_pending );
2204
2205 for( num_posted = dwEvent = 0 ; psop; psop = psop->next )
2206 {
2207 unsigned flags = psop->pws->flags;
2208 int fd = psop->pws->fd;
2209 int r, w, e;
2210
2211 w = 0;
2212 if( (r = FD_ISSET( fd, &pending_set[EVENT_IO_READ] )) ||
2213 (w = FD_ISSET( fd, &pending_set[EVENT_IO_WRITE] )) ||
2214 (e = FD_ISSET( fd, &pending_set[EVENT_IO_EXCEPT] )) )
2215 {
2216 /* This code removes WS_FD flags on one-shot events (WS_FD_CLOSE,
2217 * WS_FD_CONNECT), otherwise it clears descriptors in the io_set.
2218 * Reenabling calls turn them back on.
2219 */
2220
2221 TRACE(winsock,"\tchecking psop = 0x%08x\n", (unsigned) psop );
2222
2223 num_pending--;
2224
2225 /* Now figure out what kind of event we've got. The worst problem
2226 * we have to contend with is that some out of control applications
2227 * really want to use mutually exclusive AsyncSelect() flags all at
2228 * the same time.
2229 */
2230
2231 if((flags & WS_FD_ACCEPT) && (flags & WS_FD_LISTENING))
2232 {
2233 /* WS_FD_ACCEPT is valid only if the socket is in the
2234 * listening state */
2235
2236 FD_CLR( fd, &event_set[EVENT_IO_WRITE] );
2237 if( r )
2238 {
2239 FD_CLR( fd, &event_set[EVENT_IO_READ] ); /* reenabled by the next accept() */
2240 dwEvent = WSAMAKESELECTREPLY( WS_FD_ACCEPT, 0 );
2241 bPost = TRUE;
2242 }
2243 else continue;
2244 }
2245 else if( flags & WS_FD_CONNECT )
2246 {
2247 /* connecting socket */
2248
2249 if( w || (w = FD_ISSET( fd, &pending_set[EVENT_IO_WRITE] )) )
2250 {
2251 /* ready to write means that socket is connected
2252 *
2253 * FIXME: Netscape calls AsyncSelect( s, ... WS_FD_CONNECT .. )
2254 * right after s = socket() and somehow "s" becomes writeable
2255 * before it goes through connect()!?!?
2256 */
2257
2258 psop->pws->flags |= WS_FD_CONNECTED;
2259 psop->pws->flags &= ~(WS_FD_CONNECT | WS_FD_INACTIVE);
2260 dwEvent = WSAMAKESELECTREPLY( WS_FD_CONNECT, 0 );
2261
2262 if( flags & (WS_FD_READ | WS_FD_CLOSE))
2263 FD_SET( fd, &event_set[EVENT_IO_READ] );
2264 else
2265 FD_CLR( fd, &event_set[EVENT_IO_READ] );
2266 if( flags & WS_FD_WRITE )
2267 FD_SET( fd, &event_set[EVENT_IO_WRITE] );
2268 else
2269 FD_CLR( fd, &event_set[EVENT_IO_WRITE] );
2270 bPost = TRUE;
2271 }
2272 else if( r )
2273 {
2274 /* failure - do read() to get correct errno */
2275
2276 if( read( fd, &dwErrBytes, sizeof(dwErrBytes) ) == -1 )
2277 {
2278 dwEvent = WSAMAKESELECTREPLY( WS_FD_CONNECT, wsaErrno() );
2279 bPost = TRUE;
2280 }
2281 }
2282 /* otherwise bPost stays FALSE, should probably clear event_set */
2283 }
2284 else
2285 {
2286 /* connected socket, no WS_FD_OOB code for now. */
2287
2288 if( flags & WS_FD_WRITE &&
2289 (w || (w = FD_ISSET( fd, &pending_set[EVENT_IO_WRITE] ))) )
2290 {
2291 /* this will be reenabled when send() or sendto() fail with
2292 * WSAEWOULDBLOCK */
2293
2294 if( PostMessageA( psop->hWnd, psop->uMsg, (WPARAM)WS_PTR2HANDLE(psop->pws),
2295 (LPARAM)WSAMAKESELECTREPLY( WS_FD_WRITE, 0 ) ) )
2296 {
2297 TRACE(winsock, "\t hwnd %04x - %04x, %08x\n",
2298 psop->hWnd, psop->uMsg, (unsigned)MAKELONG(WS_FD_WRITE, 0) );
2299 FD_CLR( fd, &event_set[EVENT_IO_WRITE] );
2300 num_posted++;
2301 }
2302 }
2303
2304 if( r && (flags & (WS_FD_READ | WS_FD_CLOSE)) )
2305 {
2306 int val = (flags & WS_FD_RAW);
2307
2308 /* WS_FD_RAW is set by the WSAAsyncSelect() init */
2309
2310 bPost = TRUE;
2311 if( !val && ioctl( fd, FIONREAD, (char*)&dwErrBytes) == -1 )
2312 {
2313 /* weirdness */
2314
2315 dwEvent = WSAMAKESELECTREPLY( WS_FD_READ, wsaErrno() );
2316 }
2317 else if( val || dwErrBytes )
2318 {
2319 /* got pending data, will be reenabled by recv() or recvfrom() */
2320
2321 FD_CLR( fd, &event_set[EVENT_IO_READ] );
2322 dwEvent = WSAMAKESELECTREPLY( WS_FD_READ, 0 );
2323 }
2324 else
2325 {
2326 /* 0 bytes to read - connection reset by peer? */
2327
2328 do
2329 val = read( fd, (char*)&dwErrBytes, sizeof(dwErrBytes));
2330 while( errno == EINTR );
2331 if( errno != EWOULDBLOCK )
2332 {
2333 switch( val )
2334 {
2335 case 0: errno = ENETDOWN; /* soft reset, fall through */
2336 case -1: /* hard reset */
2337 dwEvent = WSAMAKESELECTREPLY( WS_FD_CLOSE, wsaErrno() );
2338 break;
2339
2340 default: bPost = FALSE;
2341 continue; /* FIXME: this is real bad */
2342 }
2343 }
2344 else { bPost = FALSE; continue; } /* more weirdness */
2345
2346 /* this is it, this socket is closed */
2347
2348 psop->pws->flags &= ~(WS_FD_READ | WS_FD_CLOSE | WS_FD_WRITE);
2349 FD_CLR( fd, &event_set[EVENT_IO_READ] );
2350 FD_CLR( fd, &event_set[EVENT_IO_WRITE] );
2351
2352 if( *max_fd == (fd + 1) ) (*max_fd)--;
2353 }
2354 }
2355 }
2356
2357 if( bPost )
2358 {
2359 TRACE(winsock, "\t hwnd %04x - %04x, %08x\n",
2360 psop->hWnd, psop->uMsg, (unsigned)dwEvent );
2361 PostMessageA( psop->hWnd, psop->uMsg,
2362 (WPARAM)WS_PTR2HANDLE(psop->pws), (LPARAM)dwEvent );
2363 bPost = FALSE;
2364 num_posted++;
2365 }
2366 }
2367 if( num_pending <= 0 ) break;
2368 }
2369
2370 TRACE(winsock, "\tdone, %i posted events\n", num_posted );
2371 return ( num_posted ) ? TRUE : FALSE;
2372 }
2373
2374 INT WINAPI WSAAsyncSelect(SOCKET s, HWND hWnd, UINT uMsg, UINT lEvent)
2375 {
2376 ws_socket* pws = (ws_socket*)WS_HANDLE2PTR(s);
2377 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2378
2379 TRACE(winsock, "(%08x): %04x, hWnd %04x, uMsg %08x, event %08x\n",
2380 (unsigned)pwsi, (SOCKET16)s, (HWND16)hWnd, uMsg, (unsigned)lEvent );
2381 if( _check_ws(pwsi, pws) )
2382 {
2383 ws_select_op* psop;
2384
2385 if( (psop = pws->psop) )
2386 {
2387 /* delete previous control struct */
2388
2389 if( psop == __ws_select_list )
2390 __ws_select_list = psop->next;
2391 else
2392 psop->prev->next = psop->next;
2393 if( psop->next ) psop->next->prev = psop->prev;
2394
2395 if( pws->flags & (WS_FD_ACCEPT | WS_FD_CONNECT | WS_FD_READ | WS_FD_CLOSE) )
2396 EVENT_DeleteIO( pws->fd, EVENT_IO_READ );
2397 if( pws->flags & (WS_FD_CONNECT | WS_FD_WRITE) )
2398 EVENT_DeleteIO( pws->fd, EVENT_IO_WRITE );
2399
2400 TRACE(winsock,"\tremoving psop = 0x%08x\n", (unsigned) psop );
2401
2402 WS_FREE( pws->psop );
2403 pws->flags &= ~(WS_FD_RAW | WS_FD_ACCEPT | WS_FD_CONNECT |
2404 WS_FD_READ | WS_FD_WRITE | WS_FD_CLOSE);
2405 pws->psop = NULL;
2406 }
2407
2408 if( lEvent )
2409 {
2410 psop = (ws_select_op*)WS_ALLOC(sizeof(ws_select_op));
2411 if( psop )
2412 {
2413 int sock_type, bytes = sizeof(int);
2414
2415 WINSOCK_unblock_io( pws->fd, TRUE );
2416
2417 psop->prev = NULL;
2418 psop->next = __ws_select_list;
2419 if( __ws_select_list )
2420 __ws_select_list->prev = psop;
2421 __ws_select_list = psop;
2422
2423 psop->pws = pws;
2424 psop->hWnd = hWnd;
2425 psop->uMsg = uMsg;
2426
2427 pws->psop = psop;
2428 pws->flags |= (0x0000FFFF & lEvent);
2429 getsockopt(pws->fd, SOL_SOCKET, SO_TYPE, &sock_type, &bytes);
2430 if( sock_type == SOCK_RAW ) pws->flags |= WS_FD_RAW;
2431
2432 if( lEvent & (WS_FD_ACCEPT | WS_FD_CONNECT | WS_FD_READ | WS_FD_CLOSE) )
2433 EVENT_AddIO( pws->fd, EVENT_IO_READ );
2434 if( lEvent & (WS_FD_CONNECT | WS_FD_WRITE) )
2435 EVENT_AddIO( pws->fd, EVENT_IO_WRITE );
2436
2437 /* TODO: handle WS_FD_ACCEPT right away if the socket is readable */
2438
2439 TRACE(winsock,"\tcreating psop = 0x%08x\n", (unsigned)psop );
2440
2441 return 0; /* success */
2442 }
2443 else pwsi->err = WSAENOBUFS;
2444 }
2445 else return 0;
2446 }
2447 else if( pwsi ) pwsi->err = WSAEINVAL;
2448 return SOCKET_ERROR;
2449 }
2450
2451 INT16 WINAPI WSAAsyncSelect16(SOCKET16 s, HWND16 hWnd, UINT16 wMsg, UINT lEvent)
2452 {
2453 return (INT16)WSAAsyncSelect( s, hWnd, wMsg, lEvent );
2454 }
2455
2456
2457 /***********************************************************************
2458 * __WSAFDIsSet() (WINSOCK.151)
2459 */
2460 INT16 WINAPI __WSAFDIsSet16(SOCKET16 s, ws_fd_set16 *set)
2461 {
2462 int i = set->fd_count;
2463
2464 TRACE(winsock, "(%d,%8lx(%i))\n", s,(unsigned long)set, i);
2465
2466 while (i--)
2467 if (set->fd_array[i] == s) return 1;
2468 return 0;
2469 }
2470
2471 /***********************************************************************
2472 * __WSAFDIsSet() (WSOCK32.151)
2473 */
2474 INT WINAPI __WSAFDIsSet(SOCKET s, ws_fd_set32 *set)
2475 {
2476 int i = set->fd_count;
2477
2478 TRACE(winsock, "(%d,%8lx(%i))\n", s,(unsigned long)set, i);
2479
2480 while (i--)
2481 if (set->fd_array[i] == s) return 1;
2482 return 0;
2483 }
2484
2485 /***********************************************************************
2486 * WSAIsBlocking() (WINSOCK.114)(WSOCK32.114)
2487 */
2488 BOOL WINAPI WSAIsBlocking(void)
2489 {
2490 /* By default WinSock should set all its sockets to non-blocking mode
2491 * and poll in PeekMessage loop when processing "blocking" ones. This
2492 * function is supposed to tell if the program is in this loop. Our
2493 * blocking calls are truly blocking so we always return FALSE.
2494 *
2495 * Note: It is allowed to call this function without prior WSAStartup().
2496 */
2497
2498 TRACE(winsock, "\n");
2499 return FALSE;
2500 }
2501
2502 /***********************************************************************
2503 * WSACancelBlockingCall() (WINSOCK.113)(WSOCK32.113)
2504 */
2505 INT WINAPI WSACancelBlockingCall(void)
2506 {
2507 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2508
2509 TRACE(winsock, "(%08x)\n", (unsigned)pwsi);
2510
2511 if( pwsi ) return 0;
2512 return SOCKET_ERROR;
2513 }
2514
2515
2516 /***********************************************************************
2517 * WSASetBlockingHook16() (WINSOCK.109)
2518 */
2519 FARPROC16 WINAPI WSASetBlockingHook16(FARPROC16 lpBlockFunc)
2520 {
2521 FARPROC16 prev;
2522 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2523
2524 TRACE(winsock, "(%08x): hook %08x\n",
2525 (unsigned)pwsi, (unsigned) lpBlockFunc);
2526 if( pwsi )
2527 {
2528 prev = (FARPROC16)pwsi->blocking_hook;
2529 pwsi->blocking_hook = (DWORD)lpBlockFunc;
2530 pwsi->flags &= ~WSI_BLOCKINGHOOK;
2531 return prev;
2532 }
2533 return 0;
2534 }
2535
2536
2537 /***********************************************************************
2538 * WSASetBlockingHook32()
2539 */
2540 FARPROC WINAPI WSASetBlockingHook(FARPROC lpBlockFunc)
2541 {
2542 FARPROC prev;
2543 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2544
2545 TRACE(winsock, "(%08x): hook %08x\n",
2546 (unsigned)pwsi, (unsigned) lpBlockFunc);
2547 if( pwsi ) {
2548 prev = (FARPROC)pwsi->blocking_hook;
2549 pwsi->blocking_hook = (DWORD)lpBlockFunc;
2550 pwsi->flags |= WSI_BLOCKINGHOOK;
2551 return prev;
2552 }
2553 return NULL;
2554 }
2555
2556
2557 /***********************************************************************
2558 * WSAUnhookBlockingHook16() (WINSOCK.110)
2559 */
2560 INT16 WINAPI WSAUnhookBlockingHook16(void)
2561 {
2562 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2563
2564 TRACE(winsock, "(%08x)\n", (unsigned)pwsi);
2565 if( pwsi ) return (INT16)(pwsi->blocking_hook = 0);
2566 return SOCKET_ERROR;
2567 }
2568
2569
2570 /***********************************************************************
2571 * WSAUnhookBlockingHook32()
2572 */
2573 INT WINAPI WSAUnhookBlockingHook(void)
2574 {
2575 LPWSINFO pwsi = wsi_find(GetCurrentTask());
2576
2577 TRACE(winsock, "(%08x)\n", (unsigned)pwsi);
2578 if( pwsi )
2579 {
2580 pwsi->blocking_hook = 0;
2581 pwsi->flags &= ~WSI_BLOCKINGHOOK;
2582 return 0;
2583 }
2584 return SOCKET_ERROR;
2585 }
2586
2587 /*
2588 * TCP/IP action codes.
2589 */
2590
2591
2592 #define WSCNTL_TCPIP_QUERY_INFO 0x00000000
2593 #define WSCNTL_TCPIP_SET_INFO 0x00000001
2594 #define WSCNTL_TCPIP_ICMP_ECHO 0x00000002
2595 #define WSCNTL_TCPIP_TEST 0x00000003
2596
2597
2598 /***********************************************************************
2599 * WsControl()
2600 *
2601 * WsControl seems to be an undocumented Win95 function. A lot of
2602 * discussion about WsControl can be found on the net, e.g.
2603 * Subject: Re: WSOCK32.DLL WsControl Exported Function
2604 * From: "Peter Rindfuss" <rindfuss-s@medea.wz-berlin.de>
2605 * Date: 1997/08/17
2606 */
2607
2608 DWORD WINAPI WsControl(DWORD protocoll,DWORD action,
2609 LPVOID inbuf,LPDWORD inbuflen,
2610 LPVOID outbuf,LPDWORD outbuflen)
2611 {
2612
2613 switch (action) {
2614 case WSCNTL_TCPIP_ICMP_ECHO:
2615 {
2616 unsigned int addr = *(unsigned int*)inbuf;
2617 #if 0
2618 int timeout= *(unsigned int*)(inbuf+4);
2619 short x1 = *(unsigned short*)(inbuf+8);
2620 short sendbufsize = *(unsigned short*)(inbuf+10);
2621 char x2 = *(unsigned char*)(inbuf+12);
2622 char ttl = *(unsigned char*)(inbuf+13);
2623 char service = *(unsigned char*)(inbuf+14);
2624 char type= *(unsigned char*)(inbuf+15); /* 0x2: don't fragment*/
2625 #endif
2626
2627 FIXME(winsock,"(ICMP_ECHO) to 0x%08x stub \n", addr);
2628 break;
2629 }
2630 default:
2631 FIXME(winsock,"(%lx,%lx,%p,%p,%p,%p) stub\n",
2632 protocoll,action,inbuf,inbuflen,outbuf,outbuflen);
2633 }
2634 return FALSE;
2635 }
2636 /*********************************************************
2637 * WS_s_perror WSOCK32.1108
2638 */
2639 void WINAPI WS_s_perror(LPCSTR message)
2640 {
2641 FIXME(winsock,"(%s): stub\n",message);
2642 return;
2643 }
2644
2645
2646 /* ----------------------------------- end of API stuff */
2647
2648 /* ----------------------------------- helper functions -
2649 *
2650 * TODO: Merge WS_dup_..() stuff into one function that
2651 * would operate with a generic structure containing internal
2652 * pointers (via a template of some kind).
2653 */
2654
2655 static int list_size(char** l, int item_size)
2656 {
2657 int i,j = 0;
2658 if(l)
2659 { for(i=0;l[i];i++)
2660 j += (item_size) ? item_size : strlen(l[i]) + 1;
2661 j += (i + 1) * sizeof(char*); }
2662 return j;
2663 }
2664
2665 static int list_dup(char** l_src, char* ref, char* base, int item_size)
2666 {
2667 /* base is either either equal to ref or 0 or SEGPTR */
2668
2669 char* p = ref;
2670 char** l_to = (char**)ref;
2671 int i,j,k;
2672
2673 for(j=0;l_src[j];j++) ;
2674 p += (j + 1) * sizeof(char*);
2675 for(i=0;i<j;i++)
2676 { l_to[i] = base + (p - ref);
2677 k = ( item_size ) ? item_size : strlen(l_src[i]) + 1;
2678 memcpy(p, l_src[i], k); p += k; }
2679 l_to[i] = NULL;
2680 return (p - ref);
2681 }
2682
2683 /* ----- hostent */
2684
2685 static int hostent_size(struct hostent* p_he)
2686 {
2687 int size = 0;
2688 if( p_he )
2689 { size = sizeof(struct hostent);
2690 size += strlen(p_he->h_name) + 1;
2691 size += list_size(p_he->h_aliases, 0);
2692 size += list_size(p_he->h_addr_list, p_he->h_length ); }
2693 return size;
2694 }
2695
2696 int WS_dup_he(LPWSINFO pwsi, struct hostent* p_he, int flag)
2697 {
2698 /* Convert hostent structure into ws_hostent so that the data fits
2699 * into pwsi->buffer. Internal pointers can be linear, SEGPTR, or
2700 * relative to pwsi->buffer depending on "flag" value. Returns size
2701 * of the data copied (also in the pwsi->buflen).
2702 */
2703
2704 int size = hostent_size(p_he);
2705
2706 if( size )
2707 {
2708 struct ws_hostent* p_to;
2709 char* p_name,*p_aliases,*p_addr,*p_base,*p;
2710
2711 _check_buffer_he(pwsi, size);
2712 p_to = (struct ws_hostent*)pwsi->he;
2713 p = (char*)pwsi->he;
2714 p_base = (flag & WS_DUP_OFFSET) ? NULL
2715 : ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
2716 p += sizeof(struct ws_hostent);
2717 p_name = p;
2718 strcpy(p, p_he->h_name); p += strlen(p) + 1;
2719 p_aliases = p;
2720 p += list_dup(p_he->h_aliases, p, p_base + (p - (char*)pwsi->he), 0);
2721 p_addr = p;
2722 list_dup(p_he->h_addr_list, p, p_base + (p - (char*)pwsi->he), p_he->h_length);
2723
2724 p_to->h_addrtype = (INT16)p_he->h_addrtype;
2725 p_to->h_length = (INT16)p_he->h_length;
2726 p_to->h_name = (SEGPTR)(p_base + (p_name - (char*)pwsi->he));
2727 p_to->h_aliases = (SEGPTR)(p_base + (p_aliases - (char*)pwsi->he));
2728 p_to->h_addr_list = (SEGPTR)(p_base + (p_addr - (char*)pwsi->he));
2729
2730 size += (sizeof(struct ws_hostent) - sizeof(struct hostent));
2731 }
2732 return size;
2733 }
2734
2735 /* ----- protoent */
2736
2737 static int protoent_size(struct protoent* p_pe)
2738 {
2739 int size = 0;
2740 if( p_pe )
2741 { size = sizeof(struct protoent);
2742 size += strlen(p_pe->p_name) + 1;
2743 size += list_size(p_pe->p_aliases, 0); }
2744 return size;
2745 }
2746
2747 int WS_dup_pe(LPWSINFO pwsi, struct protoent* p_pe, int flag)
2748 {
2749 int size = protoent_size(p_pe);
2750 if( size )
2751 {
2752 struct ws_protoent* p_to;
2753 char* p_name,*p_aliases,*p_base,*p;
2754
2755 _check_buffer_pe(pwsi, size);
2756 p_to = (struct ws_protoent*)pwsi->pe;
2757 p = (char*)pwsi->pe;
2758 p_base = (flag & WS_DUP_OFFSET) ? NULL
2759 : ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
2760 p += sizeof(struct ws_protoent);
2761 p_name = p;
2762 strcpy(p, p_pe->p_name); p += strlen(p) + 1;
2763 p_aliases = p;
2764 list_dup(p_pe->p_aliases, p, p_base + (p - (char*)pwsi->pe), 0);
2765
2766 p_to->p_proto = (INT16)p_pe->p_proto;
2767 p_to->p_name = (SEGPTR)(p_base) + (p_name - (char*)pwsi->pe);
2768 p_to->p_aliases = (SEGPTR)((p_base) + (p_aliases - (char*)pwsi->pe));
2769
2770 size += (sizeof(struct ws_protoent) - sizeof(struct protoent));
2771 }
2772 return size;
2773 }
2774
2775 /* ----- servent */
2776
2777 static int servent_size(struct servent* p_se)
2778 {
2779 int size = 0;
2780 if( p_se )
2781 { size += sizeof(struct servent);
2782 size += strlen(p_se->s_proto) + strlen(p_se->s_name) + 2;
2783 size += list_size(p_se->s_aliases, 0); }
2784 return size;
2785 }
2786
2787 int WS_dup_se(LPWSINFO pwsi, struct servent* p_se, int flag)
2788 {
2789 int size = servent_size(p_se);
2790 if( size )
2791 {
2792 struct ws_servent* p_to;
2793 char* p_name,*p_aliases,*p_proto,*p_base,*p;
2794
2795 _check_buffer_se(pwsi, size);
2796 p_to = (struct ws_servent*)pwsi->se;
2797 p = (char*)pwsi->se;
2798 p_base = (flag & WS_DUP_OFFSET) ? NULL
2799 : ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
2800 p += sizeof(struct ws_servent);
2801 p_name = p;
2802 strcpy(p, p_se->s_name); p += strlen(p) + 1;
2803 p_proto = p;
2804 strcpy(p, p_se->s_proto); p += strlen(p) + 1;
2805 p_aliases = p;
2806 list_dup(p_se->s_aliases, p, p_base + (p - (char*)pwsi->se), 0);
2807
2808 p_to->s_port = (INT16)p_se->s_port;
2809 p_to->s_name = (SEGPTR)(p_base + (p_name - (char*)pwsi->se));
2810 p_to->s_proto = (SEGPTR)(p_base + (p_proto - (char*)pwsi->se));
2811 p_to->s_aliases = (SEGPTR)(p_base + (p_aliases - (char*)pwsi->se));
2812
2813 size += (sizeof(struct ws_servent) - sizeof(struct servent));
2814 }
2815 return size;
2816 }
2817
2818 /* ----------------------------------- error handling */
2819
2820 UINT16 wsaErrno(void)
2821 {
2822 int loc_errno = errno;
2823 #ifdef HAVE_STRERROR
2824 WARN(winsock, "errno %d, (%s).\n", loc_errno, strerror(loc_errno));
2825 #else
2826 WARN(winsock, "errno %d\n", loc_errno);
2827 #endif
2828
2829 switch(loc_errno)
2830 {
2831 case EINTR: return WSAEINTR;
2832 case EBADF: return WSAEBADF;
2833 case EACCES: return WSAEACCES;
2834 case EFAULT: return WSAEFAULT;
2835 case EINVAL: return WSAEINVAL;
2836 case EMFILE: return WSAEMFILE;
2837 case EWOULDBLOCK: return WSAEWOULDBLOCK;
2838 case EINPROGRESS: return WSAEINPROGRESS;
2839 case EALREADY: return WSAEALREADY;
2840 case ENOTSOCK: return WSAENOTSOCK;
2841 case EDESTADDRREQ: return WSAEDESTADDRREQ;
2842 case EMSGSIZE: return WSAEMSGSIZE;
2843 case EPROTOTYPE: return WSAEPROTOTYPE;
2844 case ENOPROTOOPT: return WSAENOPROTOOPT;
2845 case EPROTONOSUPPORT: return WSAEPROTONOSUPPORT;
2846 case ESOCKTNOSUPPORT: return WSAESOCKTNOSUPPORT;
2847 case EOPNOTSUPP: return WSAEOPNOTSUPP;
2848 case EPFNOSUPPORT: return WSAEPFNOSUPPORT;
2849 case EAFNOSUPPORT: return WSAEAFNOSUPPORT;
2850 case EADDRINUSE: return WSAEADDRINUSE;
2851 case EADDRNOTAVAIL: return WSAEADDRNOTAVAIL;
2852 case ENETDOWN: return WSAENETDOWN;
2853 case ENETUNREACH: return WSAENETUNREACH;
2854 case ENETRESET: return WSAENETRESET;
2855 case ECONNABORTED: return WSAECONNABORTED;
2856 case EPIPE:
2857 case ECONNRESET: return WSAECONNRESET;
2858 case ENOBUFS: return WSAENOBUFS;
2859 case EISCONN: return WSAEISCONN;
2860 case ENOTCONN: return WSAENOTCONN;
2861 case ESHUTDOWN: return WSAESHUTDOWN;
2862 case ETOOMANYREFS: return WSAETOOMANYREFS;
2863 case ETIMEDOUT: return WSAETIMEDOUT;
2864 case ECONNREFUSED: return WSAECONNREFUSED;
2865 case ELOOP: return WSAELOOP;
2866 case ENAMETOOLONG: return WSAENAMETOOLONG;
2867 case EHOSTDOWN: return WSAEHOSTDOWN;
2868 case EHOSTUNREACH: return WSAEHOSTUNREACH;
2869 case ENOTEMPTY: return WSAENOTEMPTY;
2870 #ifdef EPROCLIM
2871 case EPROCLIM: return WSAEPROCLIM;
2872 #endif
2873 #ifdef EUSERS
2874 case EUSERS: return WSAEUSERS;
2875 #endif
2876 #ifdef EDQUOT
2877 case EDQUOT: return WSAEDQUOT;
2878 #endif
2879 #ifdef ESTALE
2880 case ESTALE: return WSAESTALE;
2881 #endif
2882 #ifdef EREMOTE
2883 case EREMOTE: return WSAEREMOTE;
2884 #endif
2885
2886 /* just in case we ever get here and there are no problems */
2887 case 0: return 0;
2888 default:
2889 WARN(winsock, "Unknown errno %d!\n", loc_errno);
2890 return WSAEOPNOTSUPP;
2891 }
2892 }
2893
2894 UINT16 wsaHerrno(void)
2895 {
2896 int loc_errno = h_errno;
2897
2898 WARN(winsock, "h_errno %d.\n", loc_errno);
2899
2900 switch(loc_errno)
2901 {
2902 case HOST_NOT_FOUND: return WSAHOST_NOT_FOUND;
2903 case TRY_AGAIN: return WSATRY_AGAIN;
2904 case NO_RECOVERY: return WSANO_RECOVERY;
2905 case NO_DATA: return WSANO_DATA;
2906
2907 case 0: return 0;
2908 default:
2909 WARN(winsock,"Unknown h_errno %d!\n", loc_errno);
2910 return WSAEOPNOTSUPP;
2911 }
2912 }
Windows API implementation