Context Navigation

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

Visit:

Last change on this file since 1874 was 1851, checked in by phaller, 26 years ago
Fix: debug
File size: 31.6 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: