Context Navigation

source: trunk/src/wsock32/wsock32.cpp@ 1384

Visit:

Last change on this file since 1384 was 1384, checked in by phaller, 26 years ago
Fix: socket fix
File size: 35.3 KB

Line
1	/* $Id: wsock32.cpp,v 1.8 1999-10-20 20:10:58 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	* 1998/08/25 Vince Vielhaber
10	*
11	* @(#) wsock32.c 1.0.0 1998/08/25 VV initial release
12	* 1.0.1 1999/04/27 VV cleanup and implement select.
13	*
14	*/
15
16
17	/*****************************************************************************
18	* Includes *
19	*****************************************************************************/
20
21
22	#define INCL_DOSPROCESS /* Process and thread values */
23	#define INCL_DOSFILEMGR /* for DosRead and DosWrite */
24	#define INCL_DOSQUEUES /* for unnamed pipes */
25	#define INCL_DOSERRORS /* DOS error values */
26	#define INCL_WINMESSAGEMGR /* Window Message Functions */
27	#define INCL_WINMENUS /* Window Menu Functions */
28
29	/* this is for IBM TCP/IP 5.0 headers as present in the current Warp 4 toolkit */
30	#define TCPV40HDRS 1
31
32	#define VV_BSD_SELECT /* undefine this if it interferes with other routines */
33
34	#ifdef VV_BSD_SELECT
35	# define BSD_SELECT
36	#endif
37
38	#include <os2wrap.h> //Odin32 OS/2 api wrappers
39	#include <stdio.h>
40	#include <stdlib.h>
41	#include <stddef.h>
42	#include <string.h>
43	#include <ctype.h>
44	#include <types.h>
45	#include <odinwrap.h>
46	#include <netdb.h>
47	#include <sys/socket.h>
48	#include <sys/ioctl.h>
49	#include <netinet/in.h>
50
51	#ifdef VV_BSD_SELECT
52	# include <sys/select.h>
53	#endif
54
55	#include <sys/time.h>
56	#include <win32type.h>
57	#include "wsock32const.h"
58	#include "wsock32.h"
59	#include "misc.h"
60
61
62	ODINDEBUGCHANNEL(WSOCK32-WSOCK32)
63
64
65	/*****************************************************************************
66	* Defines *
67	*****************************************************************************/
68
69	#define GETSERVBYNAME 1
70	#define GETSERVBYPORT 2
71	#define GETPROTOBYNAME 3
72	#define GETPROTOBYNUMBER 4
73	#define GETHOSTBYNAME 5
74	#define GETHOSTBYADDR 6
75
76	#define BLOCKING 0
77	#define NONBLOCKING 1
78
79	#ifdef FD_CLR
80	#undef FD_CLR
81	#define FD_CLR(x,y) WFD_CLR(x,y)
82	#undef FD_SET
83	#define FD_SET(x,y) WFD_SET(x,y)
84	#undef FD_ZERO
85	#define FD_ZERO(x) WFD_ZERO(x)
86	#undef FD_ISSET
87	#define FD_ISSET(x,y) WFD_SET(x,y)
88	#endif
89
90
91	/*****************************************************************************
92	* Structures *
93	*****************************************************************************/
94
95	typedef struct WSAStruct
96	{
97	int CallingWhat;
98	HWND hw;
99	u_int msg;
100	char *carg1;
101	char *carg2;
102	int iarg1;
103	int iarg2;
104	char *buf;
105	int buflen;
106	} WSAStruct;
107
108	typedef struct PipeStruct
109	{
110	AsyncStatus as;
111	int MsgLoop;
112	HFILE rcv;
113	HFILE snd;
114	} PipeStruct;
115
116	typedef struct sockaddr* PSOCKADDR;
117
118	//typedef struct _TRANSMIT_FILE_BUFFERS {
119	// PVOID Head;
120	// DWORD HeadLength;
121	// PVOID Tail;
122	// DWORD TailLength;
123	//} TRANSMIT_FILE_BUFFERS, PTRANSMIT_FILE_BUFFERS, LPTRANSMIT_FILE_BUFFERS;
124	//
125	//BOOL, OS2TransmitFile, //, IN, SOCKET, hSocket, //, IN, HANDLE, hFile, //, IN, DWORD, nNumberOfBytesToWrite, //, IN DWORD nNumberOfBytesPerSend,
126	// IN LPOVERLAPPED lpOverlapped,
127	// IN LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers,
128	// IN DWORD dwReserved)
129	//{
130	// return FALSE;
131	//}
132
133
134	/*****************************************************************************
135	* Prototypes *
136	*****************************************************************************/
137
138	void _System AsyncLoop (ULONG);
139	void CheckThreads (AsyncStatus *);
140	void NotifyApp (int,AsyncStatus *);
141	int Notify (AsyncStatus *,int);
142	int NotifyWSA (HWND hw,u_int msg,UINT wp,LONG lp);
143	void _System WSAFunct (ULONG); // for the wsa database calls
144	void SetErrForDatabaseCalls(void);
145
146
147	/*****************************************************************************
148	* Local variables *
149	*****************************************************************************/
150
151	static WHOSTENT whsnt;
152	static WSERVENT wsvnt;
153	static WPROTOENT wptnt;
154	size_t nSize;
155	int *pArray;
156
157	int MsgSent;
158	int LocalErrorNumber = 0;
159
160	TID tidAsyncLoop = 0; /* ID of AsyncSelect (AsyncLoop) thread */
161
162	PipeStruct PS;
163
164	AsyncStatus *TopASY = 0;
165
166
167	/*
168	typedef struct AsyncStatus {
169	HWND hwnd; // owner's hwindow
170	u_int msg; // message to send when event occurs
171	long event; // event that may occur
172	SOCKET socket; // the socket
173	int status; // blocking yes/no
174	TID threadID; // Thread ID for async
175	int MsgStat; // has message been sent yet?
176	struct AsyncStatus *Next; // pointer to next AsyncStatus in the list
177	struct AsyncStatus *Prev; // pointer to previous AsyncStatus in the list
178	} AsyncStatus;
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 [Tue, 1998/06/16 23:00]
192	*****************************************************************************/
193
194	void _System AsyncLoop(ULONG ASP)
195	{
196	int socks[1],r,w,e,rc,ii;
197	AsyncStatus *as;
198
199	as = (AsyncStatus *)ASP;
200
201	r = w = e = 0;
202	if(as->event & FD_READ) r = 1;
203	if(as->event & FD_WRITE) w = 1;
204	if(as->event & FD_OOB) e = 1;
205
206	socks[0] = (int)as->socket;
207
208	if((r+w+e) == 0)
209	{
210	dprintf(("WSOCK32: Turning off async\n"));
211
212	ii = 0;
213	rc = ioctl(socks[0],FIONBIO,(char *)&ii,sizeof(ii));
214	as->threadID = 0;
215	as->hwnd = 0;
216	as->msg = 0;
217	as->event = 0;
218	as->status = BLOCKING;
219	return;
220	} // end if
221	else
222	{
223	dprintf(("WSOCK32: Setting up non-blocking sockets\n"));
224	ii = 1;
225	rc = ioctl(socks[0],FIONBIO,(char *)&ii,sizeof(ii));
226	if(rc != 0)
227	{
228	dprintf(("WSOCK32: ioctl failed trying to non-block.\n"));
229	return;
230	}
231	as->status = NONBLOCKING;
232	} // end else
233
234	do
235	{
236	rc = select(socks[0],(fd_set*)&r,0,0,0); // ioctl may be better for this.
237	if(rc > 0)
238	{
239	rc = ioctl(socks[0],FIONREAD,(char *)&ii,sizeof(ii));
240	if(rc == 0 && ii > 0)
241	{
242	/* data is ready */
243	NotifyApp(FD_READ,as);
244	}
245	}
246
247	if(rc < 0)
248	{
249	rc = sock_errno();
250	/* something ain't right */
251	if(rc == 10038)
252	{ // Connection closed
253	NotifyApp(FD_CLOSE,as);
254	DosSleep(500);
255	return;
256	}
257
258	dprintf(("WSOCK32: Select error: %d\n",
259	rc));
260	} // end if
261	DosSleep(50);
262	}
263	while(1);
264	}
265
266
267	/*****************************************************************************
268	* Name :
269	* Purpose :
270	* Parameters:
271	* Variables :
272	* Result :
273	* Remark :
274	* Status : UNTESTED STUB
275	*
276	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
277	*****************************************************************************/
278
279	void CheckThreads(AsyncStatus *as)
280	{
281	AsyncStatus *asy;
282
283	if(as != NULL)
284	if(as->threadID != 0) DosKillThread(as->threadID);
285
286	for(asy = TopASY; asy; asy = asy->Next)
287	if(asy->threadID != 0)
288	DosKillThread(asy->threadID);
289	}
290
291
292	/*****************************************************************************
293	* Name :
294	* Purpose :
295	* Parameters:
296	* Variables :
297	* Result :
298	* Remark :
299	* Status : UNTESTED STUB
300	*
301	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
302	*****************************************************************************/
303
304	void NotifyApp(int xx,AsyncStatus *as)
305	{
306	BOOL fResult; /* message-posted indicator */
307	unsigned long ii;
308
309
310	//#ifdef DEBUG
311	// WriteLog("WSOCK32: Notifying the caller. rc = %d\n",xx);
312	//#endif
313
314	if(as->MsgStat == 0)
315	{
316	fResult = Notify(as,xx);
317	dprintf(("WSOCK32: Notify returns: %d\n",
318	fResult));
319	} // end if
320
321	if(as->MsgStat == 2)
322	as->MsgStat = 0;
323	else
324	as->MsgStat = 1;
325	}
326
327
328	/*****************************************************************************
329	* Name :
330	* Purpose :
331	* Parameters:
332	* Variables :
333	* Result :
334	* Remark :
335	* Status : UNTESTED STUB
336	*
337	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
338	*****************************************************************************/
339
340	void _System WSAFunct(ULONG xx)
341	{
342	WSAStruct *wsa;
343	WSERVENT *ooo;
344	char *yy;
345	int ii;
346	size_t ss;
347	UINT wp;
348	LONG lp;
349	int id = *_threadid;
350
351	wsa = (WSAStruct *)xx;
352
353	dprintf(("WSOCK32: WSAFunct: xx = %p, hwnd = %p\n",
354	xx,
355	wsa->hw));
356
357	dprintf(("WSOCK32: WSAFunct info carg1 = %s, carg2 = %s\n",
358	wsa->carg1,
359	wsa->carg2));
360
361	dprintf(("WSOCK32: WSAFunct info buf = %p, %d\n",
362	wsa->buf,
363	wsa->buflen));
364
365	switch (wsa->CallingWhat)
366	{
367	case GETSERVBYNAME:
368	yy = (char *)OS2getservbyname(wsa->carg1,wsa->carg2);
369	ss = sizeof(WSERVENT);
370	break;
371	case GETSERVBYPORT:
372	yy = (char *)OS2getservbyport(wsa->iarg1,wsa->carg1);
373	break;
374	case GETPROTOBYNUMBER:
375	yy = (char *)OS2getprotobynumber(wsa->iarg1);
376	break;
377	case GETPROTOBYNAME:
378	yy = (char *)OS2getprotobyname(wsa->carg1);
379	break;
380	case GETHOSTBYNAME:
381	yy = (char *)OS2gethostbyname(wsa->carg1);
382	break;
383	case GETHOSTBYADDR:
384	yy = (char *)OS2gethostbyaddr(wsa->carg1,wsa->iarg1,wsa->iarg2);
385	break;
386	default:
387	yy = (char *)NULL;
388	OS2WSASetLastError(-5000);
389	break;
390	} // end switch
391
392	#ifdef DEBUG
393	if(yy)
394	{
395	ooo = (WSERVENT *)yy;
396	dprintf(("WSOCK32: WSAFunct service name = %s, port = %d\n",
397	ooo->s_name,
398	(int)ooo->s_port));
399	}
400	#endif
401
402	wp = id;
403
404	if(yy == (char *)NULL)
405	{
406	dprintf(("WSOCK32: WSAFunct error carg1 = %s, carg2 = %s\n",
407	wsa->carg1,
408	wsa->carg2));
409
410	ii = OS2WSAGetLastError();
411	lp = OS2WSAMAKEASYNCREPLY(0,ii);
412	} // end if
413	else
414	{
415	if(wsa->buflen < ss)
416	ii = WSAENOBUFS;
417	else
418	ii = 0;
419
420	lp = OS2WSAMAKEASYNCREPLY(ss,ii);
421	if(ii == 0)
422	memmove(wsa->buf,yy,ss);
423	}
424
425	do
426	{
427	if(WinQueryAnchorBlock(wsa->hw))
428	ii = NotifyWSA(wsa->hw,wsa->msg,wp,lp);
429	} while(ii != TRUE);
430
431	free(wsa);
432	}
433
434
435	/*****************************************************************************
436	* Name :
437	* Purpose :
438	* Parameters:
439	* Variables :
440	* Result :
441	* Remark :
442	* Status : UNTESTED STUB
443	*
444	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
445	*****************************************************************************/
446
447	void SetErrForDatabaseCalls(void)
448	{
449	switch(h_errno)
450	{
451	case 1:
452	OS2WSASetLastError(11001); // host not found
453	break;
454	case 2:
455	OS2WSASetLastError(11002); // try again later
456	break;
457	case 3:
458	OS2WSASetLastError(11003); // No recovery
459	break;
460	case 4:
461	OS2WSASetLastError(11004); // No address or no data
462	break;
463	default:
464	OS2WSASetLastError(0); // unknown error and should never get here
465	dprintf(("WSOCK32: Unknown error condition: %d\n",
466	h_errno));
467	break;
468	}
469	}
470
471
472	/*****************************************************************************
473	* Name :
474	* Purpose :
475	* Parameters:
476	* Variables :
477	* Result :
478	* Remark :
479	* Status : UNTESTED STUB
480	*
481	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
482	*****************************************************************************/
483
484	AsyncStatus * FindASY(SOCKET s)
485	{
486	AsyncStatus *as;
487
488	for(as = TopASY; as; as = as->Next)
489	if(as->socket == s)
490	return as;
491
492	return NULL;
493	}
494
495
496	/*****************************************************************************
497	* Name :
498	* Purpose :
499	* Parameters:
500	* Variables :
501	* Result :
502	* Remark :
503	* Status : UNTESTED STUB
504	*
505	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
506	*****************************************************************************/
507
508	ODINFUNCTION2(int, OS2__WSAFDIsSet, SOCKET, fd,
509	Wfd_set FAR*, set)
510	{
511	int i = set->fd_count;
512
513	while (i--)
514	if (set->fd_array[i] == fd)
515	return 1;
516
517	return 0;
518	}
519
520
521	/*****************************************************************************
522	* Name :
523	* Purpose :
524	* Parameters:
525	* Variables :
526	* Result :
527	* Remark :
528	* Status : UNTESTED STUB
529	*
530	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
531	*****************************************************************************/
532
533	ODINFUNCTION3(SOCKET,OS2accept,SOCKET, s,
534	PSOCKADDR, addr,
535	int*, addrlen)
536	{
537	return accept(s,addr,addrlen);
538	}
539
540
541	/*****************************************************************************
542	* Name :
543	* Purpose :
544	* Parameters:
545	* Variables :
546	* Result :
547	* Remark :
548	* Status : UNTESTED STUB
549	*
550	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
551	*****************************************************************************/
552
553	ODINFUNCTION3(int,OS2bind,SOCKET, s,
554	const struct sockaddr *, addr,
555	int, namelen)
556	{
557	return bind(s,(PSOCKADDR)addr,namelen);
558	}
559
560
561	/*****************************************************************************
562	* Name :
563	* Purpose :
564	* Parameters:
565	* Variables :
566	* Result :
567	* Remark :
568	* Status : UNTESTED STUB
569	*
570	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
571	*****************************************************************************/
572
573	ODINFUNCTION1(int,OS2closesocket,SOCKET,s)
574	{
575	AsyncStatus *as;
576
577	as = FindASY(s);
578	if(as == NULL)
579	{
580	LocalErrorNumber = 10038;
581	return -1;
582	}
583
584	CheckThreads(as);
585
586	if(as->Prev && as->Next)
587	as->Prev->Prev = as->Next->Next; // I SURE HOPE THIS IS RIGHT!!!!!!!!
588
589	free(as);
590
591	return soclose((int)s);
592	}
593
594
595	/*****************************************************************************
596	* Name :
597	* Purpose :
598	* Parameters:
599	* Variables :
600	* Result :
601	* Remark :
602	* Status : UNTESTED STUB
603	*
604	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
605	*****************************************************************************/
606
607	ODINFUNCTION3(int,OS2connect,SOCKET, s,
608	const struct sockaddr*, name,
609	int, namelen)
610	{
611	return connect(s,
612	(PSOCKADDR)name,
613	namelen);
614	}
615
616
617	/*****************************************************************************
618	* Name :
619	* Purpose :
620	* Parameters:
621	* Variables :
622	* Result :
623	* Remark :
624	* Status : UNTESTED STUB
625	*
626	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
627	*****************************************************************************/
628
629	ODINFUNCTION3(int,OS2ioctlsocket,SOCKET, s,
630	long, cmd,
631	u_long*, argp)
632	{
633	return ioctl(s, cmd, (char *)argp, 4);
634	}
635
636
637	/*****************************************************************************
638	* Name :
639	* Purpose :
640	* Parameters:
641	* Variables :
642	* Result :
643	* Remark :
644	* Status : UNTESTED STUB
645	*
646	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
647	*****************************************************************************/
648
649	ODINFUNCTION3(int,OS2getpeername,SOCKET, s,
650	PSOCKADDR,name,
651	int*, namelen)
652	{
653	return getpeername(s,name,namelen);
654	}
655
656
657	/*****************************************************************************
658	* Name :
659	* Purpose :
660	* Parameters:
661	* Variables :
662	* Result :
663	* Remark :
664	* Status : UNTESTED STUB
665	*
666	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
667	*****************************************************************************/
668
669	ODINFUNCTION3(int,OS2getsockname,SOCKET, s,
670	PSOCKADDR,name,
671	int*, namelen)
672	{
673	return getsockname(s,name,namelen);
674	}
675
676
677	/*****************************************************************************
678	* Name :
679	* Purpose :
680	* Parameters:
681	* Variables :
682	* Result :
683	* Remark :
684	* Status : UNTESTED STUB
685	*
686	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
687	*****************************************************************************/
688
689	ODINFUNCTION5(int,OS2getsockopt,SOCKET,s,
690	int, level,
691	int, optname,
692	char*, optval,
693	int*, optlen)
694	{
695	return getsockopt(s,level,optname,optval,optlen);
696	}
697
698
699	/*****************************************************************************
700	* Name :
701	* Purpose :
702	* Parameters:
703	* Variables :
704	* Result :
705	* Remark :
706	* Status : UNTESTED STUB
707	*
708	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
709	*****************************************************************************/
710
711	ODINFUNCTION1(u_long,OS2htonl,u_long,hostlong)
712	{
713	return htonl(hostlong);
714	}
715
716
717	/*****************************************************************************
718	* Name :
719	* Purpose :
720	* Parameters:
721	* Variables :
722	* Result :
723	* Remark :
724	* Status : UNTESTED STUB
725	*
726	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
727	*****************************************************************************/
728
729	ODINFUNCTION1(u_short,OS2htons,u_short,hostshort)
730	{
731	return htons(hostshort);
732	}
733
734
735	/*****************************************************************************
736	* Name :
737	* Purpose :
738	* Parameters:
739	* Variables :
740	* Result :
741	* Remark :
742	* Status : UNTESTED STUB
743	*
744	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
745	*****************************************************************************/
746
747	ODINFUNCTION1(u_long,OS2inet_addr,const char*, cp)
748	{
749	return inet_addr((char *)cp);
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 [Tue, 1998/06/16 23:00]
763	*****************************************************************************/
764
765	ODINFUNCTION1(char*,OS2inet_ntoa,struct in_addr,in)
766	{
767	return inet_ntoa(in);
768	}
769
770
771	/*****************************************************************************
772	* Name :
773	* Purpose :
774	* Parameters:
775	* Variables :
776	* Result :
777	* Remark :
778	* Status : UNTESTED STUB
779	*
780	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
781	*****************************************************************************/
782
783	ODINFUNCTION2(int,OS2listen,SOCKET,s,
784	int, backlog)
785	{
786	return listen(s,backlog);
787	}
788
789
790	/*****************************************************************************
791	* Name :
792	* Purpose :
793	* Parameters:
794	* Variables :
795	* Result :
796	* Remark :
797	* Status : UNTESTED STUB
798	*
799	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
800	*****************************************************************************/
801
802	ODINFUNCTION1(u_long,OS2ntohl,u_long,netlong)
803	{
804	return ntohl(netlong);
805	}
806
807
808	/*****************************************************************************
809	* Name :
810	* Purpose :
811	* Parameters:
812	* Variables :
813	* Result :
814	* Remark :
815	* Status : UNTESTED STUB
816	*
817	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
818	*****************************************************************************/
819
820	ODINFUNCTION1(u_short,OS2ntohs,u_short,netshort)
821	{
822	return ntohs(netshort);
823	}
824
825
826	/*****************************************************************************
827	* Name :
828	* Purpose :
829	* Parameters:
830	* Variables :
831	* Result :
832	* Remark :
833	* Status : UNTESTED STUB
834	*
835	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
836	*****************************************************************************/
837
838	ODINFUNCTION4(int,OS2recv,SOCKET,s,
839	char*, buf,
840	int, len,
841	int, flags)
842	{
843	unsigned long ii;
844	int xx,
845	yy;
846	char buff[200];
847	AsyncStatus *as;
848
849	PS.MsgLoop = 0;
850
851	as = FindASY(s);
852
853	if(as != NULL)
854	as->MsgStat = 2;
855
856	xx = recv(s,buf,len,flags);
857
858	return xx;
859	}
860
861
862	/*****************************************************************************
863	* Name :
864	* Purpose :
865	* Parameters:
866	* Variables :
867	* Result :
868	* Remark :
869	* Status : UNTESTED STUB
870	*
871	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
872	*****************************************************************************/
873
874	ODINFUNCTION6(int,OS2recvfrom,SOCKET, s,
875	char*, buf,
876	int, len,
877	int, flags,
878	PSOCKADDR, from,
879	int*, fromlen)
880	{
881	return recvfrom(s,buf,len,flags,from,fromlen);
882	}
883
884
885	/*****************************************************************************
886	* Name :
887	* Purpose :
888	* Parameters:
889	* Variables :
890	* Result :
891	* Remark :
892	* Status : UNTESTED STUB
893	*
894	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
895	*****************************************************************************/
896
897	#ifdef VV_BSD_SELECT
898
899	ODINFUNCTION5(int,OS2select,int, nfds,
900	Wfd_set*, readfds,
901	Wfd_set*, writefds,
902	Wfd_set*, exceptfds,
903	const struct Wtimeval*, timeout)
904	{
905	return select(nfds,
906	(fd_set *)readfds,
907	(fd_set *)writefds,
908	(fd_set *)exceptfds,
909	(timeval *)timeout);
910	}
911
912	#else
913	# error OS/2-style select not implemented!
914	#endif
915
916
917	/*****************************************************************************
918	* Name :
919	* Purpose :
920	* Parameters:
921	* Variables :
922	* Result :
923	* Remark :
924	* Status : UNTESTED STUB
925	*
926	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
927	*****************************************************************************/
928
929	ODINFUNCTION4(int,OS2send,SOCKET, s,
930	const char*, buf,
931	int, len,
932	int, flags)
933	{
934	return send(s,(char *)buf,len,flags);
935	}
936
937
938	/*****************************************************************************
939	* Name :
940	* Purpose :
941	* Parameters:
942	* Variables :
943	* Result :
944	* Remark :
945	* Status : UNTESTED STUB
946	*
947	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
948	*****************************************************************************/
949
950	ODINFUNCTION6(int,OS2sendto,SOCKET, s,
951	const char*, buf,
952	int, len,
953	int, flags,
954	const struct sockaddr*, to,
955	int, tolen)
956	{
957	return sendto(s,(char *)buf,len,flags,(PSOCKADDR)to,tolen);
958	}
959
960
961	/*****************************************************************************
962	* Name :
963	* Purpose :
964	* Parameters:
965	* Variables :
966	* Result :
967	* Remark :
968	* Status : UNTESTED STUB
969	*
970	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
971	*****************************************************************************/
972
973	ODINFUNCTION5(int,OS2setsockopt,SOCKET, s,
974	int, level,
975	int, optname,
976	const char*, optval,
977	int, optlen)
978	{
979	struct Wlinger *yy;
980	struct linger xx;
981
982	if(level == SOL_SOCKET &&
983	optname == SO_LINGER)
984	{
985	yy = (struct Wlinger *)optval;
986	xx.l_onoff = (int)yy->l_onoff;
987	xx.l_linger = (int)yy->l_linger;
988
989	return setsockopt(s,level,optname,(char *)&xx,optlen);
990	}
991	else
992	return setsockopt(s,level,optname,(char *)optval,optlen);
993	}
994
995
996	/*****************************************************************************
997	* Name :
998	* Purpose :
999	* Parameters:
1000	* Variables :
1001	* Result :
1002	* Remark :
1003	* Status : UNTESTED STUB
1004	*
1005	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1006	*****************************************************************************/
1007
1008	ODINFUNCTION2(int,OS2shutdown,SOCKET,s,
1009	int, how)
1010	{
1011	return shutdown(s,how);
1012	}
1013
1014
1015	/*****************************************************************************
1016	* Name :
1017	* Purpose :
1018	* Parameters:
1019	* Variables :
1020	* Result :
1021	* Remark :
1022	* Status : UNTESTED STUB
1023	*
1024	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1025	*****************************************************************************/
1026
1027	ODINFUNCTION3(SOCKET,OS2socket,int,af,
1028	int,type,
1029	int,protocol)
1030	{
1031	SOCKET s;
1032	AsyncStatus *as;
1033
1034	s = (SOCKET)socket(af,type,protocol);
1035	if(s > 0)
1036	{
1037	as = (AsyncStatus *)malloc(sizeof(AsyncStatus));
1038	if(as != NULL)
1039	{
1040	as->hwnd = (HWND)0;
1041	as->msg = 0;
1042	as->event = 0L;
1043	as->socket = s;
1044	as->status = BLOCKING;
1045	as->threadID = 0;
1046	as->MsgStat = 0;
1047	as->Next = TopASY;
1048	as->Prev = NULL;
1049
1050	if(TopASY)
1051	TopASY->Prev = as;
1052
1053	TopASY = as;
1054	}
1055	else
1056	{
1057	soclose(s);
1058	return -1;
1059	}
1060	}
1061
1062	return s;
1063	}
1064
1065
1066	/*****************************************************************************
1067	* Name :
1068	* Purpose :
1069	* Parameters:
1070	* Variables :
1071	* Result :
1072	* Remark :
1073	* Status : UNTESTED STUB
1074	*
1075	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1076	*****************************************************************************/
1077
1078	ODINFUNCTION3(WHOSTENT,OS2gethostbyaddr,const char, addr,
1079	int, len,
1080	int, type)
1081	{
1082	WHOSTENT *yy;
1083	struct hostent *xx;
1084
1085	xx = gethostbyaddr((char *)addr,len,type);
1086
1087	if(xx == NULL)
1088	{
1089	SetErrForDatabaseCalls();
1090	return (WHOSTENT *)NULL;
1091	}
1092
1093	whsnt.h_name = xx->h_name;
1094	whsnt.h_aliases = xx->h_aliases;
1095	whsnt.h_addrtype = (short)xx->h_addrtype;
1096	whsnt.h_length = (short)xx->h_length;
1097	whsnt.h_addr_list = xx->h_addr_list;
1098
1099	return &whsnt;
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 [Tue, 1998/06/16 23:00]
1113	*****************************************************************************/
1114
1115	ODINFUNCTION1(WHOSTENT,OS2gethostbyname,const char,name)
1116	{
1117	WHOSTENT *yy;
1118	struct hostent *xx;
1119
1120	xx = gethostbyname((char *)name);
1121	if(xx == NULL)
1122	{
1123	SetErrForDatabaseCalls();
1124	return (WHOSTENT *)NULL;
1125	}
1126
1127	whsnt.h_name = xx->h_name;
1128	whsnt.h_aliases = xx->h_aliases;
1129	whsnt.h_addrtype = (short)xx->h_addrtype;
1130	whsnt.h_length = (short)xx->h_length;
1131	whsnt.h_addr_list = xx->h_addr_list;
1132
1133	return &whsnt;
1134	}
1135
1136
1137	/*****************************************************************************
1138	* Name :
1139	* Purpose :
1140	* Parameters:
1141	* Variables :
1142	* Result :
1143	* Remark :
1144	* Status : UNTESTED STUB
1145	*
1146	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1147	*****************************************************************************/
1148
1149	ODINFUNCTION2(int,OS2gethostname,char *,name,
1150	int, namelen)
1151	{
1152	return gethostname(name,namelen);
1153	}
1154
1155
1156	/*****************************************************************************
1157	* Name :
1158	* Purpose :
1159	* Parameters:
1160	* Variables :
1161	* Result :
1162	* Remark :
1163	* Status : UNTESTED STUB
1164	*
1165	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1166	*****************************************************************************/
1167
1168	ODINFUNCTION2(WSERVENT*,OS2getservbyport, int, port,
1169	const char*, proto)
1170	{
1171	struct servent *xx;
1172
1173	xx = getservbyport(port,(char *)proto);
1174
1175	if(xx == NULL)
1176	{ // this call doesn't generate an error message
1177	return (WSERVENT *)NULL;
1178	}
1179
1180	wsvnt.s_name = xx->s_name;
1181	wsvnt.s_aliases = xx->s_aliases;
1182	wsvnt.s_port = (short)xx->s_port;
1183	wsvnt.s_proto = xx->s_proto;
1184
1185	return &wsvnt;
1186	}
1187
1188
1189	/*****************************************************************************
1190	* Name :
1191	* Purpose :
1192	* Parameters:
1193	* Variables :
1194	* Result :
1195	* Remark :
1196	* Status : UNTESTED STUB
1197	*
1198	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1199	*****************************************************************************/
1200
1201	ODINFUNCTION2(WSERVENT,OS2getservbyname,const char,name,
1202	const char*,proto)
1203	{
1204	WSERVENT *yy;
1205	struct servent *xx;
1206
1207	xx = getservbyname((char )name,(char )proto);
1208
1209	if(xx == NULL)
1210	{ // this call doesn't generate an error message
1211	return (WSERVENT *)NULL;
1212	}
1213
1214	wsvnt.s_name = xx->s_name;
1215	wsvnt.s_aliases = xx->s_aliases;
1216	wsvnt.s_port = (short)xx->s_port;
1217	wsvnt.s_proto = xx->s_proto;
1218
1219	return &wsvnt;
1220	}
1221
1222
1223	/*****************************************************************************
1224	* Name :
1225	* Purpose :
1226	* Parameters:
1227	* Variables :
1228	* Result :
1229	* Remark :
1230	* Status : UNTESTED STUB
1231	*
1232	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1233	*****************************************************************************/
1234
1235	ODINFUNCTION1(WPROTOENT*,OS2getprotobynumber,int,proto)
1236	{
1237	struct protoent *xx;
1238
1239	xx = getprotobynumber(proto);
1240
1241	if(xx == NULL)
1242	{
1243	// this call doesn't generate an error message
1244	return (WPROTOENT *)NULL;
1245	}
1246
1247	wptnt.p_name = xx->p_name;
1248	wptnt.p_aliases = xx->p_aliases;
1249	wptnt.p_proto = (short)xx->p_proto;
1250
1251	return &wptnt;
1252	}
1253
1254
1255	/*****************************************************************************
1256	* Name :
1257	* Purpose :
1258	* Parameters:
1259	* Variables :
1260	* Result :
1261	* Remark :
1262	* Status : UNTESTED STUB
1263	*
1264	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1265	*****************************************************************************/
1266
1267	ODINFUNCTION1(WPROTOENT,OS2getprotobyname,const char,name)
1268	{
1269	struct protoent *xx;
1270
1271	xx = getprotobyname((char *)name);
1272
1273	if(xx == NULL)
1274	{ // this call doesn't generate an error message
1275	return (WPROTOENT *)NULL;
1276	}
1277
1278	wptnt.p_name = xx->p_name;
1279	wptnt.p_aliases = xx->p_aliases;
1280	wptnt.p_proto = (short)xx->p_proto;
1281
1282	return &wptnt;
1283	}
1284
1285
1286	/*****************************************************************************
1287	* Name :
1288	* Purpose :
1289	* Parameters:
1290	* Variables :
1291	* Result :
1292	* Remark :
1293	* Status : UNTESTED STUB
1294	*
1295	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1296	*****************************************************************************/
1297
1298	ODINFUNCTION2(int,OS2WSAStartup,USHORT, wVersionRequired,
1299	LPWSADATA,lpWsaData)
1300	{
1301	APIRET rc;
1302	int ii;
1303
1304	/* Make sure that the version requested is >= 1.1. */
1305	/* The low byte is the major version and the high */
1306	/* byte is the minor version. */
1307
1308	if ( LOBYTE( wVersionRequired ) < 1 \|\|
1309	( LOBYTE( wVersionRequired ) == 1 &&
1310	HIBYTE( wVersionRequired ) < 1 )) {
1311	return WSAVERNOTSUPPORTED;
1312	}
1313
1314	/* Since we only support 1.1, set both wVersion and */
1315	/* wHighVersion to 1.1. */
1316
1317	lpWsaData->wVersion = MAKEWORD( 1, 1 );
1318	lpWsaData->wHighVersion = MAKEWORD( 1, 1 );
1319	strcpy(lpWsaData->szDescription,"Win32OS2 WSOCK32.DLL Ver. 1.1");
1320	lpWsaData->iMaxUdpDg = 32767;
1321	lpWsaData->iMaxSockets = 2048;
1322	strcpy(lpWsaData->szSystemStatus,"No Status");
1323
1324	LocalErrorNumber = 0;
1325
1326	if(sock_init() == 0)
1327	{
1328	#ifdef DEBUG
1329	WriteLog("WSOCK32: WSAStartup sock_init returned 0\n");
1330	#endif
1331	return 0;
1332	}
1333	else
1334	ii = sock_errno();
1335
1336	return ii;
1337	}
1338
1339
1340	/*****************************************************************************
1341	* Name :
1342	* Purpose :
1343	* Parameters:
1344	* Variables :
1345	* Result :
1346	* Remark :
1347	* Status : UNTESTED STUB
1348	*
1349	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1350	*****************************************************************************/
1351
1352	ODINFUNCTION0(int,OS2WSACleanup)
1353	{
1354	CheckThreads((AsyncStatus *)NULL);
1355
1356	return 0;
1357	}
1358
1359
1360	/*****************************************************************************
1361	* Name :
1362	* Purpose :
1363	* Parameters:
1364	* Variables :
1365	* Result :
1366	* Remark :
1367	* Status : UNTESTED STUB
1368	*
1369	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1370	*****************************************************************************/
1371
1372	ODINPROCEDURE1(OS2WSASetLastError,int,iError)
1373	{
1374	LocalErrorNumber = iError;
1375	}
1376
1377
1378	/*****************************************************************************
1379	* Name :
1380	* Purpose :
1381	* Parameters:
1382	* Variables :
1383	* Result :
1384	* Remark :
1385	* Status : UNTESTED STUB
1386	*
1387	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1388	*****************************************************************************/
1389
1390	ODINFUNCTION0(int,OS2WSAGetLastError)
1391	{
1392	int ii;
1393
1394	if(LocalErrorNumber == 0)
1395	{
1396	ii = sock_errno(); // WSAGetLastError();
1397	return ii;
1398	}
1399	else
1400	{
1401	return LocalErrorNumber;
1402	}
1403	}
1404
1405
1406	/*****************************************************************************
1407	* Name :
1408	* Purpose :
1409	* Parameters:
1410	* Variables :
1411	* Result :
1412	* Remark :
1413	* Status : UNTESTED STUB
1414	*
1415	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1416	*****************************************************************************/
1417
1418	ODINFUNCTION0(int,OS2WSAUnhookBlockingHook)
1419	{
1420	dprintf(("WSOCK32: WSAUnhookBlockingHook unimplemented\n"));
1421
1422	return -5000; //WSAUnhookBlockingHook();
1423	}
1424
1425
1426	/*****************************************************************************
1427	* Name :
1428	* Purpose :
1429	* Parameters:
1430	* Variables :
1431	* Result :
1432	* Remark :
1433	* Status : UNTESTED STUB
1434	*
1435	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1436	*****************************************************************************/
1437
1438	ODINFUNCTION1(PROC,OS2WSASetBlockingHook,PROC,lpBlockFund)
1439	{
1440	dprintf(("WSOCK32: WSASetBlockingHook Unimplemented\n"));
1441	return (PROC)NULL;
1442	}
1443
1444
1445	/*****************************************************************************
1446	* Name :
1447	* Purpose :
1448	* Parameters:
1449	* Variables :
1450	* Result :
1451	* Remark :
1452	* Status : UNTESTED STUB
1453	*
1454	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1455	*****************************************************************************/
1456
1457	ODINFUNCTION0(int,OS2WSACancelBlockingCall)
1458	{
1459	dprintf(("WSOCK32: WSACancelBlockingCall unimplemented\n"));
1460
1461	return -5000; //WSACancelBlockingCall();
1462	}
1463
1464
1465	/*****************************************************************************
1466	* Name :
1467	* Purpose :
1468	* Parameters:
1469	* Variables :
1470	* Result :
1471	* Remark :
1472	* Status : UNTESTED STUB
1473	*
1474	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1475	*****************************************************************************/
1476
1477	ODINFUNCTION4(int, OS2WSARecvEx, SOCKET, s,
1478	char FAR*, buf,
1479	int, len,
1480	int FAR *,flags)
1481	{
1482	dprintf(("WSOCK32: WSARecvEx not implemented.\n"));
1483
1484	// return WSARecvEx(s,buf,len,flags);
1485	return 0;
1486	}
1487
1488
1489	/*****************************************************************************
1490	* Name :
1491	* Purpose :
1492	* Parameters:
1493	* Variables :
1494	* Result :
1495	* Remark :
1496	* Status : UNTESTED STUB
1497	*
1498	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1499	*****************************************************************************/
1500
1501	ODINPROCEDURE2(OS2s_perror, char*, pszMessage,
1502	void*, pUnknown)
1503	{
1504	perror(pszMessage);
1505	}
1506
1507

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

Download in other formats: