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

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

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