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