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.
12 #include <sys/types.h>
14 #include <sys/ioctl.h>
16 #include <sys/filio.h>
17 #include <sys/ioccom.h>
18 #include <sys/sockio.h>
21 #include <sys/so_ioctl.h>
22 #include <sys/param.h>
26 #include <sys/socket.h>
27 #include <netinet/in.h>
28 #include <arpa/inet.h>
45 #define DEBUG_SOCKADDR 0
46 #define dump_sockaddr(a) \
47 fprintf(stderr, "sockaddr_in: family %d, address %s, port %d\n", \
48 ((struct sockaddr_in *)a)->sin_family, \
49 inet_ntoa(((struct sockaddr_in *)a)->sin_addr), \
50 ntohs(((struct sockaddr_in *)a)->sin_port))
54 /* ----------------------------------- internal data */
58 static HANDLE32 _WSHeap
= 0;
59 static unsigned char* _ws_stub
= NULL
;
60 static LPWSINFO _wsi_list
= NULL
;
62 #define WS_ALLOC(size) \
63 HeapAlloc(_WSHeap, HEAP_ZERO_MEMORY, (size) )
64 #define WS_FREE(ptr) \
65 HeapFree(_WSHeap, 0, (ptr) )
67 #define WS_PTR2HANDLE(ptr) \
68 ((short)((int)(ptr) - (int)_ws_stub))
69 #define WS_HANDLE2PTR(handle) \
70 ((unsigned)((int)_ws_stub + (int)(handle)))
72 #define WSI_CHECK_RANGE(pwsi, pws) \
73 ( ((unsigned)(pws) > (unsigned)(pwsi)) && \
74 ((unsigned)(pws) < ((unsigned)(pwsi) + sizeof(WSINFO))) )
76 static INT32 _ws_sock_ops
[] =
77 { WS_SO_DEBUG
, WS_SO_REUSEADDR
, WS_SO_KEEPALIVE
, WS_SO_DONTROUTE
,
78 WS_SO_BROADCAST
, WS_SO_LINGER
, WS_SO_OOBINLINE
, WS_SO_SNDBUF
,
79 WS_SO_RCVBUF
, WS_SO_ERROR
, WS_SO_TYPE
, WS_SO_DONTLINGER
, 0 };
80 static int _px_sock_ops
[] =
81 { SO_DEBUG
, SO_REUSEADDR
, SO_KEEPALIVE
, SO_DONTROUTE
, SO_BROADCAST
,
82 SO_LINGER
, SO_OOBINLINE
, SO_SNDBUF
, SO_RCVBUF
, SO_ERROR
, SO_TYPE
,
85 static int _check_ws(LPWSINFO pwsi
, ws_socket
* pws
);
86 static int _check_buffer(LPWSINFO pwsi
, int size
);
88 extern void EVENT_AddIO( int fd
, unsigned flag
);
89 extern void EVENT_DeleteIO( int fd
, unsigned flag
);
91 /***********************************************************************
94 * Converts socket flags from Windows format.
96 static void convert_sockopt(INT32
*level
, INT32
*optname
)
103 for(i
=0; _ws_sock_ops
[i
]; i
++)
104 if( _ws_sock_ops
[i
] == *optname
) break;
105 if( _ws_sock_ops
[i
] ) *optname
= _px_sock_ops
[i
];
106 else fprintf(stderr
, "convert_sockopt() unknown optname %d\n", *optname
);
109 *optname
= IPPROTO_TCP
;
113 /* ----------------------------------- Per-thread info (or per-process?) */
115 static LPWSINFO
wsi_find(HTASK16 hTask
)
117 TDB
* pTask
= (TDB
*)GlobalLock16(hTask
);
120 if( pTask
->pwsi
) return pTask
->pwsi
;
123 LPWSINFO pwsi
= _wsi_list
;
124 while( pwsi
&& pwsi
->tid
!= hTask
) pwsi
= pwsi
->next
;
126 fprintf(stderr
,"loose wsi struct! pwsi=0x%08x, task=0x%04x\n",
127 (unsigned)pwsi
, hTask
);
134 static ws_socket
* wsi_alloc_socket(LPWSINFO pwsi
, int fd
)
136 /* Initialize a new entry in the socket table */
138 if( pwsi
->last_free
>= 0 )
140 int i
= pwsi
->last_free
;
142 pwsi
->last_free
= pwsi
->sock
[i
].flags
; /* free list */
143 pwsi
->sock
[i
].fd
= fd
;
144 pwsi
->sock
[i
].flags
= 0;
145 return &pwsi
->sock
[i
];
150 static fd_set
* fd_set_import( fd_set
* fds
, LPWSINFO pwsi
, void* wsfds
, int* highfd
, BOOL32 b32
)
152 /* translate Winsock fd set into local fd set */
156 #define wsfds16 ((ws_fd_set16*)wsfds)
157 #define wsfds32 ((ws_fd_set32*)wsfds)
162 count
= (b32
) ? wsfds32
->fd_count
: wsfds16
->fd_count
;
163 for( i
= 0; i
< count
; i
++ )
165 pws
= (b32
) ? (ws_socket
*)WS_HANDLE2PTR(wsfds32
->fd_array
[i
])
166 : (ws_socket
*)WS_HANDLE2PTR(wsfds16
->fd_array
[i
]);
167 if( _check_ws(pwsi
, pws
) )
169 if( pws
->fd
> *highfd
) *highfd
= pws
->fd
;
170 FD_SET(pws
->fd
, fds
);
180 __inline__
static int sock_error_p(int s
)
182 unsigned int optval
, optlen
;
184 optlen
= sizeof(optval
);
185 getsockopt(s
, SOL_SOCKET
, SO_ERROR
, &optval
, &optlen
);
186 if (optval
) dprintf_winsock(stddeb
, "\t[%i] error: %d\n", s
, optval
);
190 static int fd_set_export( LPWSINFO pwsi
, fd_set
* fds
, fd_set
* exceptfds
, void* wsfds
, BOOL32 b32
)
194 /* translate local fd set into Winsock fd set, adding
195 * errors to exceptfds (only if app requested it) */
199 #define wsfds16 ((ws_fd_set16*)wsfds)
200 #define wsfds32 ((ws_fd_set32*)wsfds)
201 int i
, j
, count
= (b32
) ? wsfds32
->fd_count
: wsfds16
->fd_count
;
203 for( i
= 0, j
= 0; i
< count
; i
++ )
205 ws_socket
*pws
= (b32
) ? (ws_socket
*)WS_HANDLE2PTR(wsfds32
->fd_array
[i
])
206 : (ws_socket
*)WS_HANDLE2PTR(wsfds16
->fd_array
[i
]);
209 if( _check_ws(pwsi
, pws
) && FD_ISSET(fd
, fds
) )
211 if ( exceptfds
&& sock_error_p(fd
) )
213 FD_SET(fd
, exceptfds
);
218 wsfds32
->fd_array
[j
++] = wsfds32
->fd_array
[i
];
220 wsfds16
->fd_array
[j
++] = wsfds16
->fd_array
[i
];
224 if( b32
) wsfds32
->fd_count
= j
;
225 else wsfds16
->fd_count
= j
;
227 dprintf_winsock(stddeb
, "\n");
234 HANDLE16
__ws_gethandle( void* ptr
)
236 return (HANDLE16
)WS_PTR2HANDLE(ptr
);
239 void* __ws_memalloc( int size
)
241 return WS_ALLOC(size
);
244 void __ws_memfree(void* ptr
)
249 /* ----------------------------------- API -----
251 * Init / cleanup / error checking.
254 /***********************************************************************
255 * WSAStartup16() (WINSOCK.115)
257 * Create socket control struct, attach it to the global list and
258 * update a pointer in the task struct.
260 INT16 WINAPI
WSAStartup16(UINT16 wVersionRequested
, LPWSADATA lpWSAData
)
262 WSADATA WINSOCK_data
= { 0x0101, 0x0101,
266 #elif defined(__NetBSD__)
270 #elif defined(__FreeBSD__)
272 #elif defined(__OpenBSD__)
277 WS_MAX_SOCKETS_PER_THREAD
,
278 WS_MAX_UDP_DATAGRAM
, (SEGPTR
)NULL
};
279 HTASK16 tid
= GetCurrentTask();
282 dprintf_winsock(stddeb
, "WSAStartup: verReq=%x\n", wVersionRequested
);
284 if (LOBYTE(wVersionRequested
) < 1 || (LOBYTE(wVersionRequested
) == 1 &&
285 HIBYTE(wVersionRequested
) < 1)) return WSAVERNOTSUPPORTED
;
287 if (!lpWSAData
) return WSAEINVAL
;
289 /* initialize socket heap */
293 _WSHeap
= HeapCreate(HEAP_ZERO_MEMORY
, 8120, 32768);
294 if( !(_ws_stub
= WS_ALLOC(0x10)) )
296 fprintf(stderr
,"Fatal: failed to create WinSock heap\n");
300 if( _WSHeap
== 0 ) return WSASYSNOTREADY
;
302 /* create socket array for this task */
304 pwsi
= wsi_find(GetCurrentTask());
307 TDB
* pTask
= (TDB
*)GlobalLock16( tid
);
309 if( (pwsi
= (LPWSINFO
)WS_ALLOC( sizeof(WSINFO
))) )
313 for( i
= 0; i
< WS_MAX_SOCKETS_PER_THREAD
; i
++ )
315 pwsi
->sock
[i
].fd
= -1;
316 pwsi
->sock
[i
].flags
= i
+ 1;
318 pwsi
->sock
[WS_MAX_SOCKETS_PER_THREAD
- 1].flags
= -1;
320 else return WSASYSNOTREADY
;
322 /* add this control struct to the global list */
326 _wsi_list
->prev
= pwsi
;
327 pwsi
->next
= _wsi_list
;
331 else pwsi
->num_startup
++;
333 /* return winsock information */
335 memcpy(lpWSAData
, &WINSOCK_data
, sizeof(WINSOCK_data
));
337 dprintf_winsock(stddeb
, "WSAStartup: succeeded\n");
341 /***********************************************************************
342 * WSAStartup32() (WSOCK32.115)
344 INT32 WINAPI
WSAStartup32(UINT32 wVersionRequested
, LPWSADATA lpWSAData
)
346 return WSAStartup16( wVersionRequested
, lpWSAData
);
349 /***********************************************************************
350 * WSACleanup() (WINSOCK.116)
352 * Cleanup functions of varying impact.
354 void WINSOCK_Shutdown()
356 /* Called on exit(), has to remove all outstanding async DNS processes. */
358 WINSOCK_cancel_task_aops( 0, __ws_memfree
);
361 INT32
WINSOCK_DeleteTaskWSI( TDB
* pTask
, LPWSINFO pwsi
)
363 /* WSACleanup() backend, called on task termination as well.
364 * Real DLL would have registered its own signal handler with
365 * TaskSetSignalHandler() and waited until USIG_TERMINATION/USIG_GPF
366 * but this scheme is much more straightforward.
371 if( --pwsi
->num_startup
> 0 ) return 0;
373 SIGNAL_MaskAsyncEvents( TRUE
);
376 WINSOCK_cancel_task_aops( pTask
->hSelf
, __ws_memfree
);
377 SIGNAL_MaskAsyncEvents( FALSE
);
379 /* unlink socket control struct */
381 if( pwsi
== _wsi_list
)
382 _wsi_list
= pwsi
->next
;
384 pwsi
->prev
->next
= pwsi
->next
;
385 if( pwsi
->next
) pwsi
->next
->prev
= pwsi
->prev
;
387 if( _wsi_list
== NULL
)
388 WINSOCK_Shutdown(); /* just in case */
390 if( pwsi
->flags
& WSI_BLOCKINGCALL
)
391 dprintf_winsock(stddeb
,"\tinside blocking call!\n");
393 /* FIXME: aop_control() doesn't decrement pwsi->num_async_rq
395 * if( pwsi->num_async_rq )
396 * dprintf_winsock(stddeb,"\thave %i outstanding async ops!\n", pwsi->num_async_rq );
399 for(i
= 0, j
= 0, n
= 0; i
< WS_MAX_SOCKETS_PER_THREAD
; i
++)
400 if( pwsi
->sock
[i
].fd
!= -1 )
402 if( pwsi
->sock
[i
].psop
)
405 WSAAsyncSelect32( (SOCKET16
)WS_PTR2HANDLE(pwsi
->sock
+ i
), 0, 0, 0 );
407 close(pwsi
->sock
[i
].fd
); j
++;
410 dprintf_winsock(stddeb
,"\tclosed %i sockets, killed %i async selects!\n", j
, n
);
412 /* delete scratch buffers */
414 if( pwsi
->buffer
) SEGPTR_FREE(pwsi
->buffer
);
415 if( pwsi
->dbuffer
) SEGPTR_FREE(pwsi
->dbuffer
);
417 memset( pwsi
, 0, sizeof(WSINFO
) );
422 INT32 WINAPI
WSACleanup(void)
424 HTASK16 hTask
= GetCurrentTask();
426 dprintf_winsock(stddeb
, "WSACleanup(%04x)\n", hTask
);
429 LPWSINFO pwsi
= wsi_find(hTask
);
431 return WINSOCK_DeleteTaskWSI( (TDB
*)GlobalLock16(hTask
), pwsi
);
435 WINSOCK_Shutdown(); /* remove all outstanding DNS requests */
440 /***********************************************************************
441 * WSAGetLastError() (WSOCK32.111)(WINSOCK.111)
443 INT32 WINAPI
WSAGetLastError(void)
445 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
448 dprintf_winsock(stddeb
, "WSAGetLastError(%08x)", (unsigned)pwsi
);
450 ret
= (pwsi
) ? pwsi
->err
: WSANOTINITIALISED
;
452 dprintf_winsock(stddeb
, " = %i\n", (int)ret
);
456 /***********************************************************************
457 * WSASetLastError32() (WSOCK32.112)
459 void WINAPI
WSASetLastError32(INT32 iError
)
461 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
463 dprintf_winsock(stddeb
, "WSASetLastError(%08x): %d\n", (unsigned)pwsi
, (int)iError
);
464 if( pwsi
) pwsi
->err
= iError
;
467 /***********************************************************************
468 * WSASetLastError16() (WINSOCK.112)
470 void WINAPI
WSASetLastError16(INT16 iError
)
472 WSASetLastError32(iError
);
475 int _check_ws(LPWSINFO pwsi
, ws_socket
* pws
)
478 if( pwsi
->flags
& WSI_BLOCKINGCALL
) pwsi
->err
= WSAEINPROGRESS
;
479 else if( WSI_CHECK_RANGE(pwsi
, pws
) ) return 1;
480 else pwsi
->err
= WSAENOTSOCK
;
484 int _check_buffer(LPWSINFO pwsi
, int size
)
486 if( pwsi
->buffer
&& pwsi
->buflen
>= size
) return 1;
487 else SEGPTR_FREE(pwsi
->buffer
);
489 pwsi
->buffer
= (char*)SEGPTR_ALLOC((pwsi
->buflen
= size
));
490 return (pwsi
->buffer
!= NULL
);
493 /* ----------------------------------- i/o APIs */
495 /***********************************************************************
496 * accept() (WSOCK32.1)
498 SOCKET32 WINAPI
WINSOCK_accept32(SOCKET32 s
, struct sockaddr
*addr
,
501 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR((SOCKET16
)s
);
502 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
504 dprintf_winsock(stddeb
, "WS_ACCEPT(%08x): socket %04x\n",
505 (unsigned)pwsi
, (UINT16
)s
);
506 if( _check_ws(pwsi
, pws
) )
510 fd_flags
= fcntl(pws
->fd
, F_GETFL
, 0);
512 if( (sock
= accept(pws
->fd
, addr
, addrlen32
)) >= 0 )
514 ws_socket
* pnew
= wsi_alloc_socket(pwsi
, sock
);
517 s
= (SOCKET32
)WS_PTR2HANDLE(pnew
);
518 if( pws
->psop
&& pws
->flags
& WS_FD_ACCEPT
)
520 EVENT_AddIO( pws
->fd
, EVENT_IO_READ
); /* reenabler */
522 /* async select the accept()'ed socket */
523 WSAAsyncSelect32( s
, pws
->psop
->hWnd
, pws
->psop
->uMsg
,
524 pws
->flags
& ~WS_FD_ACCEPT
);
528 else pwsi
->err
= WSAENOBUFS
;
530 else pwsi
->err
= wsaErrno();
532 return INVALID_SOCKET32
;
535 /***********************************************************************
536 * accept() (WINSOCK.1)
538 SOCKET16 WINAPI
WINSOCK_accept16(SOCKET16 s
, struct sockaddr
* addr
,
541 INT32 addrlen32
= addrlen16
? *addrlen16
: 0;
542 SOCKET32 retSocket
= WINSOCK_accept32( s
, addr
, &addrlen32
);
543 if( addrlen16
) *addrlen16
= (INT16
)addrlen32
;
544 return (SOCKET16
)retSocket
;
547 /***********************************************************************
550 INT32 WINAPI
WINSOCK_bind32(SOCKET32 s
, struct sockaddr
*name
, INT32 namelen
)
552 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
553 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
555 dprintf_winsock(stddeb
, "WS_BIND(%08x): socket %04x, ptr %8x, length %d\n",
556 (unsigned)pwsi
, s
, (int) name
, namelen
);
557 /* #if DEBUG_SOCKADDR */
561 if ( _check_ws(pwsi
, pws
) )
562 if ( namelen
>= sizeof(*name
) )
563 if ( ((struct ws_sockaddr_in
*)name
)->sin_family
== AF_INET
)
564 if ( bind(pws
->fd
, name
, namelen
) < 0 )
566 int loc_errno
= errno
;
567 dprintf_winsock(stddeb
,"\tfailure - errno = %i\n", errno
);
571 case EBADF
: pwsi
->err
= WSAENOTSOCK
; break;
572 case EADDRNOTAVAIL
: pwsi
->err
= WSAEINVAL
; break;
573 default: pwsi
->err
= wsaErrno();
576 else return 0; /* success */
577 else pwsi
->err
= WSAEAFNOSUPPORT
;
578 else pwsi
->err
= WSAEFAULT
;
582 /***********************************************************************
585 INT16 WINAPI
WINSOCK_bind16(SOCKET16 s
, struct sockaddr
*name
, INT16 namelen
)
587 return (INT16
)WINSOCK_bind32( s
, name
, namelen
);
590 /***********************************************************************
591 * closesocket() (WSOCK32.3)
593 INT32 WINAPI
WINSOCK_closesocket32(SOCKET32 s
)
595 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
596 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
598 dprintf_winsock(stddeb
, "WS_CLOSE(%08x): socket %08x\n", (unsigned)pwsi
, s
);
600 if( _check_ws(pwsi
, pws
) )
604 if( pws
->psop
) WSAAsyncSelect32( s
, 0, 0, 0 );
607 pws
->flags
= (unsigned)pwsi
->last_free
;
608 pwsi
->last_free
= pws
- &pwsi
->sock
[0]; /* add to free list */
612 pwsi
->err
= (errno
== EBADF
) ? WSAENOTSOCK
: wsaErrno();
617 /***********************************************************************
618 * closesocket() (WINSOCK.3)
620 INT16 WINAPI
WINSOCK_closesocket16(SOCKET16 s
)
622 return (INT16
)WINSOCK_closesocket32(s
);
625 /***********************************************************************
626 * connect() (WSOCK32.4)
628 INT32 WINAPI
WINSOCK_connect32(SOCKET32 s
, struct sockaddr
*name
, INT32 namelen
)
630 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
631 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
633 dprintf_winsock(stddeb
, "WS_CONNECT(%08x): socket %04x, ptr %8x, length %d\n",
634 (unsigned)pwsi
, s
, (int) name
, namelen
);
639 if( _check_ws(pwsi
, pws
) )
641 if (connect(pws
->fd
, name
, namelen
) == 0)
643 if( pws
->psop
&& (pws
->flags
& WS_FD_CONNECT
) )
645 /* application did AsyncSelect() but then went
646 * ahead and called connect() without waiting for
649 * FIXME: Do we have to post a notification message
653 if( !(pws
->flags
& WS_FD_CONNECTED
) )
655 if( pws
->flags
& (WS_FD_READ
| WS_FD_CLOSE
) )
656 EVENT_AddIO( pws
->fd
, EVENT_IO_READ
);
658 EVENT_DeleteIO( pws
->fd
, EVENT_IO_READ
);
659 if( pws
->flags
& WS_FD_WRITE
)
660 EVENT_AddIO( pws
->fd
, EVENT_IO_WRITE
);
662 EVENT_DeleteIO( pws
->fd
, EVENT_IO_WRITE
);
665 pws
->flags
|= WS_FD_CONNECTED
;
666 pws
->flags
&= ~(WS_FD_INACTIVE
| WS_FD_CONNECT
| WS_FD_LISTENING
);
669 pwsi
->err
= (errno
== EINPROGRESS
) ? WSAEWOULDBLOCK
: wsaErrno();
674 /***********************************************************************
675 * connect() (WINSOCK.4)
677 INT16 WINAPI
WINSOCK_connect16(SOCKET16 s
, struct sockaddr
*name
, INT16 namelen
)
679 return (INT16
)WINSOCK_connect32( s
, name
, namelen
);
682 /***********************************************************************
683 * getpeername() (WSOCK32.5)
685 INT32 WINAPI
WINSOCK_getpeername32(SOCKET32 s
, struct sockaddr
*name
,
688 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
689 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
691 dprintf_winsock(stddeb
, "WS_GETPEERNAME(%08x): socket: %04x, ptr %8x, ptr %8x\n",
692 (unsigned)pwsi
, s
, (int) name
, *namelen
);
693 if( _check_ws(pwsi
, pws
) )
695 if (getpeername(pws
->fd
, name
, namelen
) == 0)
697 pwsi
->err
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
702 /***********************************************************************
703 * getpeername() (WINSOCK.5)
705 INT16 WINAPI
WINSOCK_getpeername16(SOCKET16 s
, struct sockaddr
*name
,
708 INT32 namelen32
= *namelen16
;
709 INT32 retVal
= WINSOCK_getpeername32( s
, name
, &namelen32
);
715 *namelen16
= namelen32
;
716 return (INT16
)retVal
;
719 /***********************************************************************
720 * getsockname() (WSOCK32.6)
722 INT32 WINAPI
WINSOCK_getsockname32(SOCKET32 s
, struct sockaddr
*name
,
725 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
726 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
728 dprintf_winsock(stddeb
, "WS_GETSOCKNAME(%08x): socket: %04x, ptr %8x, ptr %8x\n",
729 (unsigned)pwsi
, s
, (int) name
, (int) *namelen
);
730 if( _check_ws(pwsi
, pws
) )
732 if (getsockname(pws
->fd
, name
, namelen
) == 0)
734 pwsi
->err
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
739 /***********************************************************************
740 * getsockname() (WINSOCK.6)
742 INT16 WINAPI
WINSOCK_getsockname16(SOCKET16 s
, struct sockaddr
*name
,
749 INT32 namelen32
= *namelen16
;
750 retVal
= WINSOCK_getsockname32( s
, name
, &namelen32
);
751 *namelen16
= namelen32
;
758 else retVal
= SOCKET_ERROR
;
759 return (INT16
)retVal
;
763 /***********************************************************************
764 * getsockopt() (WSOCK32.7)
766 INT32 WINAPI
WINSOCK_getsockopt32(SOCKET32 s
, INT32 level
,
767 INT32 optname
, char *optval
, INT32
*optlen
)
769 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
770 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
772 dprintf_winsock(stddeb
, "WS_GETSOCKOPT(%08x): socket: %04x, opt %d, ptr %8x, ptr %8x\n",
773 (unsigned)pwsi
, s
, level
, (int) optval
, (int) *optlen
);
774 if( _check_ws(pwsi
, pws
) )
776 convert_sockopt(&level
, &optname
);
777 if (getsockopt(pws
->fd
, (int) level
, optname
, optval
, optlen
) == 0 )
779 pwsi
->err
= (errno
== EBADF
) ? WSAENOTSOCK
: wsaErrno();
784 /***********************************************************************
785 * getsockopt() (WINSOCK.7)
787 INT16 WINAPI
WINSOCK_getsockopt16(SOCKET16 s
, INT16 level
,
788 INT16 optname
, char *optval
, INT16
*optlen
)
791 INT32
*p
= &optlen32
;
793 if( optlen
) optlen32
= *optlen
; else p
= NULL
;
794 retVal
= WINSOCK_getsockopt32( s
, level
, optname
, optval
, p
);
795 if( optlen
) *optlen
= optlen32
;
796 return (INT16
)retVal
;
799 /***********************************************************************
800 * htonl() (WINSOCK.8)(WSOCK32.8)
802 u_long WINAPI
WINSOCK_htonl(u_long hostlong
) { return( htonl(hostlong
) ); }
803 /***********************************************************************
804 * htons() (WINSOCK.9)(WSOCK32.9)
806 u_short WINAPI
WINSOCK_htons(u_short hostshort
) { return( htons(hostshort
) ); }
807 /***********************************************************************
808 * inet_addr() (WINSOCK.10)(WSOCK32.10)
810 u_long WINAPI
WINSOCK_inet_addr(char *cp
) { return( inet_addr(cp
) ); }
811 /***********************************************************************
812 * htohl() (WINSOCK.14)(WSOCK32.14)
814 u_long WINAPI
WINSOCK_ntohl(u_long netlong
) { return( ntohl(netlong
) ); }
815 /***********************************************************************
816 * ntohs() (WINSOCK.15)(WSOCK32.15)
818 u_short WINAPI
WINSOCK_ntohs(u_short netshort
) { return( ntohs(netshort
) ); }
820 /***********************************************************************
821 * inet_ntoa() (WINSOCK.11)(WSOCK32.11)
823 char* WINAPI
WINSOCK_inet_ntoa32(struct in_addr in
)
825 /* use "buffer for dummies" here because some applications have
826 * propensity to decode addresses in ws_hostent structure without
827 * saving them first...
830 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
834 char* s
= inet_ntoa(in
);
837 if( pwsi
->dbuffer
== NULL
)
838 if((pwsi
->dbuffer
= (char*) SEGPTR_ALLOC(32)) == NULL
)
840 pwsi
->err
= WSAENOBUFS
;
843 strncpy(pwsi
->dbuffer
, s
, 32 );
844 return pwsi
->dbuffer
;
846 pwsi
->err
= wsaErrno();
851 SEGPTR WINAPI
WINSOCK_inet_ntoa16(struct in_addr in
)
853 char* retVal
= WINSOCK_inet_ntoa32(in
);
854 return retVal
? SEGPTR_GET(retVal
) : (SEGPTR
)NULL
;
857 /***********************************************************************
858 * ioctlsocket() (WSOCK32.12)
860 INT32 WINAPI
WINSOCK_ioctlsocket32(SOCKET32 s
, UINT32 cmd
, UINT32
*argp
)
862 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
863 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
865 dprintf_winsock(stddeb
, "WS_IOCTL(%08x): socket %04x, cmd %08x, ptr %8x\n",
866 (unsigned)pwsi
, s
, cmd
, (unsigned) argp
);
867 if( _check_ws(pwsi
, pws
) )
879 if( pws
->psop
&& *argp
== 0 )
881 /* AsyncSelect()'ed sockets are always nonblocking */
882 pwsi
->err
= WSAEINVAL
;
891 case WS_IOW('f',125,u_long
):
892 fprintf(stderr
,"Warning: WS1.1 shouldn't be using async I/O\n");
893 pwsi
->err
= WSAEINVAL
;
897 /* Netscape tries hard to use bogus ioctl 0x667e */
898 dprintf_winsock(stddeb
,"\tunknown WS_IOCTL cmd (%08x)\n", cmd
);
900 if( ioctl(pws
->fd
, newcmd
, (char*)argp
) == 0 ) return 0;
901 pwsi
->err
= (errno
== EBADF
) ? WSAENOTSOCK
: wsaErrno();
906 /***********************************************************************
907 * ioctlsocket() (WINSOCK.12)
909 INT16 WINAPI
WINSOCK_ioctlsocket16(SOCKET16 s
, UINT32 cmd
, UINT32
*argp
)
911 return (INT16
)WINSOCK_ioctlsocket32( s
, cmd
, argp
);
915 /***********************************************************************
916 * listen() (WSOCK32.13)
918 INT32 WINAPI
WINSOCK_listen32(SOCKET32 s
, INT32 backlog
)
920 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
921 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
923 dprintf_winsock(stddeb
, "WS_LISTEN(%08x): socket %04x, backlog %d\n",
924 (unsigned)pwsi
, s
, backlog
);
925 if( _check_ws(pwsi
, pws
) )
927 if (listen(pws
->fd
, backlog
) == 0)
931 int fd_flags
= fcntl(pws
->fd
, F_GETFL
, 0);
932 if( !(fd_flags
& O_NONBLOCK
) ) pws
->flags
|= WS_FD_ACCEPT
;
934 pws
->flags
|= WS_FD_LISTENING
;
935 pws
->flags
&= ~(WS_FD_INACTIVE
| WS_FD_CONNECTED
); /* just in case */
938 pwsi
->err
= wsaErrno();
940 else if( pwsi
) pwsi
->err
= WSAENOTSOCK
;
944 /***********************************************************************
945 * listen() (WINSOCK.13)
947 INT16 WINAPI
WINSOCK_listen16(SOCKET16 s
, INT16 backlog
)
949 return (INT16
)WINSOCK_listen32( s
, backlog
);
953 /***********************************************************************
954 * recv() (WSOCK32.16)
956 INT32 WINAPI
WINSOCK_recv32(SOCKET32 s
, char *buf
, INT32 len
, INT32 flags
)
958 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
959 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
961 dprintf_winsock(stddeb
, "WS_RECV(%08x): socket %04x, buf %8x, len %d, flags %d",
962 (unsigned)pwsi
, s
, (unsigned)buf
, len
, flags
);
963 if( _check_ws(pwsi
, pws
) )
966 if ((length
= recv(pws
->fd
, buf
, len
, flags
)) >= 0)
968 dprintf_winsock(stddeb
, " -> %i bytes\n", length
);
970 if( pws
->psop
&& (pws
->flags
& (WS_FD_READ
| WS_FD_CLOSE
)) )
971 EVENT_AddIO( pws
->fd
, EVENT_IO_READ
); /* reenabler */
975 pwsi
->err
= wsaErrno();
977 else if( pwsi
) pwsi
->err
= WSAENOTSOCK
;
978 dprintf_winsock(stddeb
, " -> ERROR\n");
982 /***********************************************************************
983 * recv() (WINSOCK.16)
985 INT16 WINAPI
WINSOCK_recv16(SOCKET16 s
, char *buf
, INT16 len
, INT16 flags
)
987 return (INT16
)WINSOCK_recv32( s
, buf
, len
, flags
);
991 /***********************************************************************
992 * recvfrom() (WSOCK32.17)
994 INT32 WINAPI
WINSOCK_recvfrom32(SOCKET32 s
, char *buf
, INT32 len
, INT32 flags
,
995 struct sockaddr
*from
, INT32
*fromlen32
)
997 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
998 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1000 dprintf_winsock(stddeb
, "WS_RECVFROM(%08x): socket %04x, ptr %08x, len %d, flags %d",
1001 (unsigned)pwsi
, s
, (unsigned)buf
, len
, flags
);
1003 if( from
) dump_sockaddr(from
);
1004 else fprintf(stderr
, "\tfrom = NULL\n");
1007 if( _check_ws(pwsi
, pws
) )
1011 if ((length
= recvfrom(pws
->fd
, buf
, len
, flags
, from
, fromlen32
)) >= 0)
1013 dprintf_winsock(stddeb
, " -> %i bytes\n", length
);
1015 if( pws
->psop
&& (pws
->flags
& (WS_FD_READ
| WS_FD_CLOSE
)) )
1016 EVENT_AddIO( pws
->fd
, EVENT_IO_READ
); /* reenabler */
1018 return (INT16
)length
;
1020 pwsi
->err
= wsaErrno();
1022 else if( pwsi
) pwsi
->err
= WSAENOTSOCK
;
1023 dprintf_winsock(stddeb
, " -> ERROR\n");
1024 return SOCKET_ERROR
;
1027 /***********************************************************************
1028 * recvfrom() (WINSOCK.17)
1030 INT16 WINAPI
WINSOCK_recvfrom16(SOCKET16 s
, char *buf
, INT16 len
, INT16 flags
,
1031 struct sockaddr
*from
, INT16
*fromlen16
)
1034 INT32
*p
= &fromlen32
;
1037 if( fromlen16
) fromlen32
= *fromlen16
; else p
= NULL
;
1038 retVal
= WINSOCK_recvfrom32( s
, buf
, len
, flags
, from
, p
);
1039 if( fromlen16
) *fromlen16
= fromlen32
;
1040 return (INT16
)retVal
;
1043 /***********************************************************************
1044 * select() (WINSOCK.18)(WSOCK32.18)
1046 static INT32
__ws_select( BOOL32 b32
, void *ws_readfds
, void *ws_writefds
, void *ws_exceptfds
,
1047 struct timeval
*timeout
)
1049 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1051 dprintf_winsock(stddeb
, "WS_SELECT(%08x): read %8x, write %8x, excp %8x\n",
1052 (unsigned) pwsi
, (unsigned) ws_readfds
, (unsigned) ws_writefds
, (unsigned) ws_exceptfds
);
1057 fd_set readfds
, writefds
, exceptfds
;
1058 fd_set
*p_read
, *p_write
, *p_except
;
1060 p_read
= fd_set_import(&readfds
, pwsi
, ws_readfds
, &highfd
, b32
);
1061 p_write
= fd_set_import(&writefds
, pwsi
, ws_writefds
, &highfd
, b32
);
1062 p_except
= fd_set_import(&exceptfds
, pwsi
, ws_exceptfds
, &highfd
, b32
);
1064 if( (highfd
= select(highfd
+ 1, p_read
, p_write
, p_except
, timeout
)) >= 0 )
1068 fd_set_export(pwsi
, &readfds
, p_except
, ws_readfds
, b32
);
1069 fd_set_export(pwsi
, &writefds
, p_except
, ws_writefds
, b32
);
1071 if (p_except
&& ws_exceptfds
)
1073 #define wsfds16 ((ws_fd_set16*)ws_exceptfds)
1074 #define wsfds32 ((ws_fd_set32*)ws_exceptfds)
1075 int i
, j
, count
= (b32
) ? wsfds32
->fd_count
: wsfds16
->fd_count
;
1077 for (i
= j
= 0; i
< count
; i
++)
1079 ws_socket
*pws
= (b32
) ? (ws_socket
*)WS_HANDLE2PTR(wsfds32
->fd_array
[i
])
1080 : (ws_socket
*)WS_HANDLE2PTR(wsfds16
->fd_array
[i
]);
1081 if( _check_ws(pwsi
, pws
) && FD_ISSET(pws
->fd
, &exceptfds
) )
1084 wsfds32
->fd_array
[j
++] = wsfds32
->fd_array
[i
];
1086 wsfds16
->fd_array
[j
++] = wsfds16
->fd_array
[i
];
1090 wsfds32
->fd_count
= j
;
1092 wsfds16
->fd_count
= j
;
1099 pwsi
->err
= wsaErrno();
1101 return SOCKET_ERROR
;
1104 INT16 WINAPI
WINSOCK_select16(INT16 nfds
, ws_fd_set16
*ws_readfds
,
1105 ws_fd_set16
*ws_writefds
, ws_fd_set16
*ws_exceptfds
,
1106 struct timeval
*timeout
)
1108 return (INT16
)__ws_select( FALSE
, ws_readfds
, ws_writefds
, ws_exceptfds
, timeout
);
1111 INT32 WINAPI
WINSOCK_select32(INT32 nfds
, ws_fd_set32
*ws_readfds
,
1112 ws_fd_set32
*ws_writefds
, ws_fd_set32
*ws_exceptfds
,
1113 struct timeval
*timeout
)
1115 /* struct timeval is the same for both 32- and 16-bit code */
1116 return (INT32
)__ws_select( TRUE
, ws_readfds
, ws_writefds
, ws_exceptfds
, timeout
);
1120 /***********************************************************************
1121 * send() (WSOCK32.19)
1123 INT32 WINAPI
WINSOCK_send32(SOCKET32 s
, char *buf
, INT32 len
, INT32 flags
)
1125 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
1126 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1128 dprintf_winsock(stddeb
, "WS_SEND(%08x): socket %04x, ptr %08x, length %d, flags %d\n",
1129 (unsigned)pwsi
, s
, (unsigned) buf
, len
, flags
);
1130 if( _check_ws(pwsi
, pws
) )
1134 if ((length
= send(pws
->fd
, buf
, len
, flags
)) < 0 )
1136 pwsi
->err
= wsaErrno();
1137 if( pwsi
->err
== WSAEWOULDBLOCK
&&
1138 pws
->psop
&& pws
->flags
& WS_FD_WRITE
)
1139 EVENT_AddIO( pws
->fd
, EVENT_IO_WRITE
); /* reenabler */
1141 else return (INT16
)length
;
1143 else if( pwsi
) pwsi
->err
= WSAENOTSOCK
;
1144 return SOCKET_ERROR
;
1147 /***********************************************************************
1148 * send() (WINSOCK.19)
1150 INT16 WINAPI
WINSOCK_send16(SOCKET16 s
, char *buf
, INT16 len
, INT16 flags
)
1152 return WINSOCK_send32( s
, buf
, len
, flags
);
1155 /***********************************************************************
1156 * sendto() (WSOCK32.20)
1158 INT32 WINAPI
WINSOCK_sendto32(SOCKET32 s
, char *buf
, INT32 len
, INT32 flags
,
1159 struct sockaddr
*to
, INT32 tolen
)
1161 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
1162 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1164 dprintf_winsock(stddeb
, "WS_SENDTO(%08x): socket %04x, ptr %08x, length %d, flags %d\n",
1165 (unsigned)pwsi
, s
, (unsigned) buf
, len
, flags
);
1166 if( _check_ws(pwsi
, pws
) )
1170 if ((length
= sendto(pws
->fd
, buf
, len
, flags
, to
, tolen
)) < 0 )
1172 pwsi
->err
= wsaErrno();
1173 if( pwsi
->err
== WSAEWOULDBLOCK
&&
1174 pws
->psop
&& pws
->flags
& WS_FD_WRITE
)
1175 EVENT_AddIO( pws
->fd
, EVENT_IO_WRITE
); /* reenabler */
1179 else if( pwsi
) pwsi
->err
= WSAENOTSOCK
;
1180 return SOCKET_ERROR
;
1183 /***********************************************************************
1184 * sendto() (WINSOCK.20)
1186 INT16 WINAPI
WINSOCK_sendto16(SOCKET16 s
, char *buf
, INT16 len
, INT16 flags
,
1187 struct sockaddr
*to
, INT16 tolen
)
1189 return (INT16
)WINSOCK_sendto32( s
, buf
, len
, flags
, to
, tolen
);
1192 /***********************************************************************
1193 * setsockopt() (WSOCK32.21)
1195 INT32 WINAPI
WINSOCK_setsockopt32(SOCKET16 s
, INT32 level
, INT32 optname
,
1196 char *optval
, INT32 optlen
)
1198 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
1199 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1201 dprintf_winsock(stddeb
, "WS_SETSOCKOPT(%08x): socket %04x, lev %d, opt %d, ptr %08x, len %d\n",
1202 (unsigned)pwsi
, s
, level
, optname
, (int) optval
, optlen
);
1203 if( _check_ws(pwsi
, pws
) )
1205 convert_sockopt(&level
, &optname
);
1206 if (setsockopt(pws
->fd
, level
, optname
, optval
, optlen
) == 0) return 0;
1207 pwsi
->err
= wsaErrno();
1209 else if( pwsi
) pwsi
->err
= WSAENOTSOCK
;
1210 return SOCKET_ERROR
;
1213 /***********************************************************************
1214 * setsockopt() (WINSOCK.21)
1216 INT16 WINAPI
WINSOCK_setsockopt16(SOCKET16 s
, INT16 level
, INT16 optname
,
1217 char *optval
, INT16 optlen
)
1220 if( !optval
) return SOCKET_ERROR
;
1221 if( optname
== SO_LINGER
)
1223 INT16
* ptr
= (INT16
*)optval
;
1224 linger32
[0] = ptr
[0];
1225 linger32
[1] = ptr
[1];
1226 optval
= (char*)&linger32
;
1227 optlen
= sizeof(linger32
);
1229 return (INT16
)WINSOCK_setsockopt32( s
, level
, optname
, optval
, optlen
);
1233 /***********************************************************************
1234 * shutdown() (WSOCK32.22)
1236 INT32 WINAPI
WINSOCK_shutdown32(SOCKET32 s
, INT32 how
)
1238 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
1239 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1241 dprintf_winsock(stddeb
, "WS_SHUTDOWN(%08x): socket %04x, how %i\n",
1242 (unsigned)pwsi
, s
, how
);
1243 if( _check_ws(pwsi
, pws
) )
1248 case 0: /* drop receives */
1249 if( pws
->flags
& (WS_FD_READ
| WS_FD_CLOSE
) )
1250 EVENT_DeleteIO( pws
->fd
, EVENT_IO_READ
);
1251 pws
->flags
&= ~(WS_FD_READ
| WS_FD_CLOSE
);
1254 case 1: /* drop sends */
1255 if( pws
->flags
& WS_FD_WRITE
)
1256 EVENT_DeleteIO( pws
->fd
, EVENT_IO_WRITE
);
1257 pws
->flags
&= ~WS_FD_WRITE
;
1260 case 2: /* drop all */
1262 WSAAsyncSelect32( s
, 0, 0, 0 );
1266 if (shutdown(pws
->fd
, how
) == 0)
1270 pws
->flags
&= ~(WS_FD_CONNECTED
| WS_FD_LISTENING
);
1271 pws
->flags
|= WS_FD_INACTIVE
;
1275 pwsi
->err
= wsaErrno();
1277 else if( pwsi
) pwsi
->err
= WSAENOTSOCK
;
1278 return SOCKET_ERROR
;
1281 /***********************************************************************
1282 * shutdown() (WINSOCK.22)
1284 INT16 WINAPI
WINSOCK_shutdown16(SOCKET16 s
, INT16 how
)
1286 return (INT16
)WINSOCK_shutdown32( s
, how
);
1290 /***********************************************************************
1291 * socket() (WSOCK32.23)
1293 SOCKET32 WINAPI
WINSOCK_socket32(INT32 af
, INT32 type
, INT32 protocol
)
1295 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1297 dprintf_winsock(stddeb
, "WS_SOCKET(%08x): af=%d type=%d protocol=%d\n",
1298 (unsigned)pwsi
, af
, type
, protocol
);
1304 /* check the socket family */
1308 case AF_UNSPEC
: break;
1309 default: pwsi
->err
= WSAEAFNOSUPPORT
;
1310 return INVALID_SOCKET32
;
1313 /* check the socket type */
1318 case SOCK_RAW
: break;
1319 default: pwsi
->err
= WSAESOCKTNOSUPPORT
;
1320 return INVALID_SOCKET32
;
1323 /* check the protocol type */
1324 if ( protocol
< 0 ) /* don't support negative values */
1325 { pwsi
->err
= WSAEPROTONOSUPPORT
; return INVALID_SOCKET32
; }
1327 if ( af
== AF_UNSPEC
) /* did they not specify the address family? */
1331 if (type
== SOCK_STREAM
) { af
= AF_INET
; break; }
1333 if (type
== SOCK_DGRAM
) { af
= AF_INET
; break; }
1334 default: pwsi
->err
= WSAEPROTOTYPE
; return INVALID_SOCKET32
;
1337 if ((sock
= socket(af
, type
, protocol
)) >= 0)
1339 ws_socket
* pnew
= wsi_alloc_socket(pwsi
, sock
);
1341 dprintf_winsock(stddeb
,"\tcreated %04x (handle %i)\n", sock
, (UINT16
)WS_PTR2HANDLE(pnew
));
1343 if( pnew
) return (SOCKET16
)WS_PTR2HANDLE(pnew
);
1346 pwsi
->err
= WSAENOBUFS
;
1347 return INVALID_SOCKET32
;
1350 if (errno
== EPERM
) /* raw socket denied */
1352 fprintf(stderr
, "WS_SOCKET: not enough privileges\n");
1353 pwsi
->err
= WSAESOCKTNOSUPPORT
;
1354 } else pwsi
->err
= wsaErrno();
1357 dprintf_winsock(stddeb
, "\t\tfailed!\n");
1358 return INVALID_SOCKET32
;
1361 /***********************************************************************
1362 * socket() (WINSOCK.23)
1364 SOCKET16 WINAPI
WINSOCK_socket16(INT16 af
, INT16 type
, INT16 protocol
)
1366 return (SOCKET16
)WINSOCK_socket32( af
, type
, protocol
);
1370 /* ----------------------------------- DNS services
1372 * IMPORTANT: 16-bit API structures have SEGPTR pointers inside them.
1373 * Also, we have to use wsock32 stubs to convert structures and
1374 * error codes from Unix to WSA, hence no direct mapping in if1632/wsock32.spec.
1377 static char* NULL_STRING
= "NULL";
1379 /***********************************************************************
1380 * gethostbyaddr() (WINSOCK.51)(WSOCK32.51)
1382 static struct WIN_hostent
* __ws_gethostbyaddr(const char *addr
, int len
, int type
, int dup_flag
)
1384 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1388 struct hostent
* host
;
1389 if( (host
= gethostbyaddr(addr
, len
, type
)) != NULL
)
1390 if( WS_dup_he(pwsi
, host
, dup_flag
) )
1391 return (struct WIN_hostent
*)(pwsi
->buffer
);
1393 pwsi
->err
= WSAENOBUFS
;
1395 pwsi
->err
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
1400 SEGPTR WINAPI
WINSOCK_gethostbyaddr16(const char *addr
, INT16 len
, INT16 type
)
1402 struct WIN_hostent
* retval
;
1403 dprintf_winsock(stddeb
, "WS_GetHostByAddr16: ptr %08x, len %d, type %d\n",
1404 (unsigned) addr
, len
, type
);
1405 retval
= __ws_gethostbyaddr( addr
, len
, type
, WS_DUP_SEGPTR
);
1406 return retval
? SEGPTR_GET(retval
) : ((SEGPTR
)NULL
);
1409 struct WIN_hostent
* WINAPI
WINSOCK_gethostbyaddr32(const char *addr
, INT32 len
,
1412 dprintf_winsock(stddeb
, "WS_GetHostByAddr32: ptr %08x, len %d, type %d\n",
1413 (unsigned) addr
, len
, type
);
1414 return __ws_gethostbyaddr(addr
, len
, type
, WS_DUP_LINEAR
);
1417 /***********************************************************************
1418 * gethostbyname() (WINSOCK.52)(WSOCK32.52)
1420 static struct WIN_hostent
* __ws_gethostbyname(const char *name
, int dup_flag
)
1422 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1426 struct hostent
* host
;
1427 if( (host
= gethostbyname(name
)) != NULL
)
1428 if( WS_dup_he(pwsi
, host
, dup_flag
) )
1429 return (struct WIN_hostent
*)(pwsi
->buffer
);
1430 else pwsi
->err
= WSAENOBUFS
;
1431 else pwsi
->err
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
1436 SEGPTR WINAPI
WINSOCK_gethostbyname16(const char *name
)
1438 struct WIN_hostent
* retval
;
1439 dprintf_winsock(stddeb
, "WS_GetHostByName16: %s\n", (name
)?name
:NULL_STRING
);
1440 retval
= __ws_gethostbyname( name
, WS_DUP_SEGPTR
);
1441 return (retval
)? SEGPTR_GET(retval
) : ((SEGPTR
)NULL
) ;
1444 struct WIN_hostent
* WINAPI
WINSOCK_gethostbyname32(const char* name
)
1446 dprintf_winsock(stddeb
, "WS_GetHostByName32: %s\n", (name
)?name
:NULL_STRING
);
1447 return __ws_gethostbyname( name
, WS_DUP_LINEAR
);
1451 /***********************************************************************
1452 * getprotobyname() (WINSOCK.53)(WSOCK32.53)
1454 static struct WIN_protoent
* __ws_getprotobyname(const char *name
, int dup_flag
)
1456 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1460 struct protoent
* proto
;
1461 if( (proto
= getprotobyname(name
)) != NULL
)
1462 if( WS_dup_pe(pwsi
, proto
, dup_flag
) )
1463 return (struct WIN_protoent
*)(pwsi
->buffer
);
1464 else pwsi
->err
= WSAENOBUFS
;
1465 else pwsi
->err
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
1470 SEGPTR WINAPI
WINSOCK_getprotobyname16(const char *name
)
1472 struct WIN_protoent
* retval
;
1473 dprintf_winsock(stddeb
, "WS_GetProtoByName16: %s\n", (name
)?name
:NULL_STRING
);
1474 retval
= __ws_getprotobyname(name
, WS_DUP_SEGPTR
);
1475 return retval
? SEGPTR_GET(retval
) : ((SEGPTR
)NULL
);
1478 struct WIN_protoent
* WINAPI
WINSOCK_getprotobyname32(const char* name
)
1480 dprintf_winsock(stddeb
, "WS_GetProtoByName32: %s\n", (name
)?name
:NULL_STRING
);
1481 return __ws_getprotobyname(name
, WS_DUP_LINEAR
);
1485 /***********************************************************************
1486 * getprotobynumber() (WINSOCK.54)(WSOCK32.54)
1488 static struct WIN_protoent
* __ws_getprotobynumber(int number
, int dup_flag
)
1490 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1494 struct protoent
* proto
;
1495 if( (proto
= getprotobynumber(number
)) != NULL
)
1496 if( WS_dup_pe(pwsi
, proto
, dup_flag
) )
1497 return (struct WIN_protoent
*)(pwsi
->buffer
);
1498 else pwsi
->err
= WSAENOBUFS
;
1499 else pwsi
->err
= WSANO_DATA
;
1504 SEGPTR WINAPI
WINSOCK_getprotobynumber16(INT16 number
)
1506 struct WIN_protoent
* retval
;
1507 dprintf_winsock(stddeb
, "WS_GetProtoByNumber16: %i\n", number
);
1508 retval
= __ws_getprotobynumber(number
, WS_DUP_SEGPTR
);
1509 return retval
? SEGPTR_GET(retval
) : ((SEGPTR
)NULL
);
1512 struct WIN_protoent
* WINAPI
WINSOCK_getprotobynumber32(INT32 number
)
1514 dprintf_winsock(stddeb
, "WS_GetProtoByNumber32: %i\n", number
);
1515 return __ws_getprotobynumber(number
, WS_DUP_LINEAR
);
1519 /***********************************************************************
1520 * getservbyname() (WINSOCK.55)(WSOCK32.55)
1522 struct WIN_servent
* __ws_getservbyname(const char *name
, const char *proto
, int dup_flag
)
1524 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1528 struct servent
* serv
;
1529 if( (serv
= getservbyname(name
, proto
)) != NULL
)
1530 if( WS_dup_se(pwsi
, serv
, dup_flag
) )
1531 return (struct WIN_servent
*)(pwsi
->buffer
);
1532 else pwsi
->err
= WSAENOBUFS
;
1533 else pwsi
->err
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
1538 SEGPTR WINAPI
WINSOCK_getservbyname16(const char *name
, const char *proto
)
1540 struct WIN_servent
* retval
;
1541 dprintf_winsock(stddeb
, "WS_GetServByName16: '%s', '%s'\n",
1542 (name
)?name
:NULL_STRING
, (proto
)?proto
:NULL_STRING
);
1543 retval
= __ws_getservbyname(name
, proto
, WS_DUP_SEGPTR
);
1544 return retval
? SEGPTR_GET(retval
) : ((SEGPTR
)NULL
);
1547 struct WIN_servent
* WINAPI
WINSOCK_getservbyname32(const char *name
, const char *proto
)
1549 dprintf_winsock(stddeb
, "WS_GetServByName32: '%s', '%s'\n",
1550 (name
)?name
:NULL_STRING
, (proto
)?proto
:NULL_STRING
);
1551 return __ws_getservbyname(name
, proto
, WS_DUP_LINEAR
);
1555 /***********************************************************************
1556 * getservbyport() (WINSOCK.56)(WSOCK32.56)
1558 static struct WIN_servent
* __ws_getservbyport(int port
, const char* proto
, int dup_flag
)
1560 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1564 struct servent
* serv
;
1565 if( (serv
= getservbyport(port
, proto
)) != NULL
)
1566 if( WS_dup_se(pwsi
, serv
, dup_flag
) )
1567 return (struct WIN_servent
*)(pwsi
->buffer
);
1568 else pwsi
->err
= WSAENOBUFS
;
1569 else pwsi
->err
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
1574 SEGPTR WINAPI
WINSOCK_getservbyport16(INT16 port
, const char *proto
)
1576 struct WIN_servent
* retval
;
1577 dprintf_winsock(stddeb
, "WS_GetServByPort16: %i, '%s'\n",
1578 (int)port
, (proto
)?proto
:NULL_STRING
);
1579 retval
= __ws_getservbyport(port
, proto
, WS_DUP_SEGPTR
);
1580 return retval
? SEGPTR_GET(retval
) : ((SEGPTR
)NULL
);
1583 struct WIN_servent
* WINAPI
WINSOCK_getservbyport32(INT32 port
, const char *proto
)
1585 dprintf_winsock(stddeb
, "WS_GetServByPort32: %i, '%s'\n",
1586 (int)port
, (proto
)?proto
:NULL_STRING
);
1587 return __ws_getservbyport(port
, proto
, WS_DUP_LINEAR
);
1591 /***********************************************************************
1592 * gethostname() (WSOCK32.57)
1594 INT32 WINAPI
WINSOCK_gethostname32(char *name
, INT32 namelen
)
1596 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1598 dprintf_winsock(stddeb
, "WS_GetHostName(%08x): name %s, len %d\n",
1599 (unsigned)pwsi
, (name
)?name
:NULL_STRING
, namelen
);
1602 if (gethostname(name
, namelen
) == 0) return 0;
1603 pwsi
->err
= (errno
== EINVAL
) ? WSAEFAULT
: wsaErrno();
1605 return SOCKET_ERROR
;
1608 /***********************************************************************
1609 * gethostname() (WINSOCK.57)
1611 INT16 WINAPI
WINSOCK_gethostname16(char *name
, INT16 namelen
)
1613 return (INT16
)WINSOCK_gethostname32(name
, namelen
);
1617 /* ------------------------------------- Windows sockets extensions -- *
1619 * ------------------------------------------------------------------- */
1622 /***********************************************************************
1623 * Asynchronous DNS services
1627 extern HANDLE16
__WSAsyncDBQuery(LPWSINFO pwsi
, HWND32 hWnd
, UINT32 uMsg
, INT32 type
, LPCSTR init
,
1628 INT32 len
, LPCSTR proto
, void* sbuf
, INT32 buflen
, UINT32 flag
);
1630 /***********************************************************************
1631 * WSAAsyncGetHostByAddr() (WINSOCK.102)
1633 HANDLE16 WINAPI
WSAAsyncGetHostByAddr16(HWND16 hWnd
, UINT16 uMsg
, LPCSTR addr
,
1634 INT16 len
, INT16 type
, SEGPTR sbuf
, INT16 buflen
)
1636 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1638 dprintf_winsock(stddeb
, "WS_AsyncGetHostByAddr16(%08x): hwnd %04x, msg %04x, addr %08x[%i]\n",
1639 (unsigned)pwsi
, hWnd
, uMsg
, (unsigned)addr
, len
);
1642 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, type
, addr
, len
,
1643 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_HOSTBYADDR
);
1647 /***********************************************************************
1648 * WSAAsyncGetHostByAddr() (WSOCK32.102)
1650 HANDLE32 WINAPI
WSAAsyncGetHostByAddr32(HWND32 hWnd
, UINT32 uMsg
, LPCSTR addr
,
1651 INT32 len
, INT32 type
, LPSTR sbuf
, INT32 buflen
)
1653 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1655 dprintf_winsock(stddeb
, "WS_AsyncGetHostByAddr32(%08x): hwnd %04x, msg %08x, addr %08x[%i]\n",
1656 (unsigned)pwsi
, (HWND16
)hWnd
, uMsg
, (unsigned)addr
, len
);
1659 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, type
, addr
, len
,
1660 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_HOSTBYADDR
| WSMSG_ASYNC_WIN32
);
1665 /***********************************************************************
1666 * WSAAsyncGetHostByName() (WINSOCK.103)
1668 HANDLE16 WINAPI
WSAAsyncGetHostByName16(HWND16 hWnd
, UINT16 uMsg
, LPCSTR name
,
1669 SEGPTR sbuf
, INT16 buflen
)
1671 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1673 dprintf_winsock(stddeb
, "WS_AsyncGetHostByName16(%08x): hwnd %04x, msg %04x, host %s,
1674 buffer %i\n", (unsigned)pwsi
, hWnd
, uMsg
, (name
)?name
:NULL_STRING
, (int)buflen
);
1677 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, 0, name
, 0,
1678 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_HOSTBYNAME
);
1682 /***********************************************************************
1683 * WSAAsyncGetHostByName32() (WSOCK32.103)
1685 HANDLE32 WINAPI
WSAAsyncGetHostByName32(HWND32 hWnd
, UINT32 uMsg
, LPCSTR name
,
1686 LPSTR sbuf
, INT32 buflen
)
1688 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1689 dprintf_winsock(stddeb
, "WS_AsyncGetHostByName32(%08x): hwnd %04x, msg %08x, host %s,
1690 buffer %i\n", (unsigned)pwsi
, (HWND16
)hWnd
, uMsg
, (name
)?name
:NULL_STRING
, (int)buflen
);
1692 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, 0, name
, 0,
1693 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_HOSTBYNAME
| WSMSG_ASYNC_WIN32
);
1698 /***********************************************************************
1699 * WSAAsyncGetProtoByName() (WINSOCK.105)
1701 HANDLE16 WINAPI
WSAAsyncGetProtoByName16(HWND16 hWnd
, UINT16 uMsg
, LPCSTR name
,
1702 SEGPTR sbuf
, INT16 buflen
)
1704 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1706 dprintf_winsock(stddeb
, "WS_AsyncGetProtoByName16(%08x): hwnd %04x, msg %08x, protocol %s\n",
1707 (unsigned)pwsi
, (HWND16
)hWnd
, uMsg
, (name
)?name
:NULL_STRING
);
1710 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, 0, name
, 0,
1711 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_PROTOBYNAME
);
1715 /***********************************************************************
1716 * WSAAsyncGetProtoByName() (WSOCK32.105)
1718 HANDLE32 WINAPI
WSAAsyncGetProtoByName32(HWND32 hWnd
, UINT32 uMsg
, LPCSTR name
,
1719 LPSTR sbuf
, INT32 buflen
)
1721 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1723 dprintf_winsock(stddeb
, "WS_AsyncGetProtoByName32(%08x): hwnd %04x, msg %08x, protocol %s\n",
1724 (unsigned)pwsi
, (HWND16
)hWnd
, uMsg
, (name
)?name
:NULL_STRING
);
1727 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, 0, name
, 0,
1728 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_PROTOBYNAME
| WSMSG_ASYNC_WIN32
);
1733 /***********************************************************************
1734 * WSAAsyncGetProtoByNumber() (WINSOCK.104)
1736 HANDLE16 WINAPI
WSAAsyncGetProtoByNumber16(HWND16 hWnd
, UINT16 uMsg
, INT16 number
,
1737 SEGPTR sbuf
, INT16 buflen
)
1739 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1741 dprintf_winsock(stddeb
, "WS_AsyncGetProtoByNumber16(%08x): hwnd %04x, msg %04x, num %i\n",
1742 (unsigned)pwsi
, hWnd
, uMsg
, number
);
1745 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, number
, NULL
, 0,
1746 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_PROTOBYNUM
);
1750 /***********************************************************************
1751 * WSAAsyncGetProtoByNumber() (WSOCK32.104)
1753 HANDLE32 WINAPI
WSAAsyncGetProtoByNumber32(HWND32 hWnd
, UINT32 uMsg
, INT32 number
,
1754 LPSTR sbuf
, INT32 buflen
)
1756 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1758 dprintf_winsock(stddeb
, "WS_AsyncGetProtoByNumber32(%08x): hwnd %04x, msg %08x, num %i\n",
1759 (unsigned)pwsi
, (HWND16
)hWnd
, uMsg
, number
);
1762 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, number
, NULL
, 0,
1763 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_PROTOBYNUM
| WSMSG_ASYNC_WIN32
);
1768 /***********************************************************************
1769 * WSAAsyncGetServByName() (WINSOCK.107)
1771 HANDLE16 WINAPI
WSAAsyncGetServByName16(HWND16 hWnd
, UINT16 uMsg
, LPCSTR name
,
1772 LPCSTR proto
, SEGPTR sbuf
, INT16 buflen
)
1774 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1776 dprintf_winsock(stddeb
, "WS_AsyncGetServByName16(%08x): hwnd %04x, msg %04x, name %s, proto %s\n",
1777 (unsigned)pwsi
, hWnd
, uMsg
, (name
)?name
:NULL_STRING
, (proto
)?proto
:NULL_STRING
);
1780 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, 0, name
, 0,
1781 proto
, (void*)sbuf
, buflen
, WSMSG_ASYNC_SERVBYNAME
);
1785 /***********************************************************************
1786 * WSAAsyncGetServByName() (WSOCK32.107)
1788 HANDLE32 WINAPI
WSAAsyncGetServByName32(HWND32 hWnd
, UINT32 uMsg
, LPCSTR name
,
1789 LPCSTR proto
, LPSTR sbuf
, INT32 buflen
)
1791 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1793 dprintf_winsock(stddeb
, "WS_AsyncGetServByName32(%08x): hwnd %04x, msg %08x, name %s, proto %s\n",
1794 (unsigned)pwsi
, (HWND16
)hWnd
, uMsg
, (name
)?name
:NULL_STRING
, (proto
)?proto
:NULL_STRING
);
1796 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, 0, name
, 0,
1797 proto
, (void*)sbuf
, buflen
, WSMSG_ASYNC_SERVBYNAME
| WSMSG_ASYNC_WIN32
);
1802 /***********************************************************************
1803 * WSAAsyncGetServByPort() (WINSOCK.106)
1805 HANDLE16 WINAPI
WSAAsyncGetServByPort16(HWND16 hWnd
, UINT16 uMsg
, INT16 port
,
1806 LPCSTR proto
, SEGPTR sbuf
, INT16 buflen
)
1808 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1810 dprintf_winsock(stddeb
, "WS_AsyncGetServByPort16(%08x): hwnd %04x, msg %04x, port %i, proto %s\n",
1811 (unsigned)pwsi
, hWnd
, uMsg
, port
, (proto
)?proto
:NULL_STRING
);
1814 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, port
, proto
, 0,
1815 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_SERVBYPORT
);
1819 /***********************************************************************
1820 * WSAAsyncGetServByPort() (WSOCK32.106)
1822 HANDLE32 WINAPI
WSAAsyncGetServByPort32(HWND32 hWnd
, UINT32 uMsg
, INT32 port
,
1823 LPCSTR proto
, LPSTR sbuf
, INT32 buflen
)
1825 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1827 dprintf_winsock(stddeb
, "WS_AsyncGetServByPort32(%08x): hwnd %04x, msg %08x, port %i, proto %s\n",
1828 (unsigned)pwsi
, (HWND16
)hWnd
, uMsg
, port
, (proto
)?proto
:NULL_STRING
);
1831 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, port
, proto
, 0,
1832 NULL
, (void*)sbuf
, buflen
, WSMSG_ASYNC_SERVBYPORT
| WSMSG_ASYNC_WIN32
);
1837 /***********************************************************************
1838 * WSACancelAsyncRequest() (WINSOCK.108)(WSOCK32.109)
1840 INT32 WINAPI
WSACancelAsyncRequest32(HANDLE32 hAsyncTaskHandle
)
1842 INT32 retVal
= SOCKET_ERROR
;
1843 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1844 ws_async_op
* p_aop
= (ws_async_op
*)WS_HANDLE2PTR(hAsyncTaskHandle
);
1846 dprintf_winsock(stddeb
, "WS_CancelAsyncRequest(%08x): handle %08x\n",
1847 (unsigned)pwsi
, hAsyncTaskHandle
);
1850 SIGNAL_MaskAsyncEvents( TRUE
); /* block SIGIO */
1851 if( WINSOCK_cancel_async_op(p_aop
) )
1854 pwsi
->num_async_rq
--;
1857 else pwsi
->err
= WSAEINVAL
;
1858 SIGNAL_MaskAsyncEvents( FALSE
);
1863 INT16 WINAPI
WSACancelAsyncRequest16(HANDLE16 hAsyncTaskHandle
)
1865 return (HANDLE16
)WSACancelAsyncRequest16((HANDLE32
)hAsyncTaskHandle
);
1868 /***********************************************************************
1869 * WSAAsyncSelect() (WINSOCK.101)(WSOCK32.101)
1872 static ws_select_op
* __ws_select_list
= NULL
;
1874 BOOL32
WINSOCK_HandleIO( int* max_fd
, int num_pending
, fd_set io_set
[3] )
1876 /* This function is called by the event dispatcher
1877 * with io_set containing the result of select() */
1879 ws_select_op
* psop
= __ws_select_list
;
1880 BOOL32 bPost
= FALSE
;
1881 DWORD dwEvent
, dwErrBytes
;
1884 dprintf_winsock(stddeb
,"WINSOCK_HandleIO: %i pending descriptors\n", num_pending
);
1886 for( num_posted
= dwEvent
= 0 ; psop
; psop
= psop
->next
)
1888 unsigned flags
= psop
->pws
->flags
;
1889 int fd
= psop
->pws
->fd
;
1893 if( (r
= FD_ISSET( fd
, &io_set
[EVENT_IO_READ
] )) ||
1894 (w
= FD_ISSET( fd
, &io_set
[EVENT_IO_WRITE
] )) ||
1895 (e
= FD_ISSET( fd
, &io_set
[EVENT_IO_EXCEPT
] )) )
1897 /* This code removes WS_FD flags on one-shot events (WS_FD_CLOSE,
1898 * WS_FD_CONNECT), otherwise it clears descriptors in the io_set.
1899 * Reenabling calls turn them back on.
1902 dprintf_winsock(stddeb
,"\tchecking psop = 0x%08x\n", (unsigned) psop
);
1906 /* Now figure out what kind of event we've got. The worst problem
1907 * we have to contend with is that some out of control applications
1908 * really want to use mutually exclusive AsyncSelect() flags all at
1912 if((flags
& WS_FD_ACCEPT
) && (flags
& WS_FD_LISTENING
))
1914 /* WS_FD_ACCEPT is valid only if the socket is in the
1915 * listening state */
1917 FD_CLR( fd
, &io_set
[EVENT_IO_WRITE
] );
1920 FD_CLR( fd
, &io_set
[EVENT_IO_READ
] ); /* reenabled by the next accept() */
1921 dwEvent
= WSAMAKESELECTREPLY( WS_FD_ACCEPT
, 0 );
1926 else if( flags
& WS_FD_CONNECT
)
1928 /* connecting socket */
1930 if( w
|| (w
= FD_ISSET( fd
, &io_set
[EVENT_IO_WRITE
] )) )
1932 /* ready to write means that socket is connected */
1934 psop
->pws
->flags
|= WS_FD_CONNECTED
;
1935 psop
->pws
->flags
&= ~(WS_FD_CONNECT
| WS_FD_INACTIVE
);
1936 dwEvent
= WSAMAKESELECTREPLY( WS_FD_CONNECT
, 0 );
1938 if( flags
& (WS_FD_READ
| WS_FD_CLOSE
))
1939 FD_SET( fd
, &io_set
[EVENT_IO_READ
] );
1941 FD_CLR( fd
, &io_set
[EVENT_IO_READ
] );
1942 if( flags
& WS_FD_WRITE
)
1943 FD_SET( fd
, &io_set
[EVENT_IO_WRITE
] );
1945 FD_CLR( fd
, &io_set
[EVENT_IO_WRITE
] );
1950 /* failure - do read() to get correct errno */
1952 if( read( fd
, &dwErrBytes
, sizeof(dwErrBytes
) ) == -1 )
1954 dwEvent
= WSAMAKESELECTREPLY( WS_FD_CONNECT
, wsaErrno() );
1958 /* otherwise bPost stays FALSE */
1962 /* connected socket --
1963 * removed WS_FD_OOB code for now.
1966 if( flags
& WS_FD_WRITE
&&
1967 (w
|| (w
= FD_ISSET( fd
, &io_set
[EVENT_IO_WRITE
] ))) )
1969 /* this will be reenabled when send() or sendto() fail with
1972 if( PostMessage32A( psop
->hWnd
, psop
->uMsg
, (WPARAM32
)WS_PTR2HANDLE(psop
->pws
),
1973 (LPARAM
)WSAMAKESELECTREPLY( WS_FD_WRITE
, 0 ) ) )
1975 dprintf_winsock(stddeb
, "\t hwnd %04x - %04x, %08x\n",
1976 psop
->hWnd
, psop
->uMsg
, (unsigned)MAKELONG(WS_FD_WRITE
, 0) );
1977 FD_CLR( fd
, &io_set
[EVENT_IO_WRITE
] );
1982 if( r
&& (flags
& (WS_FD_READ
| WS_FD_CLOSE
)) )
1984 int val
= (flags
& WS_FD_RAW
);
1986 /* WS_FD_RAW is set by the WSAAsyncSelect() init */
1989 if( !val
&& ioctl( fd
, FIONREAD
, (char*)&dwErrBytes
) == -1 )
1993 dwEvent
= WSAMAKESELECTREPLY( WS_FD_READ
, wsaErrno() );
1995 else if( val
|| dwErrBytes
)
1997 /* got pending data, will be reenabled by recv() or recvfrom() */
1999 FD_CLR( fd
, &io_set
[EVENT_IO_READ
] );
2000 dwEvent
= WSAMAKESELECTREPLY( WS_FD_READ
, 0 );
2004 /* 0 bytes to read - connection reset by peer? */
2007 val
= read( fd
, (char*)&dwErrBytes
, sizeof(dwErrBytes
));
2008 while( errno
== EINTR
);
2009 if( errno
!= EWOULDBLOCK
)
2013 case 0: errno
= ENETDOWN
; /* soft reset, fall through */
2014 case -1: /* hard reset */
2015 dwEvent
= WSAMAKESELECTREPLY( WS_FD_CLOSE
, wsaErrno() );
2018 default: bPost
= FALSE
;
2019 continue; /* FIXME: this is real bad */
2022 else { bPost
= FALSE
; continue; } /* more weirdness */
2024 /* this is it, this socket is closed */
2026 psop
->pws
->flags
&= ~(WS_FD_READ
| WS_FD_CLOSE
| WS_FD_WRITE
);
2027 FD_CLR( fd
, &io_set
[EVENT_IO_READ
] );
2028 FD_CLR( fd
, &io_set
[EVENT_IO_WRITE
] );
2030 if( *max_fd
== (fd
+ 1) ) (*max_fd
)--;
2037 dprintf_winsock(stddeb
, "\t hwnd %04x - %04x, %08x\n",
2038 psop
->hWnd
, psop
->uMsg
, (unsigned)dwEvent
);
2039 PostMessage32A( psop
->hWnd
, psop
->uMsg
,
2040 (WPARAM32
)WS_PTR2HANDLE(psop
->pws
), (LPARAM
)dwEvent
);
2045 if( num_pending
<= 0 ) break;
2048 dprintf_winsock(stddeb
, "\tdone, %i posted events\n", num_posted
);
2049 return ( num_posted
) ? TRUE
: FALSE
;
2052 INT32 WINAPI
WSAAsyncSelect32(SOCKET32 s
, HWND32 hWnd
, UINT32 uMsg
, UINT32 lEvent
)
2054 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
2055 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
2057 dprintf_winsock(stddeb
, "WS_AsyncSelect(%08x): %04x, hWnd %04x, uMsg %08x, event %08x\n",
2058 (unsigned)pwsi
, (SOCKET16
)s
, (HWND16
)hWnd
, uMsg
, (unsigned)lEvent
);
2059 if( _check_ws(pwsi
, pws
) )
2063 if( (psop
= pws
->psop
) )
2065 /* delete previous control struct */
2067 if( psop
== __ws_select_list
)
2068 __ws_select_list
= psop
->next
;
2070 psop
->prev
->next
= psop
->next
;
2071 if( psop
->next
) psop
->next
->prev
= psop
->prev
;
2073 if( pws
->flags
& (WS_FD_ACCEPT
| WS_FD_CONNECT
| WS_FD_READ
| WS_FD_CLOSE
) )
2074 EVENT_DeleteIO( pws
->fd
, EVENT_IO_READ
);
2075 if( pws
->flags
& (WS_FD_CONNECT
| WS_FD_WRITE
) )
2076 EVENT_DeleteIO( pws
->fd
, EVENT_IO_WRITE
);
2078 dprintf_winsock(stddeb
,"\tremoving psop = 0x%08x\n", (unsigned) psop
);
2080 WS_FREE( pws
->psop
);
2081 pws
->flags
&= ~(WS_FD_RAW
| WS_FD_ACCEPT
| WS_FD_CONNECT
|
2082 WS_FD_READ
| WS_FD_WRITE
| WS_FD_CLOSE
);
2088 psop
= (ws_select_op
*)WS_ALLOC(sizeof(ws_select_op
));
2091 int sock_type
, bytes
= sizeof(int);
2093 WINSOCK_unblock_io( pws
->fd
, TRUE
);
2096 psop
->next
= __ws_select_list
;
2097 if( __ws_select_list
)
2098 __ws_select_list
->prev
= psop
;
2099 __ws_select_list
= psop
;
2106 pws
->flags
|= (0x0000FFFF &lEvent
);
2107 getsockopt(pws
->fd
, SOL_SOCKET
, SO_TYPE
, &sock_type
, &bytes
);
2108 if( sock_type
== SOCK_RAW
) pws
->flags
|= WS_FD_RAW
;
2110 if( lEvent
& (WS_FD_ACCEPT
| WS_FD_CONNECT
| WS_FD_READ
| WS_FD_CLOSE
) )
2111 EVENT_AddIO( pws
->fd
, EVENT_IO_READ
);
2112 if( lEvent
& (WS_FD_CONNECT
| WS_FD_WRITE
) )
2113 EVENT_AddIO( pws
->fd
, EVENT_IO_WRITE
);
2115 /* TODO: handle WS_FD_ACCEPT right away if the socket is readable */
2117 dprintf_winsock(stddeb
,"\tcreating psop = 0x%08x\n", (unsigned)psop
);
2119 return 0; /* success */
2121 else pwsi
->err
= WSAENOBUFS
;
2125 else if( pwsi
) pwsi
->err
= WSAEINVAL
;
2126 return SOCKET_ERROR
;
2129 INT16 WINAPI
WSAAsyncSelect16(SOCKET16 s
, HWND16 hWnd
, UINT16 wMsg
, UINT32 lEvent
)
2131 return (INT16
)WSAAsyncSelect32( s
, hWnd
, wMsg
, lEvent
);
2135 /***********************************************************************
2136 * __WSAFDIsSet() (WINSOCK.151)
2138 INT16 WINAPI
__WSAFDIsSet16(SOCKET16 s
, ws_fd_set16
*set
)
2140 int i
= set
->fd_count
;
2142 dprintf_winsock(stddeb
, "__WSAFDIsSet16(%d,%8lx)\n", s
,(unsigned long)set
);
2145 if (set
->fd_array
[i
] == s
) return 1;
2149 /***********************************************************************
2150 * __WSAFDIsSet() (WSOCK32.151)
2152 INT32 WINAPI
__WSAFDIsSet32(SOCKET32 s
, ws_fd_set32
*set
)
2154 int i
= set
->fd_count
;
2156 dprintf_winsock(stddeb
, "__WSAFDIsSet32(%d,%8lx)\n", s
,(unsigned long)set
);
2159 if (set
->fd_array
[i
] == s
) return 1;
2163 /***********************************************************************
2164 * WSAIsBlocking() (WINSOCK.114)(WSOCK32.114)
2166 BOOL32 WINAPI
WSAIsBlocking(void)
2168 /* By default WinSock should set all its sockets to non-blocking mode
2169 * and poll in PeekMessage loop when processing "blocking" ones. This
2170 * function is supposed to tell if program is in this loop. Our
2171 * blocking calls are truly blocking so we always return FALSE.
2173 * Note: It is allowed to call this function without prior WSAStartup().
2176 dprintf_winsock(stddeb
, "WS_IsBlocking()\n");
2180 /***********************************************************************
2181 * WSACancelBlockingCall() (WINSOCK.113)(WSOCK32.113)
2183 INT32 WINAPI
WSACancelBlockingCall(void)
2185 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
2187 dprintf_winsock(stddeb
, "WS_CancelBlockingCall(%08x)\n", (unsigned)pwsi
);
2189 if( pwsi
) return 0;
2190 return SOCKET_ERROR
;
2194 /***********************************************************************
2195 * WSASetBlockingHook16() (WINSOCK.109)
2197 FARPROC16 WINAPI
WSASetBlockingHook16(FARPROC16 lpBlockFunc
)
2200 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
2202 dprintf_winsock(stddeb
, "WS_SetBlockingHook16(%08x): hook %08x\n",
2203 (unsigned)pwsi
, (unsigned) lpBlockFunc
);
2206 prev
= (FARPROC16
)pwsi
->blocking_hook
;
2207 pwsi
->blocking_hook
= (DWORD
)lpBlockFunc
;
2208 pwsi
->flags
&= ~WSI_BLOCKINGHOOK32
;
2215 /***********************************************************************
2216 * WSASetBlockingHook32()
2218 FARPROC32 WINAPI
WSASetBlockingHook32(FARPROC32 lpBlockFunc
)
2221 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
2223 dprintf_winsock(stddeb
, "WS_SetBlockingHook32(%08x): hook %08x\n",
2224 (unsigned)pwsi
, (unsigned) lpBlockFunc
);
2226 prev
= (FARPROC32
)pwsi
->blocking_hook
;
2227 pwsi
->blocking_hook
= (DWORD
)lpBlockFunc
;
2228 pwsi
->flags
|= WSI_BLOCKINGHOOK32
;
2235 /***********************************************************************
2236 * WSAUnhookBlockingHook16() (WINSOCK.110)
2238 INT16 WINAPI
WSAUnhookBlockingHook16(void)
2240 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
2242 dprintf_winsock(stddeb
, "WS_UnhookBlockingHook16(%08x)\n", (unsigned)pwsi
);
2243 if( pwsi
) return (INT16
)(pwsi
->blocking_hook
= 0);
2244 return SOCKET_ERROR
;
2248 /***********************************************************************
2249 * WSAUnhookBlockingHook32()
2251 INT32 WINAPI
WSAUnhookBlockingHook32(void)
2253 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
2255 dprintf_winsock(stddeb
, "WS_UnhookBlockingHook32(%08x)\n", (unsigned)pwsi
);
2258 pwsi
->blocking_hook
= 0;
2259 pwsi
->flags
&= ~WSI_BLOCKINGHOOK32
;
2262 return SOCKET_ERROR
;
2266 * TCP/IP action codes.
2270 #define WSCNTL_TCPIP_QUERY_INFO 0x00000000
2271 #define WSCNTL_TCPIP_SET_INFO 0x00000001
2272 #define WSCNTL_TCPIP_ICMP_ECHO 0x00000002
2273 #define WSCNTL_TCPIP_TEST 0x00000003
2276 /***********************************************************************
2279 * WsControl seems to be an undocumented Win95 function. A lot of
2280 * discussion about WsControl can be found on the net, e.g.
2281 * Subject: Re: WSOCK32.DLL WsControl Exported Function
2282 * From: "Peter Rindfuss" <rindfuss-s@medea.wz-berlin.de>
2286 DWORD WINAPI
WsControl(DWORD protocoll
,DWORD action
,
2287 LPVOID inbuf
,LPDWORD inbuflen
,
2288 LPVOID outbuf
,LPDWORD outbuflen
)
2292 case WSCNTL_TCPIP_ICMP_ECHO
:
2294 unsigned int addr
= *(unsigned int*)inbuf
;
2296 int timeout
= *(unsigned int*)(inbuf
+4);
2297 short x1
= *(unsigned short*)(inbuf
+8);
2298 short sendbufsize
= *(unsigned short*)(inbuf
+10);
2299 char x2
= *(unsigned char*)(inbuf
+12);
2300 char ttl
= *(unsigned char*)(inbuf
+13);
2301 char service
= *(unsigned char*)(inbuf
+14);
2302 char type
= *(unsigned char*)(inbuf
+15); /* 0x2: don't fragment*/
2305 fprintf(stdnimp
,"WsControl(ICMP_ECHO) to 0x%08x stub \n",
2310 fprintf(stdnimp
,"WsControl(%lx,%lx,%p,%p,%p,%p) stub\n",
2311 protocoll
,action
,inbuf
,inbuflen
,outbuf
,outbuflen
);
2315 /*********************************************************
2316 * WS_s_perror WSOCK32.1108
2318 void WINAPI
WS_s_perror(LPCSTR message
)
2320 fprintf(stdnimp
,"s_perror %s stub\n",message
);
2325 /* ----------------------------------- end of API stuff */
2327 /* ----------------------------------- helper functions -
2329 * TODO: Merge WS_dup_..() stuff into one function that
2330 * would operate with a generic structure containing internal
2331 * pointers (via some sort of a template).
2334 static int list_size(char** l
, int item_size
)
2339 j
+= (item_size
) ? item_size
: strlen(l
[i
]) + 1;
2340 j
+= (i
+ 1) * sizeof(char*); }
2344 static int list_dup(char** l_src
, char* ref
, char* base
, int item_size
)
2346 /* base is either either equal to ref or 0 or SEGPTR */
2349 char** l_to
= (char**)ref
;
2352 for(j
=0;l_src
[j
];j
++) ;
2353 p
+= (j
+ 1) * sizeof(char*);
2355 { l_to
[i
] = base
+ (p
- ref
);
2356 k
= ( item_size
) ? item_size
: strlen(l_src
[i
]) + 1;
2357 memcpy(p
, l_src
[i
], k
); p
+= k
; }
2364 static int hostent_size(struct hostent
* p_he
)
2368 { size
= sizeof(struct hostent
);
2369 size
+= strlen(p_he
->h_name
) + 1;
2370 size
+= list_size(p_he
->h_aliases
, 0);
2371 size
+= list_size(p_he
->h_addr_list
, p_he
->h_length
); }
2375 int WS_dup_he(LPWSINFO pwsi
, struct hostent
* p_he
, int flag
)
2377 /* Duplicate hostent structure and flatten data (with its pointers)
2378 * into pwsi->buffer. Internal pointers can be linear, SEGPTR, or
2379 * relative to pwsi->buffer depending on "flag" value. Returns size
2380 * of the data copied (also in the pwsi->buflen).
2383 int size
= hostent_size(p_he
);
2386 struct ws_hostent
* p_to
;
2387 char* p_name
,*p_aliases
,*p_addr
,*p_base
,*p
;
2389 _check_buffer(pwsi
, size
);
2390 p_to
= (struct ws_hostent
*)pwsi
->buffer
;
2392 p_base
= (flag
& WS_DUP_OFFSET
) ? NULL
2393 : ((flag
& WS_DUP_SEGPTR
) ? (char*)SEGPTR_GET(p
) : p
);
2394 p
+= sizeof(struct ws_hostent
);
2396 strcpy(p
, p_he
->h_name
); p
+= strlen(p
) + 1;
2398 p
+= list_dup(p_he
->h_aliases
, p
, p_base
+ (p
- pwsi
->buffer
), 0);
2400 list_dup(p_he
->h_addr_list
, p
, p_base
+ (p
- pwsi
->buffer
), p_he
->h_length
);
2402 p_to
->h_addrtype
= (INT16
)p_he
->h_addrtype
;
2403 p_to
->h_length
= (INT16
)p_he
->h_length
;
2404 p_to
->h_name
= (SEGPTR
)(p_base
+ (p_name
- pwsi
->buffer
));
2405 p_to
->h_aliases
= (SEGPTR
)(p_base
+ (p_aliases
- pwsi
->buffer
));
2406 p_to
->h_addr_list
= (SEGPTR
)(p_base
+ (p_addr
- pwsi
->buffer
));
2408 size
+= (sizeof(struct ws_hostent
) - sizeof(struct hostent
));
2413 /* ----- protoent */
2415 static int protoent_size(struct protoent
* p_pe
)
2419 { size
= sizeof(struct protoent
);
2420 size
+= strlen(p_pe
->p_name
) + 1;
2421 size
+= list_size(p_pe
->p_aliases
, 0); }
2425 int WS_dup_pe(LPWSINFO pwsi
, struct protoent
* p_pe
, int flag
)
2427 int size
= protoent_size(p_pe
);
2430 struct ws_protoent
* p_to
;
2431 char* p_name
,*p_aliases
,*p_base
,*p
;
2433 _check_buffer(pwsi
, size
);
2434 p_to
= (struct ws_protoent
*)pwsi
->buffer
;
2436 p_base
= (flag
& WS_DUP_OFFSET
) ? NULL
2437 : ((flag
& WS_DUP_SEGPTR
) ? (char*)SEGPTR_GET(p
) : p
);
2438 p
+= sizeof(struct ws_protoent
);
2440 strcpy(p
, p_pe
->p_name
); p
+= strlen(p
) + 1;
2442 list_dup(p_pe
->p_aliases
, p
, p_base
+ (p
- pwsi
->buffer
), 0);
2444 p_to
->p_proto
= (INT16
)p_pe
->p_proto
;
2445 p_to
->p_name
= (SEGPTR
)(p_base
) + (p_name
- pwsi
->buffer
);
2446 p_to
->p_aliases
= (SEGPTR
)((p_base
) + (p_aliases
- pwsi
->buffer
));
2448 size
+= (sizeof(struct ws_protoent
) - sizeof(struct protoent
));
2455 static int servent_size(struct servent
* p_se
)
2459 { size
+= sizeof(struct servent
);
2460 size
+= strlen(p_se
->s_proto
) + strlen(p_se
->s_name
) + 2;
2461 size
+= list_size(p_se
->s_aliases
, 0); }
2465 int WS_dup_se(LPWSINFO pwsi
, struct servent
* p_se
, int flag
)
2467 int size
= servent_size(p_se
);
2470 struct ws_servent
* p_to
;
2471 char* p_name
,*p_aliases
,*p_proto
,*p_base
,*p
;
2473 _check_buffer(pwsi
, size
);
2474 p_to
= (struct ws_servent
*)pwsi
->buffer
;
2476 p_base
= (flag
& WS_DUP_OFFSET
) ? NULL
2477 : ((flag
& WS_DUP_SEGPTR
) ? (char*)SEGPTR_GET(p
) : p
);
2478 p
+= (flag
& WS_DUP_NATIVE
)? sizeof(struct servent
) : sizeof(struct ws_servent
);
2480 strcpy(p
, p_se
->s_name
); p
+= strlen(p
) + 1;
2482 strcpy(p
, p_se
->s_proto
); p
+= strlen(p
) + 1;
2484 list_dup(p_se
->s_aliases
, p
, p_base
+ (p
- pwsi
->buffer
), 0);
2486 p_to
->s_port
= (INT16
)p_se
->s_port
;
2487 p_to
->s_name
= (SEGPTR
)(p_base
+ (p_name
- pwsi
->buffer
));
2488 p_to
->s_proto
= (SEGPTR
)(p_base
+ (p_proto
- pwsi
->buffer
));
2489 p_to
->s_aliases
= (SEGPTR
)(p_base
+ (p_aliases
- pwsi
->buffer
));
2491 size
+= (sizeof(struct ws_servent
) - sizeof(struct servent
));
2496 /* ----------------------------------- error handling */
2498 UINT16
wsaErrno(void)
2500 int loc_errno
= errno
;
2501 #if defined(__FreeBSD__)
2502 dprintf_winsock(stderr
, "winsock: errno %d, (%s).\n",
2503 errno
, strerror(errno
));
2505 dprintf_winsock(stderr
, "winsock: errno %d\n", errno
);
2510 case EINTR
: return WSAEINTR
;
2511 case EBADF
: return WSAEBADF
;
2512 case EACCES
: return WSAEACCES
;
2513 case EFAULT
: return WSAEFAULT
;
2514 case EINVAL
: return WSAEINVAL
;
2515 case EMFILE
: return WSAEMFILE
;
2516 case EWOULDBLOCK
: return WSAEWOULDBLOCK
;
2517 case EINPROGRESS
: return WSAEINPROGRESS
;
2518 case EALREADY
: return WSAEALREADY
;
2519 case ENOTSOCK
: return WSAENOTSOCK
;
2520 case EDESTADDRREQ
: return WSAEDESTADDRREQ
;
2521 case EMSGSIZE
: return WSAEMSGSIZE
;
2522 case EPROTOTYPE
: return WSAEPROTOTYPE
;
2523 case ENOPROTOOPT
: return WSAENOPROTOOPT
;
2524 case EPROTONOSUPPORT
: return WSAEPROTONOSUPPORT
;
2525 case ESOCKTNOSUPPORT
: return WSAESOCKTNOSUPPORT
;
2526 case EOPNOTSUPP
: return WSAEOPNOTSUPP
;
2527 case EPFNOSUPPORT
: return WSAEPFNOSUPPORT
;
2528 case EAFNOSUPPORT
: return WSAEAFNOSUPPORT
;
2529 case EADDRINUSE
: return WSAEADDRINUSE
;
2530 case EADDRNOTAVAIL
: return WSAEADDRNOTAVAIL
;
2531 case ENETDOWN
: return WSAENETDOWN
;
2532 case ENETUNREACH
: return WSAENETUNREACH
;
2533 case ENETRESET
: return WSAENETRESET
;
2534 case ECONNABORTED
: return WSAECONNABORTED
;
2535 case ECONNRESET
: return WSAECONNRESET
;
2536 case ENOBUFS
: return WSAENOBUFS
;
2537 case EISCONN
: return WSAEISCONN
;
2538 case ENOTCONN
: return WSAENOTCONN
;
2539 case ESHUTDOWN
: return WSAESHUTDOWN
;
2540 case ETOOMANYREFS
: return WSAETOOMANYREFS
;
2541 case ETIMEDOUT
: return WSAETIMEDOUT
;
2542 case ECONNREFUSED
: return WSAECONNREFUSED
;
2543 case ELOOP
: return WSAELOOP
;
2544 case ENAMETOOLONG
: return WSAENAMETOOLONG
;
2545 case EHOSTDOWN
: return WSAEHOSTDOWN
;
2546 case EHOSTUNREACH
: return WSAEHOSTUNREACH
;
2547 case ENOTEMPTY
: return WSAENOTEMPTY
;
2549 case EPROCLIM
: return WSAEPROCLIM
;
2552 case EUSERS
: return WSAEUSERS
;
2555 case EDQUOT
: return WSAEDQUOT
;
2558 case ESTALE
: return WSAESTALE
;
2561 case EREMOTE
: return WSAEREMOTE
;
2564 /* just in case we ever get here and there are no problems */
2567 fprintf(stderr
, "winsock: unknown errno %d!\n", errno
);
2568 return WSAEOPNOTSUPP
;
2572 UINT16
wsaHerrno(void)
2574 int loc_errno
= h_errno
;
2576 #if defined(__FreeBSD__)
2577 dprintf_winsock(stderr
, "winsock: h_errno %d, (%s).\n",
2578 h_errno
, strerror(h_errno
));
2580 dprintf_winsock(stderr
, "winsock: h_errno %d.\n", h_errno
);
2582 if( debugging_winsock
) herror("wine: winsock: wsaherrno");
2588 case HOST_NOT_FOUND
: return WSAHOST_NOT_FOUND
;
2589 case TRY_AGAIN
: return WSATRY_AGAIN
;
2590 case NO_RECOVERY
: return WSANO_RECOVERY
;
2591 case NO_DATA
: return WSANO_DATA
;
2595 fprintf(stderr
, "winsock: unknown h_errno %d!\n", h_errno
);
2596 return WSAEOPNOTSUPP
;