2 * based on Windows Sockets 1.1 specs
3 * (ftp.microsoft.com:/Advsys/winsock/spec11/WINSOCK.TXT)
5 * (C) 1993,1994,1996,1997 John Brezak, Erik Bos, Alex Korobka.
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).
18 #include <sys/types.h>
20 #include <sys/ioctl.h>
21 #ifdef HAVE_SYS_FILIO_H
22 # include <sys/filio.h>
25 #include <sys/ioccom.h>
26 #include <sys/sockio.h>
30 # include <sys/so_ioctl.h>
33 #ifdef HAVE_SYS_PARAM_H
34 # include <sys/param.h>
39 #include <sys/socket.h>
40 #include <netinet/in.h>
41 #include <arpa/inet.h>
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))
67 /* ----------------------------------- internal data */
71 static HANDLE32 _WSHeap
= 0;
72 static unsigned char* _ws_stub
= NULL
;
73 static LPWSINFO _wsi_list
= NULL
;
75 #define WS_ALLOC(size) \
76 HeapAlloc(_WSHeap, HEAP_ZERO_MEMORY, (size) )
77 #define WS_FREE(ptr) \
78 HeapFree(_WSHeap, 0, (ptr) )
80 #define WS_PTR2HANDLE(ptr) \
81 ((short)((int)(ptr) - (int)_ws_stub))
82 #define WS_HANDLE2PTR(handle) \
83 ((unsigned)((int)_ws_stub + (int)(handle)))
85 #define WSI_CHECK_RANGE(pwsi, pws) \
86 ( ((unsigned)(pws) > (unsigned)(pwsi)) && \
87 ((unsigned)(pws) < ((unsigned)(pwsi) + sizeof(WSINFO))) )
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
,
98 static int _check_ws(LPWSINFO pwsi
, ws_socket
* pws
);
99 static char* _check_buffer(LPWSINFO pwsi
, int size
);
101 extern void EVENT_AddIO( int fd
, unsigned flag
);
102 extern void EVENT_DeleteIO( int fd
, unsigned flag
);
104 /***********************************************************************
107 * Converts socket flags from Windows format.
109 static void convert_sockopt(INT32
*level
, INT32
*optname
)
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
);
122 *optname
= IPPROTO_TCP
;
126 /* ----------------------------------- Per-thread info (or per-process?) */
128 static LPWSINFO
wsi_find(HTASK16 hTask
)
130 TDB
* pTask
= (TDB
*)GlobalLock16(hTask
);
133 if( pTask
->pwsi
) return pTask
->pwsi
;
136 LPWSINFO pwsi
= _wsi_list
;
137 while( pwsi
&& pwsi
->tid
!= hTask
) pwsi
= pwsi
->next
;
139 WARN(winsock
,"(pwsi=0x%08x,task=0x%04x):Loose wsi struct! \n",
140 (unsigned)pwsi
, hTask
);
147 static ws_socket
* wsi_alloc_socket(LPWSINFO pwsi
, int fd
)
149 /* Initialize a new entry in the socket table */
151 if( pwsi
->last_free
>= 0 )
153 int i
= pwsi
->last_free
;
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
];
163 static int wsi_strtolo(LPWSINFO pwsi
, const char* name
, const char* opt
)
165 /* Stuff a lowercase copy of the string into the local buffer */
167 int i
= strlen(name
) + 2;
168 char* p
= _check_buffer(pwsi
, i
+ ((opt
)?strlen(opt
):0));
172 do *p
++ = tolower(*name
); while(*name
++);
173 i
= (p
- (char*)(pwsi
->buffer
));
174 if( opt
) do *p
++ = tolower(*opt
); while(*opt
++);
180 static fd_set
* fd_set_import( fd_set
* fds
, LPWSINFO pwsi
, void* wsfds
, int* highfd
, BOOL32 b32
)
182 /* translate Winsock fd set into local fd set */
186 #define wsfds16 ((ws_fd_set16*)wsfds)
187 #define wsfds32 ((ws_fd_set32*)wsfds)
192 count
= b32
? wsfds32
->fd_count
: wsfds16
->fd_count
;
194 for( i
= 0; i
< count
; i
++ )
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
) )
200 if( pws
->fd
> *highfd
) *highfd
= pws
->fd
;
201 FD_SET(pws
->fd
, fds
);
211 __inline__
static int sock_error_p(int s
)
213 unsigned int optval
, optlen
;
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
);
221 static int fd_set_export( LPWSINFO pwsi
, fd_set
* fds
, fd_set
* exceptfds
, void* wsfds
, BOOL32 b32
)
225 /* translate local fd set into Winsock fd set, adding
226 * errors to exceptfds (only if app requested it) */
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
;
234 for( i
= 0, j
= 0; i
< count
; i
++ )
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
) )
242 if( FD_ISSET(fd
, fds
) )
244 if ( exceptfds
&& sock_error_p(fd
) )
246 FD_SET(fd
, exceptfds
);
250 wsfds32
->fd_array
[j
++] = wsfds32
->fd_array
[i
];
252 wsfds16
->fd_array
[j
++] = wsfds16
->fd_array
[i
];
257 if( b32
) wsfds32
->fd_count
= j
;
258 else wsfds16
->fd_count
= j
;
260 TRACE(winsock
, "\n");
267 HANDLE16
__ws_gethandle( void* ptr
)
269 return (HANDLE16
)WS_PTR2HANDLE(ptr
);
272 void* __ws_memalloc( int size
)
274 return WS_ALLOC(size
);
277 void __ws_memfree(void* ptr
)
282 /* ----------------------------------- API -----
284 * Init / cleanup / error checking.
287 /***********************************************************************
288 * WSAStartup16() (WINSOCK.115)
290 * Create socket control struct, attach it to the global list and
291 * update a pointer in the task struct.
293 INT16 WINAPI
WSAStartup16(UINT16 wVersionRequested
, LPWSADATA lpWSAData
)
295 WSADATA WINSOCK_data
= { 0x0101, 0x0101,
299 #elif defined(__NetBSD__)
303 #elif defined(__FreeBSD__)
305 #elif defined(__OpenBSD__)
310 WS_MAX_SOCKETS_PER_PROCESS
,
311 WS_MAX_UDP_DATAGRAM
, (SEGPTR
)NULL
};
312 HTASK16 tid
= GetCurrentTask();
315 TRACE(winsock
, "verReq=%x\n", wVersionRequested
);
317 if (LOBYTE(wVersionRequested
) < 1 || (LOBYTE(wVersionRequested
) == 1 &&
318 HIBYTE(wVersionRequested
) < 1)) return WSAVERNOTSUPPORTED
;
320 if (!lpWSAData
) return WSAEINVAL
;
322 /* initialize socket heap */
326 _WSHeap
= HeapCreate(HEAP_ZERO_MEMORY
, 8120, 32768);
327 if( !(_ws_stub
= WS_ALLOC(0x10)) )
329 ERR(winsock
,"Fatal: failed to create WinSock heap\n");
333 if( _WSHeap
== 0 ) return WSASYSNOTREADY
;
335 /* create socket array for this task */
337 pwsi
= wsi_find(GetCurrentTask());
340 TDB
* pTask
= (TDB
*)GlobalLock16( tid
);
342 if( (pwsi
= (LPWSINFO
)WS_ALLOC( sizeof(WSINFO
))) )
346 for( i
= 0; i
< WS_MAX_SOCKETS_PER_PROCESS
; i
++ )
348 pwsi
->sock
[i
].fd
= -1;
349 pwsi
->sock
[i
].flags
= i
+ 1;
351 pwsi
->sock
[WS_MAX_SOCKETS_PER_PROCESS
- 1].flags
= -1;
353 else return WSASYSNOTREADY
;
355 /* add this control struct to the global list */
359 _wsi_list
->prev
= pwsi
;
360 pwsi
->next
= _wsi_list
;
364 else pwsi
->num_startup
++;
366 /* return winsock information */
368 memcpy(lpWSAData
, &WINSOCK_data
, sizeof(WINSOCK_data
));
370 TRACE(winsock
, "succeeded\n");
374 /***********************************************************************
375 * WSAStartup32() (WSOCK32.115)
377 INT32 WINAPI
WSAStartup32(UINT32 wVersionRequested
, LPWSADATA lpWSAData
)
379 return WSAStartup16( wVersionRequested
, lpWSAData
);
382 /***********************************************************************
383 * WSACleanup() (WINSOCK.116)
385 * Cleanup functions of varying impact.
387 void WINSOCK_Shutdown()
389 /* Called on exit(), has to remove all outstanding async DNS processes. */
391 WINSOCK_cancel_task_aops( 0, __ws_memfree
);
394 INT32
WINSOCK_DeleteTaskWSI( TDB
* pTask
, LPWSINFO pwsi
)
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.
404 if( --pwsi
->num_startup
> 0 ) return 0;
406 SIGNAL_MaskAsyncEvents( TRUE
);
407 WINSOCK_cancel_task_aops( pTask
->hSelf
, __ws_memfree
);
408 SIGNAL_MaskAsyncEvents( FALSE
);
410 /* unlink socket control struct */
412 if( pwsi
== _wsi_list
)
413 _wsi_list
= pwsi
->next
;
415 pwsi
->prev
->next
= pwsi
->next
;
416 if( pwsi
->next
) pwsi
->next
->prev
= pwsi
->prev
;
418 if( _wsi_list
== NULL
)
419 WINSOCK_Shutdown(); /* just in case */
421 if( pwsi
->flags
& WSI_BLOCKINGCALL
)
422 TRACE(winsock
,"\tinside blocking call!\n");
424 /* FIXME: aop_control() doesn't decrement pwsi->num_async_rq
426 * if( pwsi->num_async_rq )
427 * WARN(winsock,"\thave %i outstanding async ops!\n", pwsi->num_async_rq );
430 for(i
= 0, j
= 0, n
= 0; i
< WS_MAX_SOCKETS_PER_PROCESS
; i
++)
431 if( pwsi
->sock
[i
].fd
!= -1 )
433 if( pwsi
->sock
[i
].psop
)
436 WSAAsyncSelect32( (SOCKET16
)WS_PTR2HANDLE(pwsi
->sock
+ i
), 0, 0, 0 );
438 close(pwsi
->sock
[i
].fd
); j
++;
441 TRACE(winsock
,"\tclosed %i sockets, killed %i async selects!\n", j
, n
);
443 /* delete scratch buffers */
445 if( pwsi
->buffer
) SEGPTR_FREE(pwsi
->buffer
);
446 if( pwsi
->dbuffer
) SEGPTR_FREE(pwsi
->dbuffer
);
450 memset( pwsi
, 0, sizeof(WSINFO
) );
455 INT32 WINAPI
WSACleanup(void)
457 HTASK16 hTask
= GetCurrentTask();
459 TRACE(winsock
, "(%04x)\n", hTask
);
462 LPWSINFO pwsi
= wsi_find(hTask
);
464 return WINSOCK_DeleteTaskWSI( (TDB
*)GlobalLock16(hTask
), pwsi
);
468 WINSOCK_Shutdown(); /* remove all outstanding DNS requests */
473 /***********************************************************************
474 * WSAGetLastError() (WSOCK32.111)(WINSOCK.111)
476 INT32 WINAPI
WSAGetLastError(void)
478 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
479 INT16 ret
= (pwsi
) ? pwsi
->err
: WSANOTINITIALISED
;
481 TRACE(winsock
, "(%08x) = %i\n",
482 (unsigned)pwsi
, (int)ret
);
486 /***********************************************************************
487 * WSASetLastError32() (WSOCK32.112)
489 void WINAPI
WSASetLastError32(INT32 iError
)
491 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
493 TRACE(winsock
, "(%08x): %d\n", (unsigned)pwsi
, (int)iError
);
494 if( pwsi
) pwsi
->err
= iError
;
497 /***********************************************************************
498 * WSASetLastError16() (WINSOCK.112)
500 void WINAPI
WSASetLastError16(INT16 iError
)
502 WSASetLastError32(iError
);
505 int _check_ws(LPWSINFO pwsi
, ws_socket
* pws
)
508 if( pwsi
->flags
& WSI_BLOCKINGCALL
) pwsi
->err
= WSAEINPROGRESS
;
509 else if( WSI_CHECK_RANGE(pwsi
, pws
) ) return 1;
510 else pwsi
->err
= WSAENOTSOCK
;
514 char* _check_buffer(LPWSINFO pwsi
, int size
)
516 if( pwsi
->buffer
&& pwsi
->buflen
>= size
) return pwsi
->buffer
;
517 else SEGPTR_FREE(pwsi
->buffer
);
519 pwsi
->buffer
= (char*)SEGPTR_ALLOC((pwsi
->buflen
= size
));
523 /* ----------------------------------- i/o APIs */
525 /***********************************************************************
526 * accept() (WSOCK32.1)
528 SOCKET32 WINAPI
WINSOCK_accept32(SOCKET32 s
, struct sockaddr
*addr
,
531 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR((SOCKET16
)s
);
532 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
534 TRACE(winsock
, "(%08x): socket %04x\n",
535 (unsigned)pwsi
, (UINT16
)s
);
536 if( _check_ws(pwsi
, pws
) )
540 fd_flags
= fcntl(pws
->fd
, F_GETFL
, 0);
542 if( (sock
= accept(pws
->fd
, addr
, addrlen32
)) >= 0 )
544 ws_socket
* pnew
= wsi_alloc_socket(pwsi
, sock
);
547 s
= (SOCKET32
)WS_PTR2HANDLE(pnew
);
548 if( pws
->psop
&& pws
->flags
& WS_FD_ACCEPT
)
550 EVENT_AddIO( pws
->fd
, EVENT_IO_READ
); /* reenabler */
552 /* async select the accept()'ed socket */
553 WSAAsyncSelect32( s
, pws
->psop
->hWnd
, pws
->psop
->uMsg
,
554 pws
->flags
& ~WS_FD_ACCEPT
);
558 else pwsi
->err
= WSAENOBUFS
;
560 else pwsi
->err
= wsaErrno();
562 return INVALID_SOCKET32
;
565 /***********************************************************************
566 * accept() (WINSOCK.1)
568 SOCKET16 WINAPI
WINSOCK_accept16(SOCKET16 s
, struct sockaddr
* addr
,
571 INT32 addrlen32
= addrlen16
? *addrlen16
: 0;
572 SOCKET32 retSocket
= WINSOCK_accept32( s
, addr
, &addrlen32
);
573 if( addrlen16
) *addrlen16
= (INT16
)addrlen32
;
574 return (SOCKET16
)retSocket
;
577 /***********************************************************************
580 INT32 WINAPI
WINSOCK_bind32(SOCKET32 s
, struct sockaddr
*name
, INT32 namelen
)
582 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
583 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
585 TRACE(winsock
, "(%08x): socket %04x, ptr %8x, length %d\n",
586 (unsigned)pwsi
, s
, (int) name
, namelen
);
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 )
596 int loc_errno
= errno
;
597 WARN(winsock
, "\tfailure - errno = %i\n", errno
);
601 case EBADF
: pwsi
->err
= WSAENOTSOCK
; break;
602 case EADDRNOTAVAIL
: pwsi
->err
= WSAEINVAL
; break;
603 default: pwsi
->err
= wsaErrno();
606 else return 0; /* success */
607 else pwsi
->err
= WSAEAFNOSUPPORT
;
608 else pwsi
->err
= WSAEFAULT
;
612 /***********************************************************************
615 INT16 WINAPI
WINSOCK_bind16(SOCKET16 s
, struct sockaddr
*name
, INT16 namelen
)
617 return (INT16
)WINSOCK_bind32( s
, name
, namelen
);
620 /***********************************************************************
621 * closesocket() (WSOCK32.3)
623 INT32 WINAPI
WINSOCK_closesocket32(SOCKET32 s
)
625 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
626 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
628 TRACE(winsock
, "(%08x): socket %08x\n", (unsigned)pwsi
, s
);
630 if( _check_ws(pwsi
, pws
) )
634 if( pws
->psop
) WSAAsyncSelect32( s
, 0, 0, 0 );
637 pws
->flags
= (unsigned)pwsi
->last_free
;
638 pwsi
->last_free
= pws
- &pwsi
->sock
[0]; /* add to free list */
642 pwsi
->err
= (errno
== EBADF
) ? WSAENOTSOCK
: wsaErrno();
647 /***********************************************************************
648 * closesocket() (WINSOCK.3)
650 INT16 WINAPI
WINSOCK_closesocket16(SOCKET16 s
)
652 return (INT16
)WINSOCK_closesocket32(s
);
655 /***********************************************************************
656 * connect() (WSOCK32.4)
658 INT32 WINAPI
WINSOCK_connect32(SOCKET32 s
, struct sockaddr
*name
, INT32 namelen
)
660 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
661 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
663 TRACE(winsock
, "(%08x): socket %04x, ptr %8x, length %d\n",
664 (unsigned)pwsi
, s
, (int) name
, namelen
);
669 if( _check_ws(pwsi
, pws
) )
671 if (connect(pws
->fd
, name
, namelen
) == 0)
673 if( pws
->psop
&& (pws
->flags
& WS_FD_CONNECT
) )
675 /* application did AsyncSelect() but then went
676 * ahead and called connect() without waiting for
679 * FIXME: Do we have to post a notification message
683 if( !(pws
->flags
& WS_FD_CONNECTED
) )
685 if( pws
->flags
& (WS_FD_READ
| WS_FD_CLOSE
) )
686 EVENT_AddIO( pws
->fd
, EVENT_IO_READ
);
688 EVENT_DeleteIO( pws
->fd
, EVENT_IO_READ
);
689 if( pws
->flags
& WS_FD_WRITE
)
690 EVENT_AddIO( pws
->fd
, EVENT_IO_WRITE
);
692 EVENT_DeleteIO( pws
->fd
, EVENT_IO_WRITE
);
695 pws
->flags
|= WS_FD_CONNECTED
;
696 pws
->flags
&= ~(WS_FD_INACTIVE
| WS_FD_CONNECT
| WS_FD_LISTENING
);
699 pwsi
->err
= (errno
== EINPROGRESS
) ? WSAEWOULDBLOCK
: wsaErrno();
704 /***********************************************************************
705 * connect() (WINSOCK.4)
707 INT16 WINAPI
WINSOCK_connect16(SOCKET16 s
, struct sockaddr
*name
, INT16 namelen
)
709 return (INT16
)WINSOCK_connect32( s
, name
, namelen
);
712 /***********************************************************************
713 * getpeername() (WSOCK32.5)
715 INT32 WINAPI
WINSOCK_getpeername32(SOCKET32 s
, struct sockaddr
*name
,
718 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
719 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
721 TRACE(winsock
, "(%08x): socket: %04x, ptr %8x, ptr %8x\n",
722 (unsigned)pwsi
, s
, (int) name
, *namelen
);
723 if( _check_ws(pwsi
, pws
) )
725 if (getpeername(pws
->fd
, name
, namelen
) == 0)
727 pwsi
->err
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
732 /***********************************************************************
733 * getpeername() (WINSOCK.5)
735 INT16 WINAPI
WINSOCK_getpeername16(SOCKET16 s
, struct sockaddr
*name
,
738 INT32 namelen32
= *namelen16
;
739 INT32 retVal
= WINSOCK_getpeername32( s
, name
, &namelen32
);
745 *namelen16
= namelen32
;
746 return (INT16
)retVal
;
749 /***********************************************************************
750 * getsockname() (WSOCK32.6)
752 INT32 WINAPI
WINSOCK_getsockname32(SOCKET32 s
, struct sockaddr
*name
,
755 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
756 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
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
) )
762 if (getsockname(pws
->fd
, name
, namelen
) == 0)
764 pwsi
->err
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
769 /***********************************************************************
770 * getsockname() (WINSOCK.6)
772 INT16 WINAPI
WINSOCK_getsockname16(SOCKET16 s
, struct sockaddr
*name
,
779 INT32 namelen32
= *namelen16
;
780 retVal
= WINSOCK_getsockname32( s
, name
, &namelen32
);
781 *namelen16
= namelen32
;
788 else retVal
= SOCKET_ERROR
;
789 return (INT16
)retVal
;
793 /***********************************************************************
794 * getsockopt() (WSOCK32.7)
796 INT32 WINAPI
WINSOCK_getsockopt32(SOCKET32 s
, INT32 level
,
797 INT32 optname
, char *optval
, INT32
*optlen
)
799 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
800 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
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
) )
806 convert_sockopt(&level
, &optname
);
807 if (getsockopt(pws
->fd
, (int) level
, optname
, optval
, optlen
) == 0 )
809 pwsi
->err
= (errno
== EBADF
) ? WSAENOTSOCK
: wsaErrno();
814 /***********************************************************************
815 * getsockopt() (WINSOCK.7)
817 INT16 WINAPI
WINSOCK_getsockopt16(SOCKET16 s
, INT16 level
,
818 INT16 optname
, char *optval
, INT16
*optlen
)
821 INT32
*p
= &optlen32
;
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
;
829 /***********************************************************************
830 * htonl() (WINSOCK.8)(WSOCK32.8)
832 u_long WINAPI
WINSOCK_htonl(u_long hostlong
) { return( htonl(hostlong
) ); }
833 /***********************************************************************
834 * htons() (WINSOCK.9)(WSOCK32.9)
836 u_short WINAPI
WINSOCK_htons(u_short hostshort
) { return( htons(hostshort
) ); }
837 /***********************************************************************
838 * inet_addr() (WINSOCK.10)(WSOCK32.10)
840 u_long WINAPI
WINSOCK_inet_addr(char *cp
) { return( inet_addr(cp
) ); }
841 /***********************************************************************
842 * htohl() (WINSOCK.14)(WSOCK32.14)
844 u_long WINAPI
WINSOCK_ntohl(u_long netlong
) { return( ntohl(netlong
) ); }
845 /***********************************************************************
846 * ntohs() (WINSOCK.15)(WSOCK32.15)
848 u_short WINAPI
WINSOCK_ntohs(u_short netshort
) { return( ntohs(netshort
) ); }
850 /***********************************************************************
851 * inet_ntoa() (WINSOCK.11)(WSOCK32.11)
853 char* WINAPI
WINSOCK_inet_ntoa32(struct in_addr in
)
855 /* use "buffer for dummies" here because some applications have
856 * propensity to decode addresses in ws_hostent structure without
857 * saving them first...
860 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
864 char* s
= inet_ntoa(in
);
867 if( pwsi
->dbuffer
== NULL
)
868 if((pwsi
->dbuffer
= (char*) SEGPTR_ALLOC(32)) == NULL
)
870 pwsi
->err
= WSAENOBUFS
;
873 strncpy(pwsi
->dbuffer
, s
, 32 );
874 return pwsi
->dbuffer
;
876 pwsi
->err
= wsaErrno();
881 SEGPTR WINAPI
WINSOCK_inet_ntoa16(struct in_addr in
)
883 char* retVal
= WINSOCK_inet_ntoa32(in
);
884 return retVal
? SEGPTR_GET(retVal
) : (SEGPTR
)NULL
;
887 /***********************************************************************
888 * ioctlsocket() (WSOCK32.12)
890 INT32 WINAPI
WINSOCK_ioctlsocket32(SOCKET32 s
, UINT32 cmd
, UINT32
*argp
)
892 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
893 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
895 TRACE(winsock
, "(%08x): socket %04x, cmd %08x, ptr %8x\n",
896 (unsigned)pwsi
, s
, cmd
, (unsigned) argp
);
897 if( _check_ws(pwsi
, pws
) )
909 if( pws
->psop
&& *argp
== 0 )
911 /* AsyncSelect()'ed sockets are always nonblocking */
912 pwsi
->err
= WSAEINVAL
;
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
;
927 /* Netscape tries hard to use bogus ioctl 0x667e */
928 WARN(winsock
, "\tunknown WS_IOCTL cmd (%08x)\n", cmd
);
930 if( ioctl(pws
->fd
, newcmd
, (char*)argp
) == 0 ) return 0;
931 pwsi
->err
= (errno
== EBADF
) ? WSAENOTSOCK
: wsaErrno();
936 /***********************************************************************
937 * ioctlsocket() (WINSOCK.12)
939 INT16 WINAPI
WINSOCK_ioctlsocket16(SOCKET16 s
, UINT32 cmd
, UINT32
*argp
)
941 return (INT16
)WINSOCK_ioctlsocket32( s
, cmd
, argp
);
945 /***********************************************************************
946 * listen() (WSOCK32.13)
948 INT32 WINAPI
WINSOCK_listen32(SOCKET32 s
, INT32 backlog
)
950 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
951 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
953 TRACE(winsock
, "(%08x): socket %04x, backlog %d\n",
954 (unsigned)pwsi
, s
, backlog
);
955 if( _check_ws(pwsi
, pws
) )
957 if (listen(pws
->fd
, backlog
) == 0)
961 int fd_flags
= fcntl(pws
->fd
, F_GETFL
, 0);
962 if( !(fd_flags
& O_NONBLOCK
) ) pws
->flags
|= WS_FD_ACCEPT
;
964 pws
->flags
|= WS_FD_LISTENING
;
965 pws
->flags
&= ~(WS_FD_INACTIVE
| WS_FD_CONNECT
| WS_FD_CONNECTED
); /* just in case */
968 pwsi
->err
= wsaErrno();
970 else if( pwsi
) pwsi
->err
= WSAENOTSOCK
;
974 /***********************************************************************
975 * listen() (WINSOCK.13)
977 INT16 WINAPI
WINSOCK_listen16(SOCKET16 s
, INT16 backlog
)
979 return (INT16
)WINSOCK_listen32( s
, backlog
);
983 /***********************************************************************
984 * recv() (WSOCK32.16)
986 INT32 WINAPI
WINSOCK_recv32(SOCKET32 s
, char *buf
, INT32 len
, INT32 flags
)
988 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
989 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
991 TRACE(winsock
, "(%08x): socket %04x, buf %8x, len %d, "
992 "flags %d\n", (unsigned)pwsi
, s
, (unsigned)buf
,
994 if( _check_ws(pwsi
, pws
) )
997 if ((length
= recv(pws
->fd
, buf
, len
, flags
)) >= 0)
999 TRACE(winsock
, " -> %i bytes\n", length
);
1001 if( pws
->psop
&& (pws
->flags
& (WS_FD_READ
| WS_FD_CLOSE
)) )
1002 EVENT_AddIO( pws
->fd
, EVENT_IO_READ
); /* reenabler */
1006 pwsi
->err
= wsaErrno();
1008 else if( pwsi
) pwsi
->err
= WSAENOTSOCK
;
1009 WARN(winsock
, " -> ERROR\n");
1010 return SOCKET_ERROR
;
1013 /***********************************************************************
1014 * recv() (WINSOCK.16)
1016 INT16 WINAPI
WINSOCK_recv16(SOCKET16 s
, char *buf
, INT16 len
, INT16 flags
)
1018 return (INT16
)WINSOCK_recv32( s
, buf
, len
, flags
);
1022 /***********************************************************************
1023 * recvfrom() (WSOCK32.17)
1025 INT32 WINAPI
WINSOCK_recvfrom32(SOCKET32 s
, char *buf
, INT32 len
, INT32 flags
,
1026 struct sockaddr
*from
, INT32
*fromlen32
)
1028 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
1029 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1031 TRACE(winsock
, "(%08x): socket %04x, ptr %08x, "
1032 "len %d, flags %d\n", (unsigned)pwsi
, s
, (unsigned)buf
,
1035 if( from
) dump_sockaddr(from
);
1036 else DUMP("from = NULL\n");
1039 if( _check_ws(pwsi
, pws
) )
1043 if ((length
= recvfrom(pws
->fd
, buf
, len
, flags
, from
, fromlen32
)) >= 0)
1045 TRACE(winsock
, " -> %i bytes\n", length
);
1047 if( pws
->psop
&& (pws
->flags
& (WS_FD_READ
| WS_FD_CLOSE
)) )
1048 EVENT_AddIO( pws
->fd
, EVENT_IO_READ
); /* reenabler */
1050 return (INT16
)length
;
1052 pwsi
->err
= wsaErrno();
1054 else if( pwsi
) pwsi
->err
= WSAENOTSOCK
;
1055 WARN(winsock
, " -> ERROR\n");
1056 return SOCKET_ERROR
;
1059 /***********************************************************************
1060 * recvfrom() (WINSOCK.17)
1062 INT16 WINAPI
WINSOCK_recvfrom16(SOCKET16 s
, char *buf
, INT16 len
, INT16 flags
,
1063 struct sockaddr
*from
, INT16
*fromlen16
)
1066 INT32
*p
= &fromlen32
;
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
;
1075 /***********************************************************************
1076 * select() (WINSOCK.18)(WSOCK32.18)
1078 static INT32
__ws_select( BOOL32 b32
, void *ws_readfds
, void *ws_writefds
, void *ws_exceptfds
,
1079 struct timeval
*timeout
)
1081 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1083 TRACE(winsock
, "(%08x): read %8x, write %8x, excp %8x\n",
1084 (unsigned) pwsi
, (unsigned) ws_readfds
, (unsigned) ws_writefds
, (unsigned) ws_exceptfds
);
1089 fd_set readfds
, writefds
, exceptfds
;
1090 fd_set
*p_read
, *p_write
, *p_except
;
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
);
1096 if( (highfd
= select(highfd
+ 1, p_read
, p_write
, p_except
, timeout
)) > 0 )
1098 fd_set_export(pwsi
, &readfds
, p_except
, ws_readfds
, b32
);
1099 fd_set_export(pwsi
, &writefds
, p_except
, ws_writefds
, b32
);
1101 if (p_except
&& ws_exceptfds
)
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
;
1107 for (i
= j
= 0; i
< count
; i
++)
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
) )
1114 wsfds32
->fd_array
[j
++] = wsfds32
->fd_array
[i
];
1116 wsfds16
->fd_array
[j
++] = wsfds16
->fd_array
[i
];
1120 wsfds32
->fd_count
= j
;
1122 wsfds16
->fd_count
= j
;
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;
1132 if( highfd
== 0 ) return 0;
1133 pwsi
->err
= wsaErrno();
1135 return SOCKET_ERROR
;
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
)
1142 return (INT16
)__ws_select( FALSE
, ws_readfds
, ws_writefds
, ws_exceptfds
, timeout
);
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
)
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
);
1154 /***********************************************************************
1155 * send() (WSOCK32.19)
1157 INT32 WINAPI
WINSOCK_send32(SOCKET32 s
, char *buf
, INT32 len
, INT32 flags
)
1159 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
1160 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
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
) )
1168 if ((length
= send(pws
->fd
, buf
, len
, flags
)) < 0 )
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 */
1175 else return (INT16
)length
;
1177 else if( pwsi
) pwsi
->err
= WSAENOTSOCK
;
1178 return SOCKET_ERROR
;
1181 /***********************************************************************
1182 * send() (WINSOCK.19)
1184 INT16 WINAPI
WINSOCK_send16(SOCKET16 s
, char *buf
, INT16 len
, INT16 flags
)
1186 return WINSOCK_send32( s
, buf
, len
, flags
);
1189 /***********************************************************************
1190 * sendto() (WSOCK32.20)
1192 INT32 WINAPI
WINSOCK_sendto32(SOCKET32 s
, char *buf
, INT32 len
, INT32 flags
,
1193 struct sockaddr
*to
, INT32 tolen
)
1195 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
1196 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
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
) )
1204 if ((length
= sendto(pws
->fd
, buf
, len
, flags
, to
, tolen
)) < 0 )
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 */
1213 else if( pwsi
) pwsi
->err
= WSAENOTSOCK
;
1214 return SOCKET_ERROR
;
1217 /***********************************************************************
1218 * sendto() (WINSOCK.20)
1220 INT16 WINAPI
WINSOCK_sendto16(SOCKET16 s
, char *buf
, INT16 len
, INT16 flags
,
1221 struct sockaddr
*to
, INT16 tolen
)
1223 return (INT16
)WINSOCK_sendto32( s
, buf
, len
, flags
, to
, tolen
);
1226 /***********************************************************************
1227 * setsockopt() (WSOCK32.21)
1229 INT32 WINAPI
WINSOCK_setsockopt32(SOCKET16 s
, INT32 level
, INT32 optname
,
1230 char *optval
, INT32 optlen
)
1232 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
1233 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
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
) )
1239 struct linger linger
;
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
);
1249 if (setsockopt(pws
->fd
, level
, optname
, optval
, optlen
) == 0) return 0;
1250 pwsi
->err
= wsaErrno();
1252 else if( pwsi
) pwsi
->err
= WSAENOTSOCK
;
1253 return SOCKET_ERROR
;
1256 /***********************************************************************
1257 * setsockopt() (WINSOCK.21)
1259 INT16 WINAPI
WINSOCK_setsockopt16(SOCKET16 s
, INT16 level
, INT16 optname
,
1260 char *optval
, INT16 optlen
)
1262 if( !optval
) return SOCKET_ERROR
;
1263 return (INT16
)WINSOCK_setsockopt32( s
, (UINT16
)level
, optname
, optval
, optlen
);
1267 /***********************************************************************
1268 * shutdown() (WSOCK32.22)
1270 INT32 WINAPI
WINSOCK_shutdown32(SOCKET32 s
, INT32 how
)
1272 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
1273 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1275 TRACE(winsock
, "(%08x): socket %04x, how %i\n",
1276 (unsigned)pwsi
, s
, how
);
1277 if( _check_ws(pwsi
, pws
) )
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
);
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
;
1300 case 2: /* drop all */
1305 WSAAsyncSelect32( s
, 0, 0, 0 );
1309 if (shutdown(pws
->fd
, how
) == 0)
1313 pws
->flags
&= ~(WS_FD_CONNECTED
| WS_FD_LISTENING
);
1314 pws
->flags
|= WS_FD_INACTIVE
;
1318 pwsi
->err
= wsaErrno();
1320 else if( pwsi
) pwsi
->err
= WSAENOTSOCK
;
1321 return SOCKET_ERROR
;
1324 /***********************************************************************
1325 * shutdown() (WINSOCK.22)
1327 INT16 WINAPI
WINSOCK_shutdown16(SOCKET16 s
, INT16 how
)
1329 return (INT16
)WINSOCK_shutdown32( s
, how
);
1333 /***********************************************************************
1334 * socket() (WSOCK32.23)
1336 SOCKET32 WINAPI
WINSOCK_socket32(INT32 af
, INT32 type
, INT32 protocol
)
1338 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1340 TRACE(winsock
, "(%08x): af=%d type=%d protocol=%d\n",
1341 (unsigned)pwsi
, af
, type
, protocol
);
1347 /* check the socket family */
1351 case AF_UNSPEC
: break;
1352 default: pwsi
->err
= WSAEAFNOSUPPORT
;
1353 return INVALID_SOCKET32
;
1356 /* check the socket type */
1361 case SOCK_RAW
: break;
1362 default: pwsi
->err
= WSAESOCKTNOSUPPORT
;
1363 return INVALID_SOCKET32
;
1366 /* check the protocol type */
1367 if ( protocol
< 0 ) /* don't support negative values */
1368 { pwsi
->err
= WSAEPROTONOSUPPORT
; return INVALID_SOCKET32
; }
1370 if ( af
== AF_UNSPEC
) /* did they not specify the address family? */
1374 if (type
== SOCK_STREAM
) { af
= AF_INET
; break; }
1376 if (type
== SOCK_DGRAM
) { af
= AF_INET
; break; }
1377 default: pwsi
->err
= WSAEPROTOTYPE
; return INVALID_SOCKET32
;
1380 if ((sock
= socket(af
, type
, protocol
)) >= 0)
1382 ws_socket
* pnew
= wsi_alloc_socket(pwsi
, sock
);
1384 TRACE(winsock
,"\tcreated %i (handle %04x)\n", sock
, (UINT16
)WS_PTR2HANDLE(pnew
));
1388 pnew
->flags
|= WS_FD_INACTIVE
;
1389 return (SOCKET16
)WS_PTR2HANDLE(pnew
);
1393 pwsi
->err
= WSAENOBUFS
;
1394 return INVALID_SOCKET32
;
1397 if (errno
== EPERM
) /* raw socket denied */
1399 WARN(winsock
, "WS_SOCKET: not enough privileges\n");
1400 pwsi
->err
= WSAESOCKTNOSUPPORT
;
1401 } else pwsi
->err
= wsaErrno();
1404 WARN(winsock
, "\t\tfailed!\n");
1405 return INVALID_SOCKET32
;
1408 /***********************************************************************
1409 * socket() (WINSOCK.23)
1411 SOCKET16 WINAPI
WINSOCK_socket16(INT16 af
, INT16 type
, INT16 protocol
)
1413 return (SOCKET16
)WINSOCK_socket32( af
, type
, protocol
);
1417 /* ----------------------------------- DNS services
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.
1425 static char* NULL_STRING
= "NULL";
1427 /***********************************************************************
1428 * gethostbyaddr() (WINSOCK.51)(WSOCK32.51)
1430 static struct WIN_hostent
* __ws_gethostbyaddr(const char *addr
, int len
, int type
, int dup_flag
)
1432 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
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
);
1441 pwsi
->err
= WSAENOBUFS
;
1443 pwsi
->err
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
1448 SEGPTR WINAPI
WINSOCK_gethostbyaddr16(const char *addr
, INT16 len
, INT16 type
)
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
);
1457 struct WIN_hostent
* WINAPI
WINSOCK_gethostbyaddr32(const char *addr
, INT32 len
,
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
);
1465 /***********************************************************************
1466 * gethostbyname() (WINSOCK.52)(WSOCK32.52)
1468 static struct WIN_hostent
* __ws_gethostbyname(const char *name
, int dup_flag
)
1470 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
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();
1484 SEGPTR WINAPI
WINSOCK_gethostbyname16(const char *name
)
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
) ;
1492 struct WIN_hostent
* WINAPI
WINSOCK_gethostbyname32(const char* name
)
1494 TRACE(winsock
, "%s\n", (name
)?name
:NULL_STRING
);
1495 return __ws_gethostbyname( name
, WS_DUP_LINEAR
);
1499 /***********************************************************************
1500 * getprotobyname() (WINSOCK.53)(WSOCK32.53)
1502 static struct WIN_protoent
* __ws_getprotobyname(const char *name
, int dup_flag
)
1504 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
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();
1518 SEGPTR WINAPI
WINSOCK_getprotobyname16(const char *name
)
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
);
1526 struct WIN_protoent
* WINAPI
WINSOCK_getprotobyname32(const char* name
)
1528 TRACE(winsock
, "%s\n", (name
)?name
:NULL_STRING
);
1529 return __ws_getprotobyname(name
, WS_DUP_LINEAR
);
1533 /***********************************************************************
1534 * getprotobynumber() (WINSOCK.54)(WSOCK32.54)
1536 static struct WIN_protoent
* __ws_getprotobynumber(int number
, int dup_flag
)
1538 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
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
;
1552 SEGPTR WINAPI
WINSOCK_getprotobynumber16(INT16 number
)
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
);
1560 struct WIN_protoent
* WINAPI
WINSOCK_getprotobynumber32(INT32 number
)
1562 TRACE(winsock
, "%i\n", number
);
1563 return __ws_getprotobynumber(number
, WS_DUP_LINEAR
);
1567 /***********************************************************************
1568 * getservbyname() (WINSOCK.55)(WSOCK32.55)
1570 struct WIN_servent
* __ws_getservbyname(const char *name
, const char *proto
, int dup_flag
)
1572 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1576 struct servent
* serv
;
1577 int i
= wsi_strtolo( pwsi
, name
, proto
);
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
;
1590 SEGPTR WINAPI
WINSOCK_getservbyname16(const char *name
, const char *proto
)
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
);
1599 struct WIN_servent
* WINAPI
WINSOCK_getservbyname32(const char *name
, const char *proto
)
1601 TRACE(winsock
, "'%s', '%s'\n",
1602 (name
)?name
:NULL_STRING
, (proto
)?proto
:NULL_STRING
);
1603 return __ws_getservbyname(name
, proto
, WS_DUP_LINEAR
);
1607 /***********************************************************************
1608 * getservbyport() (WINSOCK.56)(WSOCK32.56)
1610 static struct WIN_servent
* __ws_getservbyport(int port
, const char* proto
, int dup_flag
)
1612 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1616 struct servent
* serv
;
1617 int i
= wsi_strtolo( pwsi
, proto
, NULL
);
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
;
1630 SEGPTR WINAPI
WINSOCK_getservbyport16(INT16 port
, const char *proto
)
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
);
1639 struct WIN_servent
* WINAPI
WINSOCK_getservbyport32(INT32 port
, const char *proto
)
1641 TRACE(winsock
, "%i, '%s'\n",
1642 (int)port
, (proto
)?proto
:NULL_STRING
);
1643 return __ws_getservbyport(port
, proto
, WS_DUP_LINEAR
);
1647 /***********************************************************************
1648 * gethostname() (WSOCK32.57)
1650 INT32 WINAPI
WINSOCK_gethostname32(char *name
, INT32 namelen
)
1652 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1654 TRACE(winsock
, "(%08x): name %s, len %d\n",
1655 (unsigned)pwsi
, (name
)?name
:NULL_STRING
, namelen
);
1658 if (gethostname(name
, namelen
) == 0) return 0;
1659 pwsi
->err
= (errno
== EINVAL
) ? WSAEFAULT
: wsaErrno();
1661 return SOCKET_ERROR
;
1664 /***********************************************************************
1665 * gethostname() (WINSOCK.57)
1667 INT16 WINAPI
WINSOCK_gethostname16(char *name
, INT16 namelen
)
1669 return (INT16
)WINSOCK_gethostname32(name
, namelen
);
1673 /* ------------------------------------- Windows sockets extensions -- *
1675 * ------------------------------------------------------------------- */
1678 /***********************************************************************
1679 * Asynchronous DNS services
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
);
1686 /***********************************************************************
1687 * WSAAsyncGetHostByAddr() (WINSOCK.102)
1689 HANDLE16 WINAPI
WSAAsyncGetHostByAddr16(HWND16 hWnd
, UINT16 uMsg
, LPCSTR addr
,
1690 INT16 len
, INT16 type
, SEGPTR sbuf
, INT16 buflen
)
1692 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1694 TRACE(winsock
, "(%08x): hwnd %04x, msg %04x, addr %08x[%i]\n",
1695 (unsigned)pwsi
, hWnd
, uMsg
, (unsigned)addr
, len
);
1698 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, type
, addr
, len
,
1699 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_HOSTBYADDR
);
1703 /***********************************************************************
1704 * WSAAsyncGetHostByAddr() (WSOCK32.102)
1706 HANDLE32 WINAPI
WSAAsyncGetHostByAddr32(HWND32 hWnd
, UINT32 uMsg
, LPCSTR addr
,
1707 INT32 len
, INT32 type
, LPSTR sbuf
, INT32 buflen
)
1709 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1711 TRACE(winsock
, "(%08x): hwnd %04x, msg %08x, addr %08x[%i]\n",
1712 (unsigned)pwsi
, (HWND16
)hWnd
, uMsg
, (unsigned)addr
, len
);
1715 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, type
, addr
, len
,
1716 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_HOSTBYADDR
| WSMSG_WIN32_AOP
);
1721 /***********************************************************************
1722 * WSAAsyncGetHostByName() (WINSOCK.103)
1724 HANDLE16 WINAPI
WSAAsyncGetHostByName16(HWND16 hWnd
, UINT16 uMsg
, LPCSTR name
,
1725 SEGPTR sbuf
, INT16 buflen
)
1727 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1729 TRACE(winsock
, "(%08x): hwnd %04x, msg %04x, host %s,
1730 buffer %i\n", (unsigned)pwsi
, hWnd
, uMsg
, (name
)?name
:NULL_STRING
, (int)buflen
);
1733 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, 0, name
, 0,
1734 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_HOSTBYNAME
);
1738 /***********************************************************************
1739 * WSAAsyncGetHostByName32() (WSOCK32.103)
1741 HANDLE32 WINAPI
WSAAsyncGetHostByName32(HWND32 hWnd
, UINT32 uMsg
, LPCSTR name
,
1742 LPSTR sbuf
, INT32 buflen
)
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
);
1749 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, 0, name
, 0,
1750 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_HOSTBYNAME
| WSMSG_WIN32_AOP
);
1755 /***********************************************************************
1756 * WSAAsyncGetProtoByName() (WINSOCK.105)
1758 HANDLE16 WINAPI
WSAAsyncGetProtoByName16(HWND16 hWnd
, UINT16 uMsg
, LPCSTR name
,
1759 SEGPTR sbuf
, INT16 buflen
)
1761 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1763 TRACE(winsock
, "(%08x): hwnd %04x, msg %08x, protocol %s\n",
1764 (unsigned)pwsi
, (HWND16
)hWnd
, uMsg
, (name
)?name
:NULL_STRING
);
1767 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, 0, name
, 0,
1768 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_PROTOBYNAME
);
1772 /***********************************************************************
1773 * WSAAsyncGetProtoByName() (WSOCK32.105)
1775 HANDLE32 WINAPI
WSAAsyncGetProtoByName32(HWND32 hWnd
, UINT32 uMsg
, LPCSTR name
,
1776 LPSTR sbuf
, INT32 buflen
)
1778 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1780 TRACE(winsock
, "(%08x): hwnd %04x, msg %08x, protocol %s\n",
1781 (unsigned)pwsi
, (HWND16
)hWnd
, uMsg
, (name
)?name
:NULL_STRING
);
1784 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, 0, name
, 0,
1785 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_PROTOBYNAME
| WSMSG_WIN32_AOP
);
1790 /***********************************************************************
1791 * WSAAsyncGetProtoByNumber() (WINSOCK.104)
1793 HANDLE16 WINAPI
WSAAsyncGetProtoByNumber16(HWND16 hWnd
, UINT16 uMsg
, INT16 number
,
1794 SEGPTR sbuf
, INT16 buflen
)
1796 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1798 TRACE(winsock
, "(%08x): hwnd %04x, msg %04x, num %i\n",
1799 (unsigned)pwsi
, hWnd
, uMsg
, number
);
1802 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, number
, NULL
, 0,
1803 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_PROTOBYNUM
);
1807 /***********************************************************************
1808 * WSAAsyncGetProtoByNumber() (WSOCK32.104)
1810 HANDLE32 WINAPI
WSAAsyncGetProtoByNumber32(HWND32 hWnd
, UINT32 uMsg
, INT32 number
,
1811 LPSTR sbuf
, INT32 buflen
)
1813 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1815 TRACE(winsock
, "(%08x): hwnd %04x, msg %08x, num %i\n",
1816 (unsigned)pwsi
, (HWND16
)hWnd
, uMsg
, number
);
1819 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, number
, NULL
, 0,
1820 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_PROTOBYNUM
| WSMSG_WIN32_AOP
);
1825 /***********************************************************************
1826 * WSAAsyncGetServByName() (WINSOCK.107)
1828 HANDLE16 WINAPI
WSAAsyncGetServByName16(HWND16 hWnd
, UINT16 uMsg
, LPCSTR name
,
1829 LPCSTR proto
, SEGPTR sbuf
, INT16 buflen
)
1831 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
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
);
1839 int i
= wsi_strtolo( pwsi
, name
, proto
);
1842 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, 0, pwsi
->buffer
, 0,
1843 pwsi
->buffer
+ i
, (void*)sbuf
, buflen
, WSMSG_ASYNC_SERVBYNAME
);
1848 /***********************************************************************
1849 * WSAAsyncGetServByName() (WSOCK32.107)
1851 HANDLE32 WINAPI
WSAAsyncGetServByName32(HWND32 hWnd
, UINT32 uMsg
, LPCSTR name
,
1852 LPCSTR proto
, LPSTR sbuf
, INT32 buflen
)
1854 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
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
);
1861 int i
= wsi_strtolo( pwsi
, name
, proto
);
1864 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, 0, pwsi
->buffer
, 0,
1865 pwsi
->buffer
+ i
, (void*)sbuf
, buflen
, WSMSG_ASYNC_SERVBYNAME
| WSMSG_WIN32_AOP
);
1871 /***********************************************************************
1872 * WSAAsyncGetServByPort() (WINSOCK.106)
1874 HANDLE16 WINAPI
WSAAsyncGetServByPort16(HWND16 hWnd
, UINT16 uMsg
, INT16 port
,
1875 LPCSTR proto
, SEGPTR sbuf
, INT16 buflen
)
1877 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1879 TRACE(winsock
, "(%08x): hwnd %04x, msg %04x, port %i, proto %s\n",
1880 (unsigned)pwsi
, hWnd
, uMsg
, port
, (proto
)?proto
:NULL_STRING
);
1884 int i
= wsi_strtolo( pwsi
, proto
, NULL
);
1887 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, port
, pwsi
->buffer
, 0,
1888 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_SERVBYPORT
);
1893 /***********************************************************************
1894 * WSAAsyncGetServByPort() (WSOCK32.106)
1896 HANDLE32 WINAPI
WSAAsyncGetServByPort32(HWND32 hWnd
, UINT32 uMsg
, INT32 port
,
1897 LPCSTR proto
, LPSTR sbuf
, INT32 buflen
)
1899 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1901 TRACE(winsock
, "(%08x): hwnd %04x, msg %08x, port %i, proto %s\n",
1902 (unsigned)pwsi
, (HWND16
)hWnd
, uMsg
, port
, (proto
)?proto
:NULL_STRING
);
1906 int i
= wsi_strtolo( pwsi
, proto
, NULL
);
1909 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, port
, pwsi
->buffer
, 0,
1910 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_SERVBYPORT
| WSMSG_WIN32_AOP
);
1916 /***********************************************************************
1917 * WSACancelAsyncRequest() (WINSOCK.108)(WSOCK32.109)
1919 INT32 WINAPI
WSACancelAsyncRequest32(HANDLE32 hAsyncTaskHandle
)
1921 INT32 retVal
= SOCKET_ERROR
;
1922 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1923 ws_async_op
* p_aop
= (ws_async_op
*)WS_HANDLE2PTR(hAsyncTaskHandle
);
1925 TRACE(winsock
, "(%08x): handle %08x\n",
1926 (unsigned)pwsi
, hAsyncTaskHandle
);
1929 SIGNAL_MaskAsyncEvents( TRUE
); /* block SIGIO */
1930 if( WINSOCK_cancel_async_op(p_aop
) )
1933 pwsi
->num_async_rq
--;
1936 else pwsi
->err
= WSAEINVAL
;
1937 SIGNAL_MaskAsyncEvents( FALSE
);
1942 INT16 WINAPI
WSACancelAsyncRequest16(HANDLE16 hAsyncTaskHandle
)
1944 return (HANDLE16
)WSACancelAsyncRequest16((HANDLE32
)hAsyncTaskHandle
);
1947 /***********************************************************************
1948 * WSAAsyncSelect() (WINSOCK.101)(WSOCK32.101)
1951 static ws_select_op
* __ws_select_list
= NULL
;
1953 BOOL32
WINSOCK_HandleIO( int* max_fd
, int num_pending
,
1954 fd_set pending_set
[3], fd_set event_set
[3] )
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 */
1960 ws_select_op
* psop
= __ws_select_list
;
1961 BOOL32 bPost
= FALSE
;
1962 DWORD dwEvent
, dwErrBytes
;
1965 TRACE(winsock
,"%i pending descriptors\n", num_pending
);
1967 for( num_posted
= dwEvent
= 0 ; psop
; psop
= psop
->next
)
1969 unsigned flags
= psop
->pws
->flags
;
1970 int fd
= psop
->pws
->fd
;
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
] )) )
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.
1983 TRACE(winsock
,"\tchecking psop = 0x%08x\n", (unsigned) psop
);
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
1993 if((flags
& WS_FD_ACCEPT
) && (flags
& WS_FD_LISTENING
))
1995 /* WS_FD_ACCEPT is valid only if the socket is in the
1996 * listening state */
1998 FD_CLR( fd
, &event_set
[EVENT_IO_WRITE
] );
2001 FD_CLR( fd
, &event_set
[EVENT_IO_READ
] ); /* reenabled by the next accept() */
2002 dwEvent
= WSAMAKESELECTREPLY( WS_FD_ACCEPT
, 0 );
2007 else if( flags
& WS_FD_CONNECT
)
2009 /* connecting socket */
2011 if( w
|| (w
= FD_ISSET( fd
, &pending_set
[EVENT_IO_WRITE
] )) )
2013 /* ready to write means that socket is connected
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()!?!?
2020 psop
->pws
->flags
|= WS_FD_CONNECTED
;
2021 psop
->pws
->flags
&= ~(WS_FD_CONNECT
| WS_FD_INACTIVE
);
2022 dwEvent
= WSAMAKESELECTREPLY( WS_FD_CONNECT
, 0 );
2024 if( flags
& (WS_FD_READ
| WS_FD_CLOSE
))
2025 FD_SET( fd
, &event_set
[EVENT_IO_READ
] );
2027 FD_CLR( fd
, &event_set
[EVENT_IO_READ
] );
2028 if( flags
& WS_FD_WRITE
)
2029 FD_SET( fd
, &event_set
[EVENT_IO_WRITE
] );
2031 FD_CLR( fd
, &event_set
[EVENT_IO_WRITE
] );
2036 /* failure - do read() to get correct errno */
2038 if( read( fd
, &dwErrBytes
, sizeof(dwErrBytes
) ) == -1 )
2040 dwEvent
= WSAMAKESELECTREPLY( WS_FD_CONNECT
, wsaErrno() );
2044 /* otherwise bPost stays FALSE, should probably clear event_set */
2048 /* connected socket, no WS_FD_OOB code for now. */
2050 if( flags
& WS_FD_WRITE
&&
2051 (w
|| (w
= FD_ISSET( fd
, &pending_set
[EVENT_IO_WRITE
] ))) )
2053 /* this will be reenabled when send() or sendto() fail with
2056 if( PostMessage32A( psop
->hWnd
, psop
->uMsg
, (WPARAM32
)WS_PTR2HANDLE(psop
->pws
),
2057 (LPARAM
)WSAMAKESELECTREPLY( WS_FD_WRITE
, 0 ) ) )
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
] );
2066 if( r
&& (flags
& (WS_FD_READ
| WS_FD_CLOSE
)) )
2068 int val
= (flags
& WS_FD_RAW
);
2070 /* WS_FD_RAW is set by the WSAAsyncSelect() init */
2073 if( !val
&& ioctl( fd
, FIONREAD
, (char*)&dwErrBytes
) == -1 )
2077 dwEvent
= WSAMAKESELECTREPLY( WS_FD_READ
, wsaErrno() );
2079 else if( val
|| dwErrBytes
)
2081 /* got pending data, will be reenabled by recv() or recvfrom() */
2083 FD_CLR( fd
, &event_set
[EVENT_IO_READ
] );
2084 dwEvent
= WSAMAKESELECTREPLY( WS_FD_READ
, 0 );
2088 /* 0 bytes to read - connection reset by peer? */
2091 val
= read( fd
, (char*)&dwErrBytes
, sizeof(dwErrBytes
));
2092 while( errno
== EINTR
);
2093 if( errno
!= EWOULDBLOCK
)
2097 case 0: errno
= ENETDOWN
; /* soft reset, fall through */
2098 case -1: /* hard reset */
2099 dwEvent
= WSAMAKESELECTREPLY( WS_FD_CLOSE
, wsaErrno() );
2102 default: bPost
= FALSE
;
2103 continue; /* FIXME: this is real bad */
2106 else { bPost
= FALSE
; continue; } /* more weirdness */
2108 /* this is it, this socket is closed */
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
] );
2114 if( *max_fd
== (fd
+ 1) ) (*max_fd
)--;
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
);
2129 if( num_pending
<= 0 ) break;
2132 TRACE(winsock
, "\tdone, %i posted events\n", num_posted
);
2133 return ( num_posted
) ? TRUE
: FALSE
;
2136 INT32 WINAPI
WSAAsyncSelect32(SOCKET32 s
, HWND32 hWnd
, UINT32 uMsg
, UINT32 lEvent
)
2138 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
2139 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
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
) )
2147 if( (psop
= pws
->psop
) )
2149 /* delete previous control struct */
2151 if( psop
== __ws_select_list
)
2152 __ws_select_list
= psop
->next
;
2154 psop
->prev
->next
= psop
->next
;
2155 if( psop
->next
) psop
->next
->prev
= psop
->prev
;
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
);
2162 TRACE(winsock
,"\tremoving psop = 0x%08x\n", (unsigned) psop
);
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
);
2172 psop
= (ws_select_op
*)WS_ALLOC(sizeof(ws_select_op
));
2175 int sock_type
, bytes
= sizeof(int);
2177 WINSOCK_unblock_io( pws
->fd
, TRUE
);
2180 psop
->next
= __ws_select_list
;
2181 if( __ws_select_list
)
2182 __ws_select_list
->prev
= psop
;
2183 __ws_select_list
= 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
;
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
);
2199 /* TODO: handle WS_FD_ACCEPT right away if the socket is readable */
2201 TRACE(winsock
,"\tcreating psop = 0x%08x\n", (unsigned)psop
);
2203 return 0; /* success */
2205 else pwsi
->err
= WSAENOBUFS
;
2209 else if( pwsi
) pwsi
->err
= WSAEINVAL
;
2210 return SOCKET_ERROR
;
2213 INT16 WINAPI
WSAAsyncSelect16(SOCKET16 s
, HWND16 hWnd
, UINT16 wMsg
, UINT32 lEvent
)
2215 return (INT16
)WSAAsyncSelect32( s
, hWnd
, wMsg
, lEvent
);
2219 /***********************************************************************
2220 * __WSAFDIsSet() (WINSOCK.151)
2222 INT16 WINAPI
__WSAFDIsSet16(SOCKET16 s
, ws_fd_set16
*set
)
2224 int i
= set
->fd_count
;
2226 TRACE(winsock
, "(%d,%8lx(%i))\n", s
,(unsigned long)set
, i
);
2229 if (set
->fd_array
[i
] == s
) return 1;
2233 /***********************************************************************
2234 * __WSAFDIsSet() (WSOCK32.151)
2236 INT32 WINAPI
__WSAFDIsSet32(SOCKET32 s
, ws_fd_set32
*set
)
2238 int i
= set
->fd_count
;
2240 TRACE(winsock
, "(%d,%8lx(%i))\n", s
,(unsigned long)set
, i
);
2243 if (set
->fd_array
[i
] == s
) return 1;
2247 /***********************************************************************
2248 * WSAIsBlocking() (WINSOCK.114)(WSOCK32.114)
2250 BOOL32 WINAPI
WSAIsBlocking(void)
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.
2257 * Note: It is allowed to call this function without prior WSAStartup().
2260 TRACE(winsock
, "\n");
2264 /***********************************************************************
2265 * WSACancelBlockingCall() (WINSOCK.113)(WSOCK32.113)
2267 INT32 WINAPI
WSACancelBlockingCall(void)
2269 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
2271 TRACE(winsock
, "(%08x)\n", (unsigned)pwsi
);
2273 if( pwsi
) return 0;
2274 return SOCKET_ERROR
;
2278 /***********************************************************************
2279 * WSASetBlockingHook16() (WINSOCK.109)
2281 FARPROC16 WINAPI
WSASetBlockingHook16(FARPROC16 lpBlockFunc
)
2284 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
2286 TRACE(winsock
, "(%08x): hook %08x\n",
2287 (unsigned)pwsi
, (unsigned) lpBlockFunc
);
2290 prev
= (FARPROC16
)pwsi
->blocking_hook
;
2291 pwsi
->blocking_hook
= (DWORD
)lpBlockFunc
;
2292 pwsi
->flags
&= ~WSI_BLOCKINGHOOK32
;
2299 /***********************************************************************
2300 * WSASetBlockingHook32()
2302 FARPROC32 WINAPI
WSASetBlockingHook32(FARPROC32 lpBlockFunc
)
2305 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
2307 TRACE(winsock
, "(%08x): hook %08x\n",
2308 (unsigned)pwsi
, (unsigned) lpBlockFunc
);
2310 prev
= (FARPROC32
)pwsi
->blocking_hook
;
2311 pwsi
->blocking_hook
= (DWORD
)lpBlockFunc
;
2312 pwsi
->flags
|= WSI_BLOCKINGHOOK32
;
2319 /***********************************************************************
2320 * WSAUnhookBlockingHook16() (WINSOCK.110)
2322 INT16 WINAPI
WSAUnhookBlockingHook16(void)
2324 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
2326 TRACE(winsock
, "(%08x)\n", (unsigned)pwsi
);
2327 if( pwsi
) return (INT16
)(pwsi
->blocking_hook
= 0);
2328 return SOCKET_ERROR
;
2332 /***********************************************************************
2333 * WSAUnhookBlockingHook32()
2335 INT32 WINAPI
WSAUnhookBlockingHook32(void)
2337 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
2339 TRACE(winsock
, "(%08x)\n", (unsigned)pwsi
);
2342 pwsi
->blocking_hook
= 0;
2343 pwsi
->flags
&= ~WSI_BLOCKINGHOOK32
;
2346 return SOCKET_ERROR
;
2350 * TCP/IP action codes.
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
2360 /***********************************************************************
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>
2370 DWORD WINAPI
WsControl(DWORD protocoll
,DWORD action
,
2371 LPVOID inbuf
,LPDWORD inbuflen
,
2372 LPVOID outbuf
,LPDWORD outbuflen
)
2376 case WSCNTL_TCPIP_ICMP_ECHO
:
2378 unsigned int addr
= *(unsigned int*)inbuf
;
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*/
2389 FIXME(winsock
,"(ICMP_ECHO) to 0x%08x stub \n", addr
);
2393 FIXME(winsock
,"(%lx,%lx,%p,%p,%p,%p) stub\n",
2394 protocoll
,action
,inbuf
,inbuflen
,outbuf
,outbuflen
);
2398 /*********************************************************
2399 * WS_s_perror WSOCK32.1108
2401 void WINAPI
WS_s_perror(LPCSTR message
)
2403 FIXME(winsock
,"(%s): stub\n",message
);
2408 /* ----------------------------------- end of API stuff */
2410 /* ----------------------------------- helper functions -
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).
2417 static int list_size(char** l
, int item_size
)
2422 j
+= (item_size
) ? item_size
: strlen(l
[i
]) + 1;
2423 j
+= (i
+ 1) * sizeof(char*); }
2427 static int list_dup(char** l_src
, char* ref
, char* base
, int item_size
)
2429 /* base is either either equal to ref or 0 or SEGPTR */
2432 char** l_to
= (char**)ref
;
2435 for(j
=0;l_src
[j
];j
++) ;
2436 p
+= (j
+ 1) * sizeof(char*);
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
; }
2447 static int hostent_size(struct hostent
* 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
); }
2458 int WS_dup_he(LPWSINFO pwsi
, struct hostent
* p_he
, int flag
)
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).
2466 int size
= hostent_size(p_he
);
2469 struct ws_hostent
* p_to
;
2470 char* p_name
,*p_aliases
,*p_addr
,*p_base
,*p
;
2472 _check_buffer(pwsi
, size
);
2473 p_to
= (struct ws_hostent
*)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
);
2479 strcpy(p
, p_he
->h_name
); p
+= strlen(p
) + 1;
2481 p
+= list_dup(p_he
->h_aliases
, p
, p_base
+ (p
- pwsi
->buffer
), 0);
2483 list_dup(p_he
->h_addr_list
, p
, p_base
+ (p
- pwsi
->buffer
), p_he
->h_length
);
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
));
2491 size
+= (sizeof(struct ws_hostent
) - sizeof(struct hostent
));
2496 /* ----- protoent */
2498 static int protoent_size(struct protoent
* p_pe
)
2502 { size
= sizeof(struct protoent
);
2503 size
+= strlen(p_pe
->p_name
) + 1;
2504 size
+= list_size(p_pe
->p_aliases
, 0); }
2508 int WS_dup_pe(LPWSINFO pwsi
, struct protoent
* p_pe
, int flag
)
2510 int size
= protoent_size(p_pe
);
2513 struct ws_protoent
* p_to
;
2514 char* p_name
,*p_aliases
,*p_base
,*p
;
2516 _check_buffer(pwsi
, size
);
2517 p_to
= (struct ws_protoent
*)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
);
2523 strcpy(p
, p_pe
->p_name
); p
+= strlen(p
) + 1;
2525 list_dup(p_pe
->p_aliases
, p
, p_base
+ (p
- pwsi
->buffer
), 0);
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
));
2531 size
+= (sizeof(struct ws_protoent
) - sizeof(struct protoent
));
2538 static int servent_size(struct servent
* 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); }
2548 int WS_dup_se(LPWSINFO pwsi
, struct servent
* p_se
, int flag
)
2550 int size
= servent_size(p_se
);
2553 struct ws_servent
* p_to
;
2554 char* p_name
,*p_aliases
,*p_proto
,*p_base
,*p
;
2556 _check_buffer(pwsi
, size
);
2557 p_to
= (struct ws_servent
*)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
);
2563 strcpy(p
, p_se
->s_name
); p
+= strlen(p
) + 1;
2565 strcpy(p
, p_se
->s_proto
); p
+= strlen(p
) + 1;
2567 list_dup(p_se
->s_aliases
, p
, p_base
+ (p
- pwsi
->buffer
), 0);
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
));
2574 size
+= (sizeof(struct ws_servent
) - sizeof(struct servent
));
2579 /* ----------------------------------- error handling */
2581 UINT16
wsaErrno(void)
2583 int loc_errno
= errno
;
2584 #if defined(__FreeBSD__)
2585 ERR(winsock
, "errno %d, (%s).\n",
2586 errno
, strerror(errno
));
2588 ERR(winsock
, "errno %d\n", errno
);
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
;
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
;
2633 case EPROCLIM
: return WSAEPROCLIM
;
2636 case EUSERS
: return WSAEUSERS
;
2639 case EDQUOT
: return WSAEDQUOT
;
2642 case ESTALE
: return WSAESTALE
;
2645 case EREMOTE
: return WSAEREMOTE
;
2648 /* just in case we ever get here and there are no problems */
2651 WARN(winsock
, "Unknown errno %d!\n", errno
);
2652 return WSAEOPNOTSUPP
;
2656 UINT16
wsaHerrno(void)
2658 int loc_errno
= h_errno
;
2660 #if defined(__FreeBSD__)
2661 ERR(winsock
, "h_errno %d, (%s).\n",
2662 h_errno
, strerror(h_errno
));
2664 ERR(winsock
, "h_errno %d.\n", h_errno
);
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
;
2676 WARN(winsock
,"Unknown h_errno %d!\n", h_errno
);
2677 return WSAEOPNOTSUPP
;