jwaws2spi.txt

netapi中 jawwinsock2.pas文件源码

{******************************************************************************}
{                                                                              }
{ Winsock2 Service Provider API interface Unit for Object Pascal               }
{                                                                              }
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
{ Corporation. All Rights Reserved.                                            }
{                                                                              }
{ The original file is: ws2spi.h, released June 2000. The original Pascal      }
{ code is: WS2spi.pas, released December 2000. The initial developer of the    }
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl).               }
{                                                                              }
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
{ Marcel van Brakel. All Rights Reserved.                                      }
{                                                                              }
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
{                                                                              }
{ You may retrieve the latest version of this file at the Project JEDI         }
{ APILIB home page, located at http://jedi-apilib.sourceforge.net              }
{                                                                              }
{ The contents of this file are used with permission, subject to the Mozilla   }
{ Public License Version 1.1 (the "License"); you may not use this file except }
{ in compliance with the License. You may obtain a copy of the License at      }
{ http://www.mozilla.org/MPL/MPL-1.1.html                                      }
{                                                                              }
{ Software distributed under the License is distributed on an "AS IS" basis,   }
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
{ the specific language governing rights and limitations under the License.    }
{                                                                              }
{ Alternatively, the contents of this file may be used under the terms of the  }
{ GNU Lesser General Public License (the  "LGPL License"), in which case the   }
{ provisions of the LGPL License are applicable instead of those above.        }
{ If you wish to allow use of your version of this file only under the terms   }
{ of the LGPL License and not to allow others to use your version of this file }
{ under the MPL, indicate your decision by deleting  the provisions above and  }
{ replace  them with the notice and other provisions required by the LGPL      }
{ License.  If you do not delete the provisions above, a recipient may use     }
{ your version of this file under either the MPL or the LGPL License.          }
{                                                                              }
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
{                                                                              }
{******************************************************************************}

// $Id: JwaWS2spi.pas,v 1.10 2006/01/27 21:48:18 brakelm Exp $

unit JwaWS2spi;

{$WEAKPACKAGEUNIT}

{$HPPEMIT ''}
{$HPPEMIT '#include "ws2spi.h"'}
{$HPPEMIT ''}

{$I jediapilib.inc}

interface

uses
  JwaWinType, JwaWinSock2;

(*
 * Ensure structures are packed consistently.
 *)

{$IFDEF _WIN64}
{$ALIGN OFF}
{$ELSE}
{$ALIGN ON}
{$ENDIF _WIN64}

const
  WSPDESCRIPTION_LEN = 255;
  {$EXTERNALSYM WSPDESCRIPTION_LEN}

  WSS_OPERATION_IN_PROGRESS = $00000103;
  {$EXTERNALSYM WSS_OPERATION_IN_PROGRESS}

type
  WSPData = record
    wVersion: WORD;
    wHighVersion: WORD;
    szDescription: array [0..WSPDESCRIPTION_LEN] of WCHAR;
  end;
  {$EXTERNALSYM WSPData}
  LPWSPDATA = ^WSPData;
  {$EXTERNALSYM LPWSPDATA}
  TWSPData = WSPDATA;
  PWSPData = LPWSPDATA;

  _WSATHREADID = record
    ThreadHandle: HANDLE;
    Reserved: DWORD;
  end;
  {$EXTERNALSYM _WSATHREADID}
  WSATHREADID = _WSATHREADID;
  {$EXTERNALSYM WSATHREADID}
  LPWSATHREADID = ^WSATHREADID;
  {$EXTERNALSYM LPWSATHREADID}
  TWSAThreadID = WSATHREADID;
  PWSAThreadID = LPWSATHREADID;

(*
 * Pointer to a blocking callback. A pointer to a blocking callback is
 * returned from the WPUQueryBlockingCallback() upcall. Note that this
 * function's signature is not identical to an application's blocking
 * hook function.
 *)

type
  LPBLOCKINGCALLBACK = function(dwContext: DWORD): BOOL; stdcall;
  {$EXTERNALSYM LPBLOCKINGCALLBACK}
  TBlockingCallback = LPBLOCKINGCALLBACK;

(*
 * Pointer to a user APC function. This is used as a parameter to the
 * WPUQueueUserApc() upcall. Note that this function's signature is not
 * identical to an application's completion routine.
 *)

  LPWSAUSERAPC = procedure(dwContext: DWORD); stdcall;
  {$EXTERNALSYM LPWSAUSERAPC}
  TWsaUserApc = LPWSAUSERAPC;

(*
 * Pointers to the individual entries in a service provider's proc table.
 *)

  LPWSPACCEPT = function(s: TSocket; addr: PSockAddr; addrlen: PINT;
    lpfnCondition: LPCONDITIONPROC; dwCallbackData: DWORD; var Errno: Integer): TSocket; stdcall;
  {$EXTERNALSYM LPWSPACCEPT}
  TWspAccept = LPWSPACCEPT;

  LPWSPADDRESSTOSTRING = function(lpsaAddress: LPSOCKADDR; dwAddressLength: DWORD;
    lpProtocolInfo: LPWSAPROTOCOL_INFOW; lpszAddressString: LPWSTR;
    var lpdwAddressStringLength: DWORD; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPADDRESSTOSTRING}
  TWspAddressToString = LPWSPADDRESSTOSTRING;

  LPWSPASYNCSELECT = function(s: TSocket; hWnd: HWND; wMsg: u_int; lEvent: Longint; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPASYNCSELECT}
  TWspASyncSelect = LPWSPASYNCSELECT;

  LPWSPBIND = function(s: TSocket; var name: sockaddr; namelen: Integer; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPBIND}
  TWspBind = LPWSPBIND;

  LPWSPCANCELBLOCKINGCALL = function(var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPCANCELBLOCKINGCALL}
  TWspCancelBlockingCall = LPWSPCANCELBLOCKINGCALL;

  LPWSPCLEANUP = function(var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPCLEANUP}
  TWspCleanup = LPWSPCLEANUP;

  LPWSPCLOSESOCKET = function(s: TSocket; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPCLOSESOCKET}
  TWspCloseSocket = LPWSPCLOSESOCKET;

  LPWSPCONNECT = function(s: TSocket; name: PSockAddr; namelen: Integer; lpCallerData: LPWSABUF;
    lpCalleeData: LPWSABUF; lpSQOS: LPQOS; lpGQOS: LPQOS; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPCONNECT}
  TWspConnect = LPWSPCONNECT;

  LPWSPDUPLICATESOCKET = function(s: TSocket; dwProcessId: DWORD; lpProtocolInfo: LPWSAPROTOCOL_INFOW; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPDUPLICATESOCKET}
  TWspDuplicateSocket = LPWSPDUPLICATESOCKET;

  LPWSPENUMNETWORKEVENTS = function(s: TSocket; hEventObject: WSAEVENT; lpNetworkEvents: LPWSANETWORKEVENTS; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPENUMNETWORKEVENTS}
  TWspEnumNetworkEvents = LPWSPENUMNETWORKEVENTS;

  LPWSPEVENTSELECT = function(s: TSocket; hEventObject: WSAEVENT; lNetworkEvents: Longint; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPEVENTSELECT}
  TWspEventSelect = LPWSPEVENTSELECT;

  LPWSPGETOVERLAPPEDRESULT = function(s: TSocket; lpOverlapped: LPWSAOVERLAPPED;
    var lpcbTransfer: DWORD; fWait: BOOL; lpdwFlags: DWORD; var lpErrno: Integer): BOOL; stdcall;
  {$EXTERNALSYM LPWSPGETOVERLAPPEDRESULT}
  TWspGetOverlappedResult = LPWSPGETOVERLAPPEDRESULT;

  LPWSPGETPEERNAME = function(s: TSocket; var name: sockaddr; var namelen, lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPGETPEERNAME}
  TWspGetPeerName = LPWSPGETPEERNAME;

  LPWSPGETSOCKNAME = function(s: TSocket; var name: sockaddr; var namelen, lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPGETSOCKNAME}
  TWspGetSockName = LPWSPGETSOCKNAME;

  LPWSPGETSOCKOPT = function(s: TSocket; level, optname: Integer; optval: PChar; var optlen, lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPGETSOCKOPT}
  TWspGetSockOpt = LPWSPGETSOCKOPT;

  LPWSPGETQOSBYNAME = function(s: TSocket; var lpQOSName: WSABUF; lpQOS: LPQOS; lpErrno: Integer): BOOL; stdcall;
  {$EXTERNALSYM LPWSPGETQOSBYNAME}
  TWspGetQosByName = LPWSPGETQOSBYNAME;

  LPWSPIOCTL = function(s: TSocket; dwIoControlCode: DWORD; lpvInBuffer: LPVOID; cbInBuffer: DWORD;
    lpvOutBuffer: LPVOID; cbOutBuffer: DWORD; var lpcbBytesReturned: DWORD;
    lpOverlapped: LPWSAOVERLAPPED; lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE;
    lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPIOCTL}
  TWspIoctl = LPWSPIOCTL;

  LPWSPJOINLEAF = function(s: TSocket; name: sockaddr; namelen: Integer; lpCallerData: LPWSABUF;
    lpCalleeData: LPWSABUF; lpSQOS, lpGQOS: LPQOS; dwFlags: DWORD; var lpErrno: Integer): TSocket; stdcall;
  {$EXTERNALSYM LPWSPJOINLEAF}
  TWspJoinLeaf = LPWSPJOINLEAF;

  LPWSPLISTEN = function(s: TSocket; backlog: Integer; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPLISTEN}
  TWspListen = LPWSPLISTEN;

  LPWSPRECV = function(s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD;
    var lpNumberOfBytesRecvd, lpFlags: DWORD; lpOverlapped: LPWSAOVERLAPPED;
    lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE; lpThreadId: LPWSATHREADID;
    var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPRECV}
  TWspRecv = LPWSPRECV;

  LPWSPRECVDISCONNECT = function(s: TSocket; lpInboundDisconnectData: LPWSABUF; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPRECVDISCONNECT}
  TWspRecvDisconnect = LPWSPRECVDISCONNECT;

  LPWSPRECVFROM = function(s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD;
    var lpNumberOfBytesRecvd, lpFlags: DWORD; lpFrom: PSockAddr; lpFromlen: PINT;
    lpOverlapped: LPWSAOVERLAPPED; lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE;
    lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPRECVFROM}
  TWspRecvFrom = LPWSPRECVFROM;

  LPWSPSELECT = function(nfds: Integer; readfds, writefds, exceptfds: PFdSet; timeout: PTimeVal; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPSELECT}
  TWspSelect = LPWSPSELECT;

  LPWSPSEND = function(s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD;
    var lpNumberOfBytesSent: DWORD; dwFlags: DWORD; lpOverlapped: LPWSAOVERLAPPED;
    lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE;
    lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPSEND}
  TWspSend = LPWSPSEND;

  LPWSPSENDDISCONNECT = function(s: TSocket; lpOutboundDisconnectData: LPWSABUF; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPSENDDISCONNECT}
  TWspSendDisconnect = LPWSPSENDDISCONNECT;

  LPWSPSENDTO = function(s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD;
    var lpNumberOfBytesSent: DWORD; dwFlags: DWORD; lpTo: PSockAddr; iTolen: Integer;
    lpOverlapped: LPWSAOVERLAPPED; lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE;
    lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPSENDTO}
  TWspSendTo = LPWSPSENDTO;

  LPWSPSETSOCKOPT = function(s: TSocket; level, optname: Integer; optval: PChar; optlen: Integer; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPSETSOCKOPT}
  TWspSetSockOpt = LPWSPSETSOCKOPT;

  LPWSPSHUTDOWN = function(s: TSocket; how: Integer; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPSHUTDOWN}
  TWspShutdown = LPWSPSHUTDOWN;

  LPWSPSOCKET = function(af, type_, protocol: Integer; lpProtocolInfo: LPWSAPROTOCOL_INFOW;
    g: GROUP; dwFlags: DWORD; var lpErrno: Integer): TSocket; stdcall;
  {$EXTERNALSYM LPWSPSOCKET}
  TWspSocket = LPWSPSOCKET;

  LPWSPSTRINGTOADDRESS = function(AddressString: LPWSTR; AddressFamily: Integer;
    lpProtocolInfo: LPWSAPROTOCOL_INFOW; lpAddress: LPSOCKADDR;
    var lpAddressLength, lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWSPSTRINGTOADDRESS}
  TWspStringToAddress = LPWSPSTRINGTOADDRESS;

(*
 * A service provider proc table. This structure is returned by value
 * from the service provider's WSPStartup() entrypoint.
 *)

type
  _WSPPROC_TABLE = record
    lpWSPAccept: LPWSPACCEPT;
    lpWSPAddressToString: LPWSPADDRESSTOSTRING;
    lpWSPAsyncSelect: LPWSPASYNCSELECT;
    lpWSPBind: LPWSPBIND;
    lpWSPCancelBlockingCall: LPWSPCANCELBLOCKINGCALL;
    lpWSPCleanup: LPWSPCLEANUP;
    lpWSPCloseSocket: LPWSPCLOSESOCKET;
    lpWSPConnect: LPWSPCONNECT;
    lpWSPDuplicateSocket: LPWSPDUPLICATESOCKET;
    lpWSPEnumNetworkEvents: LPWSPENUMNETWORKEVENTS;
    lpWSPEventSelect: LPWSPEVENTSELECT;
    lpWSPGetOverlappedResult: LPWSPGETOVERLAPPEDRESULT;
    lpWSPGetPeerName: LPWSPGETPEERNAME;
    lpWSPGetSockName: LPWSPGETSOCKNAME;
    lpWSPGetSockOpt: LPWSPGETSOCKOPT;
    lpWSPGetQOSByName: LPWSPGETQOSBYNAME;
    lpWSPIoctl: LPWSPIOCTL;
    lpWSPJoinLeaf: LPWSPJOINLEAF;
    lpWSPListen: LPWSPLISTEN;
    lpWSPRecv: LPWSPRECV;
    lpWSPRecvDisconnect: LPWSPRECVDISCONNECT;
    lpWSPRecvFrom: LPWSPRECVFROM;
    lpWSPSelect: LPWSPSELECT;
    lpWSPSend: LPWSPSEND;
    lpWSPSendDisconnect: LPWSPSENDDISCONNECT;
    lpWSPSendTo: LPWSPSENDTO;
    lpWSPSetSockOpt: LPWSPSETSOCKOPT;
    lpWSPShutdown: LPWSPSHUTDOWN;
    lpWSPSocket: LPWSPSOCKET;
    lpWSPStringToAddress: LPWSPSTRINGTOADDRESS;
  end;
  {$EXTERNALSYM _WSPPROC_TABLE}
  WSPPROC_TABLE = _WSPPROC_TABLE;
  {$EXTERNALSYM WSPPROC_TABLE}
  LPWSPPROC_TABLE = ^WSPPROC_TABLE;
  {$EXTERNALSYM LPWSPPROC_TABLE}
  TWspProcTable = WSPPROC_TABLE;
  PWspProcTable = LPWSPPROC_TABLE;

(*
 * Pointers to the individual entries in the upcall table.
 *)

type
  LPWPUCLOSEEVENT = function(hEvent: WSAEVENT; var lpErrno: Integer): BOOL; stdcall;
  {$EXTERNALSYM LPWPUCLOSEEVENT}
  TWpuCloseEvent = LPWPUCLOSEEVENT;

  LPWPUCLOSESOCKETHANDLE = function(s: TSocket; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWPUCLOSESOCKETHANDLE}
  TWpuCloseSocketHandle = LPWPUCLOSESOCKETHANDLE;

  LPWPUCREATEEVENT = function(var lpErrno: Integer): WSAEVENT; stdcall;
  {$EXTERNALSYM LPWPUCREATEEVENT}
  TWpuCreateEvent = LPWPUCREATEEVENT;

  LPWPUCREATESOCKETHANDLE = function(dwCatalogEntryId, dwContext: DWORD;
    var lpErrno: Integer): TSocket; stdcall;
  {$EXTERNALSYM LPWPUCREATESOCKETHANDLE}
  TWpuCreateSocketHandle = LPWPUCREATESOCKETHANDLE;

  LPWPUFDISSET = function(s: TSocket; fdset: PFdSet): Integer; stdcall;
  {$EXTERNALSYM LPWPUFDISSET}
  TWpuFdIsSet = LPWPUFDISSET;

  LPWPUGETPROVIDERPATH = function(const lpProviderId: TGUID;
    lpszProviderDllPath: PWCHAR; var lpProviderDllPathLen, lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWPUGETPROVIDERPATH}
  TWpuGetProviderPath = LPWPUGETPROVIDERPATH;

  LPWPUMODIFYIFSHANDLE = function(dwCatalogEntryId: DWORD; ProposedHandle: TSocket;
    var lpErrno: Integer): TSocket; stdcall;
  {$EXTERNALSYM LPWPUMODIFYIFSHANDLE}
  TWpuMoifyIfsHandle = LPWPUMODIFYIFSHANDLE;

  LPWPUPOSTMESSAGE = function(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): BOOL; stdcall;
  {$EXTERNALSYM LPWPUPOSTMESSAGE}
  TWpuPostMessage = LPWPUPOSTMESSAGE;

  LPWPUQUERYBLOCKINGCALLBACK = function(dwCatalogEntryId: DWORD; var lplpfnCallback: LPBLOCKINGCALLBACK;
    lpdwContext: LPDWORD; var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWPUQUERYBLOCKINGCALLBACK}
  TWpuQueryBlockingCallback = LPWPUQUERYBLOCKINGCALLBACK;

  LPWPUQUERYSOCKETHANDLECONTEXT = function(s: TSocket; lpContext: LPDWORD;
    var lpErrno: Integer): Integer; stdcall;
  {$EXTERNALSYM LPWPUQUERYSOCKETHANDLECONTEXT}
  TWpuQuerySocketHandleContext = LPWPUQUERYSOCKETHANDLECONTEXT;