winsock2.pas

适用于网络监控,视频聊天,网络VOD等多媒体数据流的网络传输与回放.控件包目前包括三个控件

    lpNSProviderId: PGUID;
    lpszContext: PChar;
    dwNumberOfProtocols: DWORD;
    lpafpProtocols: PAFProtocols;
    lpszQueryString: PChar;
    dwNumberOfCsAddrs: DWORD;
    lpcsaBuffer: PCSADDR_INFO;
    dwOutputFlags: DWORD;
    lpBlob: PBLOB;
  end;
  PWSAQuerySetA = ^TWSAQuerySetA;
  LPWSAQuerySetA = PWSAQuerySetA;

  TWSAQuerySetW = packed record
    dwSize: DWORD;
    lpszServiceInstanceName: PWideChar;
    lpServiceClassId: PGUID;
    lpVersion: PWSAVERSION;
    lpszComment: PWideChar;
    dwNameSpace: DWORD;
    lpNSProviderId: PGUID;
    lpszContext: PWideChar;
    dwNumberOfProtocols: DWORD;
    lpafpProtocols: PAFProtocols;
    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;

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;

{$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 lpOverlapped: LPWSAOVERLAPPED; const dwFlags: DWORD); stdcall;

function accept(const s: TSocket; var addr: TSockAddr; var addrlen: Integer):
  TSocket; stdcall;
function bind(const s: TSocket; const addr: PSockAddr; const namelen: Integer):
  Integer; stdcall;
function closesocket(const s: TSocket): Integer; stdcall;
function connect(const s: TSocket; const name: PSockAddr; namelen: Integer):
  Integer; stdcall;
function ioctlsocket(const s: TSocket; const cmd: DWORD; var arg: u_long):
  Integer; stdcall;
function getpeername(const s: TSocket; var name: TSockAddr; var namelen:
  Integer): Integer; stdcall;
function getsockname(const s: TSocket; var name: TSockAddr; var namelen:
  Integer): Integer; stdcall;
function getsockopt(const s: TSocket; const level, optname: Integer; optval:
  PChar; var optlen: Integer): Integer; stdcall;
function htonl(hostlong: u_long): u_long; stdcall;
function htons(hostshort: u_short): u_short; stdcall;
function inet_addr(cp: PChar): u_long; stdcall;
function inet_ntoa(inaddr: TInAddr): PChar; stdcall;
function listen(s: TSocket; backlog: Integer): Integer; stdcall;
function ntohl(netlong: u_long): u_long; stdcall;
function ntohs(netshort: u_short): u_short; stdcall;
function recv(s: TSocket; var Buf; len, flags: Integer): Integer; stdcall;
function recvfrom(s: TSocket; var Buf; len, flags: Integer; var from: TSockAddr;
  var fromlen: Integer): Integer; stdcall;
function select(nfds: Integer; readfds, writefds, exceptfds: PFDSet; timeout:
  PTimeVal): Integer; stdcall;
function send(s: TSocket; var Buf; len, flags: Integer): Integer; stdcall;
function sendto(s: TSocket; var Buf; len, flags: Integer; var addrto: TSockAddr;
  tolen: Integer): Integer; stdcall;
function setsockopt(s: TSocket; level, optname: Integer; optval: PChar; optlen:
  Integer): Integer; stdcall;
function shutdown(s: TSocket; how: Integer): Integer; stdcall;
function socket(const af, struct, protocol: Integer): TSocket; stdcall;
function gethostbyaddr(addr: Pointer; len, struct: Integer): PHostEnt; stdcall;
function gethostbyname(name: PChar): PHostEnt; stdcall;
function gethostname(name: PChar; len: Integer): Integer; stdcall;
function getservbyport(port: Integer; proto: PChar): PServEnt; stdcall;
function getservbyname(const name, proto: PChar): PServEnt; stdcall;
function getprotobynumber(const proto: Integer): PProtoEnt; stdcall;
function getprotobyname(const name: PChar): PProtoEnt; stdcall;
function WSAStartup(wVersionRequired: word; var WSData: TWSAData): Integer;
  stdcall;
function WSACleanup: Integer; stdcall;
procedure WSASetLastError(iError: Integer); stdcall;
function WSAGetLastError: Integer; stdcall;
function WSAIsBlocking: BOOL; stdcall;
function WSAUnhookBlockingHook: Integer; stdcall;
function WSASetBlockingHook(lpBlockFunc: TFarProc): TFarProc; stdcall;
function WSACancelBlockingCall: Integer; stdcall;
function WSAAsyncGetServByName(HWindow: HWND; wMsg: u_int; name, proto, buf:
  PChar; buflen: Integer): THandle; stdcall;
function WSAAsyncGetServByPort(HWindow: HWND; wMsg, port: u_int; proto, buf:
  PChar; buflen: Integer): THandle; stdcall;
function WSAAsyncGetProtoByName(HWindow: HWND; wMsg: u_int; name, buf: PChar;
  buflen: Integer): THandle; stdcall;
function WSAAsyncGetProtoByNumber(HWindow: HWND; wMsg: u_int; number: Integer;
  buf: PChar; buflen: Integer): THandle; stdcall;
function WSAAsyncGetHostByName(HWindow: HWND; wMsg: u_int; name, buf: PChar;
  buflen: Integer): THandle; stdcall;
function WSAAsyncGetHostByAddr(HWindow: HWND; wMsg: u_int; addr: PChar; len,
  struct: Integer; buf: PChar; buflen: Integer): THandle; stdcall;
function WSACancelAsyncRequest(hAsyncTaskHandle: THandle): Integer; stdcall;
function WSAAsyncSelect(s: TSocket; HWindow: HWND; wMsg: u_int; lEvent:
  Longint): Integer; stdcall;
function __WSAFDIsSet(s: TSOcket; var FDSet: TFDSet): Bool; stdcall;

{ WinSock 2 API new function prototypes }
function WSAAccept(s: TSocket; addr: TSockAddr; addrlen: PInteger;
  lpfnCondition: LPCONDITIONPROC; dwCallbackData: DWORD): TSocket; stdcall;
function WSACloseEvent(hEvent: WSAEVENT): WordBool; stdcall;
function WSAConnect(s: TSocket; const name: PSockAddr; namelen: Integer;
  lpCallerData, lpCalleeData: LPWSABUF; lpSQOS, lpGQOS: LPQOS): Integer; stdcall;
function WSACreateEvent: WSAEVENT; stdcall;

function WSADuplicateSocketA(s: TSocket; dwProcessId: DWORD; lpProtocolInfo:
  LPWSAProtocol_InfoA): Integer; stdcall;
function WSADuplicateSocketW(s: TSocket; dwProcessId: DWORD; lpProtocolInfo:
  LPWSAProtocol_InfoW): Integer; stdcall;
function WSADuplicateSocket(s: TSocket; dwProcessId: DWORD; lpProtocolInfo:
  LPWSAProtocol_Info): Integer; stdcall;

function WSAEnumNetworkEvents(const s: TSocket; const hEventObject: WSAEVENT;
  lpNetworkEvents: LPWSANETWORKEVENTS): Integer; stdcall;
function WSAEnumProtocolsA(lpiProtocols: PInteger; lpProtocolBuffer:
  LPWSAProtocol_InfoA; var lpdwBufferLength: DWORD): Integer; stdcall;
function WSAEnumProtocolsW(lpiProtocols: PInteger; lpProtocolBuffer:
  LPWSAProtocol_InfoW; var lpdwBufferLength: DWORD): Integer; stdcall;
function WSAEnumProtocols(lpiProtocols: PInteger; lpProtocolBuffer:
  LPWSAProtocol_Info; var lpdwBufferLength: DWORD): Integer; stdcall;

function WSAEventSelect(s: TSocket; hEventObject: WSAEVENT; lNetworkEvents:
  LongInt): Integer; stdcall;

function WSAGetOverlappedResult(s: TSocket; lpOverlapped: LPWSAOVERLAPPED;
  lpcbTransfer: LPDWORD; fWait: BOOL; var lpdwFlags: DWORD): WordBool; stdcall;

function WSAGetQosByName(s: TSocket; lpQOSName: LPWSABUF; lpQOS: LPQOS):
  WordBool; stdcall;

function WSAhtonl(s: TSocket; hostlong: u_long; var lpnetlong: DWORD): Integer;
  stdcall;
function WSAhtons(s: TSocket; hostshort: u_short; var lpnetshort: WORD):
  Integer; stdcall;

function WSAIoctl(s: TSocket; dwIoControlCode: DWORD; lpvInBuffer: Pointer;
  cbInBuffer: DWORD; lpvOutBuffer: Pointer; cbOutBuffer: DWORD;
  lpcbBytesReturned: LPDWORD; lpOverlapped: LPWSAOVERLAPPED;
    lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): Integer; stdcall;

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

function WSANtohl(s: TSocket; netlong: u_long; var lphostlong: DWORD): Integer;
  stdcall;
function WSANtohs(s: TSocket; netshort: u_short; var lphostshort: WORD):
  Integer; stdcall;

function WSARecv(s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD; var
  lpNumberOfBytesRecvd: DWORD; var lpFlags: DWORD;
  lpOverlapped: LPWSAOVERLAPPED; lpCompletionRoutine:
    LPWSAOVERLAPPED_COMPLETION_ROUTINE): Integer; stdcall;
function WSARecvDisconnect(s: TSocket; lpInboundDisconnectData: LPWSABUF):
  Integer; stdcall;
function WSARecvFrom(s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD; var
  lpNumberOfBytesRecvd: DWORD; var lpFlags: DWORD;
  lpFrom: PSockAddr; lpFromlen: PInteger; lpOverlapped: LPWSAOVERLAPPED;
    lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): Integer; stdcall;

function WSAResetEvent(hEvent: WSAEVENT): WordBool; stdcall;

function WSASend(s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD; var
  lpNumberOfBytesSent: DWORD; dwFlags: DWORD;
  lpOverlapped: LPWSAOVERLAPPED; lpCompletionRoutine:
    LPWSAOVERLAPPED_COMPLETION_ROUTINE): Integer; stdcall;
function WSASendDisconnect(s: TSocket; lpOutboundDisconnectData: LPWSABUF):
  Integer; stdcall;
function WSASendTo(s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD; var
  lpNumberOfBytesSent: DWORD; dwFlags: DWORD;
  lpTo: PSockAddr; iTolen: Integer; lpOverlapped: LPWSAOVERLAPPED;
    lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE): Integer; stdcall;

function WSASetEvent(hEvent: WSAEVENT): WordBool; stdcall;

function WSASocketA(af, iType, protocol: Integer; lpProtocolInfo:
  LPWSAProtocol_InfoA; g: GROUP; dwFlags: DWORD): TSocket; stdcall;
function WSASocketW(af, iType, protocol: Integer; lpProtocolInfo:
  LPWSAProtocol_InfoW; g: GROUP; dwFlags: DWORD): TSocket; stdcall;
function WSASocket(af, iType, protocol: Integer; lpProtocolInfo:
  LPWSAProtocol_Info; g: GROUP; dwFlags: DWORD): TSocket; stdcall;

function WSAWaitForMultipleEvents(cEvents: DWORD; lphEvents: PWSAEVENT;
  fWaitAll: LongBool;
  dwTimeout: DWORD; fAlertable: LongBool): DWORD; stdcall;

function WSAAddressToStringA(lpsaAddress: PSockAddr; const dwAddressLength:
  DWORD; const lpProtocolInfo: LPWSAProtocol_InfoA;
  const lpszAddressString: PChar; var lpdwAddressStringLength: DWORD): Integer;
    stdcall;
function WSAAddressToStringW(lpsaAddress: PSockAddr; const dwAddressLength:
  DWORD; const lpProtocolInfo: LPWSAProtocol_InfoW;
  const lpszAddressString: PWideChar; var lpdwAddressStringLength: DWORD):
    Integer; stdcall;
function WSAAddressToString(lpsaAddress: PSockAddr; const dwAddressLength:
  DWORD; const lpProtocolInfo: LPWSAProtocol_Info;
  const lpszAddressString: PMBChar; var lpdwAddressStringLength: DWORD):
    Integer; stdcall;

function WSAStringToAddressA(const AddressString: PChar; const AddressFamily:
  Integer; const lpProtocolInfo: LPWSAProtocol_InfoA;
  var lpAddress: TSockAddr; var lpAddressLength: Integer): Integer; stdcall;
function WSAStringToAddressW(const AddressString: PWideChar; const
  AddressFamily: Integer; const lpProtocolInfo: LPWSAProtocol_InfoA;
  var lpAddress: TSockAddr; var lpAddressLength: Integer): Integer; stdcall;
function WSAStringToAddress(const AddressString: PMBChar; const AddressFamily:
  Integer; const lpProtocolInfo: LPWSAProtocol_Info;
  var lpAddress: TSockAddr; var lpAddressLength: Integer): Integer; stdcall;

{ Registration and Name Resolution API functions }
function WSALookupServiceBeginA(var qsRestrictions: TWSAQuerySetA; const
  dwControlFlags: DWORD; var hLookup: THANDLE): Integer; stdcall;