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

Last change on this file since 1372 was 1372, checked in by phaller, 26 years ago

Fix: WSA async rewrite
File size: 37.4 KB
Line 
1/* $Id: wsock32.cpp,v 1.6 1999-10-20 10:03:53 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
62ODINDEBUGCHANNEL(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
95typedef 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
108typedef struct PipeStruct
109{
110 AsyncStatus as;
111 int MsgLoop;
112 HFILE rcv;
113 HFILE snd;
114} PipeStruct;
115
116typedef 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
138void _System AsyncLoop (ULONG);
139void CheckThreads (AsyncStatus *);
140void NotifyApp (int,AsyncStatus *);
141int Notify (AsyncStatus *,int);
142int NotifyWSA (HWND hw,u_int msg,UINT wp,LONG lp);
143void _System WSAFunct (ULONG); // for the wsa database calls
144void SetErrForDatabaseCalls(void);
145
146
147/*****************************************************************************
148 * Local variables *
149 *****************************************************************************/
150
151static WHOSTENT whsnt;
152static WSERVENT wsvnt;
153static WPROTOENT wptnt;
154size_t nSize;
155int *pArray;
156
157int MsgSent;
158int LocalErrorNumber = 0;
159
160TID tidAsyncLoop = 0; /* ID of AsyncSelect (AsyncLoop) thread */
161
162PipeStruct PS;
163
164AsyncStatus *TopASY = 0;
165
166
167/*
168typedef 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
194void _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
279void 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
304void 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
340void _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
447void 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
484AsyncStatus * 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
508ODINFUNCTION2(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
533ODINFUNCTION3(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
553ODINFUNCTION3(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
573ODINFUNCTION1(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
607ODINFUNCTION3(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
629ODINFUNCTION3(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
649ODINFUNCTION3(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
669ODINFUNCTION3(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
689ODINFUNCTION5(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
711ODINFUNCTION1(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
729ODINFUNCTION1(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
747ODINFUNCTION1(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
765ODINFUNCTION1(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
783ODINFUNCTION2(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
802ODINFUNCTION1(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
820ODINFUNCTION1(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
838ODINFUNCTION4(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
874ODINFUNCTION6(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
899ODINFUNCTION5(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
929ODINFUNCTION4(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
950ODINFUNCTION6(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
973ODINFUNCTION5(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
1008ODINFUNCTION2(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
1027ODINFUNCTION3(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
1078ODINFUNCTION3(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
1115ODINFUNCTION1(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
1149ODINFUNCTION2(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
1168ODINFUNCTION2(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
1201ODINFUNCTION2(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
1235ODINFUNCTION1(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
1267ODINFUNCTION1(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
1298ODINFUNCTION2(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
1352ODINFUNCTION0(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
1372ODINPROCEDURE1(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
1390ODINFUNCTION0(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
1418ODINFUNCTION0(BOOL,OS2WSAIsBlocking)
1419{
1420 dprintf(("WSOCK32: WSAIsBlocking unimplemented\n"));
1421
1422 return -5000; //WSAIsBlocking();
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
1438ODINFUNCTION0(int,OS2WSAUnhookBlockingHook)
1439{
1440 dprintf(("WSOCK32: WSAUnhookBlockingHook unimplemented\n"));
1441
1442 return -5000; //WSAUnhookBlockingHook();
1443}
1444
1445
1446/*****************************************************************************
1447 * Name :
1448 * Purpose :
1449 * Parameters:
1450 * Variables :
1451 * Result :
1452 * Remark :
1453 * Status : UNTESTED STUB
1454 *
1455 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1456 *****************************************************************************/
1457
1458ODINFUNCTION1(PROC,OS2WSASetBlockingHook,PROC,lpBlockFund)
1459{
1460 dprintf(("WSOCK32: WSASetBlockingHook Unimplemented\n"));
1461 return (PROC)NULL;
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
1477ODINFUNCTION0(int,OS2WSACancelBlockingCall)
1478{
1479 dprintf(("WSOCK32: WSACancelBlockingCall unimplemented\n"));
1480
1481 return -5000; //WSACancelBlockingCall();
1482}
1483
1484
1485/*****************************************************************************
1486 * Name :
1487 * Purpose :
1488 * Parameters:
1489 * Variables :
1490 * Result :
1491 * Remark :
1492 * Status : UNTESTED STUB
1493 *
1494 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1495 *****************************************************************************/
1496
1497ODINFUNCTION4(int, OS2WSAAsyncSelect, SOCKET, s,
1498 HWND, hWnd,
1499 u_int, wMsg,
1500 long, lEvent)
1501{
1502 PFNTHREAD pfnAsyncThread = &AsyncLoop; /* Address of thread program */
1503 ULONG ulThreadParm = 100; /* Parameter to thread routine */
1504 APIRET rc = NO_ERROR; /* Return code */
1505 unsigned long ii;
1506 AsyncStatus *as;
1507
1508 as = FindASY(s);
1509 if(as == NULL)
1510 return 0;
1511
1512 CheckThreads(as);
1513
1514 as->hwnd = hWnd;
1515 as->msg = wMsg;
1516 as->event = lEvent;
1517
1518 ulThreadParm = (ULONG)as;
1519
1520 rc = DosCreateThread(&(as->threadID), /* Thread ID (returned by function) */
1521 pfnAsyncThread, /* Address of thread program */
1522 ulThreadParm, /* Parameter passed to ThreadProc */
1523 CREATE_READY | /* Thread is ready when created */
1524 STACK_SPARSE, /* Do not pre-commit stack pages */
1525 8192L); /* Stack size, rounded to page bdy */
1526 if (rc != NO_ERROR)
1527 {
1528 dprintf(("WSOCK32: DosCreateThread error: return code = %u\n",
1529 rc));
1530 OS2WSASetLastError(rc);
1531 return 0;
1532 }
1533
1534 return 1; //WSAAsyncSelect(s,hWnd,wMsg,lEvent);
1535}
1536
1537
1538/*****************************************************************************
1539 * Name :
1540 * Purpose :
1541 * Parameters:
1542 * Variables :
1543 * Result :
1544 * Remark :
1545 * Status : UNTESTED STUB
1546 *
1547 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1548 *****************************************************************************/
1549
1550ODINFUNCTION4(int, OS2WSARecvEx, SOCKET, s,
1551 char FAR*, buf,
1552 int, len,
1553 int FAR *,flags)
1554{
1555 dprintf(("WSOCK32: WSARecvEx not implemented.\n"));
1556
1557// return WSARecvEx(s,buf,len,flags);
1558 return 0;
1559}
1560
1561
1562/*****************************************************************************
1563 * Name :
1564 * Purpose :
1565 * Parameters:
1566 * Variables :
1567 * Result :
1568 * Remark :
1569 * Status : UNTESTED STUB
1570 *
1571 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1572 *****************************************************************************/
1573
1574ODINPROCEDURE2(OS2s_perror, char*, pszMessage,
1575 void*, pUnknown)
1576{
1577 perror(pszMessage);
1578}
1579
1580
Note: See TracBrowser for help on using the repository browser.