[Back to WIN-OS2 SWAG index] [Back to Main SWAG index] [Original]

    unit WinSock;

    {$C FIXED PRELOAD DISCARDABLE}

    (*
     * WINSOCK.H--definitions to be used with the WINSOCK.DLL
     *
     * This header file corresponds to version 1.1 of the Windows Sockets specification.
     *
     * This file includes parts which are Copyright (c) 1982-1986 Regents
     * of the University of California.  All rights reserved.  The
     * Berkeley Software License Agreement specifies the terms and
     * conditions for redistribution.
     *
     * Original WINSOCK.H Change log:
     *
     * Fri Apr 23 16:31:01 1993  Mark Towfiq  (towfiq@Microdyne.COM)
     *	New version from David Treadwell which adds extern "C" around
     *	__WSAFDIsSet() and removes "const" from buf param of
     *	WSAAsyncGetHostByAddr().  Added change log.
     *
     * Sat May 15 10:55:00 1993 David Treadwell (davidtr@microsoft.com)
     *	Fix the IN_CLASSC macro to account for class-D multicasts.
     *	Add AF_IPX == AF_NS.
     *
     * Tue Oct 19 13:05:02 1993  Mark Towfiq (Mark.Towfiq@Sun.COM)
     *	New version from David Treadwell which changes type of counter in
     *	fd_set to u_int instead of u_short, so that it is correctly
     *	promoted in Winsdows NT and other 32-bit environments.
     *
     * Translated to BP7 by:  Randy Bratton, CServe: 72355,1466
     *
     * NOTE:  I have tried to keep the declaration order in WINSOCK.PAS the
     *        same as that in WINSOCK.H.  Most of the comments from the original
     *        WINSOCK.H have been left intact in the Pascal version.
     *        My comments are labeled with RMB.
     *
     * NO WARRANTY EXPRESSED OR IMPLIED.
     *
     * WINSOCK.PAS Revision History
     *    Version         Date      By     Comments
     *      1.00        03/04/94    RMB    Initial revision.
     *      1.01        08/22/94    RMB    General cleanup before posting to
     *                                     CompuServe.
     *      1.02        09/29/94    RMB    Added h_addr function for THostEnt
     *                                     structure.
     *      1.03        03/10/96    RMB    Fixed bug (noted by P. Payzant) in
     *                                     TWSAData. Now corresponds to WINSOCK.H
     *                                     dated 10/19/93 (except where noted).
     *)

    interface

    uses
      WinTypes;

    type
    (*
     * Basic system type definitions, taken from the BSD file sys/types.h.
     *)
      u_char  = char;
      u_short = word;  (* in Borland C++, int and short are both 16-bits RMB *)
      u_int   = word;
      u_long  = longint;

    (*
     * Other basic types needed for the C to Pascal translation.  RMB
     *)
      PPChar = ^PChar;  (* used with char FAR * FAR * xxx   RMB *)

    (*
     * The new type to be used in all
     * instances which refer to sockets.
     *
     * Must be renamed from SOCKET as there is a function called
     * socket().  RMB
     *)
      PSocket = ^TSocket;
      TSocket = u_int;

    (*
     * Select uses arrays of SOCKETs.  These macros manipulate such
     * arrays.  FD_SETSIZE may be defined by the user before including
     * this file, but the default here should be >= 64.
     *
     * CAVEAT IMPLEMENTOR and USER: THESE MACROS AND TYPES MUST BE
     * INCLUDED IN WINSOCK.H EXACTLY AS SHOWN HERE.
     *)
    const
      FD_SETSIZE =64;

    type
      PFd_Set = ^TFd_Set;
      TFd_Set = record
        fd_count : u_int;                              (* how many are SET? *) (* RMB 03/10/96 1.03 *)
                                                       (* 10/19/93 update to original WINSOCK.H *)
        fd_array : array[0..FD_SETSIZE-1] of TSocket;  (* an array of SOCKETs *)
        end;

    function  __WSAFDIsSet(fd: TSocket; aset: PFd_Set): integer;

    (*
    **  NB:  Have not done any work with socket arrays, therefore these
    **  routines have not been tested.  RMB 08/22/94 1.01
    *)
    procedure Fd_Clr(fd: TSocket; aset: PFd_Set);
    procedure Fd_Set(fd: TSocket; aset: PFd_Set);
    procedure Fd_Zero(aset: PFd_Set);
    function  Fd_IsSet(fd: TSocket; aset: PFd_Set): boolean;

    (*
     * Structure used in select() call, taken from the BSD file sys/time.h.
     *)
    type
      PTimeval = ^Timeval;
      Timeval = record
            tv_sec: longint;         (* seconds *)
            tv_usec: longint;        (* and microseconds *)
            end;
    (*
     * Operations on timevals.
     *
     * NB: timercmp does not work for >= or <=.
     *)
    (*
    **  DEFINES (macros) for timerisset, timercmp, and timerclear
    **  not implemented.  RMB
    *)

    (*
     * Commands for ioctlsocket(),  taken from the BSD file fcntl.h.
     *
     *
     * Ioctl's have the command encoded in the lower word,
     * and the size of any in or out parameters in the upper
     * word.  The high 2 bits of the upper word are used
     * to encode the in/out status of the parameter; for now
     * we restrict parameters to at most 128 bytes.
     *)
    const
      IOCPARM_MASK =   $07f;            (* parameters must be < 128 bytes *)
      IOC_VOID     =   $20000000;       (* no parameters *)
      IOC_OUT      =   $040000000;      (* copy out parameters *)
      IOC_IN       =   $080000000;      (* copy in parameters *)
      IOC_INOUT    =   (IOC_IN or IOC_OUT);
    																				(* 0x20000000 distinguishes new &
    																					 old ioctl's *)
    (*
    **  DEFINES (macros) for _IO, _IOR, _IOW, FIONREAD, FIONBIO, FIOASYNC,
    **    SIOCSHIWAT, SIOCGHIWAT, SIOCSLOWAT, SIOCGLOWAT, SIOCATMARK
    **    not implemented.  RMB
    *)

    (*
     * Structures returned by network data base library, taken from the
     * BSD file netdb.h.  All addresses are supplied in host order, and
     * returned in network order (suitable for use in system calls).
     *)

    type
      PHostEnt = ^THostEnt;
      THostEnt = record
            h_name : PChar;           (* official name of host *)
            h_aliases: PPChar;        (* alias list *)
            h_addrtype: integer;      (* host address type *)
            h_length :  integer;      (* length of address *)
            h_addr_list: PPChar;      (* list of addresses *)
            end;

    {
      C #define h_addr h_addr_list[0] omitted as currently only needed for
      backward compatibility.  RMB 08/22/94 1.01
    }
    function h_addr(aHostEnt: THostEnt): PChar;  (* RMB 09/29/94 1.02 *)

    (*
     * It is assumed here that a network number
     * fits in 32 bits.
     *)
    type
      PNetEnt = ^TNetEnt;
      TNetEnt = record
            n_name : PChar;           (* official name of net *)
            n_aliases : PPChar;       (* alias list *)
            n_addrtype : integer;     (* net address type *)
            n_net : u_long;           (* network $ *)
            end;

    type
      PServEnt = ^TServEnt;
      TServEnt = record
            s_name : PChar;           (* official service name *)
            s_aliases : PPChar;       (* alias list *)
            s_port : integer;         (* port $ *)
            s_proto : PChar;          (* protocol to use *)
            end;

    type
      PProtoEnt = ^TProtoEnt;
      TProtoEnt = record
            p_name : PChar;           (* official protocol name *)
            p_aliases : PPChar;       (* alias list *)
            p_proto : integer;        (* protocol $ *)
            end;

    (*
     * Constants and procedures defined by the internet system,
     * Per RFC 790, September 1981, taken from the BSD file netinet/in.h.
     *)

    (*
     * Protocols
     *)
    const
       IPPROTO_IP          =    0;               (* dummy for IP *)
       IPPROTO_ICMP        =    1;               (* control message protocol *)
       IPPROTO_GGP         =    2;               (* gateway^2 (deprecated) *)
       IPPROTO_TCP         =    6;               (* tcp *)
       IPPROTO_PUP         =    12;              (* pup *)
       IPPROTO_UDP         =    17;              (* user datagram protocol *)
       IPPROTO_IDP         =    22;              (* xns idp *)
       IPPROTO_ND          =    77;              (* UNOFFICIAL net disk proto *)

       IPPROTO_RAW         =    255;             (* raw IP packet *)
       IPPROTO_MAX         =    256;

    (*
     * Port/socket numbers: network standard functions
     *)
       IPPORT_ECHO         =    7;
       IPPORT_DISCARD      =    9;
       IPPORT_SYSTAT       =    11;
       IPPORT_DAYTIME      =    13;
       IPPORT_NETSTAT      =    15;
       IPPORT_FTP          =    21;
       IPPORT_TELNET       =    23;
       IPPORT_SMTP         =    25;
       IPPORT_TIMESERVER   =    37;
       IPPORT_NAMESERVER   =    42;
       IPPORT_WHOIS        =    43;
       IPPORT_MTP          =    57;

    (*
     * Port/socket numbers: host specific functions
     *)
       IPPORT_TFTP         =    69;
       IPPORT_RJE          =    77;
       IPPORT_FINGER       =    79;
       IPPORT_TTYLINK      =    87;
       IPPORT_SUPDUP       =    95;

    (*
     * UNIX TCP sockets
     *)
       IPPORT_EXECSERVER   =    512;
       IPPORT_LOGINSERVER  =    513;
       IPPORT_CMDSERVER    =    514;
       IPPORT_EFSSERVER    =    520;

    (*
     * UNIX UDP sockets
     *)
       IPPORT_BIFFUDP      =    512;
       IPPORT_WHOSERVER    =    513;
       IPPORT_ROUTESERVER  =    520;
    																				(* 520+1 also used *)

    (*
     * Ports < IPPORT_RESERVED are reserved for
     * privileged processes (e.g. root).
     *)
       IPPORT_RESERVED    =     1024;

    (*
     * Link numbers
     *)
       IMPLINK_IP         =     155;
       IMPLINK_LOWEXPER   =     156;
       IMPLINK_HIGHEXPER  =     158;

    (*
     * Internet address (old style... should be updated)
     *)
    type
      PIn_Addr = ^TIn_Addr;
      TIn_Addr = record
            case integer of
              1: (S_un_b : record
                          s_b1,
                          s_b2,
                          s_b3,
                          s_b4 : u_char;
                          end);
              2: (S_un_w : record
                          s_w1,
                          s_w2 : u_short;
                          end);
              3: (S_addr : u_long);
            end;

    function s_addr(s_un: TIn_Addr): u_long;
    function s_host(s_un: TIn_Addr): u_char;
    function s_net(s_un: TIn_Addr): u_char;
    function s_imp(s_un: TIn_Addr): u_short;
    function s_impno(s_un: TIn_Addr): u_char;
    function s_lh(s_un: TIn_Addr): u_char;

    (*
     * Definitions of bits in internet address integers.
     * On subnets, the decomposition of addresses to host and net parts
     * is done according to subnet mask, not the masks here.
     *)
    const
      IN_CLASSA_NET       =    $ff000000;
      IN_CLASSA_NSHIFT    =    24;
      IN_CLASSA_HOST      =    $00ffffff;
      IN_CLASSA_MAX       =    128;

      IN_CLASSB_NET       =    $ffff0000;
      IN_CLASSB_NSHIFT    =    16;
      IN_CLASSB_HOST      =    $0000ffff;
      IN_CLASSB_MAX       =    65536;

      IN_CLASSC_NET       =    $ffffff00;
      IN_CLASSC_NSHIFT    =    8;
      IN_CLASSC_HOST      =    $000000ff;

      INADDR_ANY          =    $000000000;
      INADDR_LOOPBACK     =    $7f000001;
      INADDR_BROADCAST    =    $ffffffff;
      INADDR_NONE         =    $ffffffff;

    function In_ClassA(i : longint) : boolean;
    function In_ClassB(i : longint) : boolean;
    function In_ClassC(i : longint) : boolean;

    (*
     * Socket address, internet style.
     *)
    type
      PSockAddr_In = ^TSockAddr_In;
      TSockAddr_in = record
              sin_family  : integer;
              sin_port    : u_short;
              sin_addr    : TIn_Addr;
              sin_zero    : array[0..7] of char;
              end;

    const
      WSADESCRIPTION_LEN   =   256;
      WSASYS_STATUS_LEN    =   128;

    type
      PWSAData = ^TWSAData;
      TWSAData = record
              wVersion       : word;
              wHighVersion   : word;
              szDescription  : array[0..WSADESCRIPTION_LEN] of char;  (* RMB 03/10/96 1.03 *)
              szSystemStatus : array[0..WSASYS_STATUS_LEN] of char;   (* RMB 03/10/96 1.03 *)
              iMaxSockets    : u_short;
              iMaxUdpDg      : u_short;
              lpVendorInfo   : PChar;
              end;

    (*
     * Options for use with [gs]etsockopt at the IP level.
     *)
    const

      IP_OPTIONS  =    1;               (* set/get IP per-packet options *)

    (*
     * Definitions related to sockets: types, address families, options,
     * taken from the BSD file sys/socket.h.
     *)

    (*
     * This is used instead of -1, since the
     * SOCKET type is unsigned.
     *)
    const
      INVALID_SOCKET = TSocket(not 0);
      SOCKET_ERROR   = -1;

    (*
     * Types
     *)
      SOCK_STREAM     = 1;               (* stream socket *)
      SOCK_DGRAM      = 2;               (* datagram socket *)
      SOCK_RAW        = 3;               (* raw-protocol interface *)
      SOCK_RDM        = 4;               (* reliably-delivered message *)
      SOCK_SEQPACKET  = 5;               (* sequenced packet stream *)

    (*
     * Option flags per-socket.
     *)
      SO_DEBUG        = $0001;          (* turn on debugging info recording *)
      SO_ACCEPTCONN   = $0002;          (* socket has had listen() *)
      SO_REUSEADDR    = $0004;          (* allow local address reuse *)
      SO_KEEPALIVE    = $0008;          (* keep connections alive *)
      SO_DONTROUTE    = $0010;          (* just use interface addresses *)
      SO_BROADCAST    = $0020;          (* permit sending of broadcast msgs *)
      SO_USELOOPBACK  = $0040;          (* bypass hardware when possible *)
      SO_LINGER       = $0080;          (* linger on close if data present *)
      SO_OOBINLINE    = $0100;          (* leave received OOB data in line *)

      SO_DONTLINGER   = u_int(not SO_LINGER);

    (*
     * Additional options.
     *)
      SO_SNDBUF       = $1001;          (* send buffer size *)
      SO_RCVBUF       = $1002;          (* receive buffer size *)
      SO_SNDLOWAT     = $1003;          (* send low-water mark *)
      SO_RCVLOWAT     = $1004;          (* receive low-water mark *)
      SO_SNDTIMEO     = $1005;          (* send timeout *)
      SO_RCVTIMEO     = $1006;          (* receive timeout *)
      SO_ERROR        = $1007;          (* get error status and clear *)
      SO_TYPE         = $1008;          (* get socket type *)

    (*
     * TCP options.
     *)
      TCP_NODELAY     = $0001;

    (*
     * Address families.
     *)
      AF_UNSPEC       = 0;               (* unspecified *)
      AF_UNIX         = 1;               (* local to host (pipes, portals) *)
      AF_INET         = 2;               (* internetwork: UDP, TCP, etc. *)
      AF_IMPLINK      = 3;               (* arpanet imp addresses *)
      AF_PUP          = 4;               (* pup protocols: e.g. BSP *)
      AF_CHAOS        = 5;               (* mit CHAOS protocols *)
      AF_NS           = 6;               (* XEROX NS protocols *)
      AF_IPX          = 6;               (* IPX and SPX *) (* RMB 03/10/96 1.03 *)
                                                           (* 05/15/93 update to original WINSOCK.H *)
      AF_ISO          = 7;               (* ISO protocols *)
      AF_OSI          = AF_ISO;          (* OSI is ISO *)
      AF_ECMA         = 8;               (* european computer manufacturers *)
      AF_DATAKIT      = 9;               (* datakit protocols *)
      AF_CCITT        = 10;              (* CCITT protocols, X.25 etc *)
      AF_SNA          = 11;              (* IBM SNA *)
      AF_DECnet       = 12;              (* DECnet *)
      AF_DLI          = 13;              (* Direct data link interface *)
      AF_LAT          = 14;              (* LAT *)
      AF_HYLINK       = 15;              (* NSC Hyperchannel *)
      AF_APPLETALK    = 16;              (* AppleTalk *)
      AF_NETBIOS      = 17;              (* NetBios-style addresses *)

      AF_MAX          = 18;

    (*
     * Structure used by kernel to store most
     * addresses.
     *)
    type
      PSockAddr = ^TSockAddr;
      TSockAddr = record
            sa_family : u_short;            (* address family *)
            sa_data : array[0..13] of char; (* up to 14 bytes of direct address *)
            end;

    (*
     * Structure used by kernel to pass protocol
     * information in raw sockets.
     *)
    type
      PSockProto = ^TSockProto;
      TSockProto = record
            sp_family : u_short;              (* address family *)
            sp_protocol : u_short;            (* protocol *)
            end;

    (*
     * Protocol families, same as address families for now.
     *)
    const

      PF_UNSPEC       = AF_UNSPEC;
      PF_UNIX         = AF_UNIX;
      PF_INET         = AF_INET;
      PF_IMPLINK      = AF_IMPLINK;
      PF_PUP          = AF_PUP;
      PF_CHAOS        = AF_CHAOS;
      PF_NS           = AF_NS;
      PF_IPX          = AF_IPX;  (* RMB 3/9/96 1.03 *)
                                 (* 5/15/93 update to original WINSOCK.H *)
      PF_ISO          = AF_ISO;
      PF_OSI          = AF_OSI;
      PF_ECMA         = AF_ECMA;
      PF_DATAKIT      = AF_DATAKIT;
      PF_CCITT        = AF_CCITT;
      PF_SNA          = AF_SNA;
      PF_DECnet       = AF_DECnet;
      PF_DLI          = AF_DLI;
      PF_LAT          = AF_LAT;
      PF_HYLINK       = AF_HYLINK;
      PF_APPLETALK    = AF_APPLETALK;

      PF_MAX          = AF_MAX;

    (*
     * Structure used for manipulating linger option.
     *)
    type
      PLinger = ^TLinger;
      TLinger = record
              l_onoff  : WordBool; {was u_short RMB} (* option on/off *) (* RMB 03/10/96 1.03 *)
              l_linger : u_short;                    (* linger time *)
              end;

    (*
     * Level number for (get/set)sockopt() to apply to socket itself.
     *)
    const
      SOL_SOCKET      = -1; {was $ffff  RMB}  (* options for socket level *)

    (*
     * Maximum queue length specifiable by listen.
     *)
    const
      SOMAXCONN       = 5;

      MSG_OOB         = $1;             (* process out-of-band data *)
      MSG_PEEK        = $2;             (* peek at incoming message *)
      MSG_DONTROUTE   = $4;             (* send without using routing tables *)

      MSG_MAXIOVLEN   = 16;

    (*
     * Define constant based on rfc883, used by gethostbyxxxx() calls.
     *)
    const
      MAXGETHOSTSTRUCT        = 1024;

    (*
     * Define flags to be used with the WSAAsyncSelect() call.
     *)
    const
      FD_READ         = $01;
      FD_WRITE        = $02;
      FD_OOB          = $04;
      FD_ACCEPT       = $08;
      FD_CONNECT      = $10;
      FD_CLOSE        = $20;

    (*
     * All Windows Sockets error constants are biased by WSABASEERR from
     * the "normal"
     *)
    const
      WSABASEERR              = 10000;

    (*
     * Windows Sockets definitions of regular Microsoft C error constants
     *)
    const
      WSAEINTR                = (WSABASEERR+4);
      WSAEBADF                = (WSABASEERR+9);
      WSAEACCES               = (WSABASEERR+13);
      WSAEFAULT               = (WSABASEERR+14);
      WSAEINVAL               = (WSABASEERR+22);
      WSAEMFILE               = (WSABASEERR+24);

    (*
     * Windows Sockets definitions of regular Berkeley error constants
     *)
    const
      WSAEWOULDBLOCK          = (WSABASEERR+35);
      WSAEINPROGRESS          = (WSABASEERR+36);
      WSAEALREADY             = (WSABASEERR+37);
      WSAENOTSOCK             = (WSABASEERR+38);
      WSAEDESTADDRREQ         = (WSABASEERR+39);
      WSAEMSGSIZE             = (WSABASEERR+40);
      WSAEPROTOTYPE           = (WSABASEERR+41);
      WSAENOPROTOOPT          = (WSABASEERR+42);
      WSAEPROTONOSUPPORT      = (WSABASEERR+43);
      WSAESOCKTNOSUPPORT      = (WSABASEERR+44);
      WSAEOPNOTSUPP           = (WSABASEERR+45);
      WSAEPFNOSUPPORT         = (WSABASEERR+46);
      WSAEAFNOSUPPORT         = (WSABASEERR+47);
      WSAEADDRINUSE           = (WSABASEERR+48);
      WSAEADDRNOTAVAIL        = (WSABASEERR+49);
      WSAENETDOWN             = (WSABASEERR+50);
      WSAENETUNREACH          = (WSABASEERR+51);
      WSAENETRESET            = (WSABASEERR+52);
      WSAECONNABORTED         = (WSABASEERR+53);
      WSAECONNRESET           = (WSABASEERR+54);
      WSAENOBUFS              = (WSABASEERR+55);
      WSAEISCONN              = (WSABASEERR+56);
      WSAENOTCONN             = (WSABASEERR+57);
      WSAESHUTDOWN            = (WSABASEERR+58);
      WSAETOOMANYREFS         = (WSABASEERR+59);
      WSAETIMEDOUT            = (WSABASEERR+60);
      WSAECONNREFUSED         = (WSABASEERR+61);
      WSAELOOP                = (WSABASEERR+62);
      WSAENAMETOOLONG         = (WSABASEERR+63);
      WSAEHOSTDOWN            = (WSABASEERR+64);
      WSAEHOSTUNREACH         = (WSABASEERR+65);
      WSAENOTEMPTY            = (WSABASEERR+66);
      WSAEPROCLIM             = (WSABASEERR+67);
      WSAEUSERS               = (WSABASEERR+68);
      WSAEDQUOT               = (WSABASEERR+69);
      WSAESTALE               = (WSABASEERR+70);
      WSAEREMOTE              = (WSABASEERR+71);

    (*
     * Extended Windows Sockets error constant definitions
     *)
    const
      WSASYSNOTREADY          = (WSABASEERR+91);
      WSAVERNOTSUPPORTED      = (WSABASEERR+92);
      WSANOTINITIALISED       = (WSABASEERR+93);

    (*
     * Error return codes from gethostbyname() and gethostbyaddr()
     * (when using the resolver). Note that these errors are
     * retrieved via WSAGetLastError() and must therefore follow
     * the rules for avoiding clashes with error numbers from
     * specific implementations or language run-time systems.
     * For this reason the codes are based at WSABASEERR+1001.
     * Note also that [WSA]NO_ADDRESS is defined only for
     * compatibility purposes.
     *)

    function h_errno : integer;

    const
    (* Authoritative Answer: Host not found *)
      WSAHOST_NOT_FOUND       = (WSABASEERR+1001);
      HOST_NOT_FOUND          = WSAHOST_NOT_FOUND;

    (* Non-Authoritative: Host not found, or SERVERFAIL *)
      WSATRY_AGAIN            = (WSABASEERR+1002);
      TRY_AGAIN               = WSATRY_AGAIN;

    (* Non recoverable errors, FORMERR, REFUSED, NOTIMP *)
      WSANO_RECOVERY          = (WSABASEERR+1003);
      NO_RECOVERY             = WSANO_RECOVERY;

    (* Valid name, no data record of requested type *)
      WSANO_DATA              = (WSABASEERR+1004);
      NO_DATA                 = WSANO_DATA;

    (* no address, look for MX record *)
      WSANO_ADDRESS           = WSANO_DATA;
      NO_ADDRESS              = WSANO_ADDRESS;

    (*
     * Windows Sockets errors redefined as regular Berkeley error constants
     *)
    const
      EWOULDBLOCK             = WSAEWOULDBLOCK;
      EINPROGRESS             = WSAEINPROGRESS;
      EALREADY                = WSAEALREADY;
      ENOTSOCK                = WSAENOTSOCK;
      EDESTADDRREQ            = WSAEDESTADDRREQ;
      EMSGSIZE                = WSAEMSGSIZE;
      EPROTOTYPE              = WSAEPROTOTYPE;
      ENOPROTOOPT             = WSAENOPROTOOPT;
      EPROTONOSUPPORT         = WSAEPROTONOSUPPORT;
      ESOCKTNOSUPPORT         = WSAESOCKTNOSUPPORT;
      EOPNOTSUPP              = WSAEOPNOTSUPP;
      EPFNOSUPPORT            = WSAEPFNOSUPPORT;
      EAFNOSUPPORT            = WSAEAFNOSUPPORT;
      EADDRINUSE              = WSAEADDRINUSE;
      EADDRNOTAVAIL           = WSAEADDRNOTAVAIL;
      ENETDOWN                = WSAENETDOWN;
      ENETUNREACH             = WSAENETUNREACH;
      ENETRESET               = WSAENETRESET;
      ECONNABORTED            = WSAECONNABORTED;
      ECONNRESET              = WSAECONNRESET;
      ENOBUFS                 = WSAENOBUFS;
      EISCONN                 = WSAEISCONN;
      ENOTCONN                = WSAENOTCONN;
      ESHUTDOWN               = WSAESHUTDOWN;
      ETOOMANYREFS            = WSAETOOMANYREFS;
      ETIMEDOUT               = WSAETIMEDOUT;
      ECONNREFUSED            = WSAECONNREFUSED;
      ELOOP                   = WSAELOOP;
      ENAMETOOLONG            = WSAENAMETOOLONG;
      EHOSTDOWN               = WSAEHOSTDOWN;
      EHOSTUNREACH            = WSAEHOSTUNREACH;
      ENOTEMPTY               = WSAENOTEMPTY;
      EPROCLIM                = WSAEPROCLIM;
      EUSERS                  = WSAEUSERS;
      EDQUOT                  = WSAEDQUOT;
      ESTALE                  = WSAESTALE;
      EREMOTE                 = WSAEREMOTE;

    (* Socket function prototypes *)

    function accept(s: TSOCKET; addr: PSockAddr; addrlen: PInteger): TSOCKET;

    function bind(s: TSOCKET; const addr: PSockAddr; namelen: integer): integer;

    function closesocket(s: TSOCKET): integer;

    function connect(s: TSOCKET; const name: PSockAddr; namelen: integer): integer;

    function getpeername(s: TSOCKET; name: PSockAddr; namelen: PInteger): integer;

    function getsockname(s: TSOCKET; name: PSockAddr; namelen: PInteger): integer;

    function getsockopt(s: TSOCKET; level: integer; optname: integer;
                        optval: PChar; optlen: PInteger): integer;

    function htonl(hostlong: u_long): u_long;

    function htons(hostshort: u_short): u_short;

    function inet_addr(const cp: PChar): longint;

    function inet_ntoa(ain: TIn_Addr): PChar;

    function ioctlsocket(s: TSOCKET; cmd: longint; argp: PLongint) : integer;

    function listen (s: TSOCKET; backlog: integer): integer;

    function ntohl(netlong: u_long): u_long;

    function ntohs(netshort: u_short): u_short;

    function recv(s : TSOCKET; buf: PChar; len: integer; flags: integer): integer;

    function recvfrom(s : TSOCKET; buf: PChar; len: integer; flags: integer;
                      from: PSockAddr; fromlen: PInteger): integer;

    function select(nfds: integer; readfds: PFd_Set; writefds: PFd_Set;
                    exceptfds: PFd_Set; const timeout: PTimeval): integer;

    function send(s: TSOCKET; const buf: PChar; len: integer; flags: integer): integer;

    function sendto(s: TSOCKET; const buf: PChar; len: integer; flags: integer;
                    const ato: PSockAddr; tolen: integer): integer;

    function setsockopt(s: TSOCKET; level: integer; optname: integer;
                        const optval: PChar; optlen: integer): integer;

    function shutdown(s: TSOCKET; how: integer): integer;

    function socket(af: integer; atype: integer; protocol: integer): TSOCKET;

    (* Database function prototypes *)

    function gethostbyaddr(const addr: PChar; len: integer; atype: integer): PHostEnt;

    function gethostbyname(const name: PChar): PHostEnt;

    function gethostname(name: PChar; namelen: integer): integer;

    function getprotobyname(const name: PChar): PProtoEnt;

    function getprotobynumber(proto: integer): PProtoEnt;

    function getservbyname(const name: PChar; const proto: PChar): PServEnt;

    function getservbyport(port: integer; const proto: PChar): PServEnt;

    (* Microsoft Windows Extension function prototypes *)

    function WSAAsyncGetHostByAddr(hWnd: HWND; wMsg: u_int;
                                   const addr: PChar; len: integer; atype: integer;
                                   buf: PChar; buflen: integer): THandle;  (* RMB 03/10/96 1.03 *)
                                                      (* 04/23/93 update to original WINSOCK.H *)

    function WSAAsyncGetHostByName(hWnd: HWND; wMsg: u_int;
                                   const name: PChar; buf: PChar;
                                   buflen: integer): THandle;

    function WSAAsyncGetProtoByName(hWnd: HWND; wMsg: u_int;
                                    const name: PChar; buf: PChar;
                                    buflen: integer): THandle;

    function WSAAsyncGetProtoByNumber(hWnd: HWND; wMsg: u_int;
                                      number: integer; buf: PChar;
                                      buflen: integer): THandle;

    function WSAAsyncGetServByName(hWnd: HWND; wMsg: u_int;
                                   const name: PChar;
                                   const proto: PChar;
                                   buf: PChar; buflen: integer): THandle;

    function WSAAsyncGetServByPort(hWnd: HWND; wMsg: u_int; port: integer;
                                   const proto: PChar; buf: PChar;
                                   buflen: integer): THandle;

    function WSAAsyncSelect(s : TSocket; hWnd: HWND; wMsg: u_int;
                            lEvent: longint): integer;

    function WSACancelAsyncRequest(hAsyncTaskHandle: THandle): integer;

    function WSACancelBlockingCall: integer;

    function WSACleanup: integer;

    function WSAGetLastError: integer;

    function WSAIsBlocking: boolean;

    function WSASetBlockingHook(lpBlockFunc: TFarProc): TFarProc;

    procedure WSASetLastError(iError: integer);

    function WSAStartup(wVersionRequired: word; lpWSAData: PWSAData): integer;

    function WSAUnhookBlockingHook: integer;

    (*
     * Windows message parameter composition and decomposition
     * macros.
     *
     * WSAMAKEASYNCREPLY is inteneded for use by the Windows Sockets implementation
     * when constructing the response to a WSAAsyncGetXByX() routine.
     *)
    function WSAMakeAsyncReply(buflen, error: word): longint;
    (*
     * WSAMAKESELECTREPLY is intended for use by the Windows Sockets implementation
     * when constructing the response to WSAAsyncSelect().
     *)
    function WSAMakeSelectReply(event, error: word): longint;
    (*
     * WSAGETASYNCBUFLEN is intended for use by the Windows Sockets application
     * to extract the buffer length from the lParam in the response
     * to a WSAGetXByY().
     *)
    function WSAGetAsyncBuflen(lparam: longint): word;
    (*
     * WSAGETASYNCERROR is intended for use by the Windows Sockets application
     * to extract the error code from the lParam in the response
     * to a WSAGetXByY().
     *)
    function WSAGetAsyncError(lparam: longint): word;
    (*
     * WSAGETSELECTEVENT is intended for use by the Windows Sockets application
     * to extract the event code from the lParam in the response
     * to a WSAAsyncSelect().
     *)
    function WSAGetSelectEvent(lparam: longint): word;
    (*
     * WSAGETSELECTERROR is intended for use by the Windows Sockets application
     * to extract the error code from the lParam in the response
     * to a WSAAsyncSelect().
     *)
    function WSAGetSelectError(lparam: longint): word;

    implementation

    uses
      WinProcs;

    function accept; external 'WINSOCK' index 1;
    function bind; external 'WINSOCK' index 2;
    function closesocket; external 'WINSOCK' index 3;
    function connect; external 'WINSOCK' index 4;
    function getpeername; external 'WINSOCK' index 5;
    function getsockname; external 'WINSOCK' index 6;
    function getsockopt; external 'WINSOCK' index 7;
    function htonl; external 'WINSOCK' index 8;
    function htons; external 'WINSOCK' index 9;
    function inet_addr; external 'WINSOCK' index 10;
    function inet_ntoa; external 'WINSOCK' index 11;
    function ioctlsocket; external 'WINSOCK' index 12;
    function listen; external 'WINSOCK' index 13;
    function ntohl; external 'WINSOCK' index 14;
    function ntohs; external 'WINSOCK' index 15;
    function recv; external 'WINSOCK' index 16;
    function recvfrom; external 'WINSOCK' index 17;
    function select; external 'WINSOCK' index 18;
    function send; external 'WINSOCK' index 19;
    function sendto; external 'WINSOCK' index 20;
    function setsockopt; external 'WINSOCK' index 21;
    function shutdown; external 'WINSOCK' index 22;
    function socket; external 'WINSOCK' index 23;

    function gethostbyaddr; external 'WINSOCK' index 51;
    function gethostbyname; external 'WINSOCK' index 52;
    function getprotobyname; external 'WINSOCK' index 53;
    function getprotobynumber; external 'WINSOCK' index 54;
    function getservbyname; external 'WINSOCK' index 55;
    function getservbyport; external 'WINSOCK' index 56;
    function gethostname; external 'WINSOCK' index 57;

    function WSAAsyncSelect; external 'WINSOCK' index 101;
    function WSAAsyncGetHostByAddr; external 'WINSOCK' index 102;
    function WSAAsyncGetHostByName; external 'WINSOCK' index 103;
    function WSAAsyncGetProtoByNumber; external 'WINSOCK' index 104;
    function WSAAsyncGetProtoByName; external 'WINSOCK' index 105;
    function WSAAsyncGetServByPort; external 'WINSOCK' index 106;
    function WSAAsyncGetServByName; external 'WINSOCK' index 107;
    function WSACancelAsyncRequest; external 'WINSOCK' index 108;
    function WSASetBlockingHook; external 'WINSOCK' index 109;
    function WSAUnhookBlockingHook; external 'WINSOCK' index 110;
    function WSAGetLastError; external 'WINSOCK' index 111;
    procedure WSASetLastError; external 'WINSOCK' index 112;
    function WSACancelBlockingCall; external 'WINSOCK' index 113;
    function WSAIsBlocking; external 'WINSOCK' index 114;
    function WSAStartup; external 'WINSOCK' index 115;
    function WSACleanup; external 'WINSOCK' index 116;

    function __WSAFDIsSet; external 'WINSOCK' index 151;

    procedure Fd_Clr(fd: TSocket; aset: PFd_Set);
    var
      i: u_int;
    begin
      for i := 0 to aset^.fd_count do
        begin
        if aset^.fd_array[i] = fd then (* found the one to clear *)
          begin
          while i < (aset^.fd_count-1) do
            begin
            aset^.fd_array[i] := aset^.fd_array[i+1];
            inc(i);
            end;
          dec(aset^.fd_count);
          break;
          end;
        end;
    end;

    procedure Fd_Set(fd: TSocket; aset: PFd_Set);
    begin
      if aset^.fd_count < FD_SETSIZE then
        begin
        aset^.fd_array[aset^.fd_count] := fd;
        inc(aset^.fd_count);
        end;
    end;

    procedure Fd_Zero(aset: PFd_Set);
    begin
      aset^.fd_count := 0;
    end;

    function Fd_IsSet(fd: TSocket; aset: PFd_Set): boolean;
    begin
      Fd_IsSet := (__WSAFDIsSet(fd, aSet) > 0);
    end;

    function h_addr(aHostEnt: THostEnt): PChar;  (* RMB 09/29/94 1.02 *)
    begin
      h_addr := aHostEnt.h_addr_list^;
    end;

    function s_addr(S_un: TIn_Addr): u_long;
    begin
      s_addr := S_un.S_addr;  (* can be used for most tcp & ip code *)
    end;

    function s_host(S_un: TIn_Addr): u_char;
    begin
      s_host := S_un.S_un_b.s_b2;  (* host on imp *)
    end;

    function s_net(S_un: TIn_Addr): u_char;
    begin
      s_net := S_un.S_un_b.s_b1;  (* network *)
    end;

    function s_imp(S_un: TIn_Addr): u_short;
    begin
      s_imp := S_un.S_un_w.s_w2; (* imp *)
    end;

    function s_impno(S_un: TIn_Addr): u_char;
    begin
      s_impno := S_un.S_un_b.s_b4; (* imp $ *)
    end;

    function s_lh(S_un: TIn_Addr): u_char;
    begin
      s_lh := S_un.S_un_b.s_b3;  (* logical host *)
    end;

    function In_ClassA(i : longint) : boolean;
    begin
      In_ClassA := ((i and $80000000) = 0);
    end;

    function In_ClassB(i : longint) : boolean;
    begin
      In_ClassB := ((i and  $c0000000) = $80000000);
    end;

    function In_ClassC(i : longint) : boolean;
    begin
      In_ClassC := ((i and $e0000000) = $c0000000);   (* RMB 03/10/96 1.03 *)
                                                      (* 05/15/93 to original WINSOCK.H *)
    end;

    function h_errno : integer;
    begin
      h_errno := WSAGetLastError;
    end;

    function WSAMakeAsyncReply(buflen, error: word): longint;
    begin
      WSAMakeAsyncReply := MakeLong(buflen, error);
    end;

    function WSAMakeSelectReply(event, error: word): longint;
    begin
      WSAMakeSelectReply := MakeLong(event, error);
    end;

    function WSAGetAsyncBuflen(lparam: longint): word;
    begin
      WSAGetAsyncBuflen := LoWord(lparam);
    end;

    function WSAGetAsyncError(lparam: longint): word;
    begin
      WSAGetAsyncError := HiWord(lparam);
    end;

    function WSAGetSelectEvent(lparam: longint): word;
    begin
      WSAGetSelectEvent := LoWord(lparam);
    end;

    function WSAGetSelectError(lparam: longint): word;
    begin
      WSAGetSelectError := HiWord(lparam);
    end;

    END.

[Back to WIN-OS2 SWAG index] [Back to Main SWAG index] [Original]