2 * based on Windows Sockets 1.1 specs
3 * (ftp.microsoft.com:/Advsys/winsock/spec11/WINSOCK.TXT)
5 * (C) 1993,1994,1996 John Brezak, Erik Bos, Alex Korobka.
11 #include <sys/types.h>
13 #include <sys/ioctl.h>
15 #include <sys/filio.h>
16 #include <sys/ioccom.h>
20 #include <sys/socket.h>
21 #include <netinet/in.h>
22 #include <arpa/inet.h>
36 #define dump_sockaddr(a) \
37 fprintf(stderr, "sockaddr_in: family %d, address %s, port %d\n", \
38 ((struct sockaddr_in *)a)->sin_family, \
39 inet_ntoa(((struct sockaddr_in *)a)->sin_addr), \
40 ntohs(((struct sockaddr_in *)a)->sin_port))
42 extern void SIGNAL_MaskAsyncEvents( BOOL32
);
46 /* ----------------------------------- internal data */
49 extern void __sigio(int);
51 ws_async_ctl async_ctl
;
54 static HANDLE32 _WSHeap
= 0;
55 static unsigned char* _ws_stub
= NULL
;
56 static LPWSINFO _wsi_list
= NULL
;
58 #define WS_ALLOC(size) \
59 HeapAlloc(_WSHeap, HEAP_ZERO_MEMORY, (size) )
60 #define WS_FREE(ptr) \
61 HeapFree(_WSHeap, 0, (ptr) )
63 #define WS_PTR2HANDLE(ptr) \
64 ((short)((int)(ptr) - (int)_ws_stub))
65 #define WS_HANDLE2PTR(handle) \
66 ((unsigned)((int)_ws_stub + (int)handle))
68 #define WSI_CHECK_RANGE(pwsi, pws) \
69 ( ((unsigned)(pws) > (unsigned)(pwsi)) && \
70 ((unsigned)(pws) < ((unsigned)(pwsi) + sizeof(WSINFO))) )
72 static INT16 _ws_sock_ops
[] =
73 { WS_SO_DEBUG
, WS_SO_REUSEADDR
, WS_SO_KEEPALIVE
, WS_SO_DONTROUTE
,
74 WS_SO_BROADCAST
, WS_SO_LINGER
, WS_SO_OOBINLINE
, WS_SO_SNDBUF
,
75 WS_SO_RCVBUF
, WS_SO_ERROR
, WS_SO_TYPE
, WS_SO_DONTLINGER
, 0 };
76 static int _px_sock_ops
[] =
77 { SO_DEBUG
, SO_REUSEADDR
, SO_KEEPALIVE
, SO_DONTROUTE
, SO_BROADCAST
,
78 SO_LINGER
, SO_OOBINLINE
, SO_SNDBUF
, SO_RCVBUF
, SO_ERROR
, SO_TYPE
,
81 static INT16
init_async_select(ws_socket
* pws
, HWND16 hWnd
, UINT16 uMsg
, UINT32 lEvent
);
82 static int notify_client(ws_socket
* pws
, unsigned flag
);
84 static int _check_ws(LPWSINFO pwsi
, ws_socket
* pws
);
85 static int _check_buffer(LPWSINFO pwsi
, int size
);
87 static void fixup_wshe(struct ws_hostent
* p_wshe
, SEGPTR base
);
88 static void fixup_wspe(struct ws_protoent
* p_wspe
, SEGPTR base
);
89 static void fixup_wsse(struct ws_servent
* p_wsse
, SEGPTR base
);
91 static int delete_async_op(ws_socket
*);
93 static void convert_sockopt(INT16
*level
, INT16
*optname
)
100 for(i
=0; _ws_sock_ops
[i
]; i
++)
101 if( _ws_sock_ops
[i
] == *optname
) break;
102 if( _ws_sock_ops
[i
] ) *optname
= (INT16
)_px_sock_ops
[i
];
103 else fprintf(stderr
, "convert_sockopt() unknown optname %d\n", *optname
);
106 *optname
= IPPROTO_TCP
;
110 static void _ws_global_init()
114 _WSHeap
= HeapCreate(HEAP_ZERO_MEMORY
, 8120, 32768);
115 if( !(_ws_stub
= WS_ALLOC(0x10)) )
116 fprintf(stderr
,"Fatal: failed to create WinSock heap\n");
118 if( async_qid
== -1 )
119 if( (async_qid
= msgget(IPC_PRIVATE
, IPC_CREAT
| 0x1FF)) == -1 )
120 fprintf(stderr
,"Fatal: failed to create WinSock resource\n");
123 /* ----------------------------------- Per-thread info */
125 static void wsi_link(LPWSINFO pwsi
)
126 { if( _wsi_list
) _wsi_list
->prev
= pwsi
;
127 pwsi
->next
= _wsi_list
; _wsi_list
= pwsi
;
130 static void wsi_unlink(LPWSINFO pwsi
)
132 if( pwsi
== _wsi_list
) _wsi_list
= pwsi
->next
;
134 { pwsi
->prev
->next
= pwsi
->next
;
135 if( pwsi
->next
) pwsi
->next
->prev
= pwsi
->prev
; }
138 static LPWSINFO
wsi_find(HTASK16 hTask
)
139 { LPWSINFO pwsi
= _wsi_list
;
140 while( pwsi
&& pwsi
->tid
!= hTask
) pwsi
= pwsi
->next
;
144 static ws_socket
* wsi_alloc_socket(LPWSINFO pwsi
, int fd
)
146 if( pwsi
->last_free
>= 0 )
148 int i
= pwsi
->last_free
;
150 pwsi
->last_free
= pwsi
->sock
[i
].flags
;
151 pwsi
->sock
[i
].fd
= fd
;
152 pwsi
->sock
[i
].flags
= 0;
153 return &pwsi
->sock
[i
];
158 static void fd_set_normalize(fd_set
* fds
, LPWSINFO pwsi
, ws_fd_set
* ws
, int* highfd
)
165 for(i
=0;i
<(ws
->fd_count
);i
++)
167 pws
= (ws_socket
*)WS_HANDLE2PTR(ws
->fd_array
[i
]);
168 if( _check_ws(pwsi
, pws
) )
170 if( pws
->fd
> *highfd
) *highfd
= pws
->fd
;
171 FD_SET(pws
->fd
, fds
);
178 * Note weirdness here: sockets with errors belong in exceptfds, but
179 * are given to us in readfds or writefds, so move them to exceptfds if
180 * there is an error. Note that this means that exceptfds may have mysterious
181 * sockets set in it that the program never asked for.
184 static int inline sock_error_p(int s
)
186 unsigned int optval
, optlen
;
188 optlen
= sizeof(optval
);
189 getsockopt(s
, SOL_SOCKET
, SO_ERROR
, &optval
, &optlen
);
190 if (optval
) dprintf_winsock(stddeb
, "error: %d\n", optval
);
194 static void fd_set_update(LPWSINFO pwsi
, fd_set
* fds
, ws_fd_set
* ws
,
199 int i
, j
, count
= ws
->fd_count
;
201 for( i
= 0, j
= 0; i
< count
; i
++ )
203 ws_socket
*pws
= (ws_socket
*)WS_HANDLE2PTR(ws
->fd_array
[i
]);
206 if( _check_ws(pwsi
, pws
) && FD_ISSET(fd
, fds
) )
208 /* if error, move to errorfds */
209 if (errorfds
&& (FD_ISSET(fd
, errorfds
) || sock_error_p(fd
)))
210 FD_SET(fd
, errorfds
);
212 ws
->fd_array
[j
++] = ws
->fd_array
[i
];
216 dprintf_winsock(stddeb
, "\n");
221 static void fd_set_update_except(LPWSINFO pwsi
, fd_set
*fds
, ws_fd_set
*ws
,
226 int i
, j
, count
= ws
->fd_count
;
228 for (i
=j
=0; i
< count
; i
++)
230 ws_socket
*pws
= (ws_socket
*)WS_HANDLE2PTR(ws
->fd_array
[i
]);
232 if (_check_ws(pwsi
, pws
) && (FD_ISSET(pws
->fd
, fds
)
233 || FD_ISSET(pws
->fd
, errorfds
)))
234 ws
->fd_array
[j
++] = ws
->fd_array
[i
];
241 /* ----------------------------------- API -----
243 * Init / cleanup / error checking.
246 INT16
WSAStartup(UINT16 wVersionRequested
, LPWSADATA lpWSAData
)
248 WSADATA WINSOCK_data
= { 0x0101, 0x0101,
252 #elif defined(__NetBSD__)
256 #elif defined(__FreeBSD__)
261 WS_MAX_SOCKETS_PER_THREAD
,
262 WS_MAX_UDP_DATAGRAM
, NULL
};
263 HTASK16 tid
= GetCurrentTask();
266 dprintf_winsock(stddeb
, "WSAStartup: verReq=%x\n", wVersionRequested
);
268 if (LOBYTE(wVersionRequested
) < 1 || (LOBYTE(wVersionRequested
) == 1 &&
269 HIBYTE(wVersionRequested
) < 1)) return WSAVERNOTSUPPORTED
;
271 if (!lpWSAData
) return WSAEINVAL
;
274 if( _WSHeap
== 0 ) return WSASYSNOTREADY
;
276 pwsi
= wsi_find(GetCurrentTask());
279 if( (pwsi
= (LPWSINFO
)WS_ALLOC( sizeof(WSINFO
))) )
283 for( i
= 0; i
< WS_MAX_SOCKETS_PER_THREAD
; i
++ )
285 pwsi
->sock
[i
].fd
= -1;
286 pwsi
->sock
[i
].flags
= i
+ 1;
288 pwsi
->sock
[WS_MAX_SOCKETS_PER_THREAD
- 1].flags
= -1;
290 else return WSASYSNOTREADY
;
292 } else pwsi
->num_startup
++;
294 /* return winsock information */
295 memcpy(lpWSAData
, &WINSOCK_data
, sizeof(WINSOCK_data
));
297 dprintf_winsock(stddeb
, "WSAStartup: succeeded\n");
301 INT16
WSACleanup(void)
303 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
305 /* FIXME: do global cleanup if no current task */
307 dprintf_winsock(stddeb
, "WSACleanup(%08x)\n", (unsigned)pwsi
);
312 if( pwsi
->num_startup
-- ) return 0;
314 SIGNAL_MaskAsyncEvents( TRUE
);
315 WINSOCK_cancel_async_op(GetCurrentTask());
316 SIGNAL_MaskAsyncEvents( FALSE
);
319 if( _wsi_list
== NULL
&& async_qid
!= -1 )
320 if( msgctl(async_qid
, IPC_RMID
, NULL
) == -1 )
322 fprintf(stderr
,"failed to delete WS message queue.\n");
323 } else async_qid
= -1;
325 if( pwsi
->flags
& WSI_BLOCKINGCALL
)
326 dprintf_winsock(stddeb
,"\tinside blocking call!\n");
327 if( pwsi
->num_async_rq
)
328 dprintf_winsock(stddeb
,"\thave %i outstanding async ops!\n", pwsi
->num_async_rq
);
330 for(i
= 0, j
= 0, n
= 0; i
< WS_MAX_SOCKETS_PER_THREAD
; i
++)
331 if( pwsi
->sock
[i
].fd
!= -1 )
333 n
+= delete_async_op(&pwsi
->sock
[i
]);
334 close(pwsi
->sock
[i
].fd
); j
++;
337 dprintf_winsock(stddeb
,"\tclosed %i sockets, killed %i async selects!\n", j
, n
);
339 if( pwsi
->buffer
) SEGPTR_FREE(pwsi
->buffer
);
346 INT16
WSAGetLastError(void)
348 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
351 dprintf_winsock(stddeb
, "WSAGetLastError(%08x)", (unsigned)pwsi
);
353 ret
= (pwsi
) ? pwsi
->errno
: WSANOTINITIALISED
;
355 dprintf_winsock(stddeb
, " = %i\n", (int)ret
);
359 void WSASetLastError(INT16 iError
)
361 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
363 dprintf_winsock(stddeb
, "WSASetLastError(%08x): %d\n", (unsigned)pwsi
, (int)iError
);
365 if( pwsi
) pwsi
->errno
= iError
;
368 int _check_ws(LPWSINFO pwsi
, ws_socket
* pws
)
371 if( pwsi
->flags
& WSI_BLOCKINGCALL
) pwsi
->errno
= WSAEINPROGRESS
;
372 else if( WSI_CHECK_RANGE(pwsi
, pws
) ) return 1;
373 else pwsi
->errno
= WSAENOTSOCK
;
377 int _check_buffer(LPWSINFO pwsi
, int size
)
379 if( pwsi
->buffer
&& pwsi
->buflen
>= size
) return 1;
380 else SEGPTR_FREE(pwsi
->buffer
);
381 pwsi
->buffer
= (char*)SEGPTR_ALLOC((pwsi
->buflen
= size
));
382 return (pwsi
->buffer
!= NULL
);
385 /* ----- socket operations */
387 SOCKET16
WINSOCK_accept(SOCKET16 s
, struct sockaddr
*addr
, INT16
*addrlen16
)
389 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
390 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
392 dprintf_winsock(stddeb
, "WS_ACCEPT(%08x): socket %04x\n",
393 (unsigned)pwsi
, (UINT16
)s
);
394 if( _check_ws(pwsi
, pws
) )
396 int sock
, fd_flags
, addrlen32
= *addrlen16
;
398 /* this is how block info is supposed to be used -
399 * WSAIsBlocking() would then check WSI_BLOCKINGCALL bit.
402 fd_flags
= fcntl(pws
->fd
, F_GETFL
, 0);
403 if( !(fd_flags
& O_NONBLOCK
) ) pwsi
->flags
|= WSI_BLOCKINGCALL
;
405 if( (sock
= accept(pws
->fd
, addr
, &addrlen32
)) >= 0 )
407 ws_socket
* pnew
= wsi_alloc_socket(pwsi
, sock
);
408 notify_client(pws
, WS_FD_ACCEPT
);
412 init_async_select(pnew
, pws
->p_aop
->hWnd
,
414 pws
->p_aop
->flags
& ~WS_FD_ACCEPT
);
416 pwsi
->flags
&= ~WSI_BLOCKINGCALL
;
417 return (SOCKET16
)WS_PTR2HANDLE(pnew
);
419 else pwsi
->errno
= WSAENOBUFS
;
421 else pwsi
->errno
= wsaErrno();
423 pwsi
->flags
&= ~WSI_BLOCKINGCALL
;
425 return INVALID_SOCKET
;
428 INT16
WINSOCK_bind(SOCKET16 s
, struct sockaddr
*name
, INT16 namelen
)
430 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
431 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
433 dprintf_winsock(stddeb
, "WS_BIND(%08x): socket %04x, ptr %8x, length %d\n",
434 (unsigned)pwsi
, s
, (int) name
, namelen
);
439 if ( _check_ws(pwsi
, pws
) )
440 if (namelen
>= sizeof(*name
))
441 if ( ((struct sockaddr_in
*)name
)->sin_family
== AF_INET
)
442 if ( bind(pws
->fd
, name
, namelen
) < 0 )
444 int loc_errno
= errno
;
445 dprintf_winsock(stddeb
,"\tfailure - errno = %i\n", errno
);
449 case EBADF
: pwsi
->errno
= WSAENOTSOCK
; break;
450 case EADDRNOTAVAIL
: pwsi
->errno
= WSAEINVAL
; break;
451 default: pwsi
->errno
= wsaErrno();
455 else pwsi
->errno
= WSAEAFNOSUPPORT
;
456 else pwsi
->errno
= WSAEFAULT
;
460 INT16
WINSOCK_closesocket(SOCKET16 s
)
462 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
463 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
465 dprintf_winsock(stddeb
, "WS_CLOSE(%08x): socket %08x\n", (unsigned)pwsi
, s
);
467 if( _check_ws(pwsi
, pws
) )
471 delete_async_op(pws
);
472 pws
->p_aop
= NULL
; pws
->fd
= -1;
473 pws
->flags
= (unsigned)pwsi
->last_free
;
474 pwsi
->last_free
= pws
- &pwsi
->sock
[0];
475 if (close(fd
) < 0) pwsi
->errno
= (errno
== EBADF
) ? WSAENOTSOCK
: wsaErrno();
481 INT16
WINSOCK_connect(SOCKET16 s
, struct sockaddr
*name
, INT16 namelen
)
483 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
484 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
486 dprintf_winsock(stddeb
, "WS_CONNECT(%08x): socket %04x, ptr %8x, length %d\n",
487 (unsigned)pwsi
, s
, (int) name
, namelen
);
492 if( _check_ws(pwsi
, pws
) )
494 if (connect(pws
->fd
, name
, namelen
) == 0)
497 /* we need to notify handler process if
498 * connect() succeeded NOT in response to winsock message
500 notify_client(pws
, WS_FD_CONNECTED
);
502 pws
->flags
&= ~(WS_FD_INACTIVE
| WS_FD_CONNECT
);
505 pwsi
->errno
= (errno
== EINPROGRESS
) ? WSAEWOULDBLOCK
: wsaErrno();
510 INT16
WINSOCK_getpeername(SOCKET16 s
, struct sockaddr
*name
, INT16
*namelen
)
512 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
513 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
515 dprintf_winsock(stddeb
, "WS_GETPEERNAME(%08x): socket: %04x, ptr %8x, ptr %8x\n",
516 (unsigned)pwsi
, s
, (int) name
, *namelen
);
517 if( _check_ws(pwsi
, pws
) )
519 int namelen32
= *namelen
;
520 if (getpeername(pws
->fd
, name
, &namelen32
) == 0)
525 *namelen
= (INT16
)namelen32
;
528 pwsi
->errno
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
533 INT16
WINSOCK_getsockname(SOCKET16 s
, struct sockaddr
*name
, INT16
*namelen
)
535 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
536 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
538 dprintf_winsock(stddeb
, "WS_GETSOCKNAME(%08x): socket: %04x, ptr %8x, ptr %8x\n",
539 (unsigned)pwsi
, s
, (int) name
, (int) *namelen
);
540 if( _check_ws(pwsi
, pws
) )
542 int namelen32
= *namelen
;
543 if (getsockname(pws
->fd
, name
, &namelen32
) == 0)
545 *namelen
= (INT16
)namelen32
;
548 pwsi
->errno
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
553 INT16
WINSOCK_getsockopt(SOCKET16 s
, INT16 level
,
554 INT16 optname
, char *optval
, INT16
*optlen
)
556 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
557 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
559 dprintf_winsock(stddeb
, "WS_GETSOCKOPT(%08x): socket: %04x, opt %d, ptr %8x, ptr %8x\n",
560 (unsigned)pwsi
, s
, level
, (int) optval
, (int) *optlen
);
562 if( _check_ws(pwsi
, pws
) )
564 int optlen32
= *optlen
;
566 convert_sockopt(&level
, &optname
);
567 if (getsockopt(pws
->fd
, (int) level
, optname
, optval
, &optlen32
) == 0 )
568 { *optlen
= (INT16
)optlen32
; return 0; }
569 pwsi
->errno
= (errno
== EBADF
) ? WSAENOTSOCK
: wsaErrno();
574 u_long
WINSOCK_htonl(u_long hostlong
) { return( htonl(hostlong
) ); }
575 u_short
WINSOCK_htons(u_short hostshort
) { return( htons(hostshort
) ); }
576 u_long
WINSOCK_inet_addr(char *cp
) { return( inet_addr(cp
) ); }
577 u_long
WINSOCK_ntohl(u_long netlong
) { return( ntohl(netlong
) ); }
578 u_short
WINSOCK_ntohs(u_short netshort
) { return( ntohs(netshort
) ); }
580 SEGPTR
WINSOCK_inet_ntoa(struct in_addr in
)
582 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
583 char* s
= inet_ntoa(in
);
587 if( s
== NULL
) { pwsi
->errno
= wsaErrno(); return NULL
; }
588 if( _check_buffer( pwsi
, 32 ) )
590 strncpy(pwsi
->buffer
, s
, 32 );
591 return SEGPTR_GET(pwsi
->buffer
);
593 pwsi
->errno
= WSAENOBUFS
;
598 INT16
WINSOCK_ioctlsocket(SOCKET16 s
, UINT32 cmd
, UINT32
*argp
)
600 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
601 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
603 dprintf_winsock(stddeb
, "WS_IOCTL(%08x): socket %04x, cmd %08x, ptr %8x\n",
604 (unsigned)pwsi
, s
, cmd
, (unsigned) argp
);
605 if( _check_ws(pwsi
, pws
) )
611 case WS_FIONREAD
: newcmd
=FIONREAD
; break;
612 case WS_FIONBIO
: newcmd
=FIONBIO
;
613 if( pws
->p_aop
&& *argp
== 0 )
615 pwsi
->errno
= WSAEINVAL
;
619 case WS_SIOCATMARK
: newcmd
=SIOCATMARK
; break;
620 case WS_IOW('f',125,u_long
):
621 fprintf(stderr
,"Warning: WS1.1 shouldn't be using async I/O\n");
622 pwsi
->errno
= WSAEINVAL
; return SOCKET_ERROR
;
623 default: fprintf(stderr
,"Warning: Unknown WS_IOCTL cmd (%08x)\n", cmd
);
625 if( ioctl(pws
->fd
, newcmd
, (char*)argp
) == 0 ) return 0;
626 pwsi
->errno
= (errno
== EBADF
) ? WSAENOTSOCK
: wsaErrno();
631 INT16
WINSOCK_listen(SOCKET16 s
, INT16 backlog
)
633 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
634 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
636 dprintf_winsock(stddeb
, "WS_LISTEN(%08x): socket %04x, backlog %d\n",
637 (unsigned)pwsi
, s
, backlog
);
638 if( _check_ws(pwsi
, pws
) )
642 int fd_flags
= fcntl(pws
->fd
, F_GETFL
, 0);
643 if( !(fd_flags
& O_NONBLOCK
) ) pws
->flags
|= WS_FD_ACCEPT
;
645 else notify_client(pws
, WS_FD_ACCEPT
);
647 if (listen(pws
->fd
, backlog
) == 0) return 0;
648 pwsi
->errno
= wsaErrno();
653 INT16
WINSOCK_recv(SOCKET16 s
, char *buf
, INT16 len
, INT16 flags
)
655 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
656 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
658 dprintf_winsock(stddeb
, "WS_RECV(%08x): socket %04x, buf %8x, len %d, flags %d",
659 (unsigned)pwsi
, s
, (unsigned)buf
, len
, flags
);
660 if( _check_ws(pwsi
, pws
) )
663 if ((length
= recv(pws
->fd
, buf
, len
, flags
)) >= 0)
665 dprintf_winsock(stddeb
, " -> %i bytes\n", length
);
666 notify_client(pws
, WS_FD_READ
);
667 return (INT16
)length
;
669 pwsi
->errno
= wsaErrno();
671 dprintf_winsock(stddeb
, " -> ERROR\n");
675 INT16
WINSOCK_recvfrom(SOCKET16 s
, char *buf
, INT16 len
, INT16 flags
,
676 struct sockaddr
*from
, INT16
*fromlen16
)
678 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
679 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
681 dprintf_winsock(stddeb
, "WS_RECVFROM(%08x): socket %04x, ptr %08x, len %d, flags %d\n",
682 (unsigned)pwsi
, s
, (unsigned)buf
, len
, flags
);
683 if( _check_ws(pwsi
, pws
) )
685 int length
, fromlen32
= *fromlen16
;
686 if ((length
= recvfrom(pws
->fd
, buf
, len
, flags
, from
, &fromlen32
)) >= 0)
688 *fromlen16
= fromlen32
;
689 notify_client(pws
, WS_FD_READ
);
690 return (INT16
)length
;
692 pwsi
->errno
= wsaErrno();
697 INT16
WINSOCK_select(INT16 nfds
, ws_fd_set
*ws_readfds
,
698 ws_fd_set
*ws_writefds
,
699 ws_fd_set
*ws_exceptfds
, struct timeval
*timeout
)
701 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
703 dprintf_winsock(stddeb
, "WS_SELECT(%08x): nfds %d (ignored), read %8x, write %8x, excp %8x\n",
704 (unsigned) pwsi
, nfds
, (unsigned) ws_readfds
, (unsigned) ws_writefds
, (unsigned) ws_exceptfds
);
709 fd_set readfds
, writefds
, exceptfds
, errorfds
;
711 fd_set_normalize(&readfds
, pwsi
, ws_readfds
, &highfd
);
712 fd_set_normalize(&writefds
, pwsi
, ws_writefds
, &highfd
);
713 fd_set_normalize(&exceptfds
, pwsi
, ws_exceptfds
, &highfd
);
716 if( (highfd
= select(highfd
+ 1, &readfds
, &writefds
, &exceptfds
, timeout
)) >= 0 )
720 fd_set_update(pwsi
, &readfds
, ws_readfds
, &errorfds
);
721 fd_set_update(pwsi
, &writefds
, ws_writefds
, &errorfds
);
722 fd_set_update_except(pwsi
, &exceptfds
, ws_exceptfds
, &errorfds
);
726 pwsi
->errno
= wsaErrno();
731 INT16
WINSOCK_send(SOCKET16 s
, char *buf
, INT16 len
, INT16 flags
)
733 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
734 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
736 dprintf_winsock(stddeb
, "WS_SEND(%08x): socket %04x, ptr %08x, length %d, flags %d\n",
737 (unsigned)pwsi
, s
, (unsigned) buf
, len
, flags
);
738 if( _check_ws(pwsi
, pws
) )
741 if ((length
= send(pws
->fd
, buf
, len
, flags
)) < 0 )
743 length
= SOCKET_ERROR
;
744 pwsi
->errno
= wsaErrno();
746 notify_client(pws
, WS_FD_WRITE
);
747 return (INT16
)length
;
752 INT16
WINSOCK_sendto(SOCKET16 s
, char *buf
, INT16 len
, INT16 flags
,
753 struct sockaddr
*to
, INT16 tolen
)
755 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
756 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
758 dprintf_winsock(stddeb
, "WS_SENDTO(%08x): socket %04x, ptr %08x, length %d, flags %d\n",
759 (unsigned)pwsi
, s
, (unsigned) buf
, len
, flags
);
760 if( _check_ws(pwsi
, pws
) )
764 if ((length
= sendto(pws
->fd
, buf
, len
, flags
, to
, tolen
)) < 0 )
766 length
= SOCKET_ERROR
;
767 pwsi
->errno
= wsaErrno();
769 notify_client(pws
, WS_FD_WRITE
);
770 return (INT16
)length
;
775 INT16
WINSOCK_setsockopt(SOCKET16 s
, INT16 level
, INT16 optname
,
776 char *optval
, INT16 optlen
)
778 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
779 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
781 dprintf_winsock(stddeb
, "WS_SETSOCKOPT(%08x): socket %04x, level %d, opt %d, ptr %08x, len %d\n",
782 (unsigned)pwsi
, s
, level
, optname
, (int) optval
, optlen
);
783 if( _check_ws(pwsi
, pws
) )
786 convert_sockopt(&level
, &optname
);
787 if( optname
== SO_LINGER
)
789 INT16
* ptr
= (INT16
*)optval
;
790 linger32
[0] = ptr
[0];
791 linger32
[1] = ptr
[1];
792 optval
= (char*)&linger32
;
793 optlen
= sizeof(linger32
);
795 if (setsockopt(pws
->fd
, level
, optname
, optval
, optlen
) == 0) return 0;
796 pwsi
->errno
= wsaErrno();
801 INT16
WINSOCK_shutdown(SOCKET16 s
, INT16 how
)
803 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
804 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
806 dprintf_winsock(stddeb
, "WS_SHUTDOWN(%08x): socket %04x, how %i\n",
807 (unsigned)pwsi
, s
, how
);
808 if( _check_ws(pwsi
, pws
) )
810 pws
->flags
= WS_FD_INACTIVE
;
811 delete_async_op(pws
);
813 if (shutdown(pws
->fd
, how
) == 0) return 0;
814 pwsi
->errno
= wsaErrno();
819 SOCKET16
WINSOCK_socket(INT16 af
, INT16 type
, INT16 protocol
)
821 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
823 dprintf_winsock(stddeb
, "WS_SOCKET(%08x): af=%d type=%d protocol=%d\n",
824 (unsigned)pwsi
, af
, type
, protocol
);
830 /* check the socket family */
834 case AF_UNSPEC
: break;
835 default: pwsi
->errno
= WSAEAFNOSUPPORT
; return INVALID_SOCKET
;
838 /* check the socket type */
843 case SOCK_RAW
: break;
844 default: pwsi
->errno
= WSAESOCKTNOSUPPORT
; return INVALID_SOCKET
;
847 /* check the protocol type */
848 if ( protocol
< 0 ) /* don't support negative values */
849 { pwsi
->errno
= WSAEPROTONOSUPPORT
; return INVALID_SOCKET
; }
851 if ( af
== AF_UNSPEC
) /* did they not specify the address family? */
855 if (type
== SOCK_STREAM
) { af
= AF_INET
; break; }
857 if (type
== SOCK_DGRAM
) { af
= AF_INET
; break; }
858 default: pwsi
->errno
= WSAEPROTOTYPE
; return INVALID_SOCKET
;
861 if ((sock
= socket(af
, type
, protocol
)) >= 0)
863 ws_socket
* pnew
= wsi_alloc_socket(pwsi
, sock
);
865 /* printf("created %04x (%i)\n", sock, (UINT16)WS_PTR2HANDLE(pnew));
867 if( pnew
) return (SOCKET16
)WS_PTR2HANDLE(pnew
);
871 pwsi
->errno
= WSAENOBUFS
;
872 return INVALID_SOCKET
;
876 if (errno
== EPERM
) /* raw socket denied */
878 fprintf(stderr
, "WS_SOCKET: not enough privileges\n");
879 pwsi
->errno
= WSAESOCKTNOSUPPORT
;
880 } else pwsi
->errno
= wsaErrno();
883 dprintf_winsock(stddeb
, "\t\tfailed!\n");
884 return INVALID_SOCKET
;
888 /* ----- database functions
890 * Note that ws_...ent structures we return have SEGPTR pointers inside them.
893 static char* NULL_STRING
= "NULL";
898 SEGPTR
WINSOCK_gethostbyaddr(const char *addr
, INT16 len
, INT16 type
)
900 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
902 dprintf_winsock(stddeb
, "WS_GetHostByAddr(%08x): ptr %8x, len %d, type %d\n",
903 (unsigned)pwsi
, (unsigned) addr
, len
, type
);
906 struct hostent
* host
;
907 if( (host
= gethostbyaddr(addr
, len
, type
)) != NULL
)
908 if( WS_dup_he(pwsi
, host
, WS_DUP_SEGPTR
) )
909 return SEGPTR_GET(pwsi
->buffer
);
910 else pwsi
->errno
= WSAENOBUFS
;
911 else pwsi
->errno
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
919 SEGPTR
WINSOCK_gethostbyname(const char *name
)
921 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
923 dprintf_winsock(stddeb
, "WS_GetHostByName(%08x): %s\n",
924 (unsigned)pwsi
, (name
)?name
:"NULL");
927 struct hostent
* host
;
928 if( (host
= gethostbyname(name
)) != NULL
)
929 if( WS_dup_he(pwsi
, host
, WS_DUP_SEGPTR
) )
930 return SEGPTR_GET(pwsi
->buffer
);
931 else pwsi
->errno
= WSAENOBUFS
;
932 else pwsi
->errno
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
937 INT16
WINSOCK_gethostname(char *name
, INT16 namelen
)
939 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
941 dprintf_winsock(stddeb
, "WS_GetHostName(%08x): name %s, len %d\n",
942 (unsigned)pwsi
, (name
)?name
:NULL_STRING
, namelen
);
945 if (gethostname(name
, namelen
) == 0) return 0;
946 pwsi
->errno
= (errno
== EINVAL
) ? WSAEFAULT
: wsaErrno();
952 struct WIN_protoent *
954 SEGPTR
WINSOCK_getprotobyname(char *name
)
956 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
958 dprintf_winsock(stddeb
, "WS_GetProtoByName(%08x): %s\n",
959 (unsigned)pwsi
, (name
)?name
:NULL_STRING
);
962 struct protoent
* proto
;
963 if( (proto
= getprotobyname(name
)) != NULL
)
964 if( WS_dup_pe(pwsi
, proto
, WS_DUP_SEGPTR
) )
965 return SEGPTR_GET(pwsi
->buffer
);
966 else pwsi
->errno
= WSAENOBUFS
;
967 else pwsi
->errno
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
973 struct WIN_protoent *
975 SEGPTR
WINSOCK_getprotobynumber(INT16 number
)
977 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
979 dprintf_winsock(stddeb
, "WS_GetProtoByNumber(%08x): %i\n", (unsigned)pwsi
, number
);
983 struct protoent
* proto
;
984 if( (proto
= getprotobynumber(number
)) != NULL
)
985 if( WS_dup_pe(pwsi
, proto
, WS_DUP_SEGPTR
) )
986 return SEGPTR_GET(pwsi
->buffer
);
987 else pwsi
->errno
= WSAENOBUFS
;
988 else pwsi
->errno
= WSANO_DATA
;
996 SEGPTR
WINSOCK_getservbyname(const char *name
, const char *proto
)
998 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1000 dprintf_winsock(stddeb
, "WS_GetServByName(%08x): '%s', '%s'\n",
1001 (unsigned)pwsi
, (name
)?name
:NULL_STRING
, (proto
)?proto
:NULL_STRING
);
1005 struct servent
* serv
;
1006 if( (serv
= getservbyname(name
, proto
)) != NULL
)
1007 if( WS_dup_se(pwsi
, serv
, WS_DUP_SEGPTR
) )
1008 return SEGPTR_GET(pwsi
->buffer
);
1009 else pwsi
->errno
= WSAENOBUFS
;
1010 else pwsi
->errno
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
1016 struct WIN_servent *
1018 SEGPTR
WINSOCK_getservbyport(INT16 port
, const char *proto
)
1020 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1022 dprintf_winsock(stddeb
, "WS_GetServByPort(%08x): %i, '%s'\n",
1023 (unsigned)pwsi
, (int)port
, (proto
)?proto
:NULL_STRING
);
1026 struct servent
* serv
;
1027 if( (serv
= getservbyport(port
, proto
)) != NULL
)
1028 if( WS_dup_se(pwsi
, serv
, WS_DUP_SEGPTR
) )
1029 return SEGPTR_GET(pwsi
->buffer
);
1030 else pwsi
->errno
= WSAENOBUFS
;
1031 else pwsi
->errno
= (h_errno
< 0) ? wsaErrno() : wsaHerrno();
1037 /* ----------------------------------- Windows sockets extensions -- *
1039 * ----------------------------------------------------------------- */
1041 static int aop_control(ws_async_op
* p_aop
, int flag
)
1045 read(p_aop
->fd
[0], &lLength
, sizeof(unsigned));
1046 if( LOWORD(lLength
) )
1047 if( LOWORD(lLength
) <= p_aop
->buflen
)
1049 char* buffer
= (char*)PTR_SEG_TO_LIN(p_aop
->buffer_base
);
1050 read(p_aop
->fd
[0], buffer
, LOWORD(lLength
));
1051 switch( p_aop
->flags
)
1053 case WSMSG_ASYNC_HOSTBYNAME
:
1054 case WSMSG_ASYNC_HOSTBYADDR
:
1055 fixup_wshe((struct ws_hostent
*)buffer
, p_aop
->buffer_base
); break;
1056 case WSMSG_ASYNC_PROTOBYNAME
:
1057 case WSMSG_ASYNC_PROTOBYNUM
:
1058 fixup_wspe((struct ws_protoent
*)buffer
, p_aop
->buffer_base
); break;
1059 case WSMSG_ASYNC_SERVBYNAME
:
1060 case WSMSG_ASYNC_SERVBYPORT
:
1061 fixup_wsse((struct ws_servent
*)buffer
, p_aop
->buffer_base
); break;
1063 if( p_aop
->flags
) fprintf(stderr
,"Received unknown async request!\n");
1064 return AOP_CONTROL_REMOVE
;
1067 else lLength
= ((UINT32
)LOWORD(lLength
)) | ((unsigned)WSAENOBUFS
<< 16);
1070 printf("async op completed: hWnd [%04x], uMsg [%04x], aop [%04x], event [%08x]\n",
1071 p_aop
->hWnd
, p_aop
->uMsg
, (HANDLE16
)WS_PTR2HANDLE(p_aop
), (LPARAM
)lLength
);
1074 PostMessage(p_aop
->hWnd
, p_aop
->uMsg
, (HANDLE16
)WS_PTR2HANDLE(p_aop
), (LPARAM
)lLength
);
1075 return AOP_CONTROL_REMOVE
;
1079 static HANDLE16
__WSAsyncDBQuery(LPWSINFO pwsi
, HWND16 hWnd
, UINT16 uMsg
, LPCSTR init
,
1080 INT16 len
, INT16 type
, SEGPTR sbuf
, INT16 buflen
, UINT32 flag
)
1082 /* queue 'flag' request and fork off its handler */
1084 async_ctl
.ws_aop
= (ws_async_op
*)WS_ALLOC(sizeof(ws_async_op
));
1086 if( async_ctl
.ws_aop
)
1088 HANDLE16 handle
= (HANDLE16
)WS_PTR2HANDLE(async_ctl
.ws_aop
);
1090 if( pipe(async_ctl
.ws_aop
->fd
) == 0 )
1092 async_ctl
.ws_aop
->init
= (char*)init
;
1093 async_ctl
.lLength
= len
;
1094 async_ctl
.lEvent
= type
;
1096 async_ctl
.ws_aop
->hWnd
= hWnd
;
1097 async_ctl
.ws_aop
->uMsg
= uMsg
;
1099 async_ctl
.ws_aop
->buffer_base
= sbuf
; async_ctl
.ws_aop
->buflen
= buflen
;
1100 async_ctl
.ws_aop
->flags
= flag
;
1101 async_ctl
.ws_aop
->aop_control
= &aop_control
;
1102 WINSOCK_link_async_op( async_ctl
.ws_aop
);
1104 async_ctl
.ws_aop
->pid
= fork();
1105 if( async_ctl
.ws_aop
->pid
)
1107 close(async_ctl
.ws_aop
->fd
[1]); /* write endpoint */
1109 /* Damn, BSD'ish SIGIO doesn't work on pipes/streams
1111 * async_io(async_ctl.ws_aop->fd[0], 1);
1114 dprintf_winsock(stddeb
, "\tasync_op = %04x (child %i)\n",
1115 handle
, async_ctl
.ws_aop
->pid
);
1120 close(async_ctl
.ws_aop
->fd
[0]); /* read endpoint */
1123 case WSMSG_ASYNC_HOSTBYADDR
:
1124 case WSMSG_ASYNC_HOSTBYNAME
:
1125 WS_do_async_gethost(pwsi
,flag
);
1126 case WSMSG_ASYNC_PROTOBYNUM
:
1127 case WSMSG_ASYNC_PROTOBYNAME
:
1128 WS_do_async_getproto(pwsi
,flag
);
1129 case WSMSG_ASYNC_SERVBYPORT
:
1130 case WSMSG_ASYNC_SERVBYNAME
:
1131 WS_do_async_getserv(pwsi
,flag
);
1135 WS_FREE(async_ctl
.ws_aop
);
1136 pwsi
->errno
= wsaErrno();
1137 } else pwsi
->errno
= WSAEWOULDBLOCK
;
1141 HANDLE16
WSAAsyncGetHostByAddr(HWND16 hWnd
, UINT16 uMsg
, LPCSTR addr
,
1142 INT16 len
, INT16 type
, SEGPTR sbuf
, INT16 buflen
)
1144 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1146 dprintf_winsock(stddeb
, "WS_AsyncGetHostByAddr(%08x): hwnd %04x, msg %04x, addr %08x[%i]\n",
1147 (unsigned)pwsi
, hWnd
, uMsg
, (unsigned)addr
, len
);
1150 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, addr
, len
,
1151 type
, sbuf
, buflen
, WSMSG_ASYNC_HOSTBYADDR
);
1156 HANDLE16
WSAAsyncGetHostByName(HWND16 hWnd
, UINT16 uMsg
, LPCSTR name
,
1157 SEGPTR sbuf
, INT16 buflen
)
1159 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1161 dprintf_winsock(stddeb
, "WS_AsyncGetHostByName(%08x): hwnd %04x, msg %04x, host %s, buffer %i\n",
1162 (unsigned)pwsi
, hWnd
, uMsg
, (name
)?name
:NULL_STRING
, (int)buflen
);
1165 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, name
, 0,
1166 0, sbuf
, buflen
, WSMSG_ASYNC_HOSTBYNAME
);
1171 HANDLE16
WSAAsyncGetProtoByName(HWND16 hWnd
, UINT16 uMsg
, LPCSTR name
,
1172 SEGPTR sbuf
, INT16 buflen
)
1174 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1176 dprintf_winsock(stddeb
, "WS_AsyncGetProtoByName(%08x): hwnd %04x, msg %04x, protocol %s\n",
1177 (unsigned)pwsi
, hWnd
, uMsg
, (name
)?name
:NULL_STRING
);
1180 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, name
, 0,
1181 0, sbuf
, buflen
, WSMSG_ASYNC_PROTOBYNAME
);
1186 HANDLE16
WSAAsyncGetProtoByNumber(HWND16 hWnd
, UINT16 uMsg
, INT16 number
,
1187 SEGPTR sbuf
, INT16 buflen
)
1189 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1191 dprintf_winsock(stddeb
, "WS_AsyncGetProtoByNumber(%08x): hwnd %04x, msg %04x, num %i\n",
1192 (unsigned)pwsi
, hWnd
, uMsg
, number
);
1195 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, NULL
, 0,
1196 number
, sbuf
, buflen
, WSMSG_ASYNC_PROTOBYNUM
);
1201 HANDLE16
WSAAsyncGetServByName(HWND16 hWnd
, UINT16 uMsg
, LPCSTR name
,
1202 LPCSTR proto
, SEGPTR sbuf
, INT16 buflen
)
1204 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1206 dprintf_winsock(stddeb
, "WS_AsyncGetServByName(%08x): hwnd %04x, msg %04x, name %s, proto %s\n",
1207 (unsigned)pwsi
, hWnd
, uMsg
, (name
)?name
:NULL_STRING
, (proto
)?proto
:NULL_STRING
);
1211 async_ctl
.buffer
= (char*)proto
;
1212 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, name
, 0,
1213 0, sbuf
, buflen
, WSMSG_ASYNC_SERVBYNAME
);
1219 HANDLE16
WSAAsyncGetServByPort(HWND16 hWnd
, UINT16 uMsg
, INT16 port
,
1220 LPCSTR proto
, SEGPTR sbuf
, INT16 buflen
)
1222 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1224 dprintf_winsock(stddeb
, "WS_AsyncGetServByPort(%08x): hwnd %04x, msg %04x, port %i, proto %s\n",
1225 (unsigned)pwsi
, hWnd
, uMsg
, port
, (proto
)?proto
:NULL_STRING
);
1228 return __WSAsyncDBQuery(pwsi
, hWnd
, uMsg
, proto
, 0,
1229 port
, sbuf
, buflen
, WSMSG_ASYNC_SERVBYPORT
);
1233 INT16
WSACancelAsyncRequest(HANDLE16 hAsyncTaskHandle
)
1235 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1236 ws_async_op
* p_aop
= (ws_async_op
*)WS_HANDLE2PTR(hAsyncTaskHandle
);
1238 dprintf_winsock(stddeb
, "WS_CancelAsyncRequest(%08x): handle %04x\n",
1239 (unsigned)pwsi
, hAsyncTaskHandle
);
1241 if( WINSOCK_check_async_op(p_aop
) )
1243 kill(p_aop
->pid
, SIGKILL
);
1244 waitpid(p_aop
->pid
, NULL
, 0);
1245 close(p_aop
->fd
[0]);
1246 WINSOCK_unlink_async_op(p_aop
);
1250 else pwsi
->errno
= WSAEINVAL
;
1251 return SOCKET_ERROR
;
1254 /* ----- asynchronous select() */
1256 int delete_async_op(ws_socket
* pws
)
1260 kill(pws
->p_aop
->pid
, SIGKILL
);
1261 waitpid(pws
->p_aop
->pid
, NULL
, 0);
1262 WS_FREE(pws
->p_aop
); return 1;
1263 pws
->flags
&= WS_FD_INTERNAL
;
1268 void _sigusr1_handler_parent(int sig
)
1270 /* child process puts MTYPE_CLIENT data packet into the
1271 * 'async_qid' message queue and signals us with SIGUSR1.
1272 * This handler reads the queue and posts 'uMsg' notification
1278 signal( SIGUSR1
, _sigusr1_handler_parent
);
1279 while( msgrcv(async_qid
, (struct msgbuf
*)&ipack
,
1280 MTYPE_CLIENT_SIZE
, MTYPE_CLIENT
, IPC_NOWAIT
) != -1 )
1282 if( ipack
.wParam
&& abs((short)ipack
.wParam
) < 32768 )
1284 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(ipack
.wParam
);
1285 if( pws
->p_aop
&& abs((char*)_ws_stub
- (char*)pws
->p_aop
) < 32768 )
1287 pws
->flags
&= ~(ipack
.lParam
);
1289 printf("async event - hWnd %04x, uMsg %04x [%08x]\n",
1290 pws
->p_aop
->hWnd
, pws
->p_aop
->uMsg
, ipack
.lParam
);
1292 PostMessage(pws
->p_aop
->hWnd
, pws
->p_aop
->uMsg
,
1293 (WPARAM16
)ipack
.wParam
, (LPARAM
)ipack
.lParam
);
1295 else fprintf(stderr
,"AsyncSelect:stray async_op in socket %04x!\n", ipack
.wParam
);
1297 else fprintf(stderr
,"AsyncSelect:stray socket at %04x!\n", ipack
.wParam
);
1301 int notify_client( ws_socket
* pws
, unsigned flag
)
1303 if( pws
->p_aop
&& ((pws
->p_aop
->flags
& flag
) ||
1304 (flag
== WS_FD_CONNECTED
&& pws
->flags
& WS_FD_CONNECT
)) )
1306 async_ctl
.ip
.mtype
= MTYPE_PARENT
;
1307 async_ctl
.ip
.lParam
= flag
;
1308 while( msgsnd(async_qid
, (struct msgbuf
*)&(async_ctl
.ip
),
1309 MTYPE_PARENT_SIZE
, 0) == -1 )
1311 if( errno
== EINTR
) continue;
1314 perror("AsyncSelect(parent)");
1315 delete_async_op(pws
);
1316 pws
->flags
&= WS_FD_INTERNAL
;
1320 kill(pws
->p_aop
->pid
, SIGUSR1
);
1326 INT16
init_async_select(ws_socket
* pws
, HWND16 hWnd
, UINT16 uMsg
, UINT32 lEvent
)
1330 if( delete_async_op(pws
) ) /* delete old async handler if any */
1333 pws
->flags
&= WS_FD_INTERNAL
;
1335 if( lEvent
== 0 ) return 0;
1337 /* setup async handler - some data may be redundant */
1339 WINSOCK_unblock_io(pws
->fd
, 1);
1340 if( (p_aop
= (ws_async_op
*)WS_ALLOC(sizeof(ws_async_op
))) )
1346 async_ctl
.lEvent
= p_aop
->flags
= lEvent
;
1347 async_ctl
.ws_sock
= pws
;
1348 async_ctl
.ip
.wParam
= (UINT16
)WS_PTR2HANDLE(pws
);
1349 async_ctl
.ip
.lParam
= 0;
1351 p_aop
->pid
= fork();
1352 if( p_aop
->pid
!= -1 )
1353 if( p_aop
->pid
== 0 ) WINSOCK_do_async_select(); /* child process */
1354 else pws
->flags
|= lEvent
;
1356 signal( SIGUSR1
, _sigusr1_handler_parent
);
1357 return 0; /* Wine process */
1359 return SOCKET_ERROR
;
1362 INT16
WSAAsyncSelect(SOCKET16 s
, HWND16 hWnd
, UINT16 uMsg
, UINT32 lEvent
)
1364 ws_socket
* pws
= (ws_socket
*)WS_HANDLE2PTR(s
);
1365 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1367 dprintf_winsock(stddeb
, "WS_AsyncSelect(%08x): %04x, hWnd %04x, uMsg %04x, event %08x\n",
1368 (unsigned)pwsi
, s
, hWnd
, uMsg
, (unsigned)lEvent
);
1369 if( _check_ws(pwsi
, pws
) )
1370 if( init_async_select(pws
, hWnd
, uMsg
, lEvent
) == 0 ) return 0;
1371 else pwsi
->errno
= WSAENOBUFS
;
1372 return SOCKET_ERROR
;
1375 /* ----- miscellaneous */
1377 INT16
__WSAFDIsSet(SOCKET16 fd
, ws_fd_set
*set
)
1379 int i
= set
->fd_count
;
1381 dprintf_winsock(stddeb
, "__WSAFDIsSet(%d,%8lx)\n",fd
,(unsigned long)set
);
1384 if (set
->fd_array
[i
] == fd
) return 1;
1388 BOOL16
WSAIsBlocking(void)
1390 /* By default WinSock should set all its sockets to non-blocking mode
1391 * and poll in PeekMessage loop when processing "blocking" ones. This
1392 * function * is supposed to tell if program is in this loop. Our
1393 * blocking calls are truly blocking so we always return FALSE.
1395 * Note: It is allowed to call this function without prior WSAStartup().
1398 dprintf_winsock(stddeb
, "WS_IsBlocking()\n");
1402 INT16
WSACancelBlockingCall(void)
1404 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1406 dprintf_winsock(stddeb
, "WS_CancelBlockingCall(%08x)\n", (unsigned)pwsi
);
1408 if( pwsi
) return 0;
1409 return SOCKET_ERROR
;
1412 FARPROC16
WSASetBlockingHook(FARPROC16 lpBlockFunc
)
1415 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1417 dprintf_winsock(stddeb
, "WS_SetBlockingHook(%08x): hook %08x\n",
1418 (unsigned)pwsi
, (unsigned) lpBlockFunc
);
1421 prev
= pwsi
->blocking_hook
;
1422 pwsi
->blocking_hook
= lpBlockFunc
;
1428 INT16
WSAUnhookBlockingHook(void)
1430 LPWSINFO pwsi
= wsi_find(GetCurrentTask());
1432 dprintf_winsock(stddeb
, "WS_UnhookBlockingHook(%08x)\n", (unsigned)pwsi
);
1433 if( pwsi
) return (INT16
)(INT32
)(pwsi
->blocking_hook
= (FARPROC16
)NULL
);
1434 return SOCKET_ERROR
;
1438 WsControl(DWORD x1
,DWORD x2
,LPDWORD x3
,LPDWORD x4
,LPDWORD x5
,LPDWORD x6
)
1440 fprintf(stdnimp
,"WsControl(%lx,%lx,%p,%p,%p,%p)\n",
1443 fprintf(stdnimp
,"WsControl(x,x,%lx,%lx,%lx,%lx)\n",
1444 x3
?*x3
:0,x4
?*x4
:0,x5
?*x5
:0,x6
?*x6
:0
1448 /* ----------------------------------- end of API stuff */
1452 /* ----------------------------------- helper functions */
1454 static int list_size(char** l
, int item_size
)
1459 j
+= (item_size
) ? item_size
: strlen(l
[i
]) + 1;
1460 j
+= (i
+ 1) * sizeof(char*); }
1464 static int list_dup(char** l_src
, char* ref
, char* base
, int item_size
)
1466 /* base is either either equal to ref or 0 or SEGPTR */
1469 char** l_to
= (char**)ref
;
1472 for(j
=0;l_src
[j
];j
++) ;
1473 p
+= (j
+ 1) * sizeof(char*);
1475 { l_to
[i
] = base
+ (p
- ref
);
1476 k
= ( item_size
) ? item_size
: strlen(l_src
[i
]) + 1;
1477 memcpy(p
, l_src
[i
], k
); p
+= k
; }
1484 static int hostent_size(struct hostent
* p_he
)
1488 { size
= sizeof(struct hostent
);
1489 size
+= strlen(p_he
->h_name
) + 1;
1490 size
+= list_size(p_he
->h_aliases
, 0);
1491 size
+= list_size(p_he
->h_addr_list
, p_he
->h_length
); }
1495 int WS_dup_he(LPWSINFO pwsi
, struct hostent
* p_he
, int flag
)
1497 /* Duplicate hostent structure and flatten data (with its pointers)
1498 * into pwsi->buffer. Internal pointers can be linear, SEGPTR, or
1499 * relative to 0 depending on "flag" value. Return data size (also
1500 * in the pwsi->buflen).
1503 int size
= hostent_size(p_he
);
1506 char* p_name
,*p_aliases
,*p_addr
,*p_base
,*p
;
1508 _check_buffer(pwsi
, size
);
1510 p_base
= (flag
& WS_DUP_OFFSET
) ? NULL
1511 : ((flag
& WS_DUP_SEGPTR
) ? (char*)SEGPTR_GET(p
) : p
);
1512 p
+= (flag
& WS_DUP_SEGPTR
) ? sizeof(struct ws_hostent
) : sizeof(struct hostent
);
1514 strcpy(p
, p_he
->h_name
); p
+= strlen(p
) + 1;
1516 p
+= list_dup(p_he
->h_aliases
, p
, p_base
+ (p
- pwsi
->buffer
), 0);
1518 list_dup(p_he
->h_addr_list
, p
, p_base
+ (p
- pwsi
->buffer
), p_he
->h_length
);
1519 if( !(flag
& WS_DUP_SEGPTR
) )
1520 { struct hostent
* p_to
= (struct hostent
*)pwsi
->buffer
;
1521 p_to
->h_addrtype
= p_he
->h_addrtype
; p_to
->h_length
= p_he
->h_length
;
1522 p_to
->h_name
= p_base
+ (p_name
- pwsi
->buffer
);
1523 p_to
->h_aliases
= (char**)(p_base
+ (p_aliases
- pwsi
->buffer
));
1524 p_to
->h_addr_list
= (char**)(p_base
+ (p_addr
- pwsi
->buffer
)); }
1526 { struct ws_hostent
* p_to
= (struct ws_hostent
*)pwsi
->buffer
;
1527 p_to
->h_addrtype
= (INT16
)p_he
->h_addrtype
;
1528 p_to
->h_length
= (INT16
)p_he
->h_length
;
1529 p_to
->h_name
= (SEGPTR
)(p_base
+ (p_name
- pwsi
->buffer
));
1530 p_to
->h_aliases
= (SEGPTR
)(p_base
+ (p_aliases
- pwsi
->buffer
));
1531 p_to
->h_addr_list
= (SEGPTR
)(p_base
+ (p_addr
- pwsi
->buffer
));
1532 return (size
+ sizeof(struct ws_hostent
) - sizeof(struct hostent
)); }
1537 void fixup_wshe(struct ws_hostent
* p_wshe
, SEGPTR base
)
1539 /* add 'base' to ws_hostent pointers to convert them from offsets */
1542 unsigned* p_aliases
,*p_addr
;
1544 p_aliases
= (unsigned*)((char*)p_wshe
+ (unsigned)p_wshe
->h_aliases
);
1545 p_addr
= (unsigned*)((char*)p_wshe
+ (unsigned)p_wshe
->h_addr_list
);
1546 ((unsigned)(p_wshe
->h_name
)) += (unsigned)base
;
1547 ((unsigned)(p_wshe
->h_aliases
)) += (unsigned)base
;
1548 ((unsigned)(p_wshe
->h_addr_list
)) += (unsigned)base
;
1549 for(i
=0;p_aliases
[i
];i
++) p_aliases
[i
] += (unsigned)base
;
1550 for(i
=0;p_addr
[i
];i
++) p_addr
[i
] += (unsigned)base
;
1553 /* ----- protoent */
1555 static int protoent_size(struct protoent
* p_pe
)
1559 { size
= sizeof(struct protoent
);
1560 size
+= strlen(p_pe
->p_name
) + 1;
1561 size
+= list_size(p_pe
->p_aliases
, 0); }
1565 int WS_dup_pe(LPWSINFO pwsi
, struct protoent
* p_pe
, int flag
)
1567 int size
= protoent_size(p_pe
);
1570 char* p_name
,*p_aliases
,*p_base
,*p
;
1572 _check_buffer(pwsi
, size
);
1574 p_base
= (flag
& WS_DUP_OFFSET
) ? NULL
1575 : ((flag
& WS_DUP_SEGPTR
) ? (char*)SEGPTR_GET(p
) : p
);
1576 p
+= (flag
& WS_DUP_SEGPTR
)? sizeof(struct ws_protoent
) : sizeof(struct protoent
);
1578 strcpy(p
, p_pe
->p_name
); p
+= strlen(p
) + 1;
1580 list_dup(p_pe
->p_aliases
, p
, p_base
+ (p
- pwsi
->buffer
), 0);
1581 if( !(flag
& WS_DUP_NATIVE
) )
1582 { struct protoent
* p_to
= (struct protoent
*)pwsi
->buffer
;
1583 p_to
->p_proto
= p_pe
->p_proto
;
1584 p_to
->p_name
= p_base
+ (p_name
- pwsi
->buffer
);
1585 p_to
->p_aliases
= (char**)(p_base
+ (p_aliases
- pwsi
->buffer
)); }
1587 { struct ws_protoent
* p_to
= (struct ws_protoent
*)pwsi
->buffer
;
1588 p_to
->p_proto
= (INT16
)p_pe
->p_proto
;
1589 p_to
->p_name
= (SEGPTR
)(p_base
) + (p_name
- pwsi
->buffer
);
1590 p_to
->p_aliases
= (SEGPTR
)((p_base
) + (p_aliases
- pwsi
->buffer
));
1591 return (size
+ sizeof(struct ws_protoent
) - sizeof(struct protoent
)); }
1596 void fixup_wspe(struct ws_protoent
* p_wspe
, SEGPTR base
)
1599 unsigned* p_aliases
= (unsigned*)((char*)p_wspe
+ (unsigned)p_wspe
->p_aliases
);
1600 ((unsigned)(p_wspe
->p_name
)) += (unsigned)base
;
1601 ((unsigned)(p_wspe
->p_aliases
)) += (unsigned)base
;
1602 for(i
=0;p_aliases
[i
];i
++) p_aliases
[i
] += (unsigned)base
;
1607 static int servent_size(struct servent
* p_se
)
1611 { size
+= sizeof(struct servent
);
1612 size
+= strlen(p_se
->s_proto
) + strlen(p_se
->s_name
) + 2;
1613 size
+= list_size(p_se
->s_aliases
, 0); }
1617 int WS_dup_se(LPWSINFO pwsi
, struct servent
* p_se
, int flag
)
1619 int size
= servent_size(p_se
);
1622 char* p_name
,*p_aliases
,*p_proto
,*p_base
,*p
;
1624 _check_buffer(pwsi
, size
);
1626 p_base
= (flag
& WS_DUP_OFFSET
) ? NULL
1627 : ((flag
& WS_DUP_SEGPTR
) ? (char*)SEGPTR_GET(p
) : p
);
1628 p
+= (flag
& WS_DUP_SEGPTR
)? sizeof(struct ws_servent
) : sizeof(struct servent
);
1630 strcpy(p
, p_se
->s_name
); p
+= strlen(p
) + 1;
1632 strcpy(p
, p_se
->s_proto
); p
+= strlen(p
) + 1;
1634 list_dup(p_se
->s_aliases
, p
, p_base
+ (p
- pwsi
->buffer
), 0);
1636 if( !(flag
& WS_DUP_SEGPTR
) )
1637 { struct servent
* p_to
= (struct servent
*)pwsi
->buffer
;
1638 p_to
->s_port
= p_se
->s_port
;
1639 p_to
->s_name
= p_base
+ (p_name
- pwsi
->buffer
);
1640 p_to
->s_proto
= p_base
+ (p_proto
- pwsi
->buffer
);
1641 p_to
->s_aliases
= (char**)(p_base
+ (p_aliases
- pwsi
->buffer
)); }
1643 { struct ws_servent
* p_to
= (struct ws_servent
*)pwsi
->buffer
;
1644 p_to
->s_port
= (INT16
)p_se
->s_port
;
1645 p_to
->s_name
= (SEGPTR
)(p_base
+ (p_name
- pwsi
->buffer
));
1646 p_to
->s_proto
= (SEGPTR
)(p_base
+ (p_proto
- pwsi
->buffer
));
1647 p_to
->s_aliases
= (SEGPTR
)(p_base
+ (p_aliases
- pwsi
->buffer
));
1648 return (size
+ sizeof(struct ws_servent
) - sizeof(struct servent
)); }
1653 void fixup_wsse(struct ws_servent
* p_wsse
, SEGPTR base
)
1656 unsigned* p_aliases
= (unsigned*)((char*)p_wsse
+ (unsigned)p_wsse
->s_aliases
);
1657 ((unsigned)(p_wsse
->s_name
)) += (unsigned)base
;
1658 ((p_wsse
->s_proto
)) += (unsigned)base
;
1659 ((p_wsse
->s_aliases
)) += (unsigned)base
;
1660 for(i
=0;p_aliases
[i
];i
++) p_aliases
[i
] += (unsigned)base
;
1663 /* ----------------------------------- error handling */
1665 UINT16
wsaErrno(void)
1667 int loc_errno
= errno
;
1668 #if defined(__FreeBSD__)
1669 dprintf_winsock(stderr
, "winsock: errno %d, (%s).\n",
1670 errno
, sys_errlist
[errno
]);
1672 dprintf_winsock(stderr
, "winsock: errno %d\n", errno
);
1677 case EINTR
: return WSAEINTR
;
1678 case EBADF
: return WSAEBADF
;
1679 case EACCES
: return WSAEACCES
;
1680 case EFAULT
: return WSAEFAULT
;
1681 case EINVAL
: return WSAEINVAL
;
1682 case EMFILE
: return WSAEMFILE
;
1683 case EWOULDBLOCK
: return WSAEWOULDBLOCK
;
1684 case EINPROGRESS
: return WSAEINPROGRESS
;
1685 case EALREADY
: return WSAEALREADY
;
1686 case ENOTSOCK
: return WSAENOTSOCK
;
1687 case EDESTADDRREQ
: return WSAEDESTADDRREQ
;
1688 case EMSGSIZE
: return WSAEMSGSIZE
;
1689 case EPROTOTYPE
: return WSAEPROTOTYPE
;
1690 case ENOPROTOOPT
: return WSAENOPROTOOPT
;
1691 case EPROTONOSUPPORT
: return WSAEPROTONOSUPPORT
;
1692 case ESOCKTNOSUPPORT
: return WSAESOCKTNOSUPPORT
;
1693 case EOPNOTSUPP
: return WSAEOPNOTSUPP
;
1694 case EPFNOSUPPORT
: return WSAEPFNOSUPPORT
;
1695 case EAFNOSUPPORT
: return WSAEAFNOSUPPORT
;
1696 case EADDRINUSE
: return WSAEADDRINUSE
;
1697 case EADDRNOTAVAIL
: return WSAEADDRNOTAVAIL
;
1698 case ENETDOWN
: return WSAENETDOWN
;
1699 case ENETUNREACH
: return WSAENETUNREACH
;
1700 case ENETRESET
: return WSAENETRESET
;
1701 case ECONNABORTED
: return WSAECONNABORTED
;
1702 case ECONNRESET
: return WSAECONNRESET
;
1703 case ENOBUFS
: return WSAENOBUFS
;
1704 case EISCONN
: return WSAEISCONN
;
1705 case ENOTCONN
: return WSAENOTCONN
;
1706 case ESHUTDOWN
: return WSAESHUTDOWN
;
1707 case ETOOMANYREFS
: return WSAETOOMANYREFS
;
1708 case ETIMEDOUT
: return WSAETIMEDOUT
;
1709 case ECONNREFUSED
: return WSAECONNREFUSED
;
1710 case ELOOP
: return WSAELOOP
;
1711 case ENAMETOOLONG
: return WSAENAMETOOLONG
;
1712 case EHOSTDOWN
: return WSAEHOSTDOWN
;
1713 case EHOSTUNREACH
: return WSAEHOSTUNREACH
;
1714 case ENOTEMPTY
: return WSAENOTEMPTY
;
1716 case EPROCLIM
: return WSAEPROCLIM
;
1719 case EUSERS
: return WSAEUSERS
;
1722 case EDQUOT
: return WSAEDQUOT
;
1724 case ESTALE
: return WSAESTALE
;
1725 case EREMOTE
: return WSAEREMOTE
;
1727 /* just in case we ever get here and there are no problems */
1730 fprintf(stderr
, "winsock: unknown errno %d!\n", errno
);
1731 return WSAEOPNOTSUPP
;
1735 UINT16
wsaHerrno(void)
1737 int loc_errno
= h_errno
;
1739 #if defined(__FreeBSD__)
1740 dprintf_winsock(stderr
, "winsock: h_errno %d, (%s).\n",
1741 h_errno
, sys_errlist
[h_errno
]);
1743 dprintf_winsock(stderr
, "winsock: h_errno %d.\n", h_errno
);
1745 if( debugging_winsock
) herror("wine: winsock: wsaherrno");
1751 case HOST_NOT_FOUND
: return WSAHOST_NOT_FOUND
;
1752 case TRY_AGAIN
: return WSATRY_AGAIN
;
1753 case NO_RECOVERY
: return WSANO_RECOVERY
;
1754 case NO_DATA
: return WSANO_DATA
;
1758 fprintf(stderr
, "winsock: unknown h_errno %d!\n", h_errno
);
1759 return WSAEOPNOTSUPP
;