idwinsock2.pas

photo.163.com 相册下载器 多线程下载

    lpszQueryString         : PWideChar;
    dwNumberOfCsAddrs       : DWORD;
    lpcsaBuffer             : PCSADDR_INFO;
    dwOutputFlags           : DWORD;
    lpBlob                  : PBLOB;
  end;
  PWSAQuerySetW = ^TWSAQuerySetW;
  LPWSAQuerySetW = PWSAQuerySetW;

{$IFDEF UNICODE}
  TWSAQuerySet  = TWSAQuerySetA;
  PWSAQuerySet  = PWSAQuerySetW;
  LPWSAQuerySet = PWSAQuerySetW;
{$ELSE}
  TWSAQuerySet  = TWSAQuerySetA;
  PWSAQuerySet  = PWSAQuerySetA;
  LPWSAQuerySet = PWSAQuerySetA;
{$ENDIF}

const
  lup_deep                = $0001;
  lup_containers          = $0002;
  lup_nocontainers        = $0004;
  lup_nearest             = $0008;
  lup_return_name         = $0010;
  lup_return_type         = $0020;
  lup_return_version      = $0040;
  lup_return_comment      = $0080;
  lup_return_addr         = $0100;
  lup_return_blob         = $0200;
  lup_return_aliases      = $0400;
  lup_return_query_string = $0800;
  lup_return_all          = $0FF0;
  lup_res_service         = $8000;

  lup_flushcache          = $1000;
  lup_flushprevious       = $2000;

// Return flags
  result_is_alias = $0001;

// WSARecvMsg flags
  {$NODEFINE MSG_TRUNC}
  MSG_TRUNC     =  $0100;
  {$NODEFINE MSG_CTRUNC}
  MSG_CTRUNC    =  $0200;
  {$NODEFINE MSG_BCAST}
  MSG_BCAST     =  $0400;
  {$NODEFINE MSG_MCAST}
  MSG_MCAST     =  $0800;

type
// Service Address Registration and Deregistration Data Types.
  TWSAeSetServiceOp = ( RNRSERVICE_REGISTER{=0}, RNRSERVICE_DEREGISTER, RNRSERVICE_DELETE );

{ Service Installation/Removal Data Types. }
  TWSANSClassInfoA = packed record
    lpszName    : PChar;
    dwNameSpace : DWORD;
    dwValueType : DWORD;
    dwValueSize : DWORD;
    lpValue     : Pointer;
  end;
  PWSANSClassInfoA = ^TWSANSClassInfoA;

  TWSANSClassInfoW = packed record
    lpszName    : PWideChar;
    dwNameSpace : DWORD;
    dwValueType : DWORD;
    dwValueSize : DWORD;
    lpValue     : Pointer;
  end {TWSANSClassInfoW};
  PWSANSClassInfoW = ^TWSANSClassInfoW;

{$IFDEF UNICODE}
  WSANSClassInfo   = TWSANSClassInfoW;
  TWSANSClassInfo  = TWSANSClassInfoW;
  PWSANSClassInfo  = PWSANSClassInfoW;
  LPWSANSClassInfo = PWSANSClassInfoW;
{$ELSE}
  WSANSClassInfo   = TWSANSClassInfoA;
  TWSANSClassInfo  = TWSANSClassInfoA;
  PWSANSClassInfo  = PWSANSClassInfoA;
  LPWSANSClassInfo = PWSANSClassInfoA;
{$ENDIF // UNICODE}

  TWSAServiceClassInfoA = packed record
    lpServiceClassId     : PGUID;
    lpszServiceClassName : PChar;
    dwCount              : DWORD;
    lpClassInfos         : PWSANSClassInfoA;
  end;
  PWSAServiceClassInfoA  = ^TWSAServiceClassInfoA;
  LPWSAServiceClassInfoA = PWSAServiceClassInfoA;

  TWSAServiceClassInfoW = packed record
    lpServiceClassId     : PGUID;
    lpszServiceClassName : PWideChar;
    dwCount              : DWORD;
    lpClassInfos         : PWSANSClassInfoW;
  end;
  PWSAServiceClassInfoW  = ^TWSAServiceClassInfoW;
  LPWSAServiceClassInfoW = PWSAServiceClassInfoW;

{$IFDEF UNICODE}
  WSAServiceClassInfo   = TWSAServiceClassInfoW;
  TWSAServiceClassInfo  = TWSAServiceClassInfoW;
  PWSAServiceClassInfo  = PWSAServiceClassInfoW;
  LPWSAServiceClassInfo = PWSAServiceClassInfoW;
{$ELSE}
  WSAServiceClassInfo   = TWSAServiceClassInfoA;
  TWSAServiceClassInfo  = TWSAServiceClassInfoA;
  PWSAServiceClassInfo  = PWSAServiceClassInfoA;
  LPWSAServiceClassInfo = PWSAServiceClassInfoA;
{$ENDIF}

  TWSANameSpace_InfoA = packed record
    NSProviderId   : TGUID;
    dwNameSpace    : DWORD;
    fActive        : DWORD{Bool};
    dwVersion      : DWORD;
    lpszIdentifier : PChar;
  end;
  PWSANameSpace_InfoA = ^TWSANameSpace_InfoA;
  LPWSANameSpace_InfoA = PWSANameSpace_InfoA;

  TWSANameSpace_InfoW = packed record
    NSProviderId   : TGUID;
    dwNameSpace    : DWORD;
    fActive        : DWORD{Bool};
    dwVersion      : DWORD;
    lpszIdentifier : PWideChar;
  end {TWSANameSpace_InfoW};
  PWSANameSpace_InfoW = ^TWSANameSpace_InfoW;
  LPWSANameSpace_InfoW = PWSANameSpace_InfoW;

  _WSAMSG = packed record
    name : LPSOCKADDR;  ///* Remote address */
    namelen : Integer; ///* Remote address length *
    lpBuffers : LPWSABUF;  //  /* Data buffer array */
    dwBufferCount : DWord; //  /* Number of elements in the array */
    Control : WSABUF;  //  /* Control buffer */
    dwFlags : DWord; //  /* Flags */
  end;
  TWSAMSG = _WSAMSG;
  PWSAMSG = ^TWSAMSG;
  LPWSAMSG = PWSAMSG;

{$IFDEF UNICODE}
  WSANameSpace_Info   = TWSANameSpace_InfoW;
  TWSANameSpace_Info  = TWSANameSpace_InfoW;
  PWSANameSpace_Info  = PWSANameSpace_InfoW;
  LPWSANameSpace_Info = PWSANameSpace_InfoW;
{$ELSE}
  WSANameSpace_Info   = TWSANameSpace_InfoA;
  TWSANameSpace_Info  = TWSANameSpace_InfoA;
  PWSANameSpace_Info  = PWSANameSpace_InfoA;
  LPWSANameSpace_Info = PWSANameSpace_InfoA;
{$ENDIF}

{ WinSock 2 extensions -- data types for the condition function in }
{ WSAAccept() and overlapped I/O completion routine. }
type
  LPCONDITIONPROC = function (lpCallerId: LPWSABUF; lpCallerData : LPWSABUF; lpSQOS,lpGQOS : LPQOS; lpCalleeId,lpCalleeData : LPWSABUF;
    g : GROUP; dwCallbackData : DWORD ) : Integer; stdcall;
  LPwsaoverlapped_COMPLETION_ROUTINE = procedure ( const dwError, cbTransferred : DWORD; const AOverlapped: Pointer; const dwFlags : DWORD ); stdcall;

function WSAStartup( const wVersionRequired: word; var WSData: TWSAData ): Integer; stdcall;

type
  {$NODEFINE TWSAStartupProc}
  TWSAStartupProc = function ( const wVersionRequired: word; var WSData: TWSAData ): Integer; stdcall;
  TWSACleanupProc = function : Integer; stdcall;
  {$IFDEF CIL}
  TacceptProc = function ( const s: TSocket; addr: PSockAddr; var addrlen: Integer ): TSocket; stdcall;
  TrecvfromProc = function ( const s: TSocket; var Buf; len, flags: Integer; from: PSockAddr; var fromlen: Integer ): Integer; stdcall;
  {$ELSE}
  TacceptProc = function ( const s: TSocket; addr: PSockAddr; addrlen: PInteger ): TSocket; stdcall;
  TrecvfromProc = function ( const s: TSocket; var Buf; len, flags: Integer; from: PSockAddr; fromlen: PInteger ): Integer; stdcall;
  {$ENDIF}
  TbindProc = function ( const s: TSocket; const name: PSockAddr; const namelen: Integer ): Integer; stdcall;
  TclosesocketProc = function ( const s: TSocket ): Integer; stdcall;
  TconnectProc = function ( const s: TSocket; const name: PSockAddr; const namelen: Integer): Integer; stdcall;
  TioctlsocketProc = function ( const s: TSocket; const cmd: DWORD; var arg: u_long ): Integer; stdcall;
  TgetpeernameProc = function ( const s: TSocket; const name: PSockAddr; var namelen: Integer ): Integer; stdcall;
  TgetsocknameProc = function ( const s: TSocket; const name: PSockAddr; var namelen: Integer ): Integer; stdcall;
  TgetsockoptProc = function ( const s: TSocket; const level, optname: Integer; optval: PChar; var optlen: Integer ): Integer; stdcall;
  ThtonlProc = function (hostlong: u_long): u_long; stdcall;
  ThtonsProc = function (hostshort: u_short): u_short; stdcall;
  Tinet_addrProc = function (cp: PChar): u_long; stdcall;
  Tinet_ntoaProc = function (inaddr: TInAddr): PChar; stdcall;
  TlistenProc = function ( const s: TSocket; backlog: Integer ): Integer; stdcall;
  TntohlProc = function (netlong: u_long): u_long; stdcall;
  TntohsProc = function (netshort: u_short): u_short; stdcall;
  TrecvProc = function ( const s: TSocket; var Buf; len, flags: Integer ): Integer; stdcall;
  TselectProc = function (nfds: Integer; readfds, writefds, exceptfds: PFDSet; timeout: PTimeVal ): Integer; stdcall;
  TsendProc = function ( const s: TSocket; const Buf; len, flags: Integer ): Integer; stdcall;
  TsendtoProc = function ( const s: TSocket; const Buf; const len, flags: Integer; const addrto: PSockAddr; const tolen: Integer ): Integer; stdcall;
  TsetsockoptProc = function ( const s: TSocket; const level, optname: Integer; optval: PChar; const optlen: Integer ): Integer; stdcall;
  TshutdownProc = function ( const s: TSocket; const how: Integer ): Integer; stdcall;
  TsocketProc = function ( const af, istruct, protocol: Integer ): TSocket; stdcall;
  TgethostbyaddrProc = function ( addr: Pointer; const len, addrtype: Integer ): PHostEnt; stdcall;
  TgethostbynameProc = function ( name: PChar ): PHostEnt; stdcall;
  TgethostnameProc = function ( name: PChar; len: Integer ): Integer; stdcall;
  TgetservbyportProc = function ( const port: Integer; const proto: PChar ): PServEnt; stdcall;
  TgetservbynameProc = function ( const name, proto: PChar ): PServEnt; stdcall;
  TgetprotobynumberProc = function ( const proto: Integer ): PProtoEnt; stdcall;
  TgetprotobynameProc = function ( const name: PChar ): PProtoEnt; stdcall;
  TWSASetLastErrorProc = procedure ( const iError: Integer ); stdcall;
  TWSAGetLastErrorProc = function : Integer; stdcall;
  TWSAIsBlockingProc = function : BOOL; stdcall;
  TWSAUnhookBlockingHookProc = function : Integer; stdcall;
  TWSASetBlockingHookProc = function ( lpBlockFunc: TFarProc ): TFarProc; stdcall;
  TWSACancelBlockingCallProc = function : Integer; stdcall;
  TWSAAsyncGetServByNameProc = function ( HWindow: HWND; wMsg: u_int; name, proto, buf: PChar; buflen: Integer ): THandle; stdcall;
  TWSAAsyncGetServByPortProc = function ( HWindow: HWND; wMsg, port: u_int; proto, buf: PChar; buflen: Integer ): THandle; stdcall;
  TWSAAsyncGetProtoByNameProc = function ( HWindow: HWND; wMsg: u_int; name, buf: PChar; buflen: Integer ): THandle; stdcall;
  TWSAAsyncGetProtoByNumberProc = function ( HWindow: HWND; wMsg: u_int; number: Integer; buf: PChar; buflen: Integer ): THandle; stdcall;
  TWSAAsyncGetHostByNameProc = function ( HWindow: HWND; wMsg: u_int; name, buf: PChar; buflen: Integer ): THandle; stdcall;
  TWSAAsyncGetHostByAddrProc = function ( HWindow: HWND; wMsg: u_int; addr: PChar; len, istruct: Integer; buf: PChar; buflen: Integer ): THandle; stdcall;
  TWSACancelAsyncRequestProc = function ( hAsyncTaskHandle: THandle ): Integer; stdcall;
  TWSAAsyncSelectProc = function ( const s: TSocket; HWindow: HWND; wMsg: u_int; lEvent: Longint ): Integer; stdcall;
  T__WSAFDIsSetProc = function ( const s: TSocket; var FDSet: TFDSet ): Bool; stdcall;

// WinSock 2 API new function prototypes
  {$IFDEF CIL}
  TWSAAcceptProc = function ( const s : TSocket; addr : PSockAddr; var addrlen : Integer; lpfnCondition : LPCONDITIONPROC; const dwCallbackData : DWORD ): TSocket; stdcall;
  TWSAEnumProtocolsAProc = function ( var lpiProtocols : Integer; lpProtocolBuffer : LPWSAProtocol_InfoA; var lpdwBufferLength : DWORD ) : Integer; stdcall;
  TWSAEnumProtocolsWProc = function ( var lpiProtocols : Integer; lpProtocolBuffer : LPWSAProtocol_InfoW; var lpdwBufferLength : DWORD ) : Integer; stdcall;
  TWSAEnumProtocolsProc = function ( var lpiProtocols : Integer; lpProtocolBuffer : LPWSAProtocol_Info; var lpdwBufferLength : DWORD ) : Integer; stdcall;
  TWSAGetOverlappedResultProc = function ( const s : TSocket; var AOverlapped: TOverlapped; var lpcbTransfer : DWORD; fWait : BOOL; var lpdwFlags : DWORD ) : WordBool; stdcall;
  // IOCTL under CIL ???
//  TWSAIoctlProc = function ( const s : TSocket; dwIoControlCode : DWORD; lpvInBuffer : Pointer; cbInBuffer : DWORD; lpvOutBuffer : Pointer; cbOutBuffer : DWORD;
//    lpcbBytesReturned : LPDWORD; AOverlapped: Pointer; lpCompletionRoutine : LPwsaoverlapped_COMPLETION_ROUTINE ) : Integer; stdcall;
  TWSARecvFromProc = function ( const s : TSocket; lpBuffers : LPWSABUF; dwBufferCount : DWORD; var lpNumberOfBytesRecvd : DWORD; var lpFlags : DWORD;
    lpFrom : PSockAddr; var lpFromlen : Integer; var AOverlapped: Overlapped; lpCompletionRoutine : LPwsaoverlapped_COMPLETION_ROUTINE ): Integer; stdcall;
      {$NODEFINE TTransmitFileProc}
  TTransmitFileProc = function (hSocket: TSocket; hFile: THandle; nNumberOfBytesToWrite: DWORD;
    nNumberOfBytesPerSend: DWORD; var lpOverlapped: Overlapped;
    lpTransmitBuffers: PTransmitFileBuffers; dwReserved: DWORD): BOOL; stdcall;
     {$NODEFINE TAcceptExProc}
  TAcceptExProc = function (sListenSocket, sAcceptSocket: TSocket;
    lpOutputBuffer: Pointer; dwReceiveDataLength, dwLocalAddressLength,
    dwRemoteAddressLength: DWORD; var lpdwBytesReceived: DWORD;
    var lpOverlapped: Overlapped): BOOL; stdcall;
  {$ELSE}
  TWSAAcceptProc = function ( const s : TSocket; addr : PSockAddr; addrlen : PInteger; lpfnCondition : LPCONDITIONPROC; const dwCallbackData : DWORD ): TSocket; stdcall;
  TWSAEnumProtocolsAProc = function ( lpiProtocols : PInteger; lpProtocolBuffer : LPWSAProtocol_InfoA; var lpdwBufferLength : DWORD ) : Integer; stdcall;
  TWSAEnumProtocolsWProc = function ( lpiProtocols : PInteger; lpProtocolBuffer : LPWSAProtocol_InfoW; var lpdwBufferLength : DWORD ) : Integer; stdcall;
  TWSAEnumProtocolsProc = function ( lpiProtocols : PInteger; lpProtocolBuffer : LPWSAProtocol_Info; var lpdwBufferLength : DWORD ) : Integer; stdcall;
  TWSAGetOverlappedResultProc = function ( const s : TSocket; AOverlapped: Pointer; lpcbTransfer : LPDWORD; fWait : BOOL; var lpdwFlags : DWORD ) : WordBool; stdcall;
  TWSAIoctlProc = function ( const s : TSocket; dwIoControlCode : DWORD; lpvInBuffer : Pointer; cbInBuffer : DWORD; lpvOutBuffer : Pointer; cbOutBuffer : DWORD;
    lpcbBytesReturned : LPDWORD; AOverlapped: Pointer; lpCompletionRoutine : LPwsaoverlapped_COMPLETION_ROUTINE ) : Integer; stdcall;
  TWSARecvFromProc = function ( const s : TSocket; lpBuffers : LPWSABUF; dwBufferCount : DWORD; var lpNumberOfBytesRecvd : DWORD; var lpFlags : DWORD;
    lpFrom : PSockAddr; lpFromlen : PInteger; AOverlapped: Pointer; lpCompletionRoutine : LPwsaoverlapped_COMPLETION_ROUTINE ): Integer; stdcall;
      {$NODEFINE TTransmitFileProc}
  TTransmitFileProc = function (hSocket: TSocket; hFile: THandle; nNumberOfBytesToWrite: DWORD;
    nNumberOfBytesPerSend: DWORD; lpOverlapped: POverlapped;
    lpTransmitBuffers: PTransmitFileBuffers; dwReserved: DWORD): BOOL; stdcall;
     {$NODEFINE TAcceptExProc}
  TAcceptExProc = function (sListenSocket, sAcceptSocket: TSocket;
    lpOutputBuffer: Pointer; dwReceiveDataLength, dwLocalAddressLength,
    dwRemoteAddressLength: DWORD; var lpdwBytesReceived: DWORD;
    lpOverlapped: POverlapped): BOOL; stdcall;
  {$ENDIF}
  TWSACloseEventProc = function ( const hEvent : wsaevent ) : WordBool; stdcall;
  TWSAConnectProc = function ( const s : TSocket; const name : PSockAddr; const namelen : Integer; lpCallerData,lpCalleeData : LPWSABUF; lpSQOS,lpGQOS : LPQOS ) : Integer; stdcall;
  TWSACreateEventProc  = function : wsaevent; stdcall;

  TWSADuplicateSocketAProc = function ( const s : TSocket; const dwProcessId : DWORD; lpProtocolInfo : LPWSAProtocol_InfoA ) : Integer; stdcall;
  TWSADuplicateSocketWProc = function ( const s : TSocket; const dwProcessId : DWORD; lpProtocolInfo : LPWSAProtocol_InfoW ) : Integer; stdcall;
  TWSADuplicateSocketProc = function ( const s : TSocket; const dwProcessId : DWORD; lpProtocolInfo : LPWSAProtocol_Info ) : Integer; stdcall;

  TWSAEnumNetworkEventsProc = function ( const s : TSocket; const hEventObject : wsaevent; lpNetworkEvents : LPWSANETWORKEVENTS ) :Integer; stdcall;

  TWSAEventSelectProc = function ( const s : TSocket; const hEventObject : wsaevent; lNetworkEvents : LongInt ): Integer; stdcall;


  TWSAGetQOSByNameProc = function ( const s : TSocket; lpQOSName : LPWSABUF; lpQOS : LPQOS ): WordBool; stdcall;
  TWSAHtonlProc = function ( const s : TSocket; hostlong : u_long; var lpnetlong : DWORD ): Integer; stdcall;
  TWSAHtonsProc = function ( const s : TSocket; hostshort : u_short; var lpnetshort : WORD ): Integer; stdcall;


  TWSAJoinLeafProc = function ( const s : TSocket; name : PSockAddr; namelen : Integer; lpCallerData,lpCalleeData : LPWSABUF;
	  lpSQOS,lpGQOS : LPQOS; dwFlags : DWORD ) : TSocket; stdcall;

  TWSANtohlProc = function ( const s : TSocket; netlong : u_long; var lphostlong : DWORD ): Integer; stdcall;
  TWSANtohsProc = function ( const s : TSocket; netshort : u_short; var lphostshort : WORD ): Integer; stdcall;

  TWSARecvProc = function ( const s : TSocket; lpBuffers : LPWSABUF; dwBufferCount : DWORD; var lpNumberOfBytesRecvd : DWORD; var lpFlags : DWORD;
    AOverlapped: Pointer; lpCompletionRoutine : LPwsaoverlapped_COMPLETION_ROUTINE ): Integer; stdcall;
  TWSARecvDisconnectProc = function ( const s : TSocket; lpInboundDisconnectData : LPWSABUF ): Integer; stdcall;

  TWSAResetEventProc = function ( hEvent : wsaevent ): WordBool; stdcall;

  TWSASendProc = function ( const s : TSocket; lpBuffers : LPWSABUF; dwBufferCount : DWORD; var lpNumberOfBytesSent : DWORD; dwFlags : DWORD;
    AOverlapped: Pointer; lpCompletionRoutine : LPwsaoverlapped_COMPLETION_ROUTINE ): Integer; stdcall;
  TWSASendDisconnectProc = function ( const s : TSocket; lpOutboundDisconnectData : LPWSABUF ): Integer; stdcall;
  TWSASendToProc = function ( const s : TSocket; lpBuffers : LPWSABUF; dwBufferCount : DWORD; var lpNumberOfBytesSent : DWORD; dwFlags : DWORD;
    lpTo : PSockAddr; iTolen : Integer; AOverlapped: Pointer; lpCompletionRoutine : LPwsaoverlapped_COMPLETION_ROUTINE ): Integer; stdcall;

  TWSASetEventProc = function ( hEvent : wsaevent ): WordBool; stdcall;

  TWSASocketAProc = function ( af, iType, protocol : Integer; lpProtocolInfo : LPWSAProtocol_InfoA; g : GROUP; dwFlags : DWORD ): TSocket; stdcall;
  TWSASocketWProc = function ( af, iType, protocol : Integer; lpProtocolInfo : LPWSAProtocol_InfoW; g : GROUP; dwFlags : DWORD ): TSocket; stdcall;
  TWSASocketProc = function ( af, iType, protocol : Integer; lpProtocolInfo : LPWSAProtocol_Info; g : GROUP; dwFlags : DWORD ): TSocket; stdcall;

  TWSAWaitForMultipleEventsProc = function ( cEvents : DWORD; lphEvents : Pwsaevent; fWaitAll : LongBool;
	  dwTimeout : DWORD; fAlertable : LongBool ): DWORD; stdcall;

  TWSAAddressToStringAProc = function ( lpsaAddress : PSockAddr; const dwAddressLength : DWORD; const lpProtocolInfo : LPWSAProtocol_InfoA;
	  const lpszAddressString : PChar; var lpdwAddressStringLength : DWORD ): Integer; stdcall;
  TWSAAddressToStringWProc = function ( lpsaAddress : PSockAddr; const dwAddressLength : DWORD; const lpProtocolInfo : LPWSAProtocol_InfoW;
	  const lpszAddressString : PWideChar; var lpdwAddressStringLength : DWORD ): Integer; stdcall;
  TWSAAddressToStringProc = function ( lpsaAddress : PSockAddr; const dwAddressLength : DWORD; const lpProtocolInfo : LPWSAProtocol_Info;
	  const lpszAddressString : PMBChar; var lpdwAddressStringLength : DWORD ): Integer; stdcall;

  TWSAStringToAddressAProc = function ( const AddressString : PChar; const AddressFamily: Integer; const lpProtocolInfo : LPWSAProtocol_InfoA;
	  var lpAddress : TSockAddr; var lpAddressLength : Integer ): Integer; stdcall;
  TWSAStringToAddressWProc = function ( const AddressString : PWideChar; const AddressFamily: Integer; const lpProtocolInfo : LPWSAProtocol_InfoW;
	  var lpAddress : TSockAddr; var lpAddressLength : Integer ): Integer; stdcall;
  TWSAStringToAddressProc = function ( const Ad