Changeset 2013 for trunk/src/wsock32


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

promoted new wsock32 as default

Location:
trunk/src/wsock32
Files:
3 added
4 deleted
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wsock32/initterm.cpp

    r951 r2013  
    1 /* $Id: initterm.cpp,v 1.7 1999-09-15 23:26:11 sandervl Exp $ */
     1/* $Id: initterm.cpp,v 1.8 1999-12-07 20:25:47 achimha Exp $ */
    22
    33/*

  • trunk/src/wsock32/makefile

    r1715 r2013  
    1 # $Id: makefile,v 1.13 1999-11-12 15:46:19 bird Exp $
     1# $Id: makefile,v 1.14 1999-12-07 20:26:08 achimha Exp $
    22
    33#
    … …  
    77#
    88
    9 PDWIN32_INCLUDE = ..\..\include
    10 PDWIN32_LIB = ..\..\lib
    11 PDWIN32_BIN = ..\..\bin
    12 PDWIN32_TOOLS = ..\..\tools\bin
     9PDWIN32_INCLUDE = ..\..\..\include
     10PDWIN32_LIB = ..\..\..\lib
     11PDWIN32_BIN = ..\..\..\bin
     12PDWIN32_TOOLS = ..\..\..\tools\bin
    1313
    1414!include $(PDWIN32_INCLUDE)/pdwin32.mk
    … …  
    2121TARGET = wsock32
    2222
    23 OBJS =  wsock32.obj initterm.obj unknown.obj async.obj
     23OBJS =  wsock32.obj initterm.obj unknown.obj relaywin.obj
    2424
    2525all: $(TARGET).dll $(TARGET).lib
    … …  
    2828$(TARGET).dll: $(OBJS) $(TARGET).def
    2929        $(LD) $(LDFLAGS) -Fm -Fe$@ $(OBJS) $(TARGET).def \
    30               $(PDWIN32_LIB)\pmwinx.lib $(PDWIN32_LIB)\user32.lib \
    31               tcp32dll.lib so32dll.lib  $(PDWIN32_LIB)\kernel32.lib \
     30              pmwsock.lib $(PDWIN32_LIB)\kernel32.lib \
     31              $(PDWIN32_LIB)\user32.lib \
    3232              $(PDWIN32_LIB)/odincrt.lib OS2386.LIB $(RTLLIB_O)
    3333        $(CP) $@ $(PDWIN32_BIN)
    … …  
    4040    $(IMPDEF) $** $@
    4141
    42 wsock32.obj: wsock32.cpp wsock32.h wsock32const.h
    43 unknown.obj: unknown.cpp wsock32.h
    44 async.obj:   async.cpp wsock32const.h
     42wsock32.obj: wsock32.cpp   relaywin.h wsock32.h
     43unknown.obj: unknown.cpp   wsock32.h
    4544initterm.obj: initterm.cpp
     45relaywin.obj: relaywin.cpp relaywin.h wsock32.h
    4646
    4747

  • trunk/src/wsock32/unknown.cpp

    r1367 r2013  
    1 /* $Id: unknown.cpp,v 1.3 1999-10-20 01:18:30 phaller Exp $ */
     1/* $Id: unknown.cpp,v 1.4 1999-12-07 20:25:48 achimha Exp $ */
    22
    33/*
    … …  
    2222 * Prototypes & Types & Defines                                              *
    2323 *****************************************************************************/
     24
     25typedef int SOCKET;
    2426
    2527int _System rexec(char **, int, char *, char *, char *, int *);
    … …  
    9193
    9294
     95/*****************************************************************************
     96 * Name      :
     97 * Purpose   :
     98 * Parameters:
     99 * Variables :
     100 * Result    :
     101 * Remark    :
     102 * Status    : UNTESTED STUB
     103 *
     104 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     105 *****************************************************************************/
     106
     107ODINFUNCTION4(int, OS2WSARecvEx, SOCKET,    s,
     108                                 char FAR*, buf,
     109                                 int,       len,
     110                                 int FAR *,flags)
     111{
     112  dprintf(("WSOCK32: WSARecvEx not implemented.\n"));
     113
     114//    return WSARecvEx(s,buf,len,flags);
     115  return 0;
     116}
     117
     118
     119/*****************************************************************************
     120 * Name      :
     121 * Purpose   :
     122 * Parameters:
     123 * Variables :
     124 * Result    :
     125 * Remark    :
     126 * Status    : UNTESTED STUB
     127 *
     128 * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
     129 *****************************************************************************/
     130
     131ODINPROCEDURE2(OS2s_perror, char*, pszMessage,
     132                            void*, pUnknown)
     133{
     134  dprintf(("WSOCK32: s_perror not implemented.\n"));
     135
     136  //perror(pszMessage);
     137}
     138
     139

  • 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}

  • trunk/src/wsock32/wsock32.def

    r1690 r2013  
    1 ; $Id: wsock32.def,v 1.14 1999-11-10 16:36:16 phaller Exp $
     1; $Id: wsock32.def,v 1.15 1999-12-07 20:25:48 achimha Exp $
    22
    33;Created by BLAST for IBM's compiler
    … …  
    55DATA MULTIPLE NONSHARED
    66
    7 IMPORTS
    8     PostMessageA           = USER32.416
    9     bsd_select             = SO32DLL.32
    10     os2_select             = SO32DLL.12
    117
    128EXPORTS
    13 ;   Arecv = _OS2Arecv
    14 ;   Asend = _OS2Asend
    15 ;   EnumProtocolsA = _OS2EnumProtocolsA
    16 ;   EnumProtocolsW = _OS2EnumProtocolsW
    17 ;   GetAddressByNameA = _OS2GetAddressByNameA
    18 ;   GetAddressByNameW = _OS2GetAddressByNameW
    19 ;   GetNameByTypeA = _OS2GetNameByTypeA
    20 ;   GetNameByTypeW = _OS2GetNameByTypeW
    21 ;   GetServiceA = _OS2GetServiceA
    22 ;   GetServiceW = _OS2GetServiceW
    23 ;   GetTypeByNameA = _OS2GetTypeByNameA
    24 ;   GetTypeByNameW = _OS2GetTypeByNameW
    25 ;   NPLoadNameSpaces = _OS2NPLoadNameSpaces
    26 ;   SetServiceA = _OS2SetServiceA
    27 ;   SetServiceW = _OS2SetServiceW
    28 ;   TransmitFile = _OS2TransmitFile
    29    accept =                    _OS2accept@12                           @1
    30    bind =                      _OS2bind@12                             @2
    31    closesocket =               _OS2closesocket@4                       @3
    32    connect =                   _OS2connect@12                          @4
    33    getpeername =               _OS2getpeername@12                      @5
    34    getsockname =               _OS2getsockname@12                      @6
    35    getsockopt =        _OS2getsockopt@20                       @7
    36    htonl =                     _OS2htonl@4                             @8
    37    htons =                     _OS2htons@4                             @9
    38    inet_addr =         _OS2inet_addr@4                         @10
    39    inet_ntoa =         _OS2inet_ntoa@4                         @11
    40    ioctlsocket =               _OS2ioctlsocket@12                      @12
    41    listen =                    _OS2listen@8                            @13
    42    ntohl =                     _OS2ntohl@4                             @14
    43    ntohs =                     _OS2ntohs@4                             @15
    44    recv =                      _OS2recv@16                             @16
    45    recvfrom =                  _OS2recvfrom@24                         @17
    46    select =                    _OS2select@20                           @18
    47    send =                      _OS2send@16                             @19
    48    sendto =                    _OS2sendto@24                           @20
    49    setsockopt                  =  _OS2setsockopt@20                    @21
    50    shutdown =                  _OS2shutdown@8                          @22
    51    socket =                    _OS2socket@12                           @23
    529
    53    gethostbyaddr =             _OS2gethostbyaddr@12                    @51
    54    gethostbyname =             _OS2gethostbyname@4                     @52
    55    getprotobyname =            _OS2getprotobyname@4                    @53
    56    getprotobynumber =          _OS2getprotobynumber@4                  @54
    57    getservbyname =             _OS2getservbyname@8                     @55
    58    getservbyport =             _OS2getservbyport@8                     @56
    59    gethostname =               _OS2gethostname@8                       @57
     10; ----------------------
     11; BSD Standard Functions
     12; ----------------------
    6013
    61    WSAAsyncSelect              = _WSAAsyncSelect@16                    @101
     14   accept                      = _OS2accept@12                            @1
     15   bind                        = _OS2bind@12                              @2
     16   closesocket                 = _OS2closesocket@4                        @3
     17   connect                     = _OS2connect@12                           @4
     18   getpeername                 = _OS2getpeername@12                       @5
     19   getsockname                 = _OS2getsockname@12                       @6
     20   getsockopt                  = _OS2getsockopt@20                        @7
     21   htonl                       = _OS2htonl@4                              @8
     22   htons                       = _OS2htons@4                              @9
     23   inet_addr                   = _OS2inet_addr@4                          @10
     24   inet_ntoa                   = _OS2inet_ntoa@4                          @11
     25   ioctlsocket                 = _OS2ioctlsocket@12                       @12
     26   listen                      = _OS2listen@8                             @13
     27   ntohl                       = _OS2ntohl@4                              @14
     28   ntohs                       = _OS2ntohs@4                              @15
     29   recv                        = _OS2recv@16                              @16
     30   recvfrom                    = _OS2recvfrom@24                          @17
     31   select                      = _OS2select@20                            @18
     32   send                        = _OS2send@16                              @19
     33   sendto                      = _OS2sendto@24                            @20
     34   setsockopt                  = _OS2setsockopt@20                        @21
     35   shutdown                    = _OS2shutdown@8                           @22
     36   socket                      = _OS2socket@12                            @23
    6237
    63    WSAAsyncGetHostByAddr       = _WSAAsyncGetHostByAddr@28             @102
    64    WSAAsyncGetHostByName       = _WSAAsyncGetHostByName@20             @103
    65    WSAAsyncGetProtoByNumber    = _WSAAsyncGetProtoByNumber@20          @104
    66    WSAAsyncGetProtoByName      = _WSAAsyncGetProtoByName@20            @105
    67    WSAAsyncGetServByPort       = _WSAAsyncGetServByPort@24             @106
    68    WSAAsyncGetServByName       = _WSAAsyncGetServByName@24             @107
    69    WSACancelAsyncRequest       = _WSACancelAsyncRequest@4              @108
     38   gethostbyaddr               = _OS2gethostbyaddr@12                     @51
     39   gethostbyname               = _OS2gethostbyname@4                      @52
     40   getprotobyname              = _OS2getprotobyname@4                     @53
     41   getprotobynumber            = _OS2getprotobynumber@4                   @54
     42   getservbyname               = _OS2getservbyname@8                      @55
     43   getservbyport               = _OS2getservbyport@8                      @56
     44   gethostname                 = _OS2gethostname@8                        @57
    7045
    71    WSASetBlockingHook =      _OS2WSASetBlockingHook@4                  @109
    72    WSAUnhookBlockingHook =   _OS2WSAUnhookBlockingHook@0       @110
    73    WSAGetLastError =           _WSAGetLastError@0                   @111
    74    WSASetLastError =           _WSASetLastError@4                   @112
    75    WSACancelBlockingCall =   _OS2WSACancelBlockingCall@0       @113
     46; ----------------------------
     47; Microsoft WinSock Extensions
     48; ----------------------------
    7649
    77    WSAIsBlocking               = _WSAIsBlocking@0                      @114
     50   WSAAsyncSelect              = _OS2WSAAsyncSelect@16                    @101
     51   WSAAsyncGetHostByAddr       = _OS2WSAAsyncGetHostByAddr@28             @102
     52   WSAAsyncGetHostByName       = _OS2WSAAsyncGetHostByName@20             @103
     53   WSAAsyncGetProtoByNumber    = _OS2WSAAsyncGetProtoByNumber@20          @104
     54   WSAAsyncGetProtoByName      = _OS2WSAAsyncGetProtoByName@20            @105
     55   WSAAsyncGetServByPort       = _OS2WSAAsyncGetServByPort@24             @106
     56   WSAAsyncGetServByName       = _OS2WSAAsyncGetServByName@24             @107
     57   WSACancelAsyncRequest       = _OS2WSACancelAsyncRequest@4              @108
     58   WSASetBlockingHook          = _OS2WSASetBlockingHook@4                 @109
     59   WSAUnhookBlockingHook       = _OS2WSAUnhookBlockingHook@0              @110
     60   WSAGetLastError             = _OS2WSAGetLastError@0                    @111
     61   WSASetLastError             = _OS2WSASetLastError@4                    @112
     62   WSACancelBlockingCall       = _OS2WSACancelBlockingCall@0              @113
     63   WSAIsBlocking               = _OS2WSAIsBlocking@0                      @114
     64   WSAStartup                  = _OS2WSAStartup@8                         @115
     65   WSACleanup                  = _OS2WSACleanup@0                         @116
     66   __WSAFDIsSet                = _OS2__WSAFDIsSet@8                       @151
    7867
    79    WSAStartup =        _OS2WSAStartup@8                        @115
    80    WSACleanup =        _OS2WSACleanup@0                        @116
     68   rcmd                        = _OS2rcmd@24                              @1102
     69   rexec                       = _OS2rexec@24                             @1103
     70   WSARecvEx                   = _OS2WSARecvEx@16                         @1107
     71   s_perror                    = _OS2s_perror@8                           @1108
    8172
    82    __WSAFDIsSet =              _OS2__WSAFDIsSet@8                      @151
     73; -------------------
     74; not yet implemented
     75; -------------------
    8376
    84 ;   WsControl =                _OS2WsControl                           @1000
    85 ;   closesockinfo =            _OS2closesockinfo                       @1001
    86 ;   WSHEnumProtocols =         _OS2WSHEnumProtocols                    @1004
    87 ;   inet_network =             _OS2inet_network                        @1100
    88 ;   getnetbyname =             _OS2getnetbyname                        @1101
    89     rcmd =                     _OS2rcmd@24                             @1102
    90     rexec =                    _OS2rexec@24                            @1103
    91 ;   rresvport =                _OS2rresvport                           @1104
    92 ;   sethostname =              _OS2sethostname                         @1105
    93 ;   dn_expand =                _OS2dn_expand                           @1106
    94    WSARecvEx =         _OS2WSARecvEx@16                        @1107
    95    s_perror =          _OS2s_perror@8                          @1108
     77;  WsControl                   = _OS2WsControl                            @1000
     78;  closesockinfo               = _OS2closesockinfo                        @1001
     79;  WSHEnumProtocols            = _OS2WSHEnumProtocols                     @1004
     80;  inet_network                = _OS2inet_network                         @1100
     81;  getnetbyname                = _OS2getnetbyname                         @1101
     82;  rresvport                   = _OS2rresvport                            @1104
     83;  sethostname                 = _OS2sethostname                          @1105
     84;  dn_expand                   = _OS2dn_expand                            @1106
     85;  Arecv                       = _OS2Arecv
     86;  Asend                       = _OS2Asend
     87;  EnumProtocolsA              = _OS2EnumProtocolsA
     88;  EnumProtocolsW              = _OS2EnumProtocolsW
     89;  GetAddressByNameA           = _OS2GetAddressByNameA
     90;  GetAddressByNameW           = _OS2GetAddressByNameW
     91;  GetNameByTypeA              = _OS2GetNameByTypeA
     92;  GetNameByTypeW              = _OS2GetNameByTypeW
     93;  GetServiceA                 = _OS2GetServiceA
     94;  GetServiceW                 = _OS2GetServiceW
     95;  GetTypeByNameA              = _OS2GetTypeByNameA
     96;  GetTypeByNameW              = _OS2GetTypeByNameW
     97;  NPLoadNameSpaces            = _OS2NPLoadNameSpaces
     98;  SetServiceA                 = _OS2SetServiceA
     99;  SetServiceW                 = _OS2SetServiceW
     100;  TransmitFile                = _OS2TransmitFile
    96101
    97 _OS2gethostname@8                            @2000
     102; -----------------------
     103; ODIN internal functions
     104; -----------------------
     105
     106                                 _OS2gethostname@8                        @2000

  • trunk/src/wsock32/wsock32.h

    r1807 r2013  
    1 /* $Id: wsock32.h,v 1.8 1999-11-22 08:18:02 phaller Exp $ */
     1/* $Id: wsock32.h,v 1.9 1999-12-07 20:25:48 achimha Exp $ */
    22
    33/* WSOCK32.H--definitions & conversions for Odin's wsock32.dll.
    … …  
    1313 */
    1414
    15 #ifndef _WINSOCKAPI_
    16 #define _WINSOCKAPI_
     15#ifndef _WINSOCK32CONST_
     16#define _WINSOCK32CONST_
    1717
    18 
    19 #ifdef MAKELONG
    20 #  undef MAKELONG
    21 #endif
    22 
    23 #ifdef MAKEWORD
    24 #  undef MAKEWORD
    25 #endif
    26 
    27 #ifdef LOBYTE
    28 #  undef LOBYTE
    29 #endif
    30 
    31 #ifdef LOWORD
    32 #  undef LOWORD
    33 #endif
    34 
    35 #ifdef HIBYTE
    36 #  undef HIBYTE
    37 #endif
    38 
    39 #ifdef HIWORD
    40 #  undef HIWORD
    41 #endif
    42 
    43 #define MAKEWORD(a, b)      ((WORD)(((BYTE)(a)) | ((WORD)((BYTE)(b))) << 8))
    44 #define MAKELONG(a, b)      ((LONG)(((WORD)(a)) | ((DWORD)((WORD)(b))) << 16))
    45 #define LOWORD(l)           ((WORD)(l))
    46 #define HIWORD(l)           ((WORD)(((DWORD)(l) >> 16) & 0xFFFF))
    47 #define LOBYTE(w)           ((BYTE)(w))
    48 #define HIBYTE(w)           ((BYTE)(((WORD)(w) >> 8) & 0xFF))
    49 
    50 
    51 
    52 /*
    53  * Basic system type definitions, taken from the BSD file sys/types.h.
    54  */
    55 
    56 #ifdef __WATCOM__
    57 typedef unsigned char   u_char;
    58 typedef unsigned short  u_short;
    59 typedef unsigned int    u_int;
    60 typedef unsigned long   u_long;
    61   typedef int ( WIN32API *PROC)();
    62 #else
    63   typedef int (*  WIN32API PROC)();
    64 #endif
    65 
    66 //typedef unsigned short  WORD;
    67 //typedef unsigned long   DWORD;
    68 //typedef ULONG HANDLE, *PHANDLE, *LPHANDLE, *SPHANDLE;
    69 
    70 /*
    71  * The new type to be used in all
    72  * instances which refer to sockets.
    73  */
    74 typedef u_int           SOCKET;
    75 
    76 
    77 
    78 /*
    79  * Select uses arrays of SOCKETs.  These macros manipulate such
    80  * arrays.  FD_SETSIZE may be defined by the user before including
    81  * this file, but the default here should be >= 64.
    82  *
    83  * CAVEAT IMPLEMENTOR and USER: THESE MACROS AND TYPES MUST BE
    84  * INCLUDED IN WINSOCK.H EXACTLY AS SHOWN HERE.
    85  */
    86 #ifndef FD_SETSIZE
    87 #define FD_SETSIZE      64
    88 #endif /* FD_SETSIZE */
    89 
    90 typedef struct Wfd_set {
    91         u_int   fd_count;               /* how many are SET? */
    92         SOCKET  fd_array[FD_SETSIZE];   /* an array of SOCKETs */
    93 } Wfd_set;
    94 
    95 
    96 
    97 #ifdef __cplusplus
    98 extern "C" {
    99 #endif
    100 
    101 extern int PASCAL  __WSAFDIsSet(SOCKET, Wfd_set  *);
    102 
    103 #ifdef __cplusplus
    104 }
    105 #endif
    106 
    107 /*
    108 #define FD_CLR(fd, set) do { \
    109     u_int __i; \
    110     for (__i = 0; __i < ((Wfd_set  *)(set))->fd_count ; __i++) { \
    111         if (((Wfd_set  *)(set))->fd_array[__i] == fd) { \
    112             while (__i < ((Wfd_set  *)(set))->fd_count-1) { \
    113                 ((Wfd_set  *)(set))->fd_array[__i] = \
    114                     ((Wfd_set  *)(set))->fd_array[__i+1]; \
    115                 __i++; \
    116             } \
    117             ((Wfd_set  *)(set))->fd_count--; \
    118             break; \
    119         } \
    120     } \
    121 } while(0)
    122 
    123 #define FD_SET(fd, set) do { \
    124     if (((Wfd_set  *)(set))->fd_count < FD_SETSIZE) \
    125         ((Wfd_set  *)(set))->fd_array[((Wfd_set  *)(set))->fd_count++]=(fd);\
    126 } while(0)
    127 
    128 #define FD_ZERO(set) (((Wfd_set  *)(set))->fd_count=0)
    129 
    130 #define FD_ISSET(fd, set) __WSAFDIsSet((SOCKET)(fd), (Wfd_set  *)(set))
    131 */
    132 
    133 /*
    134  * Structure used in select() call, taken from the BSD file sys/time.h.
    135  */
    136 struct Wtimeval {
    137         long    tv_sec;         /* seconds */
    138         long    tv_usec;        /* and microseconds */
    139 };
    140 
    141 /*
    142  * Operations on timevals.
    143  *
    144  * NB: timercmp does not work for >= or <=.
    145  */
    146 #define timerisset(tvp)         ((tvp)->tv_sec || (tvp)->tv_usec)
    147 #define Wtimercmp(tvp, uvp, cmp) \
    148         ((tvp)->tv_sec cmp (uvp)->tv_sec || \
    149          (tvp)->tv_sec == (uvp)->tv_sec && (tvp)->tv_usec cmp (uvp)->tv_usec)
    150 #define timerclear(tvp)         (tvp)->tv_sec = (tvp)->tv_usec = 0
    151 
    152 /*
    153  * Commands for ioctlsocket(),  taken from the BSD file fcntl.h.
    154  *
    155  *
    156  * Ioctl's have the command encoded in the lower word,
    157  * and the size of any in or out parameters in the upper
    158  * word.  The high 2 bits of the upper word are used
    159  * to encode the in/out status of the parameter; for now
    160  * we restrict parameters to at most 128 bytes.
    161  */
    162 #define IOCPARM_MASK    0x7f            /* parameters must be < 128 bytes */
    163 #define IOC_VOID        0x20000000      /* no parameters */
    164 #define IOC_OUT         0x40000000      /* copy out parameters */
    165 #define IOC_IN          0x80000000      /* copy in parameters */
    166 #define IOC_INOUT       (IOC_IN|IOC_OUT)
    167                                         /* 0x20000000 distinguishes new &
    168                                            old ioctl's */
    169 #define _IO(x,y)        (IOC_VOID|((x)<<8)|(y))
    170 
    171 #define _IOR(x,y,t)     (IOC_OUT|(((long)sizeof(t)&IOCPARM_MASK)<<16)|((x)<<8)|(y))
    172 
    173 #define _IOW(x,y,t)     (IOC_IN|(((long)sizeof(t)&IOCPARM_MASK)<<16)|((x)<<8)|(y))
    174 
    175 #define WFIONREAD    _IOR('f', 127, u_long) /* get # bytes to read */
    176 #define WFIONBIO     _IOW('f', 126, u_long) /* set/clear non-blocking i/o */
    177 #define WFIOASYNC    _IOW('f', 125, u_long) /* set/clear async i/o */
    178 
    179 /* Socket I/O Controls */
    180 #define WSIOCSHIWAT  _IOW('s',  0, u_long)  /* set high watermark */
    181 #define WSIOCGHIWAT  _IOR('s',  1, u_long)  /* get high watermark */
    182 #define WSIOCSLOWAT  _IOW('s',  2, u_long)  /* set low watermark */
    183 #define WSIOCGLOWAT  _IOR('s',  3, u_long)  /* get low watermark */
    184 #define WSIOCATMARK  _IOR('s',  7, u_long)  /* at oob mark? */
    185 
    186 /*
    187  * Constants and structures defined by the internet system,
    188  * Per RFC 790, September 1981, taken from the BSD file netinet/in.h.
    189  */
    190 
    191 /*
    192  * Protocols
    193  */
    194 #define IPPROTO_IP              0               /* dummy for IP */
    195 #define IPPROTO_ICMP            1               /* control message protocol */
    196 //#define IPPROTO_GGP             2               /* gateway^2 (deprecated) */
    197 #define IPPROTO_TCP             6               /* tcp */
    198 #define IPPROTO_PUP             12              /* pup */
    199 #define IPPROTO_UDP             17              /* user datagram protocol */
    200 #define IPPROTO_IDP             22              /* xns idp */
    201 #define IPPROTO_ND              77              /* UNOFFICIAL net disk proto */
    202 
    203 #define IPPROTO_RAW             255             /* raw IP packet */
    204 #define IPPROTO_MAX             256
    205 
    206 /*
    207  * Port/socket numbers: network standard functions
    208  */
    209 #define IPPORT_ECHO             7
    210 #define IPPORT_DISCARD          9
    211 #define IPPORT_SYSTAT           11
    212 #define IPPORT_DAYTIME          13
    213 #define IPPORT_NETSTAT          15
    214 #define IPPORT_FTP              21
    215 #define IPPORT_TELNET           23
    216 #define IPPORT_SMTP             25
    217 #define IPPORT_TIMESERVER       37
    218 #define IPPORT_NAMESERVER       42
    219 #define IPPORT_WHOIS            43
    220 #define IPPORT_MTP              57
    221 
    222 /*
    223  * Port/socket numbers: host specific functions
    224  */
    225 #define IPPORT_TFTP             69
    226 #define IPPORT_RJE              77
    227 #define IPPORT_FINGER           79
    228 #define IPPORT_TTYLINK          87
    229 #define IPPORT_SUPDUP           95
    230 
    231 /*
    232  * UNIX TCP sockets
    233  */
    234 #define IPPORT_EXECSERVER       512
    235 #define IPPORT_LOGINSERVER      513
    236 #define IPPORT_CMDSERVER        514
    237 #define IPPORT_EFSSERVER        520
    238 
    239 /*
    240  * UNIX UDP sockets
    241  */
    242 #define IPPORT_BIFFUDP          512
    243 #define IPPORT_WHOSERVER        513
    244 #define IPPORT_ROUTESERVER      520
    245                                         /* 520+1 also used */
    246 
    247 /*
    248  * Ports < IPPORT_RESERVED are reserved for
    249  * privileged processes (e.g. root).
    250  */
    251 #define IPPORT_RESERVED         1024
    252 
    253 /*
    254  * Link numbers
    255  */
    256 #define IMPLINK_IP              155
    257 #define IMPLINK_LOWEXPER        156
    258 #define IMPLINK_HIGHEXPER       158
    259 
    260 /*
    261  * Internet address (old style... should be updated)
    262  */
    263 struct Win_addr {
    264         union {
    265                 struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
    266                 struct { u_short s_w1,s_w2; } S_un_w;
    267                 u_long S_addr;
    268         } S_un;
    269 #define s_addr  S_un.S_addr
    270                                 /* can be used for most tcp & ip code */
    271 #define s_host  S_un.S_un_b.s_b2
    272                                 /* host on imp */
    273 #define s_net   S_un.S_un_b.s_b1
    274                                 /* network */
    275 #define s_imp   S_un.S_un_w.s_w2
    276                                 /* imp */
    277 #define s_impno S_un.S_un_b.s_b4
    278                                 /* imp # */
    279 #define s_lh    S_un.S_un_b.s_b3
    280                                 /* logical host */
    281 };
    282 
    283 /*
    284  * Definitions of bits in internet address integers.
    285  * On subnets, the decomposition of addresses to host and net parts
    286  * is done according to subnet mask, not the masks here.
    287  */
    288 #define WIN_CLASSA(i)            (((long)(i) & 0x80000000) == 0)
    289 #define WIN_CLASSA_NET           0xff000000
    290 #define WIN_CLASSA_NSHIFT        24
    291 #define WIN_CLASSA_HOST          0x00ffffff
    292 #define WIN_CLASSA_MAX           128
    293 
    294 #define WIN_CLASSB(i)            (((long)(i) & 0xc0000000) == 0x80000000)
    295 #define WIN_CLASSB_NET           0xffff0000
    296 #define WIN_CLASSB_NSHIFT        16
    297 #define WIN_CLASSB_HOST          0x0000ffff
    298 #define WIN_CLASSB_MAX           65536
    299 
    300 #define WIN_CLASSC(i)            (((long)(i) & 0xe0000000) == 0xc0000000)
    301 #define WIN_CLASSC_NET           0xffffff00
    302 #define WIN_CLASSC_NSHIFT        8
    303 #define WIN_CLASSC_HOST          0x000000ff
    304 
    305 #define WINADDR_ANY              (u_long)0x00000000
    306 #define WINADDR_LOOPBACK         0x7f000001
    307 #define WINADDR_BROADCAST        (u_long)0xffffffff
    308 #define WINADDR_NONE             0xffffffff
    309 
    310 /*
    311  * Socket address, internet style.
    312  */
    313 struct Wsockaddr_in {
    314         short   sin_family;
    315         u_short sin_port;
    316         struct  in_addr sin_addr;
    317         char    sin_zero[8];
    318 };
    319 
    320 #define WSADESCRIPTION_LEN      256
    321 #define WSASYS_STATUS_LEN       128
    322 
    323 typedef struct WSAData {
    324         WORD                    wVersion;
    325         WORD                    wHighVersion;
    326         char                    szDescription[WSADESCRIPTION_LEN+1];
    327         char                    szSystemStatus[WSASYS_STATUS_LEN+1];
    328         unsigned short          iMaxSockets;
    329         unsigned short          iMaxUdpDg;
    330         char  *              lpVendorInfo;
    331 } WSADATA;
    332 
    333 typedef WSADATA  *LPWSADATA;
    334 
    335 /*
    336  * Options for use with [gs]etsockopt at the IP level.
    337  */
    338 #define IP_OPTIONS          1           /* set/get IP per-packet options    */
    339 
    340 /*
    341  * Definitions related to sockets: types, address families, options,
    342  * taken from the BSD file sys/socket.h.
    343  */
    344 
    345 
    346 /*
    347  * Types
    348  */
    349 #define SOCK_STREAM     1               /* stream socket */
    350 #define SOCK_DGRAM      2               /* datagram socket */
    351 #define SOCK_RAW        3               /* raw-protocol interface */
    352 #define SOCK_RDM        4               /* reliably-delivered message */
    353 #define SOCK_SEQPACKET  5               /* sequenced packet stream */
    354 
    355 /*
    356  * Option flags per-socket.
    357  */
    358 #define SO_DEBUG        0x0001          /* turn on debugging info recording */
    359 #define SO_ACCEPTCONN   0x0002          /* socket has had listen() */
    360 #define SO_REUSEADDR    0x0004          /* allow local address reuse */
    361 #define SO_KEEPALIVE    0x0008          /* keep connections alive */
    362 #define SO_DONTROUTE    0x0010          /* just use interface addresses */
    363 #define SO_BROADCAST    0x0020          /* permit sending of broadcast msgs */
    364 #define SO_USELOOPBACK  0x0040          /* bypass hardware when possible */
    365 #define SO_LINGER       0x0080          /* linger on close if data present */
    366 #define SO_OOBINLINE    0x0100          /* leave received OOB data in line */
    367 
    368 #define SO_DONTLINGER   (u_int)(~SO_LINGER)
    369 
    370 /*
    371  * Additional options.
    372  */
    373 #define SO_SNDBUF       0x1001          /* send buffer size */
    374 #define SO_RCVBUF       0x1002          /* receive buffer size */
    375 #define SO_SNDLOWAT     0x1003          /* send low-water mark */
    376 #define SO_RCVLOWAT     0x1004          /* receive low-water mark */
    377 #define SO_SNDTIMEO     0x1005          /* send timeout */
    378 #define SO_RCVTIMEO     0x1006          /* receive timeout */
    379 #define SO_ERROR        0x1007          /* get error status and clear */
    380 #define SO_TYPE         0x1008          /* get socket type */
    381 
    382 
    383 /*
    384  * TCP options.
    385  */
    386 #define TCP_NODELAY     0x0001
    387 #define TCP_BSDURGENT   0x7000
    388 
    389 /*
    390  * Address families.
    391  */
    392 #define AF_UNSPEC       0               /* unspecified */
    393 #define AF_UNIX         1               /* local to host (pipes, portals) */
    394 #define AF_INET         2               /* internetwork: UDP, TCP, etc. */
    395 #define AF_IMPLINK      3               /* arpanet imp addresses */
    396 #define AF_PUP          4               /* pup protocols: e.g. BSP */
    397 #define AF_CHAOS        5               /* mit CHAOS protocols */
    398 #define AF_IPX          6               /* IPX and SPX */
    399 #define AF_NS           6               /* XEROX NS protocols */
    400 #define AF_ISO          7               /* ISO protocols */
    401 #define AF_OSI          AF_ISO          /* OSI is ISO */
    402 #define AF_ECMA         8               /* european computer manufacturers */
    403 #define AF_DATAKIT      9               /* datakit protocols */
    404 #define AF_CCITT        10              /* CCITT protocols, X.25 etc */
    405 #define AF_SNA          11              /* IBM SNA */
    406 #define AF_DECnet       12              /* DECnet */
    407 #define AF_DLI          13              /* Direct data link interface */
    408 #define AF_LAT          14              /* LAT */
    409 #define AF_HYLINK       15              /* NSC Hyperchannel */
    410 #define AF_APPLETALK    16              /* AppleTalk */
    411 //#define AF_NETBIOS      17              /* NetBios-style addresses */
    412 #define AF_VOICEVIEW    18              /* VoiceView */
    413 
    414 //#define AF_MAX          19
    415 
    416 /*
    417  * Structure used by kernel to store most
    418  * addresses.
    419  */
    420 struct Wsockaddr {
    421         u_short sa_family;              /* address family */
    422         char    sa_data[14];            /* up to 14 bytes of direct address */
    423 };
    424 
    425 /*
    426  * Structure used by kernel to pass protocol
    427  * information in raw sockets.
    428  */
    429 struct Wsockproto {
    430         u_short sp_family;              /* address family */
    431         u_short sp_protocol;            /* protocol */
    432 };
    433 
    434 /*
    435  * Protocol families, same as address families for now.
    436  */
    437 #define PF_UNSPEC       AF_UNSPEC
    438 #define PF_UNIX         AF_UNIX
    439 #define PF_INET         AF_INET
    440 #define PF_IMPLINK      AF_IMPLINK
    441 #define PF_PUP          AF_PUP
    442 #define PF_CHAOS        AF_CHAOS
    443 #define PF_NS           AF_NS
    444 #define PF_IPX          AF_IPX
    445 #define PF_ISO          AF_ISO
    446 #define PF_OSI          AF_OSI
    447 #define PF_ECMA         AF_ECMA
    448 #define PF_DATAKIT      AF_DATAKIT
    449 #define PF_CCITT        AF_CCITT
    450 #define PF_SNA          AF_SNA
    451 #define PF_DECnet       AF_DECnet
    452 #define PF_DLI          AF_DLI
    453 #define PF_LAT          AF_LAT
    454 #define PF_HYLINK       AF_HYLINK
    455 #define PF_APPLETALK    AF_APPLETALK
    456 #define PF_VOICEVIEW    AF_VOICEVIEW
    457 
    458 #define PF_MAX          AF_MAX
    45918
    46019/*
    … …  
    46625};
    46726
    468 /*
    469  * Level number for (get/set)sockopt() to apply to socket itself.
    470  */
    471 #define SOL_SOCKET      0xffff          /* options for socket level */
    47227
    47328/*
    474  * Maximum queue length specifiable by listen.
     29 * Structures returned by network data base library, taken from the
     30 * BSD file netdb.h.  All addresses are supplied in host order, and
     31 * returned in network order (suitable for use in system calls).
    47532 */
    476 #define SOMAXCONN       5
    47733
    478 #define MSG_OOB         0x1             /* process out-of-band data */
    479 #define MSG_PEEK        0x2             /* peek at incoming message */
    480 #define MSG_DONTROUTE   0x4             /* send without using routing tables */
    481 
    482 #define MSG_MAXIOVLEN   16
    483 
    484 #define MSG_PARTIAL     0x8000          /* partial send or recv for message xport */
     34struct  Whostent {
     35        char     * h_name;           /* official name of host */
     36        char     *  * h_aliases;  /* alias list */
     37        short   h_addrtype;             /* host address type */
     38        short   h_length;               /* length of address */
     39        char     *  * h_addr_list; /* list of addresses */
     40#define h_addr  h_addr_list[0]          /* address, for backward compat */
     41};
    48542
    48643/*
    487  * Define constant based on rfc883, used by gethostbyxxxx() calls.
     44 * It is assumed here that a network number
     45 * fits in 32 bits.
    48846 */
    489 #define MAXGETHOSTSTRUCT        1024
     47struct  Wnetent {
     48        char     * n_name;           /* official name of net */
     49        char     *  * n_aliases;  /* alias list */
     50        short   n_addrtype;             /* net address type */
     51        u_long  n_net;                  /* network # */
     52};
     53typedef struct Whostent WHOSTENT;
     54typedef WHOSTENT *PWHOSTENT;
    49055
    491 /*
    492  * Define flags to be used with the WSAAsyncSelect() call.
    493  */
    494 #define FD_READ         0x01
    495 #define FD_WRITE        0x02
    496 #define FD_OOB          0x04
    497 #define FD_ACCEPT       0x08
    498 #define FD_CONNECT      0x10
    499 #define FD_CLOSE        0x20
     56struct  Wservent {
     57        char     * s_name;           /* official service name */
     58        char     *  * s_aliases;  /* alias list */
     59        short   s_port;                 /* port # */
     60        char     * s_proto;          /* protocol to use */
     61};
     62typedef struct Wservent WSERVENT;
     63typedef WSERVENT *PWSERVENT;
     64
     65struct  Wprotoent {
     66        char     * p_name;           /* official protocol name */
     67        char     *  * p_aliases;  /* alias list */
     68        short   p_proto;                /* protocol # */
     69};
     70typedef struct Wprotoent WPROTOENT;
     71typedef WPROTOENT *PWPROTOENT;
     72
     73typedef struct tagWsockThreadData
     74{
     75  int              dwLastError; // Get/SetLastError
     76  struct Whostent  whsnt;       // database conversion buffers
     77  struct Wservent  wsvnt;
     78  struct Wprotoent wptnt;
     79  struct Wnetent   wntnt;
     80  struct Wlinger   wlinger;
     81} WSOCKTHREADDATA, *PWSOCKTHREADDATA;
     82
     83// internal prototype
     84PWSOCKTHREADDATA iQueryWsockThreadData(void);
    50085
    50186
    502 /* Socket function prototypes */
    503 
    504 #ifdef __cplusplus
    505 extern "C" {
    506 #endif
    507 
    508 SOCKET  WIN32API  OS2accept (SOCKET s, struct sockaddr *addr, int *addrlen);
    509 int     WIN32API  OS2bind (SOCKET s, const struct sockaddr  *addr, int namelen);
    510 int     WIN32API  OS2closesocket (SOCKET s);
    511 int     WIN32API  OS2connect (SOCKET s, const struct sockaddr  *name, int namelen);
    512 int     WIN32API  OS2ioctlsocket (SOCKET s, long cmd, u_long  *argp);
    513 int     WIN32API  OS2getpeername (SOCKET s, struct sockaddr  *name,  int  * namelen);
    514 int     WIN32API  OS2getsockname (SOCKET s, struct sockaddr  *name, int  * namelen);
    515 int     WIN32API  OS2getsockopt (SOCKET s, int level, int optname, char  * optval, int  *optlen);
    516 u_long  WIN32API  OS2htonl (u_long hostlong);
    517 u_short WIN32API  OS2htons (u_short hostshort);
    518 u_long  WIN32API  OS2inet_addr (const char  * cp);
    519 char  * WIN32API  OS2inet_ntoa (struct in_addr in);
    520 int     WIN32API  OS2listen (SOCKET s, int backlog);
    521 u_long  WIN32API  OS2ntohl (u_long netlong);
    522 u_short WIN32API  OS2ntohs (u_short netshort);
    523 int     WIN32API  OS2recv (SOCKET s, char  * buf, int len, int flags);
    524 int     WIN32API  OS2recvfrom (SOCKET s, char  * buf, int len, int flags, struct sockaddr  *from, int  * fromlen);
    525 int     WIN32API  OS2select (int nfds, Wfd_set  *readfds, Wfd_set  *writefds, Wfd_set  *exceptfds, const struct Wtimeval  *timeout);
    526 int     WIN32API  OS2send (SOCKET s, const char  * buf, int len, int flags);
    527 int     WIN32API  OS2sendto (SOCKET s, const char  * buf, int len, int flags, const struct sockaddr  *to, int tolen);
    528 int     WIN32API  OS2setsockopt (SOCKET s, int level, int optname, const char  * optval, int optlen);
    529 int     WIN32API  OS2shutdown (SOCKET s, int how);
    530 SOCKET  WIN32API  OS2socket (int af, int type, int protocol);
    531 
    532 /* Database function prototypes */
    533 struct Whostent  *  WIN32API OS2gethostbyaddr(const char  * addr, int len, int type);
    534 struct Whostent  *  WIN32API OS2gethostbyname(const char  * name);
    535 int                 WIN32API OS2gethostname (char  * name, int namelen);
    536 struct Wservent  *  WIN32API OS2getservbyport(int port, const char  * proto);
    537 struct Wservent  *  WIN32API OS2getservbyname(const char  * name, const char  * proto);
    538 struct Wprotoent  * WIN32API OS2getprotobynumber(int proto);
    539 struct Wprotoent  * WIN32API OS2getprotobyname(const char  * name);
    540 
    541 /* Microsoft Windows Extension function prototypes */
    542 int    WIN32API  OS2WSAStartup(WORD wVersionRequired, LPWSADATA lpWSAData);
    543 int    WIN32API  OS2WSACleanup(void);
    544 BOOL   WIN32API  OS2WSAIsBlocking(void);
    545 int    WIN32API  OS2WSAUnhookBlockingHook(void);
    546 PROC   WIN32API  OS2WSASetBlockingHook(PROC lpBlockFunc);
    547 int    WIN32API  OS2WSACancelBlockingCall(void);
    548 HANDLE WIN32API  OS2WSAAsyncGetServByName(HWND hWnd, u_int wMsg, const char  * name, const char  * proto, char  * buf, int buflen);
    549 HANDLE WIN32API  OS2WSAAsyncGetServByPort(HWND hWnd, u_int wMsg, int port, const char  * proto, char  * buf, int buflen);
    550 HANDLE WIN32API  OS2WSAAsyncGetProtoByName(HWND hWnd, u_int wMsg, const char  * name, char  * buf, int buflen);
    551 HANDLE WIN32API  OS2WSAAsyncGetProtoByNumber(HWND hWnd, u_int wMsg, int number, char  * buf, int buflen);
    552 HANDLE WIN32API  OS2WSAAsyncGetHostByName(HWND hWnd, u_int wMsg, const char  * name, char  * buf, int buflen);
    553 HANDLE WIN32API  OS2WSAAsyncGetHostByAddr(HWND hWnd, u_int wMsg, const char  * addr, int len, int type, char  * buf, int buflen);
    554 int    WIN32API  OS2WSACancelAsyncRequest(HANDLE hAsyncTaskHandle);
    555 int    WIN32API  OS2WSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg, long lEvent);
    556 int    WIN32API  OS2WSARecvEx (SOCKET s, char  * buf, int len, int  *flags);
     87#endif  /* _WINSOCK32CONST_ */
    55788
    55889
    559 typedef struct _TRANSMIT_FILE_BUFFERS {
    560     PVOID Head;
    561     DWORD HeadLength;
    562     PVOID Tail;
    563     DWORD TailLength;
    564 } TRANSMIT_FILE_BUFFERS, *PTRANSMIT_FILE_BUFFERS, *LPTRANSMIT_FILE_BUFFERS;
    565 
    566 typedef struct _OVERLAPPED {
    567     DWORD   Internal;
    568     DWORD   InternalHigh;
    569     DWORD   Offset;
    570     DWORD   OffsetHigh;
    571     HANDLE  hEvent;
    572 } OVERLAPPED, *LPOVERLAPPED;
    573 
    574 
    575 BOOL WIN32API OS2TransmitFile (SOCKET                  hSocket,
    576                                HANDLE                  hFile,
    577                                DWORD                   nNumberOfBytesToWrite,
    578                                DWORD                   nNumberOfBytesPerSend,
    579                                LPOVERLAPPED            lpOverlapped,
    580                                LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers,
    581                                DWORD                   dwReserved);
    582 
    583 #ifdef __cplusplus
    584 }
    585 #endif
    586 
    587 typedef struct sockaddr SOCKADDR;
    588 typedef struct sockaddr *PSOCKADDR;
    589 typedef struct sockaddr *LPSOCKADDR;
    590 
    591 typedef struct sockaddr_in SOCKADDR_IN;
    592 typedef struct sockaddr_in *PSOCKADDR_IN;
    593 typedef struct sockaddr_in *LPSOCKADDR_IN;
    594 
    595 typedef struct linger LINGER;
    596 typedef struct linger *PLINGER;
    597 typedef struct linger *LPLINGER;
    598 
    599 typedef struct in_addr IN_ADDR;
    600 typedef struct in_addr *PIN_ADDR;
    601 typedef struct in_addr *LPIN_ADDR;
    602 
    603 typedef struct Wfd_set WFD_SET;
    604 typedef struct Wfd_set *PWFD_SET;
    605 typedef struct Wfd_set *LPWFD_SET;
    606 
    607 typedef struct Whostent WHOSTENT;
    608 typedef struct Whostent *PWHOSTENT;
    609 typedef struct Whostent *LPWHOSTENT;
    610 
    611 typedef struct Wservent WSERVENT;
    612 typedef struct Wservent *PWSERVENT;
    613 typedef struct Wservent *LPWSERVENT;
    614 
    615 typedef struct Wprotoent WPROTOENT;
    616 typedef struct Wprotoent *PWPROTOENT;
    617 typedef struct Wprotoent *LPWPROTOENT;
    618 
    619 typedef struct Wtimeval WTIMEVAL;
    620 typedef struct Wtimeval *PWTIMEVAL;
    621 typedef struct Wtimeval *LPWTIMEVAL;
    622 
    623 /*
    624  * Windows message parameter composition and decomposition
    625  * macros.
    626  *
    627  * WSAMAKEASYNCREPLY is intended for use by the Windows Sockets implementation
    628  * when constructing the response to a WSAAsyncGetXByY() routine.
    629  */
    630 #define OS2WSAMAKEASYNCREPLY(buflen,error)     MAKELONG(buflen,error)
    631 /*
    632  * WSAMAKESELECTREPLY is intended for use by the Windows Sockets implementation
    633  * when constructing the response to WSAAsyncSelect().
    634  */
    635 #define OS2WSAMAKESELECTREPLY(event,error)     MAKELONG(event,error)
    636 /*
    637  * WSAGETASYNCBUFLEN is intended for use by the Windows Sockets application
    638  * to extract the buffer length from the lParam in the response
    639  * to a WSAGetXByY().
    640  */
    641 #define OS2WSAGETASYNCBUFLEN(lParam)           LOWORD(lParam)
    642 /*
    643  * WSAGETASYNCERROR is intended for use by the Windows Sockets application
    644  * to extract the error code from the lParam in the response
    645  * to a WSAGetXByY().
    646  */
    647 #define OS2WSAGETASYNCERROR(lParam)            HIWORD(lParam)
    648 /*
    649  * WSAGETSELECTEVENT is intended for use by the Windows Sockets application
    650  * to extract the event code from the lParam in the response
    651  * to a WSAAsyncSelect().
    652  */
    653 #define OS2WSAGETSELECTEVENT(lParam)           LOWORD(lParam)
    654 /*
    655  * WSAGETSELECTERROR is intended for use by the Windows Sockets application
    656  * to extract the error code from the lParam in the response
    657  * to a WSAAsyncSelect().
    658  */
    659 #define OS2WSAGETSELECTERROR(lParam)           HIWORD(lParam)
    660 
    661 #endif  /* _WINSOCKAPI_ */
    662 
    663 
Note: See TracChangeset for help on using the changeset viewer.