Ignore:
Timestamp:
Dec 7, 1999, 9:27:01 PM (26 years ago)
Author:
achimha
Message:

promoted new wsock32 as default

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wsock32/wsock32.cpp

    r1807 r2013  
    1 /* $Id: wsock32.cpp,v 1.15 1999-11-22 08:18:02 phaller Exp $ */
     1/* $Id: wsock32.cpp,v 1.16 1999-12-07 20:25:48 achimha Exp $ */
    22
    33/*
    … …  
    77 * Win32 SOCK32 for OS/2
    88 *
    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.
     9 * Copyright (C) 1999 Patrick Haller <phaller@gmx.net>
    1310 *
    1411 */
    1512
    1613/* Remark:
    17  * PH 1999/11/10 memory leak as WSOCKTHREADDATA is NOT yet
    18  *               freed when thread dies!
    19  * PH 1999/11/10 asyncSelect() still left to proper implementation
     14 * 1999/11/21 experimental rewrite using IBM's PMWSock only
     15 *            -> some structural differences remain! (hostent)
     16 * 1999/12/01 experimental rewrite works (TELNET)
     17 *            -> open issue: WSASetLastError / WSAGetLastError
     18 *               call SetLastError / GetLastError according to docs
     19 *
     20 * identical structures:
     21 * - sockaddr_in
     22 * - WSADATA
     23 * - sockaddr
     24 * - fd_set
     25 * - timeval
     26 *
     27 * incompatible structures:
     28 * - hostent
     29 * - netent
     30 * - servent
     31 * - protent
     32 * - linger
    2033 */
    2134
    … …  
    2538 *****************************************************************************/
    2639
    27 
    28 #define INCL_DOSPROCESS     /* Process and thread values */
    29 #define INCL_DOSFILEMGR     /* for DosRead and DosWrite */
    30 #define INCL_DOSQUEUES      /* for unnamed pipes */
    31 #define INCL_DOSERRORS      /* DOS error values          */
    32 #define INCL_WINMESSAGEMGR  /* Window Message Functions     */
    33 #define INCL_WINMENUS       /* Window Menu Functions        */
    34 
    35 /* this is for IBM TCP/IP 5.0 headers as present in the current Warp 4 toolkit */
    36 #define TCPV40HDRS 1
    37 
    38 #define VV_BSD_SELECT       /* undefine this if it interferes with other routines */
    39 
    40 #ifdef VV_BSD_SELECT
    41 # define BSD_SELECT
    42 #endif
    43 
    44 #include <os2wrap.h>                     //Odin32 OS/2 api wrappers
    45 #include <stdio.h>
    46 #include <stdlib.h>
    47 #include <stddef.h>
    48 #include <string.h>
    49 #include <ctype.h>
    50 #include <types.h>
     40#include <pmwsock.h>
     41#include <odin.h>
    5142#include <odinwrap.h>
    52 #include <netdb.h>
    53 #include <sys/socket.h>
    54 #include <sys/ioctl.h>
    55 #include <netinet/in.h>
    56 
    57 #ifdef VV_BSD_SELECT
    58 # include <sys/select.h>
    59 #endif
    60 
    61 #include <sys/time.h>
    62 #include <win32type.h>
     43#include <os2sel.h>
     44#include <misc.h>
    6345#include <wprocess.h>
    6446#include <heapstring.h>
    65 
    66 #include "wsock32const.h"
     47#include <win32wnd.h>
     48
     49
    6750#include "wsock32.h"
    68 #include "misc.h"
     51#include "relaywin.h"
    6952
    7053
    … …  
    7356
    7457/*****************************************************************************
    75  * Defines                                                                   *
    76  *****************************************************************************/
    77 
    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 #ifndef ERROR_SUCCESS
     58 * Local variables                                                           *
     59 *****************************************************************************/
     60
    9161#define ERROR_SUCCESS 0
    92 #endif
    93 
    94 
    95 
    96 /*****************************************************************************
    97  * Structures                                                                *
    98  *****************************************************************************/
    99 
    100 typedef struct sockaddr* PSOCKADDR;
    101 
    102 //typedef struct _TRANSMIT_FILE_BUFFERS {
    103 //    PVOID Head;
    104 //    DWORD HeadLength;
    105 //    PVOID Tail;
    106 //    DWORD TailLength;
    107 //} TRANSMIT_FILE_BUFFERS, *PTRANSMIT_FILE_BUFFERS, *LPTRANSMIT_FILE_BUFFERS;
    108 //
    109 //BOOL, OS2TransmitFile, //, IN, SOCKET, hSocket, //, IN, HANDLE, hFile, //, IN, DWORD, nNumberOfBytesToWrite, //, IN DWORD nNumberOfBytesPerSend,
    110 //    IN LPOVERLAPPED lpOverlapped,
    111 //    IN LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers,
    112 //    IN DWORD dwReserved)
    113 //{
    114 //    return FALSE;
    115 //}
     62
     63
     64static WSOCKTHREADDATA wstdFallthru; // for emergency only
     65
     66static HWND hwndRelay = NULL; // handle to our relay window
    11667
    11768
    … …  
    12071 *****************************************************************************/
    12172
    122 
    123 /*****************************************************************************
    124  * Local variables                                                           *
    125  *****************************************************************************/
    126 
    127 static WSOCKTHREADDATA wstdFallthru; // for emergency only
     73void __stdcall SetLastError(DWORD dwError);
    12874
    12975
    … …  
    166112
    167113
    168 /*****************************************************************************
    169  * Name      :
    170  * Purpose   :
    171  * Parameters:
    172  * Variables :
    173  * Result    :
    174  * Remark    :
    175  * Status    : UNTESTED STUB
    176  *
    177  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     114#if 0
     115/*****************************************************************************
     116 * Name      :
     117 * Purpose   :
     118 * Parameters:
     119 * Variables :
     120 * Result    :
     121 * Remark    :
     122 * Status    : UNTESTED STUB
     123 *
     124 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
    178125 *****************************************************************************/
    179126
    … …  
    239186}
    240187
    241 
    242 /*****************************************************************************
    243  * Name      :
    244  * Purpose   :
    245  * Parameters:
    246  * Variables :
    247  * Result    :
    248  * Remark    :
    249  * Status    : UNTESTED STUB
    250  *
    251  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    252  *****************************************************************************/
    253 
    254 ODINFUNCTION2(int, OS2__WSAFDIsSet, SOCKET,       fd,
    255                                     Wfd_set FAR*, set)
    256 {
    257   int i = set->fd_count;
    258 
    259   while (i--)
    260     if (set->fd_array[i] == fd)
    261       return 1;
    262 
    263   return 0;
    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 ODINFUNCTION3(SOCKET,OS2accept,SOCKET,    s,
    280                                PSOCKADDR, addr,
    281                                int*,      addrlen)
    282 {
    283   SOCKET rc = accept(s,addr,addrlen);
    284 
    285   if (rc == INVALID_SOCKET)
    286     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    287   else
    288     WSASetLastError(ERROR_SUCCESS);
    289 
    290   return rc;
    291 }
    292 
    293 
    294 /*****************************************************************************
    295  * Name      :
    296  * Purpose   :
    297  * Parameters:
    298  * Variables :
    299  * Result    :
    300  * Remark    :
    301  * Status    : UNTESTED STUB
    302  *
    303  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    304  *****************************************************************************/
    305 
    306 ODINFUNCTION3(int,OS2bind,SOCKET,          s,
    307                           const struct sockaddr *, addr,
    308                           int,             namelen)
    309 {
    310   int rc = bind(s,(PSOCKADDR)addr,namelen);
    311 
    312   if (rc < 0)
    313     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    314   else
    315     WSASetLastError(ERROR_SUCCESS);
    316   return rc;
    317 }
    318 
    319 
    320 /*****************************************************************************
    321  * Name      :
    322  * Purpose   :
    323  * Parameters:
    324  * Variables :
    325  * Result    :
    326  * Remark    :
    327  * Status    : UNTESTED STUB
    328  *
    329  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    330  *****************************************************************************/
    331 
    332 ODINFUNCTION1(int,OS2closesocket,SOCKET,s)
    333 {
    334   int rc = soclose((int)s);
    335 
    336   if (rc < 0)
    337     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    338   else
    339     WSASetLastError(ERROR_SUCCESS);
    340 
    341   return rc;
    342 }
    343 
    344 
    345 /*****************************************************************************
    346  * Name      :
    347  * Purpose   :
    348  * Parameters:
    349  * Variables :
    350  * Result    :
    351  * Remark    :
    352  * Status    : UNTESTED STUB
    353  *
    354  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    355  *****************************************************************************/
    356 
    357 ODINFUNCTION3(int,OS2connect,SOCKET,          s,
    358                              const struct sockaddr*, name,
    359                              int,             namelen)
    360 {
    361   int rc = connect(s,
    362                    (PSOCKADDR)name,
    363                    namelen);
    364 
    365   if (rc < 0)
    366     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    367   else
    368     WSASetLastError(ERROR_SUCCESS);
    369 
    370   return rc;
    371 }
    372 
    373 
    374 /*****************************************************************************
    375  * Name      :
    376  * Purpose   :
    377  * Parameters:
    378  * Variables :
    379  * Result    :
    380  * Remark    :
    381  * Status    : UNTESTED STUB
    382  *
    383  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    384  *****************************************************************************/
    385 
    386 ODINFUNCTION3(int,OS2ioctlsocket,SOCKET,  s,
    387                                  long,    cmd,
    388                                  u_long*, argp)
    389 {
    390   int rc = ioctl(s, cmd, (char *)argp, 4);
    391 
    392   if (rc < 0)
    393     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    394   else
    395     WSASetLastError(ERROR_SUCCESS);
    396 
    397   return rc;
    398 }
    399 
    400 
    401 /*****************************************************************************
    402  * Name      :
    403  * Purpose   :
    404  * Parameters:
    405  * Variables :
    406  * Result    :
    407  * Remark    :
    408  * Status    : UNTESTED STUB
    409  *
    410  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    411  *****************************************************************************/
    412 
    413 ODINFUNCTION3(int,OS2getpeername,SOCKET,   s,
    414                                  PSOCKADDR,name,
    415                                  int*,     namelen)
    416 {
    417   SOCKET rc = getpeername(s,name,namelen);
    418 
    419   if (rc == SOCKET_ERROR)
    420     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    421   else
    422     WSASetLastError(ERROR_SUCCESS);
    423 
    424   return rc;
    425 }
    426 
    427 
    428 /*****************************************************************************
    429  * Name      :
    430  * Purpose   :
    431  * Parameters:
    432  * Variables :
    433  * Result    :
    434  * Remark    :
    435  * Status    : UNTESTED STUB
    436  *
    437  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    438  *****************************************************************************/
    439 
    440 ODINFUNCTION3(int,OS2getsockname,SOCKET,   s,
    441                                  PSOCKADDR,name,
    442                                  int*,     namelen)
    443 {
    444   SOCKET rc = getsockname(s,name,namelen);
    445 
    446   if (rc == SOCKET_ERROR)
    447     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    448   else
    449     WSASetLastError(ERROR_SUCCESS);
    450 
    451   return rc;
    452 }
    453 
    454 
    455 /*****************************************************************************
    456  * Name      :
    457  * Purpose   :
    458  * Parameters:
    459  * Variables :
    460  * Result    :
    461  * Remark    :
    462  * Status    : UNTESTED STUB
    463  *
    464  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    465  *****************************************************************************/
    466 
    467 ODINFUNCTION5(int,OS2getsockopt,SOCKET,s,
    468                                 int,   level,
    469                                 int,   optname,
    470                                 char*, optval,
    471                                 int*,  optlen)
    472 {
    473   int rc = getsockopt(s,level,optname,optval,optlen);
    474 
    475   if (rc == SOCKET_ERROR)
    476     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    477   else
    478     WSASetLastError(ERROR_SUCCESS);
    479 
    480   return rc;
    481 }
    482 
    483 
    484 /*****************************************************************************
    485  * Name      :
    486  * Purpose   :
    487  * Parameters:
    488  * Variables :
    489  * Result    :
    490  * Remark    :
    491  * Status    : UNTESTED STUB
    492  *
    493  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    494  *****************************************************************************/
    495 
    496 ODINFUNCTION1(u_long,OS2htonl,u_long,hostlong)
    497 {
    498   return htonl(hostlong);
    499 }
    500 
    501 
    502 /*****************************************************************************
    503  * Name      :
    504  * Purpose   :
    505  * Parameters:
    506  * Variables :
    507  * Result    :
    508  * Remark    :
    509  * Status    : UNTESTED STUB
    510  *
    511  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    512  *****************************************************************************/
    513 
    514 ODINFUNCTION1(u_short,OS2htons,u_short,hostshort)
    515 {
    516   return htons(hostshort);
    517 }
    518 
    519 
    520 /*****************************************************************************
    521  * Name      :
    522  * Purpose   :
    523  * Parameters:
    524  * Variables :
    525  * Result    :
    526  * Remark    :
    527  * Status    : UNTESTED STUB
    528  *
    529  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    530  *****************************************************************************/
    531 
    532 ODINFUNCTION1(u_long,OS2inet_addr,const char*, cp)
    533 {
    534   return inet_addr((char *)cp);
    535 }
    536 
    537 
    538 /*****************************************************************************
    539  * Name      :
    540  * Purpose   :
    541  * Parameters:
    542  * Variables :
    543  * Result    :
    544  * Remark    :
    545  * Status    : UNTESTED STUB
    546  *
    547  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    548  *****************************************************************************/
    549 
    550 ODINFUNCTION1(char*,OS2inet_ntoa,struct in_addr,in)
    551 {
    552   return inet_ntoa(in);
    553 }
    554 
    555 
    556 /*****************************************************************************
    557  * Name      :
    558  * Purpose   :
    559  * Parameters:
    560  * Variables :
    561  * Result    :
    562  * Remark    :
    563  * Status    : UNTESTED STUB
    564  *
    565  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    566  *****************************************************************************/
    567 
    568 ODINFUNCTION2(int,OS2listen,SOCKET,s,
    569                             int,   backlog)
    570 {
    571   int rc = listen(s,backlog);
    572 
    573   if (rc < 0)
    574     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    575   else
    576     WSASetLastError(ERROR_SUCCESS);
    577 
    578   return rc;
    579 }
    580 
    581 
    582 /*****************************************************************************
    583  * Name      :
    584  * Purpose   :
    585  * Parameters:
    586  * Variables :
    587  * Result    :
    588  * Remark    :
    589  * Status    : UNTESTED STUB
    590  *
    591  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    592  *****************************************************************************/
    593 
    594 ODINFUNCTION1(u_long,OS2ntohl,u_long,netlong)
    595 {
    596   return ntohl(netlong);
    597 }
    598 
    599 
    600 /*****************************************************************************
    601  * Name      :
    602  * Purpose   :
    603  * Parameters:
    604  * Variables :
    605  * Result    :
    606  * Remark    :
    607  * Status    : UNTESTED STUB
    608  *
    609  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    610  *****************************************************************************/
    611 
    612 ODINFUNCTION1(u_short,OS2ntohs,u_short,netshort)
    613 {
    614   return ntohs(netshort);
    615 }
    616 
    617 
    618 /*****************************************************************************
    619  * Name      :
    620  * Purpose   :
    621  * Parameters:
    622  * Variables :
    623  * Result    :
    624  * Remark    :
    625  * Status    : UNTESTED STUB
    626  *
    627  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    628  *****************************************************************************/
    629 
    630 ODINFUNCTION4(int,OS2recv,SOCKET,s,
    631                           char*, buf,
    632                           int,   len,
    633                           int,   flags)
    634 {
    635   int rc = recv(s,buf,len,flags);
    636 
    637   if (rc < 0)
    638     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    639   else
    640     WSASetLastError(ERROR_SUCCESS);
    641 
    642   return rc;
    643 }
    644 
    645 
    646 /*****************************************************************************
    647  * Name      :
    648  * Purpose   :
    649  * Parameters:
    650  * Variables :
    651  * Result    :
    652  * Remark    :
    653  * Status    : UNTESTED STUB
    654  *
    655  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    656  *****************************************************************************/
    657 
    658 ODINFUNCTION6(int,OS2recvfrom,SOCKET,    s,
    659                               char*,     buf,
    660                               int,       len,
    661                               int,       flags,
    662                               PSOCKADDR, from,
    663                               int*,      fromlen)
    664 {
    665   int rc = recvfrom(s,buf,len,flags,from,fromlen);
    666 
    667   if (rc < 0)
    668     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    669   else
    670     WSASetLastError(ERROR_SUCCESS);
    671 
    672   return rc;
    673 }
    674 
    675 
    676 /*****************************************************************************
    677  * Name      :
    678  * Purpose   :
    679  * Parameters:
    680  * Variables :
    681  * Result    :
    682  * Remark    :
    683  * Status    : UNTESTED STUB
    684  *
    685  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    686  *****************************************************************************/
    687 
    688 #ifdef VV_BSD_SELECT
    689 
    690 ODINFUNCTION5(int,OS2select,int,      nfds,
    691                             Wfd_set*, readfds,
    692                             Wfd_set*, writefds,
    693                             Wfd_set*, exceptfds,
    694                             const struct Wtimeval*, timeout)
    695 {
    696   int rc = select(nfds,
    697                 (fd_set *)readfds,
    698                 (fd_set *)writefds,
    699                 (fd_set *)exceptfds,
    700                 (timeval *)timeout);
    701 
    702   if (rc == SOCKET_ERROR)
    703     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    704   else
    705     WSASetLastError(ERROR_SUCCESS);
    706 
    707   return rc;
    708 }
    709 
    710 #else
    711 #  error OS/2-style select not implemented!
    712188#endif
    713189
    714190
    715 /*****************************************************************************
    716  * Name      :
    717  * Purpose   :
    718  * Parameters:
    719  * Variables :
    720  * Result    :
    721  * Remark    :
    722  * Status    : UNTESTED STUB
    723  *
    724  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    725  *****************************************************************************/
    726 
    727 ODINFUNCTION4(int,OS2send,SOCKET,      s,
    728                           const char*, buf,
    729                           int,         len,
    730                           int,         flags)
    731 {
    732   int rc = send(s,(char *)buf,len,flags);
    733 
    734   if (rc < 0)
    735     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    736   else
    737     WSASetLastError(ERROR_SUCCESS);
    738 
    739   return rc;
    740 }
    741 
    742 
    743 /*****************************************************************************
    744  * Name      :
    745  * Purpose   :
    746  * Parameters:
    747  * Variables :
    748  * Result    :
    749  * Remark    :
    750  * Status    : UNTESTED STUB
    751  *
    752  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    753  *****************************************************************************/
    754 
    755 ODINFUNCTION6(int,OS2sendto,SOCKET,          s,
    756                             const char*,     buf,
    757                             int,             len,
    758                             int,             flags,
    759                             const struct sockaddr*, to,
    760                             int,             tolen)
    761 {
    762   int rc = sendto(s,(char *)buf,len,flags,(PSOCKADDR)to,tolen);
    763 
    764   if (rc < 0)
    765     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    766   else
    767     WSASetLastError(ERROR_SUCCESS);
    768 
    769   return rc;
    770 }
    771 
    772 
    773 /*****************************************************************************
    774  * Name      :
    775  * Purpose   :
    776  * Parameters:
    777  * Variables :
    778  * Result    :
    779  * Remark    :
    780  * Status    : UNTESTED STUB
    781  *
    782  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    783  *****************************************************************************/
    784 
    785 ODINFUNCTION5(int,OS2setsockopt,SOCKET,      s,
    786                                 int,         level,
    787                                 int,         optname,
    788                                 const char*, optval,
    789                                 int,         optlen)
     191
     192
     193
     194
     195
     196/*****************************************************************************
     197 * Name      :
     198 * Purpose   :
     199 * Parameters:
     200 * Variables :
     201 * Result    :
     202 * Remark    :
     203 * Status    : UNTESTED STUB
     204 *
     205 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     206 *****************************************************************************/
     207
     208
     209ODINPROCEDURE1(OS2WSASetLastError,
     210               int,iError)
     211{
     212  // according to the docs, WSASetLastError() is just a call-through
     213  // to SetLastError()
     214  WSASetLastError(iError);
     215  SetLastError(iError);
     216}
     217
     218
     219/*****************************************************************************
     220 * Name      :
     221 * Purpose   :
     222 * Parameters:
     223 * Variables :
     224 * Result    :
     225 * Remark    :
     226 * Status    : UNTESTED STUB
     227 *
     228 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     229 *****************************************************************************/
     230
     231ODINFUNCTION0(int,OS2WSAGetLastError)
     232{
     233  // according to the docs, WSASetLastError() is just a call-through
     234  // to SetLastError(). However, what can be implemented here?
     235  return WSAGetLastError();
     236}
     237
     238
     239/*****************************************************************************
     240 * Name      :
     241 * Purpose   :
     242 * Parameters:
     243 * Variables :
     244 * Result    :
     245 * Remark    :
     246 * Status    : UNTESTED STUB
     247 *
     248 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     249 *****************************************************************************/
     250
     251ODINFUNCTION2(int,OS2__WSAFDIsSet,SOCKET, s,
     252                                  fd_set*,fds)
     253{
     254  return (__WSAFDIsSet(s,fds));
     255}
     256
     257
     258/*****************************************************************************
     259 * Name      :
     260 * Purpose   :
     261 * Parameters:
     262 * Variables :
     263 * Result    :
     264 * Remark    :
     265 * Status    : UNTESTED STUB
     266 *
     267 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     268 *****************************************************************************/
     269
     270ODINFUNCTION3(SOCKET,OS2accept, SOCKET,           s,
     271                                struct sockaddr *,addr,
     272                                int *,            addrlen)
     273{
     274  return(accept(s,addr,addrlen));
     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 [Thu, 1999/11/25 23:00]
     288 *****************************************************************************/
     289
     290ODINFUNCTION3(int,OS2bind,
     291              SOCKET ,s,
     292              const struct sockaddr *,addr,
     293              int, namelen)
     294{
     295  return(bind(s,addr,namelen));
     296}
     297
     298
     299/*****************************************************************************
     300 * Name      :
     301 * Purpose   :
     302 * Parameters:
     303 * Variables :
     304 * Result    :
     305 * Remark    :
     306 * Status    : UNTESTED STUB
     307 *
     308 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     309 *****************************************************************************/
     310
     311ODINFUNCTION1(int,OS2closesocket,SOCKET, s)
     312{
     313  return(closesocket(s));
     314}
     315
     316
     317/*****************************************************************************
     318 * Name      :
     319 * Purpose   :
     320 * Parameters:
     321 * Variables :
     322 * Result    :
     323 * Remark    :
     324 * Status    : UNTESTED STUB
     325 *
     326 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     327 *****************************************************************************/
     328
     329ODINFUNCTION3(int,OS2connect,
     330              SOCKET, s,
     331              const struct sockaddr *,name,
     332              int, namelen)
     333{
     334  return(connect(s,name,namelen));
     335}
     336
     337
     338/*****************************************************************************
     339 * Name      :
     340 * Purpose   :
     341 * Parameters:
     342 * Variables :
     343 * Result    :
     344 * Remark    :
     345 * Status    : UNTESTED STUB
     346 *
     347 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     348 *****************************************************************************/
     349
     350ODINFUNCTION3(int,OS2ioctlsocket,
     351              SOCKET,s,
     352              long, cmd,
     353              u_long *,argp)
     354{
     355  return(ioctlsocket(s,cmd,argp));
     356}
     357
     358
     359/*****************************************************************************
     360 * Name      :
     361 * Purpose   :
     362 * Parameters:
     363 * Variables :
     364 * Result    :
     365 * Remark    :
     366 * Status    : UNTESTED STUB
     367 *
     368 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     369 *****************************************************************************/
     370
     371ODINFUNCTION3(int,OS2getpeername,
     372              SOCKET, s,
     373              struct sockaddr *,name,
     374              int *, namelen)
     375{
     376  return(getpeername(s,name,namelen));
     377}
     378
     379
     380/*****************************************************************************
     381 * Name      :
     382 * Purpose   :
     383 * Parameters:
     384 * Variables :
     385 * Result    :
     386 * Remark    :
     387 * Status    : UNTESTED STUB
     388 *
     389 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     390 *****************************************************************************/
     391
     392ODINFUNCTION3(int,OS2getsockname,
     393              SOCKET,s,
     394              struct sockaddr *,name,
     395              int *, namelen)
     396{
     397  return(getsockname(s,name,namelen));
     398}
     399
     400
     401/*****************************************************************************
     402 * Name      :
     403 * Purpose   :
     404 * Parameters:
     405 * Variables :
     406 * Result    :
     407 * Remark    :
     408 * Status    : UNTESTED STUB
     409 *
     410 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     411 *****************************************************************************/
     412
     413ODINFUNCTION5(int,OS2getsockopt,
     414              SOCKET, s,
     415              int, level,
     416              int, optname,
     417              char *, optval,
     418              int *,optlen)
     419{
     420  return(getsockopt(s,
     421                    level,
     422                    optname,
     423                    optval,
     424                    optlen));
     425}
     426
     427
     428/*****************************************************************************
     429 * Name      :
     430 * Purpose   :
     431 * Parameters:
     432 * Variables :
     433 * Result    :
     434 * Remark    :
     435 * Status    : UNTESTED STUB
     436 *
     437 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     438 *****************************************************************************/
     439
     440ODINFUNCTION1(u_long,OS2htonl,
     441              u_long,hostlong)
     442{
     443  return(htonl(hostlong));
     444}
     445
     446
     447/*****************************************************************************
     448 * Name      :
     449 * Purpose   :
     450 * Parameters:
     451 * Variables :
     452 * Result    :
     453 * Remark    :
     454 * Status    : UNTESTED STUB
     455 *
     456 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     457 *****************************************************************************/
     458
     459ODINFUNCTION1(u_short,OS2htons,
     460              u_short,hostshort)
     461{
     462  return(htons(hostshort));
     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 [Thu, 1999/11/25 23:00]
     476 *****************************************************************************/
     477
     478ODINFUNCTION1(unsigned long,OS2inet_addr,
     479              const char *, cp)
     480{
     481  dprintf(("WSOCK32: OS2inet_addr(%s)\n",
     482           cp));
     483
     484  return (inet_addr(cp));
     485}
     486
     487
     488/*****************************************************************************
     489 * Name      :
     490 * Purpose   :
     491 * Parameters:
     492 * Variables :
     493 * Result    :
     494 * Remark    :
     495 * Status    : UNTESTED STUB
     496 *
     497 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     498 *****************************************************************************/
     499
     500ODINFUNCTION1(char *,OS2inet_ntoa,
     501              struct in_addr, in)
     502{
     503  return(inet_ntoa(in));
     504}
     505
     506
     507/*****************************************************************************
     508 * Name      :
     509 * Purpose   :
     510 * Parameters:
     511 * Variables :
     512 * Result    :
     513 * Remark    :
     514 * Status    : UNTESTED STUB
     515 *
     516 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     517 *****************************************************************************/
     518
     519ODINFUNCTION2(int,OS2listen,
     520              SOCKET, s,
     521              int, backlog)
     522{
     523  return(listen(s,backlog));
     524}
     525
     526
     527/*****************************************************************************
     528 * Name      :
     529 * Purpose   :
     530 * Parameters:
     531 * Variables :
     532 * Result    :
     533 * Remark    :
     534 * Status    : UNTESTED STUB
     535 *
     536 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     537 *****************************************************************************/
     538
     539ODINFUNCTION1(u_long,OS2ntohl,
     540              u_long,netlong)
     541{
     542  return(ntohl(netlong));
     543}
     544
     545
     546/*****************************************************************************
     547 * Name      :
     548 * Purpose   :
     549 * Parameters:
     550 * Variables :
     551 * Result    :
     552 * Remark    :
     553 * Status    : UNTESTED STUB
     554 *
     555 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     556 *****************************************************************************/
     557
     558ODINFUNCTION1(u_short,OS2ntohs,
     559              u_short,netshort)
     560{
     561  return(ntohs(netshort));
     562}
     563
     564
     565/*****************************************************************************
     566 * Name      :
     567 * Purpose   :
     568 * Parameters:
     569 * Variables :
     570 * Result    :
     571 * Remark    :
     572 * Status    : UNTESTED STUB
     573 *
     574 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     575 *****************************************************************************/
     576
     577ODINFUNCTION4(int,OS2recv,
     578              SOCKET,s,
     579              char *,buf,
     580              int,len,
     581              int,flags)
     582{
     583  return(recv(s,
     584              buf,
     585              len,
     586              flags));
     587}
     588
     589
     590/*****************************************************************************
     591 * Name      :
     592 * Purpose   :
     593 * Parameters:
     594 * Variables :
     595 * Result    :
     596 * Remark    :
     597 * Status    : UNTESTED STUB
     598 *
     599 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     600 *****************************************************************************/
     601
     602ODINFUNCTION6(int,OS2recvfrom,
     603              SOCKET,s,
     604              char *,buf,
     605              int,len,
     606              int,flags,
     607              struct sockaddr *,from,
     608              int *,fromlen)
     609{
     610
     611  return(recvfrom(s,
     612                buf,
     613                len,
     614                flags,
     615                from,
     616                fromlen));
     617}
     618
     619
     620/*****************************************************************************
     621 * Name      :
     622 * Purpose   :
     623 * Parameters:
     624 * Variables :
     625 * Result    :
     626 * Remark    :
     627 * Status    : UNTESTED STUB
     628 *
     629 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     630 *****************************************************************************/
     631
     632ODINFUNCTION5(int,OS2select,
     633              int,nfds,
     634              fd_set *,readfds,
     635              fd_set *,writefds,
     636              fd_set *,exceptfds,
     637              const struct timeval *,timeout)
     638{
     639  return(select(nfds,
     640                readfds,
     641                writefds,
     642                exceptfds,
     643                timeout));
     644}
     645
     646
     647/*****************************************************************************
     648 * Name      :
     649 * Purpose   :
     650 * Parameters:
     651 * Variables :
     652 * Result    :
     653 * Remark    :
     654 * Status    : UNTESTED STUB
     655 *
     656 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     657 *****************************************************************************/
     658
     659ODINFUNCTION4(int,OS2send,
     660              SOCKET,s,
     661              const char *,buf,
     662              int,len,
     663              int,flags)
     664{
     665  return(send(s,
     666              buf,
     667              len,
     668              flags));
     669}
     670
     671
     672/*****************************************************************************
     673 * Name      :
     674 * Purpose   :
     675 * Parameters:
     676 * Variables :
     677 * Result    :
     678 * Remark    :
     679 * Status    : UNTESTED STUB
     680 *
     681 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     682 *****************************************************************************/
     683
     684ODINFUNCTION6(int,OS2sendto,
     685              SOCKET,s,
     686              const char *,buf,
     687              int,len,
     688              int,flags,
     689              const struct sockaddr *,to,
     690              int,tolen)
     691{
     692  return(sendto(s,
     693              buf,
     694              len,
     695              flags,
     696              to,
     697              tolen));
     698}
     699
     700
     701/*****************************************************************************
     702 * Name      :
     703 * Purpose   :
     704 * Parameters:
     705 * Variables :
     706 * Result    :
     707 * Remark    :
     708 * Status    : UNTESTED STUB
     709 *
     710 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     711 *****************************************************************************/
     712
     713ODINFUNCTION5(int,OS2setsockopt,
     714              SOCKET,s,
     715              int,level,
     716              int,optname,
     717              const char *,optval,
     718              int,optlen)
    790719{
    791720  struct Wlinger *yy;
    … …  
    806735
    807736  if (rc == SOCKET_ERROR)
    808     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
     737    //OS2WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
     738    OS2WSASetLastError(WSAEINVAL);
    809739  else
    810     WSASetLastError(ERROR_SUCCESS);
     740    OS2WSASetLastError(ERROR_SUCCESS);
    811741
    812742  return rc;
    … …  
    823753 * Status    : UNTESTED STUB
    824754 *
    825  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    826  *****************************************************************************/
    827 
    828 ODINFUNCTION2(int,OS2shutdown,SOCKET,s,
    829                               int,   how)
    830 {
    831   int rc = shutdown(s,how);
    832 
    833   if (rc == SOCKET_ERROR)
    834     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    835   else
    836     WSASetLastError(ERROR_SUCCESS);
    837 
    838   return rc;
    839 }
    840 
    841 
    842 /*****************************************************************************
    843  * Name      :
    844  * Purpose   :
    845  * Parameters:
    846  * Variables :
    847  * Result    :
    848  * Remark    :
    849  * Status    : UNTESTED STUB
    850  *
    851  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    852  *****************************************************************************/
    853 
    854 ODINFUNCTION3(SOCKET,OS2socket,int,af,
    855                                int,type,
    856                                int,protocol)
    857 {
    858   SOCKET rc = socket(af,type,protocol);
    859 
    860   if (rc == INVALID_SOCKET)
    861     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    862   else
    863     WSASetLastError(ERROR_SUCCESS);
    864 
    865   return rc;
    866 }
    867 
    868 
    869 /*****************************************************************************
    870  * Name      :
    871  * Purpose   :
    872  * Parameters:
    873  * Variables :
    874  * Result    :
    875  * Remark    :
    876  * Status    : UNTESTED STUB
    877  *
    878  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    879  *****************************************************************************/
    880 
    881 ODINFUNCTION3(WHOSTENT*,OS2gethostbyaddr,const char*, addr,
    882                                          int,         len,
    883                                          int,         type)
     755 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     756 *****************************************************************************/
     757
     758ODINFUNCTION2(int,OS2shutdown,
     759              SOCKET,s,
     760              int,how)
     761{
     762  return(shutdown(s,
     763                  how));
     764}
     765
     766
     767/*****************************************************************************
     768 * Name      :
     769 * Purpose   :
     770 * Parameters:
     771 * Variables :
     772 * Result    :
     773 * Remark    :
     774 * Status    : UNTESTED STUB
     775 *
     776 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     777 *****************************************************************************/
     778
     779ODINFUNCTION3(SOCKET,OS2socket,
     780              int,af,
     781              int,type,
     782              int,protocol)
     783{
     784  return(socket(af,
     785                type,
     786                protocol));
     787}
     788
     789
     790/* Database function prototypes */
     791
     792/*****************************************************************************
     793 * Name      :
     794 * Purpose   :
     795 * Parameters:
     796 * Variables :
     797 * Result    :
     798 * Remark    :
     799 * Status    : UNTESTED STUB
     800 *
     801 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     802 *****************************************************************************/
     803
     804ODINFUNCTION3(struct Whostent *,OS2gethostbyaddr,
     805              const char *,addr,
     806              int,len,
     807              int,type)
    884808{
    885809  WHOSTENT         *yy;
    … …  
    888812
    889813  xx = gethostbyaddr((char *)addr,len,type);
     814  //PH: we assume PMWSOCK sets WSASetLastError correctly!
    890815
    891816  if(xx == NULL)
    892   {
    893      WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    894817     return (WHOSTENT *)NULL;
    895   }
    896   else
    897     WSASetLastError(ERROR_SUCCESS);
    898818
    899819  // access current thread wsock data block
    … …  
    919839 * Status    : UNTESTED STUB
    920840 *
    921  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    922  *****************************************************************************/
    923 
    924 ODINFUNCTION1(WHOSTENT*,OS2gethostbyname,const char*,name)
     841 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     842 *****************************************************************************/
     843
     844ODINFUNCTION1(struct Whostent *,OS2gethostbyname,
     845              const char *,name)
    925846{
    926847  WHOSTENT         *yy;
    … …  
    930851
    931852  xx = gethostbyname((char *)name);
     853  //PH: we assume PMWSOCK sets WSASetLastError correctly!
     854
    932855  if(xx == NULL)
    933   {
    934     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    935856    return (WHOSTENT *)NULL;
    936   }
    937   else
    938     WSASetLastError(ERROR_SUCCESS);
    939857
    940858  // access current thread wsock data block
    … …  
    960878 * Status    : UNTESTED STUB
    961879 *
    962  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    963  *****************************************************************************/
    964 
    965 ODINFUNCTION2(int,OS2gethostname,char *,name,
    966                                  int,   namelen)
    967 {
    968   int rc = gethostname(name,namelen);
    969 
    970   if (rc == SOCKET_ERROR)
    971     WSASetLastError(ERROR_SUCCESS);
    972   else
    973     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    974 
    975   return (rc);
    976 }
    977 
    978 
    979 /*****************************************************************************
    980  * Name      :
    981  * Purpose   :
    982  * Parameters:
    983  * Variables :
    984  * Result    :
    985  * Remark    :
    986  * Status    : UNTESTED STUB
    987  *
    988  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    989  *****************************************************************************/
    990 
    991 ODINFUNCTION2(WSERVENT*,OS2getservbyport, int,         port,
    992                                           const char*, proto)
     880 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     881 *****************************************************************************/
     882
     883ODINFUNCTION2(int,OS2gethostname,
     884              char *,name,
     885              int,namelen)
     886{
     887   //PH: we assume PMWSOCK sets WSASetLastError correctly!
     888   return(gethostname(name,
     889                     namelen));
     890}
     891
     892
     893/*****************************************************************************
     894 * Name      :
     895 * Purpose   :
     896 * Parameters:
     897 * Variables :
     898 * Result    :
     899 * Remark    :
     900 * Status    : UNTESTED STUB
     901 *
     902 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     903 *****************************************************************************/
     904
     905ODINFUNCTION2(struct Wservent *,OS2getservbyport,
     906              int,              port,
     907              const char *,     proto)
    993908{
    994909  struct servent   *xx;
    995910  PWSOCKTHREADDATA pwstd;
    996911
     912  //PH: we assume PMWSOCK sets WSASetLastError correctly!
    997913  xx = getservbyport(port,(char *)proto);
    998914
    999915  if(xx == NULL)
    1000   { // this call doesn't generate an error message
    1001     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    1002916    return (WSERVENT *)NULL;
    1003   }
    1004   else
    1005     WSASetLastError(ERROR_SUCCESS);
    1006917
    1007918  // access current thread wsock data block
    … …  
    1026937 * Status    : UNTESTED STUB
    1027938 *
    1028  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    1029  *****************************************************************************/
    1030 
    1031 ODINFUNCTION2(WSERVENT*,OS2getservbyname,const char*,name,
    1032                                          const char*,proto)
     939 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     940 *****************************************************************************/
     941
     942ODINFUNCTION2(struct Wservent *,OS2getservbyname,
     943              const char *,     name,
     944              const char *,     proto)
    1033945{
    1034946  WSERVENT         *yy;
    … …  
    1037949
    1038950
     951  //PH: we assume PMWSOCK sets WSASetLastError correctly!
    1039952  xx = getservbyname((char *)name,(char *)proto);
    1040953
    1041954  if(xx == NULL)
    1042   { // this call doesn't generate an error message
    1043     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    1044955    return (WSERVENT *)NULL;
    1045   }
    1046   else
    1047     WSASetLastError(ERROR_SUCCESS);
    1048956
    1049957  // access current thread wsock data block
    … …  
    1068976 * Status    : UNTESTED STUB
    1069977 *
    1070  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    1071  *****************************************************************************/
    1072 
    1073 ODINFUNCTION1(WPROTOENT*,OS2getprotobynumber,int,proto)
     978 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     979 *****************************************************************************/
     980
     981ODINFUNCTION1(struct Wprotoent *,OS2getprotobynumber,
     982              int,proto)
    1074983{
    1075984  struct protoent  *xx;
    1076985  PWSOCKTHREADDATA pwstd;
    1077986
     987  //PH: we assume PMWSOCK sets WSASetLastError correctly!
    1078988  xx = getprotobynumber(proto);
    1079989
    1080990  if(xx == NULL)
    1081   {
    1082      // this call doesn't generate an error message
    1083     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    1084991    return (WPROTOENT *)NULL;
    1085   }
    1086   else
    1087     WSASetLastError(ERROR_SUCCESS);
    1088992
    1089993  // access current thread wsock data block
    … …  
    11071011 * Status    : UNTESTED STUB
    11081012 *
    1109  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    1110  *****************************************************************************/
    1111 
    1112 ODINFUNCTION1(WPROTOENT*,OS2getprotobyname,const char*,name)
     1013 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1014 *****************************************************************************/
     1015
     1016ODINFUNCTION1(struct Wprotoent *,OS2getprotobyname,
     1017              const char *,name)
    11131018{
    11141019  struct protoent  *xx;
    11151020  PWSOCKTHREADDATA pwstd;
    11161021
     1022  //PH: we assume PMWSOCK sets WSASetLastError correctly!
    11171023  xx = getprotobyname((char *)name);
    11181024
    11191025  if(xx == NULL)
    1120   { // this call doesn't generate an error message
    1121     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    11221026    return (WPROTOENT *)NULL;
    1123   }
    1124   else
    1125     WSASetLastError(ERROR_SUCCESS);
    11261027
    11271028  // access current thread wsock data block
    … …  
    11361037
    11371038
    1138 /*****************************************************************************
    1139  * Name      :
    1140  * Purpose   :
    1141  * Parameters:
    1142  * Variables :
    1143  * Result    :
    1144  * Remark    :
    1145  * Status    : UNTESTED STUB
    1146  *
    1147  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    1148  *****************************************************************************/
    1149 
    1150 ODINFUNCTION2(int,OS2WSAStartup,USHORT,   wVersionRequired,
    1151                                 LPWSADATA,lpWsaData)
    1152 {
    1153   APIRET rc;
    1154 
    1155   /* Make sure that the version requested is >= 1.1.   */
    1156   /* The low byte is the major version and the high    */
    1157   /* byte is the minor version.                        */
    1158 
    1159   if ( LOBYTE( wVersionRequired ) < 1 ||
    1160        ( LOBYTE( wVersionRequired ) == 1 &&
    1161          HIBYTE( wVersionRequired ) < 1 )) {
    1162       return WSAVERNOTSUPPORTED;
    1163   }
    1164 
    1165   /* Since we only support 1.1, set both wVersion and  */
    1166   /* wHighVersion to 1.1.                              */
    1167 
    1168   lpWsaData->wVersion = MAKEWORD( 1, 1 );
    1169   lpWsaData->wHighVersion = MAKEWORD( 1, 1 );
    1170   strcpy(lpWsaData->szDescription,"Win32OS2 WSOCK32.DLL Ver. 1.1");
    1171   lpWsaData->iMaxUdpDg = 32767;
    1172   lpWsaData->iMaxSockets = 2048;
    1173   strcpy(lpWsaData->szSystemStatus,"No Status");
    1174 
    1175   if(sock_init() == 0)
     1039
     1040/* Microsoft Windows Extension function prototypes */
     1041
     1042/*****************************************************************************
     1043 * Name      :
     1044 * Purpose   :
     1045 * Parameters:
     1046 * Variables :
     1047 * Result    :
     1048 * Remark    :
     1049 * Status    : UNTESTED STUB
     1050 *
     1051 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1052 *****************************************************************************/
     1053
     1054ODINFUNCTION2(int,OS2WSAStartup,
     1055              USHORT,wVersionRequired,
     1056              LPWSADATA,lpWSAData)
     1057{
     1058  return(WSAStartup(wVersionRequired,
     1059                    lpWSAData));
     1060}
     1061
     1062
     1063/*****************************************************************************
     1064 * Name      :
     1065 * Purpose   :
     1066 * Parameters:
     1067 * Variables :
     1068 * Result    :
     1069 * Remark    :
     1070 * Status    : UNTESTED STUB
     1071 *
     1072 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1073 *****************************************************************************/
     1074
     1075ODINFUNCTION0(int,OS2WSACleanup)
     1076{
     1077  return(WSACleanup());
     1078}
     1079
     1080
     1081/*****************************************************************************
     1082 * Name      :
     1083 * Purpose   :
     1084 * Parameters:
     1085 * Variables :
     1086 * Result    :
     1087 * Remark    :
     1088 * Status    : UNTESTED STUB
     1089 *
     1090 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1091 *****************************************************************************/
     1092
     1093ODINFUNCTION0(BOOL,OS2WSAIsBlocking)
     1094{
     1095  return WSAIsBlocking();
     1096}
     1097
     1098
     1099/*****************************************************************************
     1100 * Name      :
     1101 * Purpose   :
     1102 * Parameters:
     1103 * Variables :
     1104 * Result    :
     1105 * Remark    :
     1106 * Status    : UNTESTED STUB
     1107 *
     1108 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1109 *****************************************************************************/
     1110
     1111ODINFUNCTION0(int,OS2WSAUnhookBlockingHook)
     1112{
     1113  return WSAUnhookBlockingHook();
     1114}
     1115
     1116
     1117/*****************************************************************************
     1118 * Name      :
     1119 * Purpose   :
     1120 * Parameters:
     1121 * Variables :
     1122 * Result    :
     1123 * Remark    :
     1124 * Status    : UNTESTED STUB
     1125 *
     1126 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1127 *****************************************************************************/
     1128
     1129ODINFUNCTION1(PFN,OS2WSASetBlockingHook,
     1130              PFN,lpBlockFunc)
     1131{
     1132  return(WSASetBlockingHook(lpBlockFunc));
     1133}
     1134
     1135
     1136/*****************************************************************************
     1137 * Name      :
     1138 * Purpose   :
     1139 * Parameters:
     1140 * Variables :
     1141 * Result    :
     1142 * Remark    :
     1143 * Status    : UNTESTED STUB
     1144 *
     1145 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1146 *****************************************************************************/
     1147
     1148ODINFUNCTION0(int,OS2WSACancelBlockingCall)
     1149{
     1150  return(WSACancelBlockingCall());
     1151}
     1152
     1153
     1154/*****************************************************************************
     1155 * Name      :
     1156 * Purpose   :
     1157 * Parameters:
     1158 * Variables :
     1159 * Result    :
     1160 * Remark    :
     1161 * Status    : UNTESTED STUB
     1162 *
     1163 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1164 *****************************************************************************/
     1165
     1166ODINFUNCTION6(LHANDLE,OS2WSAAsyncGetServByName,
     1167              HWND,hWnd,
     1168              u_int,wMsg,
     1169              const char *,name,
     1170              const char *,proto,
     1171              char *,buf,
     1172              int,buflen)
     1173{
     1174  int   rc;
     1175  HWND  hwndOS2 = Win32ToOS2Handle(hWnd);
     1176  ULONG ulNewID;
     1177
     1178  if (hwndRelay == NULL) // already initialized ?
     1179    hwndRelay = RelayInitialize(hwndOS2);
     1180
     1181  // add entry to list, we need to store both our temp buffer and the apps buffer
     1182  ulNewID = RelayAlloc(hWnd,
     1183                       wMsg,
     1184                       ASYNCREQUEST_GETSERVBYNAME,
     1185                       FALSE,
     1186                       buf);
     1187
     1188  // call pmwsock function, will fill our temp buffer
     1189  rc = WSAAsyncGetServByName(hwndRelay,
     1190                              ulNewID,
     1191                              name,
     1192                              proto,
     1193                              buf,
     1194                              buflen);
     1195
     1196  // if an error occurs, free the allocated relay entry
     1197  if (rc == SOCKET_ERROR)
     1198    RelayFree(ulNewID);
     1199
     1200  return (rc);
     1201}
     1202
     1203
     1204/*****************************************************************************
     1205 * Name      :
     1206 * Purpose   :
     1207 * Parameters:
     1208 * Variables :
     1209 * Result    :
     1210 * Remark    :
     1211 * Status    : UNTESTED STUB
     1212 *
     1213 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1214 *****************************************************************************/
     1215
     1216ODINFUNCTION6(LHANDLE,OS2WSAAsyncGetServByPort,
     1217              HWND,hWnd,
     1218              u_int,wMsg,
     1219              int,port,
     1220              const char *,proto,
     1221              char *,buf,
     1222              int,buflen)
     1223{
     1224  int   rc;
     1225  HWND  hwndOS2 = Win32ToOS2Handle(hWnd);
     1226  ULONG ulNewID;
     1227
     1228  if (hwndRelay == NULL) // already initialized ?
     1229    hwndRelay = RelayInitialize(hwndOS2);
     1230
     1231  // add entry to list, we need to store both our temp buffer and the apps buffer
     1232  ulNewID = RelayAlloc(hWnd,
     1233                       wMsg,
     1234                       ASYNCREQUEST_GETSERVBYPORT,
     1235                       FALSE,
     1236                       buf);
     1237
     1238  // call pmwsock function, will fill our temp buffer
     1239  rc = WSAAsyncGetServByPort(hwndRelay,
     1240                             ulNewID,
     1241                             port,
     1242                             proto,
     1243                             buf,
     1244                             buflen);
     1245
     1246  // if an error occurs, free the allocated relay entry
     1247  if (rc == SOCKET_ERROR)
     1248    RelayFree(ulNewID);
     1249
     1250  return rc;
     1251}
     1252
     1253
     1254/*****************************************************************************
     1255 * Name      :
     1256 * Purpose   :
     1257 * Parameters:
     1258 * Variables :
     1259 * Result    :
     1260 * Remark    :
     1261 * Status    : UNTESTED STUB
     1262 *
     1263 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1264 *****************************************************************************/
     1265
     1266ODINFUNCTION5(LHANDLE,OS2WSAAsyncGetProtoByName,
     1267              HWND,hWnd,
     1268              u_int,wMsg,
     1269              const char *,name,
     1270              char *,buf,
     1271              int,buflen)
     1272{
     1273  int   rc;
     1274  HWND  hwndOS2 = Win32ToOS2Handle(hWnd);
     1275  ULONG ulNewID;
     1276
     1277  if (hwndRelay == NULL) // already initialized ?
     1278    hwndRelay = RelayInitialize(hwndOS2);
     1279
     1280  // add entry to list, we need to store both our temp buffer and the apps buffer
     1281  ulNewID = RelayAlloc(hWnd,
     1282                       wMsg,
     1283                       ASYNCREQUEST_GETPROTOBYNAME,
     1284                       FALSE,
     1285                       buf);
     1286
     1287  // call pmwsock function, will fill our temp buffer
     1288  rc = WSAAsyncGetProtoByName(hwndRelay,
     1289                              ulNewID,
     1290                              name,
     1291                              buf,
     1292                              buflen);
     1293
     1294  // if an error occurs, free the allocated relay entry
     1295  if (rc == SOCKET_ERROR)
     1296    RelayFree(ulNewID);
     1297
     1298  return (rc);
     1299}
     1300
     1301
     1302/*****************************************************************************
     1303 * Name      :
     1304 * Purpose   :
     1305 * Parameters:
     1306 * Variables :
     1307 * Result    :
     1308 * Remark    :
     1309 * Status    : UNTESTED STUB
     1310 *
     1311 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1312 *****************************************************************************/
     1313
     1314ODINFUNCTION5(LHANDLE,OS2WSAAsyncGetProtoByNumber,
     1315              HWND,hWnd,
     1316              u_int,wMsg,
     1317              int,number,
     1318              char *,buf,
     1319              int,buflen)
     1320{
     1321  int   rc;
     1322  HWND  hwndOS2 = Win32ToOS2Handle(hWnd);
     1323  ULONG ulNewID;
     1324
     1325  if (hwndRelay == NULL) // already initialized ?
     1326    hwndRelay = RelayInitialize(hwndOS2);
     1327
     1328  // add entry to list, we need to store both our temp buffer and the apps buffer
     1329  ulNewID = RelayAlloc(hWnd,
     1330                       wMsg,
     1331                       ASYNCREQUEST_GETPROTOBYNUMBER,
     1332                       FALSE,
     1333                       buf);
     1334
     1335  // call pmwsock function, will fill our temp buffer
     1336  rc = WSAAsyncGetProtoByNumber(hwndRelay,
     1337                                ulNewID,
     1338                                number,
     1339                                buf,
     1340                                buflen);
     1341
     1342  // if an error occurs, free the allocated relay entry
     1343  if (rc == SOCKET_ERROR)
     1344    RelayFree(ulNewID);
     1345
     1346  return rc;
     1347}
     1348
     1349
     1350/*****************************************************************************
     1351 * Name      :
     1352 * Purpose   :
     1353 * Parameters:
     1354 * Variables :
     1355 * Result    :
     1356 * Remark    :
     1357 * Status    : UNTESTED STUB
     1358 *
     1359 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1360 *****************************************************************************/
     1361
     1362ODINFUNCTION5(LHANDLE,OS2WSAAsyncGetHostByName,
     1363              HWND,hWnd,
     1364              u_int,wMsg,
     1365              const char *,name,
     1366              char *,buf,
     1367              int,buflen)
     1368{
     1369  int   rc;
     1370  HWND  hwndOS2 = Win32ToOS2Handle(hWnd);
     1371  ULONG ulNewID;
     1372
     1373  if (hwndRelay == NULL) // already initialized ?
     1374    hwndRelay = RelayInitialize(hwndOS2);
     1375
     1376  // add entry to list, we need to store both our temp buffer and the apps buffer
     1377  ulNewID = RelayAlloc(hWnd,
     1378                       wMsg,
     1379                       ASYNCREQUEST_GETHOSTBYNAME,
     1380                       FALSE,
     1381                       (PVOID)buf, (PVOID)buflen);
     1382
     1383  // call pmwsock function, will fill our temp buffer
     1384  rc = WSAAsyncGetHostByName(hwndRelay,
     1385                             ulNewID,
     1386                             name,
     1387                             buf,
     1388                             buflen);
     1389
     1390  // if an error occurs, free the allocated relay entry
     1391  if (rc == SOCKET_ERROR)
     1392    RelayFree(ulNewID);
     1393
     1394  return rc;
     1395}
     1396
     1397
     1398/*****************************************************************************
     1399 * Name      :
     1400 * Purpose   :
     1401 * Parameters:
     1402 * Variables :
     1403 * Result    :
     1404 * Remark    :
     1405 * Status    : UNTESTED STUB
     1406 *
     1407 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1408 *****************************************************************************/
     1409
     1410ODINFUNCTION7(LHANDLE,OS2WSAAsyncGetHostByAddr,
     1411              HWND,hWnd,
     1412              u_int,wMsg,
     1413              const char *,addr,
     1414              int,len,
     1415              int,type,
     1416              char *,buf,
     1417              int,buflen)
     1418{
     1419  int   rc;
     1420  HWND  hwndOS2 = Win32ToOS2Handle(hWnd);
     1421  ULONG ulNewID;
     1422
     1423  if (hwndRelay == NULL) // already initialized ?
     1424    hwndRelay = RelayInitialize(hwndOS2);
     1425
     1426  // add entry to list, we need to store both our temp buffer and the apps buffer
     1427  ulNewID = RelayAlloc(hWnd,
     1428                       wMsg,
     1429                       ASYNCREQUEST_GETHOSTBYADDR,
     1430                       FALSE,
     1431                       buf);
     1432
     1433  // call pmwsock function, will fill our temp buffer
     1434  rc = WSAAsyncGetHostByAddr(hwndRelay,
     1435                             ulNewID,
     1436                             addr,
     1437                             len,
     1438                             type,
     1439                             buf,
     1440                             buflen);
     1441
     1442  // if an error occurs, free the allocated relay entry
     1443  if (rc == SOCKET_ERROR)
     1444    RelayFree(ulNewID);
     1445
     1446  return (rc);
     1447}
     1448
     1449
     1450/*****************************************************************************
     1451 * Name      :
     1452 * Purpose   :
     1453 * Parameters:
     1454 * Variables :
     1455 * Result    :
     1456 * Remark    :
     1457 * Status    : UNTESTED STUB
     1458 *
     1459 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1460 *****************************************************************************/
     1461
     1462ODINFUNCTION1(int,OS2WSACancelAsyncRequest,
     1463              LHANDLE,hAsyncTaskHandle)
     1464{
     1465  return(WSACancelAsyncRequest(hAsyncTaskHandle));
     1466}
     1467
     1468
     1469/*****************************************************************************
     1470 * Name      :
     1471 * Purpose   :
     1472 * Parameters:
     1473 * Variables :
     1474 * Result    :
     1475 * Remark    :
     1476 * Status    : UNTESTED STUB
     1477 *
     1478 * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
     1479 *****************************************************************************/
     1480
     1481ODINFUNCTION4(int,OS2WSAAsyncSelect,
     1482              SOCKET,s,
     1483              HWND,hWnd,
     1484              u_int,wMsg,
     1485              long,lEvent)
     1486{
     1487  int   rc;
     1488//  int   iError;
     1489  HWND  hwndOS2 = Win32ToOS2Handle(hWnd);
     1490  ULONG ulNewID;
     1491
     1492  if (hwndRelay == NULL) // already initialized ?
     1493    hwndRelay = RelayInitialize(hwndOS2);
     1494
     1495  /* @@@PH: our source window doesn't seem to have an anchor block.
     1496            Docs suggest we've missed to call WinInitialize on the
     1497            caller thread.
     1498
     1499            Cause however is the Open32 handle is (of course!) invalid
     1500            in plain PM Window Manager! -> use DAPWSOCK
     1501
     1502            Unfortunately, DAPWSOCK calls WinQueryAnchorBlock(hOpen32), too.
     1503            So, we're stuck until I resolve hWnd to it's valid PM
     1504            counterpart.
     1505
     1506            new problem: we've ultimately got to use PostMessageA instead
     1507            anything else. => create invisible msg relay window:
     1508            - hMsg = registerMessage(hWnd, wMsg)
     1509            - call WSAAsyncSelect with object window handle
     1510            - overwrite hWnd relay for "same handles"
     1511   */
     1512
     1513  // add event to list or remove any list entry in case of WSAAsyncSelect(hwnd,0,0)
     1514  if ( (wMsg == 0) && (lEvent == 0) )
    11761515  {
    1177 #ifdef DEBUG
    1178     WriteLog("WSOCK32: WSAStartup sock_init returned 0\n");
    1179 #endif
    1180     WSASetLastError(ERROR_SUCCESS);
    1181     return 0;
     1516    // remove entry from list
     1517    RelayFreeByHwnd(hWnd);
    11821518  }
    11831519  else
    1184   {
    1185     WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
    1186     return(WSASYSNOTREADY);
    1187   }
    1188 }
    1189 
    1190 
    1191 /*****************************************************************************
    1192  * Name      :
    1193  * Purpose   :
    1194  * Parameters:
    1195  * Variables :
    1196  * Result    :
    1197  * Remark    :
    1198  * Status    : UNTESTED STUB
    1199  *
    1200  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    1201  *****************************************************************************/
    1202 
    1203 ODINFUNCTION0(int,OS2WSACleanup)
    1204 {
    1205   WSASetLastError(ERROR_SUCCESS);
    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 
    1222 ODINPROCEDURE1(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 
    1241 ODINFUNCTION0(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 
    1260 ODINFUNCTION0(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 
    1280 ODINFUNCTION1(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 
    1299 ODINFUNCTION0(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 
    1319 ODINFUNCTION4(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 
    1343 ODINPROCEDURE2(OS2s_perror, char*, pszMessage,
    1344                             void*, pUnknown)
    1345 {
    1346   perror(pszMessage);
    1347 }
    1348 
    1349 
     1520    // add entry to list
     1521    ulNewID = RelayAlloc(hWnd,
     1522                         wMsg,
     1523                         ASYNCREQUEST_SELECT,
     1524                         TRUE);
     1525
     1526  rc = WSAAsyncSelect(s,
     1527                      hwndRelay,
     1528                      ulNewID,
     1529                      lEvent);
     1530
     1531//  iError = WSAGetLastError();
     1532//  dprintf(("res=%d, err=%d\n",
     1533//           rc,
     1534//           iError));
     1535  return (rc);
     1536}
Note: See TracChangeset for help on using the changeset viewer.