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