source: trunk/src/wsock32/new/wsock32.cpp@ 1943

Last change on this file since 1943 was 1943, checked in by achimha, 26 years ago

async gethostbyname fixes
File size: 33.5 KB
Line 
1/* $Id: wsock32.cpp,v 1.10 1999-12-02 16:12:24 achimha Exp $ */
2
3/*
4 *
5 * Project Odin Software License can be found in LICENSE.TXT
6 *
7 * Win32 SOCK32 for OS/2
8 *
9 * Copyright (C) 1999 Patrick Haller <phaller@gmx.net>
10 *
11 */
12
13/* Remark:
14 * 1999/11/21 experimental rewrite using IBM's PMWSock only
15 * -> some structural differences remain! (hostent)
16 * 1999/12/01 experimental rewrite works (TELNET)
17 * -> open issue: WSASetLastError / WSAGetLastError
18 * call SetLastError / GetLastError according to docs
19 *
20 * identical structures:
21 * - sockaddr_in
22 * - WSADATA
23 * - sockaddr
24 * - fd_set
25 * - timeval
26 *
27 * incompatible structures:
28 * - hostent
29 * - netent
30 * - servent
31 * - protent
32 * - linger
33 */
34
35
36/*****************************************************************************
37 * Includes *
38 *****************************************************************************/
39
40#include <pmwsock.h>
41#include <odin.h>
42#include <odinwrap.h>
43#include <os2sel.h>
44#include <misc.h>
45#include <wprocess.h>
46#include <heapstring.h>
47#include <win32wnd.h>
48
49#include "wsock32.h"
50#include "relaywin.h"
51
52
53ODINDEBUGCHANNEL(WSOCK32-WSOCK32)
54
55
56/*****************************************************************************
57 * Local variables *
58 *****************************************************************************/
59
60#define ERROR_SUCCESS 0
61
62
63static WSOCKTHREADDATA wstdFallthru; // for emergency only
64
65static HWND hwndRelay; // handle to our relay window
66
67/*****************************************************************************
68 * Name :
69 * Purpose :
70 * Parameters:
71 * Variables :
72 * Result :
73 * Remark : free memory when thread dies
74 * Status : UNTESTED STUB
75 *
76 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
77 *****************************************************************************/
78
79PWSOCKTHREADDATA iQueryWsockThreadData(void)
80{
81 struct _THDB* pThreadDB = (struct _THDB*)GetThreadTHDB();
82 PWSOCKTHREADDATA pwstd;
83
84 // check for existing pointer
85 if (pThreadDB != NULL)
86 {
87 if (pThreadDB->pWsockData == NULL)
88 {
89 // allocate on demand + initialize
90 pwstd = (PWSOCKTHREADDATA)HEAP_malloc (sizeof(WSOCKTHREADDATA));
91 pThreadDB->pWsockData = (LPVOID)pwstd;
92 }
93 else
94 // use already allocated memory
95 pwstd = (PWSOCKTHREADDATA)pThreadDB->pWsockData;
96 }
97
98 if (pwstd == NULL)
99 pwstd = &wstdFallthru; // no memory and not allocated already
100
101 return pwstd;
102}
103
104
105#if 0
106/*****************************************************************************
107 * Name :
108 * Purpose :
109 * Parameters:
110 * Variables :
111 * Result :
112 * Remark :
113 * Status : UNTESTED STUB
114 *
115 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
116 *****************************************************************************/
117
118#define CASEERR2(a) case SOC##a: case a: return WSA##a;
119#define CASEERR1(a) case SOC##a: return WSA##a;
120
121int iTranslateSockErrToWSock(int iError)
122{
123 switch(iError)
124 {
125 CASEERR2(EINTR)
126 CASEERR2(EBADF)
127 CASEERR2(EACCES)
128 CASEERR2(EINVAL)
129 CASEERR2(EMFILE)
130
131 CASEERR1(EWOULDBLOCK)
132 CASEERR1(EINPROGRESS)
133 CASEERR1(EALREADY)
134 CASEERR1(ENOTSOCK)
135// CASEERR1(EDESTADRREQ)
136 CASEERR1(EMSGSIZE)
137 CASEERR1(EPROTOTYPE)
138 CASEERR1(ENOPROTOOPT)
139 CASEERR1(EPROTONOSUPPORT)
140 CASEERR1(ESOCKTNOSUPPORT)
141 CASEERR1(EOPNOTSUPP)
142 CASEERR1(EPFNOSUPPORT)
143 CASEERR1(EAFNOSUPPORT)
144 CASEERR1(EADDRINUSE)
145 CASEERR1(EADDRNOTAVAIL)
146 CASEERR1(ENETDOWN)
147 CASEERR1(ENETUNREACH)
148 CASEERR1(ENETRESET)
149 CASEERR1(ECONNABORTED)
150 CASEERR1(ECONNRESET)
151 CASEERR1(ENOBUFS)
152 CASEERR1(EISCONN)
153 CASEERR1(ENOTCONN)
154 CASEERR1(ESHUTDOWN)
155 CASEERR1(ETOOMANYREFS)
156 CASEERR1(ETIMEDOUT)
157 CASEERR1(ECONNREFUSED)
158 CASEERR1(ELOOP)
159 CASEERR1(ENAMETOOLONG)
160 CASEERR1(EHOSTDOWN)
161 CASEERR1(EHOSTUNREACH)
162
163 CASEERR1(ENOTEMPTY)
164// CASEERR(EPROCLIM)
165// CASEERR(EUSERS)
166// CASEERR(EDQUOT)
167// CASEERR(ESTALE)
168// CASEERR(EREMOTE)
169// CASEERR(EDISCON)
170
171
172 default:
173 dprintf(("WSOCK32: Unknown error condition: %d\n",
174 iError));
175 return iError;
176 }
177}
178
179#endif
180
181
182
183
184
185
186
187/*****************************************************************************
188 * Name :
189 * Purpose :
190 * Parameters:
191 * Variables :
192 * Result :
193 * Remark :
194 * Status : UNTESTED STUB
195 *
196 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
197 *****************************************************************************/
198
199
200ODINPROCEDURE1(OS2WSASetLastError,
201 int,iError)
202{
203 WSASetLastError(iError);
204}
205
206
207/*****************************************************************************
208 * Name :
209 * Purpose :
210 * Parameters:
211 * Variables :
212 * Result :
213 * Remark :
214 * Status : UNTESTED STUB
215 *
216 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
217 *****************************************************************************/
218
219ODINFUNCTION0(int,OS2WSAGetLastError)
220{
221 return WSAGetLastError();
222}
223
224
225/*****************************************************************************
226 * Name :
227 * Purpose :
228 * Parameters:
229 * Variables :
230 * Result :
231 * Remark :
232 * Status : UNTESTED STUB
233 *
234 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
235 *****************************************************************************/
236
237ODINFUNCTION2(int,OS2__WSAFDIsSet,SOCKET, s,
238 fd_set*,fds)
239{
240 return (__WSAFDIsSet(s,fds));
241}
242
243
244/*****************************************************************************
245 * Name :
246 * Purpose :
247 * Parameters:
248 * Variables :
249 * Result :
250 * Remark :
251 * Status : UNTESTED STUB
252 *
253 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
254 *****************************************************************************/
255
256ODINFUNCTION3(SOCKET,OS2accept, SOCKET, s,
257 struct sockaddr *,addr,
258 int *, addrlen)
259{
260 return(accept(s,addr,addrlen));
261}
262
263
264/*****************************************************************************
265 * Name :
266 * Purpose :
267 * Parameters:
268 * Variables :
269 * Result :
270 * Remark :
271 * Status : UNTESTED STUB
272 *
273 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
274 *****************************************************************************/
275
276ODINFUNCTION3(int,OS2bind,
277 SOCKET ,s,
278 const struct sockaddr *,addr,
279 int, namelen)
280{
281 return(bind(s,addr,namelen));
282}
283
284
285/*****************************************************************************
286 * Name :
287 * Purpose :
288 * Parameters:
289 * Variables :
290 * Result :
291 * Remark :
292 * Status : UNTESTED STUB
293 *
294 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
295 *****************************************************************************/
296
297ODINFUNCTION1(int,OS2closesocket,SOCKET, s)
298{
299 return(closesocket(s));
300}
301
302
303/*****************************************************************************
304 * Name :
305 * Purpose :
306 * Parameters:
307 * Variables :
308 * Result :
309 * Remark :
310 * Status : UNTESTED STUB
311 *
312 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
313 *****************************************************************************/
314
315ODINFUNCTION3(int,OS2connect,
316 SOCKET, s,
317 const struct sockaddr *,name,
318 int, namelen)
319{
320 return(connect(s,name,namelen));
321}
322
323
324/*****************************************************************************
325 * Name :
326 * Purpose :
327 * Parameters:
328 * Variables :
329 * Result :
330 * Remark :
331 * Status : UNTESTED STUB
332 *
333 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
334 *****************************************************************************/
335
336ODINFUNCTION3(int,OS2ioctlsocket,
337 SOCKET,s,
338 long, cmd,
339 u_long *,argp)
340{
341 return(ioctlsocket(s,cmd,argp));
342}
343
344
345/*****************************************************************************
346 * Name :
347 * Purpose :
348 * Parameters:
349 * Variables :
350 * Result :
351 * Remark :
352 * Status : UNTESTED STUB
353 *
354 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
355 *****************************************************************************/
356
357ODINFUNCTION3(int,OS2getpeername,
358 SOCKET, s,
359 struct sockaddr *,name,
360 int *, namelen)
361{
362 return(getpeername(s,name,namelen));
363}
364
365
366/*****************************************************************************
367 * Name :
368 * Purpose :
369 * Parameters:
370 * Variables :
371 * Result :
372 * Remark :
373 * Status : UNTESTED STUB
374 *
375 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
376 *****************************************************************************/
377
378ODINFUNCTION3(int,OS2getsockname,
379 SOCKET,s,
380 struct sockaddr *,name,
381 int *, namelen)
382{
383 return(getsockname(s,name,namelen));
384}
385
386
387/*****************************************************************************
388 * Name :
389 * Purpose :
390 * Parameters:
391 * Variables :
392 * Result :
393 * Remark :
394 * Status : UNTESTED STUB
395 *
396 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
397 *****************************************************************************/
398
399ODINFUNCTION5(int,OS2getsockopt,
400 SOCKET, s,
401 int, level,
402 int, optname,
403 char *, optval,
404 int *,optlen)
405{
406 return(getsockopt(s,
407 level,
408 optname,
409 optval,
410 optlen));
411}
412
413
414/*****************************************************************************
415 * Name :
416 * Purpose :
417 * Parameters:
418 * Variables :
419 * Result :
420 * Remark :
421 * Status : UNTESTED STUB
422 *
423 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
424 *****************************************************************************/
425
426ODINFUNCTION1(u_long,OS2htonl,
427 u_long,hostlong)
428{
429 return(htonl(hostlong));
430}
431
432
433/*****************************************************************************
434 * Name :
435 * Purpose :
436 * Parameters:
437 * Variables :
438 * Result :
439 * Remark :
440 * Status : UNTESTED STUB
441 *
442 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
443 *****************************************************************************/
444
445ODINFUNCTION1(u_short,OS2htons,
446 u_short,hostshort)
447{
448 return(htons(hostshort));
449}
450
451
452/*****************************************************************************
453 * Name :
454 * Purpose :
455 * Parameters:
456 * Variables :
457 * Result :
458 * Remark :
459 * Status : UNTESTED STUB
460 *
461 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
462 *****************************************************************************/
463
464ODINFUNCTION1(unsigned long,OS2inet_addr,
465 const char *, cp)
466{
467 dprintf(("WSOCK32: OS2inet_addr(%s)\n",
468 cp));
469
470 return (inet_addr(cp));
471}
472
473
474/*****************************************************************************
475 * Name :
476 * Purpose :
477 * Parameters:
478 * Variables :
479 * Result :
480 * Remark :
481 * Status : UNTESTED STUB
482 *
483 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
484 *****************************************************************************/
485
486ODINFUNCTION1(char *,OS2inet_ntoa,
487 struct in_addr, in)
488{
489 return(inet_ntoa(in));
490}
491
492
493/*****************************************************************************
494 * Name :
495 * Purpose :
496 * Parameters:
497 * Variables :
498 * Result :
499 * Remark :
500 * Status : UNTESTED STUB
501 *
502 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
503 *****************************************************************************/
504
505ODINFUNCTION2(int,OS2listen,
506 SOCKET, s,
507 int, backlog)
508{
509 return(listen(s,backlog));
510}
511
512
513/*****************************************************************************
514 * Name :
515 * Purpose :
516 * Parameters:
517 * Variables :
518 * Result :
519 * Remark :
520 * Status : UNTESTED STUB
521 *
522 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
523 *****************************************************************************/
524
525ODINFUNCTION1(u_long,OS2ntohl,
526 u_long,netlong)
527{
528 return(ntohl(netlong));
529}
530
531
532/*****************************************************************************
533 * Name :
534 * Purpose :
535 * Parameters:
536 * Variables :
537 * Result :
538 * Remark :
539 * Status : UNTESTED STUB
540 *
541 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
542 *****************************************************************************/
543
544ODINFUNCTION1(u_short,OS2ntohs,
545 u_short,netshort)
546{
547 return(ntohs(netshort));
548}
549
550
551/*****************************************************************************
552 * Name :
553 * Purpose :
554 * Parameters:
555 * Variables :
556 * Result :
557 * Remark :
558 * Status : UNTESTED STUB
559 *
560 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
561 *****************************************************************************/
562
563ODINFUNCTION4(int,OS2recv,
564 SOCKET,s,
565 char *,buf,
566 int,len,
567 int,flags)
568{
569 return(recv(s,
570 buf,
571 len,
572 flags));
573}
574
575
576/*****************************************************************************
577 * Name :
578 * Purpose :
579 * Parameters:
580 * Variables :
581 * Result :
582 * Remark :
583 * Status : UNTESTED STUB
584 *
585 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
586 *****************************************************************************/
587
588ODINFUNCTION6(int,OS2recvfrom,
589 SOCKET,s,
590 char *,buf,
591 int,len,
592 int,flags,
593 struct sockaddr *,from,
594 int *,fromlen)
595{
596
597 return(recvfrom(s,
598 buf,
599 len,
600 flags,
601 from,
602 fromlen));
603}
604
605
606/*****************************************************************************
607 * Name :
608 * Purpose :
609 * Parameters:
610 * Variables :
611 * Result :
612 * Remark :
613 * Status : UNTESTED STUB
614 *
615 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
616 *****************************************************************************/
617
618ODINFUNCTION5(int,OS2select,
619 int,nfds,
620 fd_set *,readfds,
621 fd_set *,writefds,
622 fd_set *,exceptfds,
623 const struct timeval *,timeout)
624{
625 return(select(nfds,
626 readfds,
627 writefds,
628 exceptfds,
629 timeout));
630}
631
632
633/*****************************************************************************
634 * Name :
635 * Purpose :
636 * Parameters:
637 * Variables :
638 * Result :
639 * Remark :
640 * Status : UNTESTED STUB
641 *
642 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
643 *****************************************************************************/
644
645ODINFUNCTION4(int,OS2send,
646 SOCKET,s,
647 const char *,buf,
648 int,len,
649 int,flags)
650{
651 return(send(s,
652 buf,
653 len,
654 flags));
655}
656
657
658/*****************************************************************************
659 * Name :
660 * Purpose :
661 * Parameters:
662 * Variables :
663 * Result :
664 * Remark :
665 * Status : UNTESTED STUB
666 *
667 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
668 *****************************************************************************/
669
670ODINFUNCTION6(int,OS2sendto,
671 SOCKET,s,
672 const char *,buf,
673 int,len,
674 int,flags,
675 const struct sockaddr *,to,
676 int,tolen)
677{
678 return(sendto(s,
679 buf,
680 len,
681 flags,
682 to,
683 tolen));
684}
685
686
687/*****************************************************************************
688 * Name :
689 * Purpose :
690 * Parameters:
691 * Variables :
692 * Result :
693 * Remark :
694 * Status : UNTESTED STUB
695 *
696 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
697 *****************************************************************************/
698
699ODINFUNCTION5(int,OS2setsockopt,
700 SOCKET,s,
701 int,level,
702 int,optname,
703 const char *,optval,
704 int,optlen)
705{
706 struct Wlinger *yy;
707 struct linger xx;
708 int rc;
709
710 if(level == SOL_SOCKET &&
711 optname == SO_LINGER)
712 {
713 yy = (struct Wlinger *)optval;
714 xx.l_onoff = (int)yy->l_onoff;
715 xx.l_linger = (int)yy->l_linger;
716
717 rc = setsockopt(s,level,optname,(char *)&xx,optlen);
718 }
719 else
720 rc = setsockopt(s,level,optname,(char *)optval,optlen);
721
722 if (rc == SOCKET_ERROR)
723 //OS2WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
724 OS2WSASetLastError(WSAEINVAL);
725 else
726 OS2WSASetLastError(ERROR_SUCCESS);
727
728 return rc;
729}
730
731
732/*****************************************************************************
733 * Name :
734 * Purpose :
735 * Parameters:
736 * Variables :
737 * Result :
738 * Remark :
739 * Status : UNTESTED STUB
740 *
741 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
742 *****************************************************************************/
743
744ODINFUNCTION2(int,OS2shutdown,
745 SOCKET,s,
746 int,how)
747{
748 return(shutdown(s,
749 how));
750}
751
752
753/*****************************************************************************
754 * Name :
755 * Purpose :
756 * Parameters:
757 * Variables :
758 * Result :
759 * Remark :
760 * Status : UNTESTED STUB
761 *
762 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
763 *****************************************************************************/
764
765ODINFUNCTION3(SOCKET,OS2socket,
766 int,af,
767 int,type,
768 int,protocol)
769{
770 return(socket(af,
771 type,
772 protocol));
773}
774
775
776/* Database function prototypes */
777
778/*****************************************************************************
779 * Name :
780 * Purpose :
781 * Parameters:
782 * Variables :
783 * Result :
784 * Remark :
785 * Status : UNTESTED STUB
786 *
787 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
788 *****************************************************************************/
789
790ODINFUNCTION3(struct Whostent *,OS2gethostbyaddr,
791 const char *,addr,
792 int,len,
793 int,type)
794{
795 WHOSTENT *yy;
796 struct hostent *xx;
797 PWSOCKTHREADDATA pwstd;
798
799 xx = gethostbyaddr((char *)addr,len,type);
800 //PH: we assume PMWSOCK sets WSASetLastError correctly!
801
802 if(xx == NULL)
803 return (WHOSTENT *)NULL;
804
805 // access current thread wsock data block
806 pwstd = iQueryWsockThreadData();
807
808 pwstd->whsnt.h_name = xx->h_name;
809 pwstd->whsnt.h_aliases = xx->h_aliases;
810 pwstd->whsnt.h_addrtype = (short)xx->h_addrtype;
811 pwstd->whsnt.h_length = (short)xx->h_length;
812 pwstd->whsnt.h_addr_list = xx->h_addr_list;
813
814 return &pwstd->whsnt;
815}
816
817
818/*****************************************************************************
819 * Name :
820 * Purpose :
821 * Parameters:
822 * Variables :
823 * Result :
824 * Remark :
825 * Status : UNTESTED STUB
826 *
827 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
828 *****************************************************************************/
829
830ODINFUNCTION1(struct Whostent *,OS2gethostbyname,
831 const char *,name)
832{
833 WHOSTENT *yy;
834 struct hostent *xx;
835 PWSOCKTHREADDATA pwstd;
836
837
838 xx = gethostbyname((char *)name);
839 //PH: we assume PMWSOCK sets WSASetLastError correctly!
840
841 if(xx == NULL)
842 return (WHOSTENT *)NULL;
843
844 // access current thread wsock data block
845 pwstd = iQueryWsockThreadData();
846
847 pwstd->whsnt.h_name = xx->h_name;
848 pwstd->whsnt.h_aliases = xx->h_aliases;
849 pwstd->whsnt.h_addrtype = (short)xx->h_addrtype;
850 pwstd->whsnt.h_length = (short)xx->h_length;
851 pwstd->whsnt.h_addr_list = xx->h_addr_list;
852
853 return &pwstd->whsnt;
854}
855
856
857/*****************************************************************************
858 * Name :
859 * Purpose :
860 * Parameters:
861 * Variables :
862 * Result :
863 * Remark :
864 * Status : UNTESTED STUB
865 *
866 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
867 *****************************************************************************/
868
869ODINFUNCTION2(int,OS2gethostname,
870 char *,name,
871 int,namelen)
872{
873 //PH: we assume PMWSOCK sets WSASetLastError correctly!
874 return(gethostname(name,
875 namelen));
876}
877
878
879/*****************************************************************************
880 * Name :
881 * Purpose :
882 * Parameters:
883 * Variables :
884 * Result :
885 * Remark :
886 * Status : UNTESTED STUB
887 *
888 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
889 *****************************************************************************/
890
891ODINFUNCTION2(struct Wservent *,OS2getservbyport,
892 int,port,
893 const char *, proto)
894{
895 struct servent *xx;
896 PWSOCKTHREADDATA pwstd;
897
898 //PH: we assume PMWSOCK sets WSASetLastError correctly!
899 xx = getservbyport(port,(char *)proto);
900
901 if(xx == NULL)
902 return (WSERVENT *)NULL;
903
904 // access current thread wsock data block
905 pwstd = iQueryWsockThreadData();
906
907 pwstd->wsvnt.s_name = xx->s_name;
908 pwstd->wsvnt.s_aliases = xx->s_aliases;
909 pwstd->wsvnt.s_port = (short)xx->s_port;
910 pwstd->wsvnt.s_proto = xx->s_proto;
911
912 return &pwstd->wsvnt;
913}
914
915
916/*****************************************************************************
917 * Name :
918 * Purpose :
919 * Parameters:
920 * Variables :
921 * Result :
922 * Remark :
923 * Status : UNTESTED STUB
924 *
925 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
926 *****************************************************************************/
927
928ODINFUNCTION2(struct Wservent *,OS2getservbyname,
929 const char *,name,
930 const char *,proto)
931{
932 WSERVENT *yy;
933 struct servent *xx;
934 PWSOCKTHREADDATA pwstd;
935
936
937 //PH: we assume PMWSOCK sets WSASetLastError correctly!
938 xx = getservbyname((char *)name,(char *)proto);
939
940 if(xx == NULL)
941 return (WSERVENT *)NULL;
942
943 // access current thread wsock data block
944 pwstd = iQueryWsockThreadData();
945
946 pwstd->wsvnt.s_name = xx->s_name;
947 pwstd->wsvnt.s_aliases = xx->s_aliases;
948 pwstd->wsvnt.s_port = (short)xx->s_port;
949 pwstd->wsvnt.s_proto = xx->s_proto;
950
951 return &pwstd->wsvnt;
952}
953
954
955/*****************************************************************************
956 * Name :
957 * Purpose :
958 * Parameters:
959 * Variables :
960 * Result :
961 * Remark :
962 * Status : UNTESTED STUB
963 *
964 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
965 *****************************************************************************/
966
967ODINFUNCTION1(struct Wprotoent *,OS2getprotobynumber,
968 int,proto)
969{
970 struct protoent *xx;
971 PWSOCKTHREADDATA pwstd;
972
973 //PH: we assume PMWSOCK sets WSASetLastError correctly!
974 xx = getprotobynumber(proto);
975
976 if(xx == NULL)
977 return (WPROTOENT *)NULL;
978
979 // access current thread wsock data block
980 pwstd = iQueryWsockThreadData();
981
982 pwstd->wptnt.p_name = xx->p_name;
983 pwstd->wptnt.p_aliases = xx->p_aliases;
984 pwstd->wptnt.p_proto = (short)xx->p_proto;
985
986 return &pwstd->wptnt;
987}
988
989
990/*****************************************************************************
991 * Name :
992 * Purpose :
993 * Parameters:
994 * Variables :
995 * Result :
996 * Remark :
997 * Status : UNTESTED STUB
998 *
999 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1000 *****************************************************************************/
1001
1002ODINFUNCTION1(struct Wprotoent *,OS2getprotobyname,
1003 const char *,name)
1004{
1005 struct protoent *xx;
1006 PWSOCKTHREADDATA pwstd;
1007
1008 //PH: we assume PMWSOCK sets WSASetLastError correctly!
1009 xx = getprotobyname((char *)name);
1010
1011 if(xx == NULL)
1012 return (WPROTOENT *)NULL;
1013
1014 // access current thread wsock data block
1015 pwstd = iQueryWsockThreadData();
1016
1017 pwstd->wptnt.p_name = xx->p_name;
1018 pwstd->wptnt.p_aliases = xx->p_aliases;
1019 pwstd->wptnt.p_proto = (short)xx->p_proto;
1020
1021 return &pwstd->wptnt;
1022}
1023
1024
1025
1026/* Microsoft Windows Extension function prototypes */
1027
1028/*****************************************************************************
1029 * Name :
1030 * Purpose :
1031 * Parameters:
1032 * Variables :
1033 * Result :
1034 * Remark :
1035 * Status : UNTESTED STUB
1036 *
1037 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1038 *****************************************************************************/
1039
1040ODINFUNCTION2(int,OS2WSAStartup,
1041 USHORT,wVersionRequired,
1042 LPWSADATA,lpWSAData)
1043{
1044 return(WSAStartup(wVersionRequired,
1045 lpWSAData));
1046}
1047
1048
1049/*****************************************************************************
1050 * Name :
1051 * Purpose :
1052 * Parameters:
1053 * Variables :
1054 * Result :
1055 * Remark :
1056 * Status : UNTESTED STUB
1057 *
1058 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1059 *****************************************************************************/
1060
1061ODINFUNCTION0(int,OS2WSACleanup)
1062{
1063 return(WSACleanup());
1064}
1065
1066
1067/*****************************************************************************
1068 * Name :
1069 * Purpose :
1070 * Parameters:
1071 * Variables :
1072 * Result :
1073 * Remark :
1074 * Status : UNTESTED STUB
1075 *
1076 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1077 *****************************************************************************/
1078
1079ODINFUNCTION0(BOOL,OS2WSAIsBlocking)
1080{
1081 return WSAIsBlocking();
1082}
1083
1084
1085/*****************************************************************************
1086 * Name :
1087 * Purpose :
1088 * Parameters:
1089 * Variables :
1090 * Result :
1091 * Remark :
1092 * Status : UNTESTED STUB
1093 *
1094 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1095 *****************************************************************************/
1096
1097ODINFUNCTION0(int,OS2WSAUnhookBlockingHook)
1098{
1099 return WSAUnhookBlockingHook();
1100}
1101
1102
1103/*****************************************************************************
1104 * Name :
1105 * Purpose :
1106 * Parameters:
1107 * Variables :
1108 * Result :
1109 * Remark :
1110 * Status : UNTESTED STUB
1111 *
1112 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1113 *****************************************************************************/
1114
1115ODINFUNCTION1(PFN,OS2WSASetBlockingHook,
1116 PFN,lpBlockFunc)
1117{
1118 return(WSASetBlockingHook(lpBlockFunc));
1119}
1120
1121
1122/*****************************************************************************
1123 * Name :
1124 * Purpose :
1125 * Parameters:
1126 * Variables :
1127 * Result :
1128 * Remark :
1129 * Status : UNTESTED STUB
1130 *
1131 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1132 *****************************************************************************/
1133
1134ODINFUNCTION0(int,OS2WSACancelBlockingCall)
1135{
1136 return(WSACancelBlockingCall());
1137}
1138
1139
1140/*****************************************************************************
1141 * Name :
1142 * Purpose :
1143 * Parameters:
1144 * Variables :
1145 * Result :
1146 * Remark :
1147 * Status : UNTESTED STUB
1148 *
1149 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1150 *****************************************************************************/
1151
1152ODINFUNCTION6(LHANDLE,OS2WSAAsyncGetServByName,
1153 HWND,hWnd,
1154 u_int,wMsg,
1155 const char *,name,
1156 const char *,proto,
1157 char *,buf,
1158 int,buflen)
1159{
1160 return(WSAAsyncGetServByName(hWnd,
1161 wMsg,
1162 name,
1163 proto,
1164 buf,
1165 buflen));
1166}
1167
1168
1169/*****************************************************************************
1170 * Name :
1171 * Purpose :
1172 * Parameters:
1173 * Variables :
1174 * Result :
1175 * Remark :
1176 * Status : UNTESTED STUB
1177 *
1178 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1179 *****************************************************************************/
1180
1181ODINFUNCTION6(LHANDLE,OS2WSAAsyncGetServByPort,
1182 HWND,hWnd,
1183 u_int,wMsg,
1184 int,port,
1185 const char *,proto,
1186 char *,buf,
1187 int,buflen)
1188{
1189 return(WSAAsyncGetServByPort(hWnd,
1190 wMsg,
1191 port,
1192 proto,
1193 buf,
1194 buflen));
1195}
1196
1197
1198/*****************************************************************************
1199 * Name :
1200 * Purpose :
1201 * Parameters:
1202 * Variables :
1203 * Result :
1204 * Remark :
1205 * Status : UNTESTED STUB
1206 *
1207 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1208 *****************************************************************************/
1209
1210ODINFUNCTION5(LHANDLE,OS2WSAAsyncGetProtoByName,
1211 HWND,hWnd,
1212 u_int,wMsg,
1213 const char *,name,
1214 char *,buf,
1215 int,buflen)
1216{
1217 return(WSAAsyncGetProtoByName(hWnd,
1218 wMsg,
1219 name,
1220 buf,
1221 buflen));
1222}
1223
1224
1225/*****************************************************************************
1226 * Name :
1227 * Purpose :
1228 * Parameters:
1229 * Variables :
1230 * Result :
1231 * Remark :
1232 * Status : UNTESTED STUB
1233 *
1234 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1235 *****************************************************************************/
1236
1237ODINFUNCTION5(LHANDLE,OS2WSAAsyncGetProtoByNumber,
1238 HWND,hWnd,
1239 u_int,wMsg,
1240 int,number,
1241 char *,buf,
1242 int,buflen)
1243{
1244 return(WSAAsyncGetProtoByNumber(hWnd,
1245 wMsg,
1246 number,
1247 buf,
1248 buflen));
1249}
1250
1251
1252/*****************************************************************************
1253 * Name :
1254 * Purpose :
1255 * Parameters:
1256 * Variables :
1257 * Result :
1258 * Remark :
1259 * Status : UNTESTED STUB
1260 *
1261 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1262 *****************************************************************************/
1263
1264ODINFUNCTION5(LHANDLE,OS2WSAAsyncGetHostByName,
1265 HWND,hWnd,
1266 u_int,wMsg,
1267 const char *,name,
1268 char *,buf,
1269 int,buflen)
1270{
1271 int rc;
1272 HWND hwndOS2 = Win32ToOS2Handle(hWnd);
1273 ULONG ulNewID;
1274
1275 if (hwndRelay == NULL) // already initialized ?
1276 hwndRelay = RelayInitialize(hwndOS2);
1277
1278 // TODO: Is this the original behaviour?
1279 if ((name == NULL) || (buf == NULL))
1280 {
1281 // remove entry from list
1282 RelayFreeByHwnd(hWnd);
1283 }
1284 else
1285 // add entry to list, we need to store both our temp buffer and the apps buffer
1286 ulNewID = RelayAlloc(hWnd, wMsg, ASYNCREQUEST_GETHOSTBYNAME, buf);
1287
1288 // call pmwsock function, will fill our temp buffer
1289 rc = WSAAsyncGetHostByName(hwndRelay,
1290 ulNewID,
1291 name,
1292 buf,
1293 buflen);
1294
1295 return rc;
1296}
1297
1298
1299/*****************************************************************************
1300 * Name :
1301 * Purpose :
1302 * Parameters:
1303 * Variables :
1304 * Result :
1305 * Remark :
1306 * Status : UNTESTED STUB
1307 *
1308 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1309 *****************************************************************************/
1310
1311ODINFUNCTION7(LHANDLE,OS2WSAAsyncGetHostByAddr,
1312 HWND,hWnd,
1313 u_int,wMsg,
1314 const char *,addr,
1315 int,len,
1316 int,type,
1317 char *,buf,
1318 int,buflen)
1319{
1320 return(WSAAsyncGetHostByAddr(hWnd,
1321 wMsg,
1322 addr,
1323 len,
1324 type,
1325 buf,
1326 buflen));
1327}
1328
1329
1330/*****************************************************************************
1331 * Name :
1332 * Purpose :
1333 * Parameters:
1334 * Variables :
1335 * Result :
1336 * Remark :
1337 * Status : UNTESTED STUB
1338 *
1339 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1340 *****************************************************************************/
1341
1342ODINFUNCTION1(int,OS2WSACancelAsyncRequest,
1343 LHANDLE,hAsyncTaskHandle)
1344{
1345 return(WSACancelAsyncRequest(hAsyncTaskHandle));
1346}
1347
1348
1349/*****************************************************************************
1350 * Name :
1351 * Purpose :
1352 * Parameters:
1353 * Variables :
1354 * Result :
1355 * Remark :
1356 * Status : UNTESTED STUB
1357 *
1358 * Author : Patrick Haller [Thu, 1999/11/25 23:00]
1359 *****************************************************************************/
1360
1361ODINFUNCTION4(int,OS2WSAAsyncSelect,
1362 SOCKET,s,
1363 HWND,hWnd,
1364 u_int,wMsg,
1365 long,lEvent)
1366{
1367 int rc;
1368// int iError;
1369 HWND hwndOS2 = Win32ToOS2Handle(hWnd);
1370 ULONG ulNewID;
1371
1372 if (hwndRelay == NULL) // already initialized ?
1373 hwndRelay = RelayInitialize(hwndOS2);
1374
1375 /* @@@PH: our source window doesn't seem to have an anchor block.
1376 Docs suggest we've missed to call WinInitialize on the
1377 caller thread.
1378
1379 Cause however is the Open32 handle is (of course!) invalid
1380 in plain PM Window Manager! -> use DAPWSOCK
1381
1382 Unfortunately, DAPWSOCK calls WinQueryAnchorBlock(hOpen32), too.
1383 So, we're stuck until I resolve hWnd to it's valid PM
1384 counterpart.
1385
1386 new problem: we've ultimately got to use PostMessageA instead
1387 anything else. => create invisible msg relay window:
1388 - hMsg = registerMessage(hWnd, wMsg)
1389 - call WSAAsyncSelect with object window handle
1390 - overwrite hWnd relay for "same handles"
1391 */
1392
1393 // add event to list or remove any list entry in case of WSAAsyncSelect(hwnd,0,0)
1394 if ( (wMsg == 0) && (lEvent == 0) )
1395 {
1396 // remove entry from list
1397 RelayFreeByHwnd(hWnd);
1398 }
1399 else
1400 // add entry to list
1401 ulNewID = RelayAlloc(hWnd, wMsg, ASYNCREQUEST_SELECT);
1402
1403 rc = WSAAsyncSelect(s,
1404 hwndRelay,
1405 ulNewID,
1406 lEvent);
1407
1408// iError = WSAGetLastError();
1409// dprintf(("res=%d, err=%d\n",
1410// rc,
1411// iError));
1412 return (rc);
1413}
Note: See TracBrowser for help on using the repository browser.