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