开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
JwaWS2spi.pas
资源名称：win32api.zip　[点击查看]
上传用户：davidchvip
上传日期：2009-07-28
资源大小：1749k
文件大小：38k
源码类别：

Windows编程

开发平台：

Delphi

JwaWS2spi.pas：源码内容
  1. {******************************************************************************}
  2. {                                                                       }
  3. { Winsock2 Service Provider API interface Unit for Object Pascal               }
  4. {                                                                       }
  5. { Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
  6. { Corporation. All Rights Reserved.                                            }
  7. {                 }
  8. { The original file is: ws2spi.h, released June 2000. The original Pascal      }
  9. { code is: WS2spi.pas, released December 2000. The initial developer of the    }
  10. { Pascal code is Marcel van Brakel (brakelm@chello.nl).                        }
  11. {                                                                              }
  12. { Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
  13. { Marcel van Brakel. All Rights Reserved.                                      }
  14. {                 }
  15. { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
  16. {                }
  17. { You may retrieve the latest version of this file at the Project JEDI home    }
  18. { page, located at http://delphi-jedi.org or my personal homepage located at   }
  19. { http://members.chello.nl/m.vanbrakel2                                        }
  20. {                }
  21. { The contents of this file are used with permission, subject to the Mozilla   }
  22. { Public License Version 1.1 (the "License"); you may not use this file except }
  23. { in compliance with the License. You may obtain a copy of the License at      }
  24. { http://www.mozilla.org/MPL/MPL-1.1.html                                      }
  25. {                                                                              }
  26. { Software distributed under the License is distributed on an "AS IS" basis,   }
  27. { WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
  28. { the specific language governing rights and limitations under the License.    }
  29. {                                                                              }
  30. { Alternatively, the contents of this file may be used under the terms of the  }
  31. { GNU Lesser General Public License (the  "LGPL License"), in which case the   }
  32. { provisions of the LGPL License are applicable instead of those above.        }
  33. { If you wish to allow use of your version of this file only under the terms   }
  34. { of the LGPL License and not to allow others to use your version of this file }
  35. { under the MPL, indicate your decision by deleting  the provisions above and  }
  36. { replace  them with the notice and other provisions required by the LGPL      }
  37. { License.  If you do not delete the provisions above, a recipient may use     }
  38. { your version of this file under either the MPL or the LGPL License.          }
  39. {                 }
  40. { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
  41. {                 }
  42. {******************************************************************************}
  44. unit JwaWS2spi;
  46. {$WEAKPACKAGEUNIT}
  48. {$HPPEMIT ''}
  49. {$HPPEMIT '#include "ws2spi.h"'}
  50. {$HPPEMIT ''}
  52. {$I WINDEFINES.INC}
  54. interface
  56. uses
  57.   JwaWinType, JwaWinSock2;
  59. (*
  60.  * Ensure structures are packed consistently.
  61.  *)
  63. {$IFNDEF _WIN64}
  64. {$ALIGN ON}
  65. {$ELSE}
  66. {$ALIGN OFF}
  67. {$ENDIF}
  69. const
  70.   WSPDESCRIPTION_LEN = 255;
  71.   {$EXTERNALSYM WSPDESCRIPTION_LEN}
  73.   WSS_OPERATION_IN_PROGRESS = $00000103;
  74.   {$EXTERNALSYM WSS_OPERATION_IN_PROGRESS}
  76. type
  77.   WSPData = record
  78.     wVersion: WORD;
  79.     wHighVersion: WORD;
  80.     szDescription: array [0..WSPDESCRIPTION_LEN] of WCHAR;
  81.   end;
  82.   {$EXTERNALSYM WSPData}
  83.   LPWSPDATA = ^WSPData;
  84.   {$EXTERNALSYM LPWSPDATA}
  85.   TWSPData = WSPDATA;
  86.   PWSPData = LPWSPDATA;
  88.   _WSATHREADID = record
  89.     ThreadHandle: HANDLE;
  90.     Reserved: DWORD;
  91.   end;
  92.   {$EXTERNALSYM _WSATHREADID}
  93.   WSATHREADID = _WSATHREADID;
  94.   {$EXTERNALSYM WSATHREADID}
  95.   LPWSATHREADID = ^WSATHREADID;
  96.   {$EXTERNALSYM LPWSATHREADID}
  97.   TWSAThreadID = WSATHREADID;
  98.   PWSAThreadID = LPWSATHREADID;
  100. (*
  101.  * Pointer to a blocking callback. A pointer to a blocking callback is
  102.  * returned from the WPUQueryBlockingCallback() upcall. Note that this
  103.  * function's signature is not identical to an application's blocking
  104.  * hook function.
  105.  *)
  107. type
  108.   LPBLOCKINGCALLBACK = function (dwContext: DWORD): BOOL; stdcall;
  109.   {$EXTERNALSYM LPBLOCKINGCALLBACK}
  110.   TBlockingCallback = LPBLOCKINGCALLBACK;
  112. (*
  113.  * Pointer to a user APC function. This is used as a parameter to the
  114.  * WPUQueueUserApc() upcall. Note that this function's signature is not
  115.  * identical to an application's completion routine.
  116.  *)
  118.   LPWSAUSERAPC = procedure (dwContext: DWORD); stdcall;
  119.   {$EXTERNALSYM LPWSAUSERAPC}
  120.   TWsaUserApc = LPWSAUSERAPC;
  122. (*
  123.  * Pointers to the individual entries in a service provider's proc table.
  124.  *)
  126.   LPWSPACCEPT = function (s: TSocket; addr: PSockAddr; addrlen: PINT;
  127.     lpfnCondition: LPCONDITIONPROC; dwCallbackData: DWORD; var Errno: Integer): TSocket; stdcall;
  128.   {$EXTERNALSYM LPWSPACCEPT}
  129.   TWspAccept = LPWSPACCEPT;
  131.   LPWSPADDRESSTOSTRING = function (lpsaAddress: LPSOCKADDR; dwAddressLength: DWORD;
  132.     lpProtocolInfo: LPWSAPROTOCOL_INFOW; lpszAddressString: LPWSTR;
  133.     var lpdwAddressStringLength: DWORD; var lpErrno: Integer): Integer; stdcall;
  134.   {$EXTERNALSYM LPWSPADDRESSTOSTRING}
  135.   TWspAddressToString = LPWSPADDRESSTOSTRING;
  137.   LPWSPASYNCSELECT = function (s: TSocket; hWnd: HWND; wMsg: u_int; lEvent: Longint; var lpErrno: Integer): Integer; stdcall;
  138.   {$EXTERNALSYM LPWSPASYNCSELECT}
  139.   TWspASyncSelect = LPWSPASYNCSELECT;
  141.   LPWSPBIND = function (s: TSocket; var name: sockaddr; namelen: Integer; var lpErrno: Integer): Integer; stdcall;
  142.   {$EXTERNALSYM LPWSPBIND}
  143.   TWspBind = LPWSPBIND;
  145.   LPWSPCANCELBLOCKINGCALL = function (var lpErrno: Integer): Integer; stdcall;
  146.   {$EXTERNALSYM LPWSPCANCELBLOCKINGCALL}
  147.   TWspCancelBlockingCall = LPWSPCANCELBLOCKINGCALL;
  149.   LPWSPCLEANUP = function (var lpErrno: Integer): Integer; stdcall;
  150.   {$EXTERNALSYM LPWSPCLEANUP}
  151.   TWspCleanup = LPWSPCLEANUP;
  153.   LPWSPCLOSESOCKET = function (s: TSocket; var lpErrno: Integer): Integer; stdcall;
  154.   {$EXTERNALSYM LPWSPCLOSESOCKET}
  155.   TWspCloseSocket = LPWSPCLOSESOCKET;
  157.   LPWSPCONNECT = function (s: TSocket; name: PSockAddr; namelen: Integer; lpCallerData: LPWSABUF;
  158.     lpCalleeData: LPWSABUF; lpSQOS: LPQOS; lpGQOS: LPQOS; var lpErrno: Integer): Integer; stdcall;
  159.   {$EXTERNALSYM LPWSPCONNECT}
  160.   TWspConnect = LPWSPCONNECT;
  162.   LPWSPDUPLICATESOCKET = function (s: TSocket; dwProcessId: DWORD; lpProtocolInfo: LPWSAPROTOCOL_INFOW; var lpErrno: Integer): Integer; stdcall;
  163.   {$EXTERNALSYM LPWSPDUPLICATESOCKET}
  164.   TWspDuplicateSocket = LPWSPDUPLICATESOCKET;
  166.   LPWSPENUMNETWORKEVENTS = function (s: TSocket; hEventObject: WSAEVENT; lpNetworkEvents: LPWSANETWORKEVENTS; var lpErrno: Integer): Integer; stdcall;
  167.   {$EXTERNALSYM LPWSPENUMNETWORKEVENTS}
  168.   TWspEnumNetworkEvents = LPWSPENUMNETWORKEVENTS;
  170.   LPWSPEVENTSELECT = function (s: TSocket; hEventObject: WSAEVENT; lNetworkEvents: Longint; var lpErrno: Integer): Integer; stdcall;
  171.   {$EXTERNALSYM LPWSPEVENTSELECT}
  172.   TWspEventSelect = LPWSPEVENTSELECT;
  174.   LPWSPGETOVERLAPPEDRESULT = function (s: TSocket; lpOverlapped: LPWSAOVERLAPPED;
  175.     var lpcbTransfer: DWORD; fWait: BOOL; lpdwFlags: DWORD; var lpErrno: Integer): BOOL; stdcall;
  176.   {$EXTERNALSYM LPWSPGETOVERLAPPEDRESULT}
  177.   TWspGetOverlappedResult = LPWSPGETOVERLAPPEDRESULT;
  179.   LPWSPGETPEERNAME = function (s: TSocket; var name: sockaddr; var namelen, lpErrno: Integer): Integer; stdcall;
  180.   {$EXTERNALSYM LPWSPGETPEERNAME}
  181.   TWspGetPeerName = LPWSPGETPEERNAME;
  183.   LPWSPGETSOCKNAME = function (s: TSocket; var name: sockaddr; var namelen, lpErrno: Integer): Integer; stdcall;
  184.   {$EXTERNALSYM LPWSPGETSOCKNAME}
  185.   TWspGetSockName = LPWSPGETSOCKNAME;
  187.   LPWSPGETSOCKOPT = function (s: TSocket; level, optname: Integer; optval: PChar; var optlen, lpErrno: Integer): Integer; stdcall;
  188.   {$EXTERNALSYM LPWSPGETSOCKOPT}
  189.   TWspGetSockOpt = LPWSPGETSOCKOPT;
  191.   LPWSPGETQOSBYNAME = function (s: TSocket; var lpQOSName: WSABUF; lpQOS: LPQOS; lpErrno: Integer): BOOL; stdcall;
  192.   {$EXTERNALSYM LPWSPGETQOSBYNAME}
  193.   TWspGetQosByName = LPWSPGETQOSBYNAME;
  195.   LPWSPIOCTL = function (s: TSocket; dwIoControlCode: DWORD; lpvInBuffer: LPVOID; cbInBuffer: DWORD;
  196.     lpvOutBuffer: LPVOID; cbOutBuffer: DWORD; var lpcbBytesReturned: DWORD;
  197.     lpOverlapped: LPWSAOVERLAPPED; lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE;
  198.     lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
  199.   {$EXTERNALSYM LPWSPIOCTL}
  200.   TWspIoctl = LPWSPIOCTL;
  202.   LPWSPJOINLEAF = function (s: TSocket; name: sockaddr; namelen: Integer; lpCallerData: LPWSABUF;
  203.     lpCalleeData: LPWSABUF; lpSQOS, lpGQOS: LPQOS; dwFlags: DWORD; var lpErrno: Integer): TSocket; stdcall;
  204.   {$EXTERNALSYM LPWSPJOINLEAF}
  205.   TWspJoinLeaf = LPWSPJOINLEAF;
  207.   LPWSPLISTEN = function (s: TSocket; backlog: Integer; var lpErrno: Integer): Integer; stdcall;
  208.   {$EXTERNALSYM LPWSPLISTEN}
  209.   TWspListen = LPWSPLISTEN;
  211.   LPWSPRECV = function (s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD;
  212.     var lpNumberOfBytesRecvd, lpFlags: DWORD; lpOverlapped: LPWSAOVERLAPPED;
  213.     lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE; lpThreadId: LPWSATHREADID;
  214.     var lpErrno: Integer): Integer; stdcall;
  215.   {$EXTERNALSYM LPWSPRECV}
  216.   TWspRecv = LPWSPRECV;
  218.   LPWSPRECVDISCONNECT = function (s: TSocket; lpInboundDisconnectData: LPWSABUF; var lpErrno: Integer): Integer; stdcall;
  219.   {$EXTERNALSYM LPWSPRECVDISCONNECT}
  220.   TWspRecvDisconnect = LPWSPRECVDISCONNECT;
  222.   LPWSPRECVFROM = function (s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD;
  223.     var lpNumberOfBytesRecvd, lpFlags: DWORD; lpFrom: PSockAddr; lpFromlen: PINT;
  224.     lpOverlapped: LPWSAOVERLAPPED; lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE;
  225.     lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
  226.   {$EXTERNALSYM LPWSPRECVFROM}
  227.   TWspRecvFrom = LPWSPRECVFROM;
  229.   LPWSPSELECT = function (nfds: Integer; readfds, writefds, exceptfds: PFdSet; timeout: PTimeVal; var lpErrno: Integer): Integer; stdcall;
  230.   {$EXTERNALSYM LPWSPSELECT}
  231.   TWspSelect = LPWSPSELECT;
  233.   LPWSPSEND = function (s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD;
  234.     var lpNumberOfBytesSent: DWORD; dwFlags: DWORD; lpOverlapped: LPWSAOVERLAPPED;
  235.     lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE;
  236.     lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
  237.   {$EXTERNALSYM LPWSPSEND}
  238.   TWspSend = LPWSPSEND;
  240.   LPWSPSENDDISCONNECT = function (s: TSocket; lpOutboundDisconnectData: LPWSABUF; var lpErrno: Integer): Integer; stdcall;
  241.   {$EXTERNALSYM LPWSPSENDDISCONNECT}
  242.   TWspSendDisconnect = LPWSPSENDDISCONNECT;
  244.   LPWSPSENDTO = function (s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD;
  245.     var lpNumberOfBytesSent: DWORD; dwFlags: DWORD; lpTo: PSockAddr; iTolen: Integer;
  246.     lpOverlapped: LPWSAOVERLAPPED; lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE;
  247.     lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
  248.   {$EXTERNALSYM LPWSPSENDTO}
  249.   TWspSendTo = LPWSPSENDTO;
  251.   LPWSPSETSOCKOPT = function (s: TSocket; level, optname: Integer; optval: PChar; optlen: Integer; var lpErrno: Integer): Integer; stdcall;
  252.   {$EXTERNALSYM LPWSPSETSOCKOPT}
  253.   TWspSetSockOpt = LPWSPSETSOCKOPT;
  255.   LPWSPSHUTDOWN = function (s: TSocket; how: Integer; var lpErrno: Integer): Integer; stdcall;
  256.   {$EXTERNALSYM LPWSPSHUTDOWN}
  257.   TWspShutdown = LPWSPSHUTDOWN;
  259.   LPWSPSOCKET = function (af, type_, protocol: Integer; lpProtocolInfo: LPWSAPROTOCOL_INFOW;
  260.     g: GROUP; dwFlags: DWORD; var lpErrno: Integer): TSocket; stdcall;
  261.   {$EXTERNALSYM LPWSPSOCKET}
  262.   TWspSocket = LPWSPSOCKET;
  264.   LPWSPSTRINGTOADDRESS = function (AddressString: LPWSTR; AddressFamily: Integer;
  265.     lpProtocolInfo: LPWSAPROTOCOL_INFOW; lpAddress: LPSOCKADDR;
  266.     var lpAddressLength, lpErrno: Integer): Integer; stdcall;
  267.   {$EXTERNALSYM LPWSPSTRINGTOADDRESS}
  268.   TWspStringToAddress = LPWSPSTRINGTOADDRESS;
  270. (*
  271.  * A service provider proc table. This structure is returned by value
  272.  * from the service provider's WSPStartup() entrypoint.
  273.  *)
  275. type
  276.   _WSPPROC_TABLE = record
  277.     lpWSPAccept: LPWSPACCEPT;
  278.     lpWSPAddressToString: LPWSPADDRESSTOSTRING;
  279.     lpWSPAsyncSelect: LPWSPASYNCSELECT;
  280.     lpWSPBind: LPWSPBIND;
  281.     lpWSPCancelBlockingCall: LPWSPCANCELBLOCKINGCALL;
  282.     lpWSPCleanup: LPWSPCLEANUP;
  283.     lpWSPCloseSocket: LPWSPCLOSESOCKET;
  284.     lpWSPConnect: LPWSPCONNECT;
  285.     lpWSPDuplicateSocket: LPWSPDUPLICATESOCKET;
  286.     lpWSPEnumNetworkEvents: LPWSPENUMNETWORKEVENTS;
  287.     lpWSPEventSelect: LPWSPEVENTSELECT;
  288.     lpWSPGetOverlappedResult: LPWSPGETOVERLAPPEDRESULT;
  289.     lpWSPGetPeerName: LPWSPGETPEERNAME;
  290.     lpWSPGetSockName: LPWSPGETSOCKNAME;
  291.     lpWSPGetSockOpt: LPWSPGETSOCKOPT;
  292.     lpWSPGetQOSByName: LPWSPGETQOSBYNAME;
  293.     lpWSPIoctl: LPWSPIOCTL;
  294.     lpWSPJoinLeaf: LPWSPJOINLEAF;
  295.     lpWSPListen: LPWSPLISTEN;
  296.     lpWSPRecv: LPWSPRECV;
  297.     lpWSPRecvDisconnect: LPWSPRECVDISCONNECT;
  298.     lpWSPRecvFrom: LPWSPRECVFROM;
  299.     lpWSPSelect: LPWSPSELECT;
  300.     lpWSPSend: LPWSPSEND;
  301.     lpWSPSendDisconnect: LPWSPSENDDISCONNECT;
  302.     lpWSPSendTo: LPWSPSENDTO;
  303.     lpWSPSetSockOpt: LPWSPSETSOCKOPT;
  304.     lpWSPShutdown: LPWSPSHUTDOWN;
  305.     lpWSPSocket: LPWSPSOCKET;
  306.     lpWSPStringToAddress: LPWSPSTRINGTOADDRESS;
  307.   end;
  308.   {$EXTERNALSYM _WSPPROC_TABLE}
  309.   WSPPROC_TABLE = _WSPPROC_TABLE;
  310.   {$EXTERNALSYM WSPPROC_TABLE}
  311.   LPWSPPROC_TABLE = ^WSPPROC_TABLE;
  312.   {$EXTERNALSYM LPWSPPROC_TABLE}
  313.   TWspProcTable = WSPPROC_TABLE;
  314.   PWspProcTable = LPWSPPROC_TABLE;
  316. (*
  317.  * Pointers to the individual entries in the upcall table.
  318.  *)
  320. type
  321.   LPWPUCLOSEEVENT = function (hEvent: WSAEVENT; var lpErrno: Integer): BOOL; stdcall;
  322.   {$EXTERNALSYM LPWPUCLOSEEVENT}
  323.   TWpuCloseEvent = LPWPUCLOSEEVENT;
  325.   LPWPUCLOSESOCKETHANDLE = function (s: TSocket; var lpErrno: Integer): Integer; stdcall;
  326.   {$EXTERNALSYM LPWPUCLOSESOCKETHANDLE}
  327.   TWpuCloseSocketHandle = LPWPUCLOSESOCKETHANDLE;
  329.   LPWPUCREATEEVENT = function (var lpErrno: Integer): WSAEVENT; stdcall;
  330.   {$EXTERNALSYM LPWPUCREATEEVENT}
  331.   TWpuCreateEvent = LPWPUCREATEEVENT;
  333.   LPWPUCREATESOCKETHANDLE = function (dwCatalogEntryId, dwContext: DWORD;
  334.     var lpErrno: Integer): TSocket; stdcall;
  335.   {$EXTERNALSYM LPWPUCREATESOCKETHANDLE}
  336.   TWpuCreateSocketHandle = LPWPUCREATESOCKETHANDLE;
  338.   LPWPUFDISSET = function (s: TSocket; fdset: PFdSet): Integer; stdcall;
  339.   {$EXTERNALSYM LPWPUFDISSET}
  340.   TWpuFdIsSet = LPWPUFDISSET;
  342.   LPWPUGETPROVIDERPATH = function (const lpProviderId: TGUID;
  343.     lpszProviderDllPath: PWCHAR; var lpProviderDllPathLen, lpErrno: Integer): Integer; stdcall;
  344.   {$EXTERNALSYM LPWPUGETPROVIDERPATH}
  345.   TWpuGetProviderPath = LPWPUGETPROVIDERPATH;
  347.   LPWPUMODIFYIFSHANDLE = function (dwCatalogEntryId: DWORD; ProposedHandle: TSocket;
  348.     var lpErrno: Integer): TSocket; stdcall;
  349.   {$EXTERNALSYM LPWPUMODIFYIFSHANDLE}
  350.   TWpuMoifyIfsHandle = LPWPUMODIFYIFSHANDLE;
  352.   LPWPUPOSTMESSAGE = function (hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): BOOL; stdcall;
  353.   {$EXTERNALSYM LPWPUPOSTMESSAGE}
  354.   TWpuPostMessage = LPWPUPOSTMESSAGE;
  356.   LPWPUQUERYBLOCKINGCALLBACK = function (dwCatalogEntryId: DWORD; var lplpfnCallback: LPBLOCKINGCALLBACK;
  357.     lpdwContext: LPDWORD; var lpErrno: Integer): Integer; stdcall;
  358.   {$EXTERNALSYM LPWPUQUERYBLOCKINGCALLBACK}
  359.   TWpuQueryBlockingCallback = LPWPUQUERYBLOCKINGCALLBACK;
  361.   LPWPUQUERYSOCKETHANDLECONTEXT = function (s: TSocket; lpContext: LPDWORD;
  362.     var lpErrno: Integer): Integer; stdcall;
  363.   {$EXTERNALSYM LPWPUQUERYSOCKETHANDLECONTEXT}
  364.   TWpuQuerySocketHandleContext = LPWPUQUERYSOCKETHANDLECONTEXT;
  366.   LPWPUQUEUEAPC = function (lpThreadId: LPWSATHREADID; lpfnUserApc: LPWSAUSERAPC;
  367.     dwContext: DWORD; var lpErrno: Integer): Integer; stdcall;
  368.   {$EXTERNALSYM LPWPUQUEUEAPC}
  369.   TWpuQueueApc = LPWPUQUEUEAPC;
  371.   LPWPURESETEVENT = function (hEvent: WSAEVENT; var lpErrno: Integer): BOOL; stdcall;
  372.   {$EXTERNALSYM LPWPURESETEVENT}
  373.   TWpuResetEvent = LPWPURESETEVENT;
  375.   LPWPUSETEVENT = function (hEvent: WSAEVENT; var lpErrno: Integer): BOOL; stdcall;
  376.   {$EXTERNALSYM LPWPUSETEVENT}
  377.   TWpuSetEvent = LPWPUSETEVENT;
  379.   LPWPUOPENCURRENTTHREAD = function (lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
  380.   {$EXTERNALSYM LPWPUOPENCURRENTTHREAD}
  381.   TWpuOpenCurrentThread = LPWPUOPENCURRENTTHREAD;
  383.   LPWPUCLOSETHREAD = function (lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
  384.   {$EXTERNALSYM LPWPUCLOSETHREAD}
  385.   TWpuCloseThread = LPWPUCLOSETHREAD;
  387. // Available only directly from ws2_32.dll
  389.   LPWPUCOMPLETEOVERLAPPEDREQUEST = function (s: TSocket; lpOverlapped: LPWSAOVERLAPPED;
  390.     dwError: DWORD; cbTransferred: DWORD; var lpErrno: Integer): Integer; stdcall;
  391.   {$EXTERNALSYM LPWPUCOMPLETEOVERLAPPEDREQUEST}
  392.   TWpuCompleteOverlappedRequest = LPWPUCOMPLETEOVERLAPPEDREQUEST;
  394. (*
  395.  * The upcall table. This structure is passed by value to the service
  396.  * provider's WSPStartup() entrypoint.
  397.  *)
  399.   _WSPUPCALLTABLE = record
  400.     lpWPUCloseEvent: LPWPUCLOSEEVENT;
  401.     lpWPUCloseSocketHandle: LPWPUCLOSESOCKETHANDLE;
  402.     lpWPUCreateEvent: LPWPUCREATEEVENT;
  403.     lpWPUCreateSocketHandle: LPWPUCREATESOCKETHANDLE;
  404.     lpWPUFDIsSet: LPWPUFDISSET;
  405.     lpWPUGetProviderPath: LPWPUGETPROVIDERPATH;
  406.     lpWPUModifyIFSHandle: LPWPUMODIFYIFSHANDLE;
  407.     lpWPUPostMessage: LPWPUPOSTMESSAGE;
  408.     lpWPUQueryBlockingCallback: LPWPUQUERYBLOCKINGCALLBACK;
  409.     lpWPUQuerySocketHandleContext: LPWPUQUERYSOCKETHANDLECONTEXT;
  410.     lpWPUQueueApc: LPWPUQUEUEAPC;
  411.     lpWPUResetEvent: LPWPURESETEVENT;
  412.     lpWPUSetEvent: LPWPUSETEVENT;
  413.     lpWPUOpenCurrentThread: LPWPUOPENCURRENTTHREAD;
  414.     lpWPUCloseThread: LPWPUCLOSETHREAD;
  415.   end;
  416.   {$EXTERNALSYM _WSPUPCALLTABLE}
  417.   WSPUPCALLTABLE = _WSPUPCALLTABLE;
  418.   {$EXTERNALSYM WSPUPCALLTABLE}
  419.   LPWSPUPCALLTABLE = ^WSPUPCALLTABLE;
  420.   {$EXTERNALSYM LPWSPUPCALLTABLE}
  421.   TWspUpCallTable = WSPUPCALLTABLE;
  422.   PWspUpCallTable = LPWSPUPCALLTABLE;  
  424. (*
  425.  *  WinSock 2 SPI socket function prototypes
  426.  *)
  428. //function WSPStartup(wVersionRequested: WORD; lpWSPData: LPWSPDATA;
  429. //  lpProtocolInfo: LPWSAPROTOCOL_INFOW; UpcallTable: WSPUPCALLTABLE;
  430. //  lpProcTable: LPWSPPROC_TABLE): Integer; stdcall;
  431. //{$EXTERNALSYM WSPStartup}
  433. type
  434.   LPWSPSTARTUP = function (wVersionRequested: WORD; lpWSPData: LPWSPDATA;
  435.     lpProtocolInfo: LPWSAPROTOCOL_INFOW; UpcallTable: WSPUPCALLTABLE;
  436.     lpProcTable: LPWSPPROC_TABLE): Integer; stdcall;
  437.   {$EXTERNALSYM LPWSPSTARTUP}
  438.   TWspStartUp = LPWSPSTARTUP;
  440. (*
  441.  * Installation and configuration entrypoints.
  442.  *)
  444. function WSCEnumProtocols(lpiProtocols: PINT; lpProtocolBuffer: LPWSAPROTOCOL_INFOW;
  445.   var lpdwBufferLength: DWORD; var lpErrno: Integer): Integer; stdcall;
  446. {$EXTERNALSYM WSCEnumProtocols}
  448. type
  449.   LPWSCENUMPROTOCOLS = function (lpiProtocols: PINT; lpProtocolBuffer: LPWSAPROTOCOL_INFOW;
  450.     var lpdwBufferLength: DWORD; var lpErrno: Integer): Integer; stdcall;
  451.   {$EXTERNALSYM LPWSCENUMPROTOCOLS}
  452.   TWscEnumProtocols = LPWSCENUMPROTOCOLS;
  454. {$IFDEF _WIN64}
  456. //
  457. // 64-bit architectures capable of running 32-bit code have
  458. // separate 64-bit and 32-bit catalogs.  API with '32' prefix
  459. // allow 32 bit catalog manipulations by 64 bit process.
  460. //
  462. function WSCEnumProtocols32(lpiProtocols: PINT; lpProtocolBuffer: LPWSAPROTOCOL_INFOW; lpdwBufferLength: LPDWORD; lpErrno: PINT): Integer; stdcall;
  463. {$EXTERNALSYM WSCEnumProtocols32}
  465. {$ENDIF _WIN64}
  467. function WSCDeinstallProvider(const lpProviderId: TGUID; var lpErrno: Integer): Integer; stdcall;
  468. {$EXTERNALSYM WSCDeinstallProvider}
  470. type
  471.   LPWSCDEINSTALLPROVIDER = function (const lpProviderId: TGUID; var lpErrno: Integer): Integer; stdcall;
  472.   {$EXTERNALSYM LPWSCDEINSTALLPROVIDER}
  473.   TWscDeinstallProvider = LPWSCDEINSTALLPROVIDER;
  475. {$IFDEF _WIN64}
  477. function WSCDeinstallProvider32(lpProviderId: PGUID; lpErrno: PINT): Integer; stdcall;
  478. {$EXTERNALSYM WSCDeinstallProvider32}
  480. {$ENDIF _WIN64}
  482. function WSCInstallProvider(const lpProviderId: TGUID; lpszProviderDllPath: PWCHAR;
  483.   lpProtocolInfoList: LPWSAPROTOCOL_INFOW; dwNumberOfEntries: DWORD; var lpErrno: Integer): Integer; stdcall;
  484. {$EXTERNALSYM WSCInstallProvider}
  486. type
  487.   LPWSCINSTALLPROVIDER = function (const lpProviderId: TGUID; lpszProviderDllPath: PWCHAR;
  488.     lpProtocolInfoList: LPWSAPROTOCOL_INFOW; dwNumberOfEntries: DWORD; var lpErrno: Integer): Integer; stdcall;
  489.   {$EXTERNALSYM LPWSCINSTALLPROVIDER}
  490.   TWscInstallProvider = LPWSCINSTALLPROVIDER;
  492. {$IFDEF _WIN64}
  494. //
  495. // This API manipulates 64-bit and 32-bit catalogs simulteneously.
  496. // It is needed to guarantee the same catalog IDs for provider catalog
  497. // entries in both 64-bit and 32-bit catalogs.
  498. //
  500. function WSCInstallProvider64_32(lpProviderId: PGUID; lpszProviderDllPath: PWCHAR; lpProtocolInfoList: LPWSAPROTOCOL_INFOW;
  501.   dwNumberOfEntries: DWORD; lpErrno: PINT): Integer; stdcall;
  502. {$EXTERNALSYM WSCInstallProvider64_32}
  504. {$ENDIF _WIN64}
  506. function WSCGetProviderPath(const lpProviderId: TGUID; lpszProviderDllPath: PWCHAR;
  507.   var lpProviderDllPathLen, lpErrno: Integer): Integer; stdcall;
  508. {$EXTERNALSYM WSCGetProviderPath}
  510. type
  511.   LPWSCGETPROVIDERPATH = function (const lpProviderId: TGUID; lpszProviderDllPath: PWCHAR;
  512.   var lpProviderDllPathLen, lpErrno: Integer): Integer; stdcall;
  513.   {$EXTERNALSYM LPWSCGETPROVIDERPATH}
  514.   TWscGetProviderPath = LPWSCGETPROVIDERPATH;
  516. {$IFDEF _WIN64}
  518. function WSCGetProviderPath32(lpProviderId: PGUID; lpszProviderDllPath: PWCHAR; lpProviderDllPathLen: PINT; lpErrno: PINT): Integer; stdcall;
  519. {$EXTERNALSYM WSCGetProviderPath32}
  521. {$ENDIF _WIN64}
  523. function WSCUpdateProvider(lpProviderId: PGUID; lpszProviderDllPath: PWCHAR; lpProtocolInfoList: LPWSAPROTOCOL_INFOW;
  524.   dwNumberOfEntries: DWORD; lpErrno: PINT): Integer; stdcall;
  525. {$EXTERNALSYM WSCUpdateProvider}
  527. type
  528.   LPWSCUPDATEPROVIDER = function (lpProviderId: PGUID; lpszProviderDllPath: PWCHAR; lpProtocolInfoList: LPWSAPROTOCOL_INFOW;
  529.     dwNumberOfEntries: DWORD; lpErrno: PINT): Integer; stdcall;
  530.   {$EXTERNALSYM LPWSCUPDATEPROVIDER}
  532. {$IFDEF _WIN64}
  534. function WSCUpdateProvider32(lpProviderId: PGUID; lpszProviderDllPath: PWCHAR; lpProtocolInfoList: LPWSAPROTOCOL_INFOW;
  535.   dwNumberOfEntries: DWORD; lpErrno: PINT): Integer; stdcall;
  536. {$EXTERNALSYM WSCUpdateProvider32}
  538. {$ENDIF _WIN64}
  540. function WSCInstallQOSTemplate(const Guid: TGUID; QosName: LPWSABUF; Qos: LPQOS): Integer; stdcall;
  541. {$EXTERNALSYM WSCInstallQOSTemplate}
  543. type
  544.   LPWSCINSTALLQOSTEMPLATE = function (const Guid: TGUID; QosName: LPWSABUF; Qos: LPQOS): Integer; stdcall;
  545.   {$EXTERNALSYM LPWSCINSTALLQOSTEMPLATE}
  546.   TWscInstallQosTemplate = LPWSCINSTALLQOSTEMPLATE;
  548. function WSCRemoveQOSTemplate(const Guid: TGUID; QosName: LPWSABUF): Integer; stdcall;
  549. {$EXTERNALSYM WSCRemoveQOSTemplate}
  551. type
  552.   LPWSCREMOVEQOSTEMPLATE = function (const Guid: TGUID; QosName: LPWSABUF): Integer; stdcall;
  553.   {$EXTERNALSYM LPWSCREMOVEQOSTEMPLATE}
  554.   TWscRemoveQosTemplate = LPWSCREMOVEQOSTEMPLATE;
  556. (*
  557.  *  The following upcall function prototypes are only used by WinSock 2 DLL and
  558.  *  should not be used by any service providers.
  559.  *
  561. function WPUCloseEvent(hEvent: WSAEVENT; var lpErrno: Integer): BOOL; stdcall;
  562. {$EXTERNALSYM WPUCloseEvent}
  564. function WPUCloseSocketHandle(s: TSocket; var lpErrno: Integer): Integer; stdcall;
  565. {$EXTERNALSYM WPUCloseSocketHandle}
  567. function WPUCreateEvent(var lpErrno: Integer): WSAEVENT; stdcall;
  568. {$EXTERNALSYM WPUCreateEvent}
  570. function WPUCreateSocketHandle(dwCatalogEntryId, dwContext: DWORD; var lpErrno: Integer): SOCKET; stdcall;
  571. {$EXTERNALSYM WPUCreateSocketHandle}
  573. function WPUFDIsSet(s: TSocket; const fdset: fd_set): Integer; stdcall;
  574. {$EXTERNALSYM WPUFDIsSet}
  576. function WPUGetProviderPath(const lpProviderId: TGUID; lpszProviderDllPath: PWCHAR;
  577.   var lpProviderDllPathLen, lpErrno: : Integer): Integer; stdcall;
  578. {$EXTERNALSYM WPUGetProviderPath}
  580. function WPUModifyIFSHandle(dwCatalogEntryId: DWORD; ProposedHandle: SOCKET; var lpErrno: Integer): SOCKET; stdcall;
  581. {$EXTERNALSYM WPUModifyIFSHandle}
  583. function WPUPostMessage(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): BOOL; stdcall;
  584. {$EXTERNALSYM WPUPostMessage}
  586. function WPUQueryBlockingCallback(dwCatalogEntryId: DWORD; var lplpfnCallback: LPBLOCKINGCALLBACK;
  587.   var lpdwContext: DWORD_PTR; var lpErrno: Integer): Integer; stdcall;
  588. {$EXTERNALSYM WPUQueryBlockingCallback}
  590. function WPUQuerySocketHandleContext(s: SOCKET; var lpContext: DWORD_PTR; lpErrno: Integer): Integer; stdcall;
  591. {$EXTERNALSYM WPUQuerySocketHandleContext}
  593. function WPUQueueApc(lpThreadId: LPWSATHREADID; lpfnUserApc: LPWSAUSERAPC;
  594.   dwContext: DWORD_PTR; var lpErrno: Integer): Integer; stdcall;
  595. {$EXTERNALSYM WPUQueueApc}
  597. function WPUResetEvent(hEvent: WSAEVENT; var lpErrno: Integer): BOOL; stcall;
  598. {$EXTERNALSYM WPUResetEvent}
  600. function WPUSetEvent(hEvent: WSAEVENT; var lpErrno: Integer): BOOL; stdcall;
  601. {$EXTERNALSYM WPUSetEvent}
  603. function WPUCompleteOverlappedRequest(s: SOCKET; lpOverlapped: LPWSAOVERLAPPED;
  604.   dwError, cbTransferred: DWORD; var lpErrno: Integer): Integerl stdcall;
  605. {$EXTERNALSYM WPUCompleteOverlappedRequest}
  607. function WPUOpenCurrentThread(lpThreadId: LPWSATHREADID; lpErrno: PINT): Integer; stdcall;
  608. {$EXTERNALSYM WPUOpenCurrentThread}
  610. function WPUCloseThread(lpThreadId: LPWSATHREADID; lpErrno: PINT): Integer; stdcall;
  611. {$EXTERNALSYM WPUCloseThread}
  613. *)
  615. (*
  616.  * Installing and uninstalling name space providers.
  617.  *)
  619. //
  620. // SPI and API for enumerating name space providers are
  621. // currently equivalent since there is no concept of a hidden
  622. // name space provider
  623. //
  625. //TODO
  626. //#define WSCEnumNameSpaceProviders WSAEnumNameSpaceProvidersW
  627. //#define LPFN_WSCENUMNAMESPACEPROVIDERS LPFN_WSAENUMNAMESPACEPROVIDERSW
  629. {$IFDEF _WIN64}
  631. function WSCEnumNameSpaceProviders32(lpdwBufferLength: LPDWORD; lpnspBuffer: LPWSANAMESPACE_INFOW): Integer; stdcall;
  632. {$EXTERNALSYM WSCEnumNameSpaceProviders32}
  634. {$ENDIF _WIN64}
  636. function WSCInstallNameSpace(lpszIdentifier, lpszPathName: LPWSTR; dwNameSpace,
  637.   dwVersion: DWORD; const lpProviderId: TGUID): Integer; stdcall;
  638. {$EXTERNALSYM WSCInstallNameSpace}
  640. type
  641.   LPWSCINSTALLNAMESPACE = function (lpszIdentifier, lpszPathName: LPWSTR;
  642.     dwNameSpace, dwVersion: DWORD; const lpProviderId: TGUID): Integer; stdcall;
  643.   {$EXTERNALSYM LPWSCINSTALLNAMESPACE}
  644.   TWscInstallNamespace = LPWSCINSTALLNAMESPACE;
  646. {$IFDEF _WIN64}
  648. function WSCInstallNameSpace32(lpszIdentifier, lpszPathName: LPWSTR; dwNameSpace, dwVersion: DWORD; lpProviderId: PGUID): Integer; stdcall;
  649. {$EXTERNALSYM WSCInstallNameSpace32}
  651. {$ENDIF _WIN64}
  653. function WSCUnInstallNameSpace(const lpProviderId: TGUID): Integer; stdcall;
  654. {$EXTERNALSYM WSCUnInstallNameSpace}
  656. type
  657.   LPWSCUNINSTALLNAMESPACE = function (const lpProviderId: TGUID): Integer; stdcall;
  658.   {$EXTERNALSYM LPWSCUNINSTALLNAMESPACE}
  659.   TWscUninstallNamespace = LPWSCUNINSTALLNAMESPACE;
  661. {$IFDEF _WIN64}
  663. function WSCUnInstallNameSpace32(lpProviderId: PGUID): Integer; stdcall;
  664. {$EXTERNALSYM WSCUnInstallNameSpace32}
  666. {$ENDIF _WIN64}
  668. function WSCEnableNSProvider(const lpProviderId: TGUID; fEnable: BOOL): Integer; stdcall;
  669. {$EXTERNALSYM WSCEnableNSProvider}
  671. type
  672.   LPWSCENABLENSPROVIDER = function (const lpProviderId: TGUID; fEnable: BOOL): Integer; stdcall;
  673.   {$EXTERNALSYM LPWSCENABLENSPROVIDER}
  674.   TWscEnableNsProvider = LPWSCENABLENSPROVIDER;
  676. {$IFDEF _WIN64}
  678. function WSCEnableNSProvider32(lpProviderId: PGUID; fEnable: BOOL): Integer; stdcall;
  679. {$EXTERNALSYM WSCEnableNSProvider32}
  681. {$ENDIF _WIN64}
  684. (*
  685.  * Pointers to the individual entries in the namespace proc table.
  686.  *)
  688. type
  689.   LPNSPCLEANUP = function (const lpProviderId: TGUID): Integer; stdcall;
  690.   {$EXTERNALSYM LPNSPCLEANUP}
  691.   TNspCleanup = LPNSPCLEANUP;
  693.   LPNSPLOOKUPSERVICEBEGIN = function (const lpProviderId: TGUID;
  694.     lpqsRestrictions: LPWSAQUERYSETW; lpServiceClassInfo: LPWSASERVICECLASSINFOW;
  695.     dwControlFlags: DWORD; lphLookup: LPHANDLE): Integer; stdcall;
  696.   {$EXTERNALSYM LPNSPLOOKUPSERVICEBEGIN}
  697.   TNspLookupServiceBegin = LPNSPLOOKUPSERVICEBEGIN;
  699.   LPNSPLOOKUPSERVICENEXT = function (hLookup: HANDLE; dwControlFlags: DWORD;
  700.     lpdwBufferLength: LPDWORD; lpqsResults: LPWSAQUERYSETW): Integer; stdcall;
  701.   {$EXTERNALSYM LPNSPLOOKUPSERVICENEXT}
  702.   TNspLookupServiceNext = LPNSPLOOKUPSERVICENEXT;
  704.   LPNSPIOCTL = function (hLookup: HANDLE; dwControlCode: DWORD; lpvInBuffer: LPVOID;
  705.     cbInBuffer: DWORD; lpvOutBuffer: LPVOID; cbOutBuffer: DWORD; lpcbBytesReturned: LPDWORD;
  706.     lpCompletion: LPWSACOMPLETION; lpThreadId: LPWSATHREADID): Integer; stdcall;
  707.   {$EXTERNALSYM LPNSPIOCTL}
  709.   LPNSPLOOKUPSERVICEEND = function (hLookup: HANDLE): Integer; stdcall;
  710.   {$EXTERNALSYM LPNSPLOOKUPSERVICEEND}
  711.   TNspLookupServiceEnd = LPNSPLOOKUPSERVICEEND;
  713.   LPNSPSETSERVICE = function (const lpProviderId: TGUID;
  714.     lpServiceClassInfo: LPWSASERVICECLASSINFOW; lpqsRegInfo: LPWSAQUERYSETW;
  715.     essOperation: WSAESETSERVICEOP; dwControlFlags: DWORD): Integer; stdcall;
  716.   {$EXTERNALSYM LPNSPSETSERVICE}
  717.   TNspSetService = LPNSPSETSERVICE;
  719.   LPNSPINSTALLSERVICECLASS = function (const lpProviderId: TGUID;
  720.     lpServiceClassInfo: LPWSASERVICECLASSINFOW): Integer; stdcall;
  721.   {$EXTERNALSYM LPNSPINSTALLSERVICECLASS}
  722.   TNspInstallServiceClass = LPNSPINSTALLSERVICECLASS;
  724.   LPNSPREMOVESERVICECLASS = function (const lpProviderId, lpServiceClassId: TGUID): Integer; stdcall;
  725.   {$EXTERNALSYM LPNSPREMOVESERVICECLASS}
  726.   TNspRemoveServiceClass = LPNSPREMOVESERVICECLASS;
  728.   LPNSPGETSERVICECLASSINFO = function (const lpProviderId: TGUID; lpdwBufSize: LPDWORD;
  729.     lpServiceClassInfo: LPWSASERVICECLASSINFOW): Integer; stdcall;
  730.   {$EXTERNALSYM LPNSPGETSERVICECLASSINFO}
  731.   TNspGetServiceClassInfo = LPNSPGETSERVICECLASSINFO;
  733. (*
  734.  * The name space service provider procedure table.
  735.  *)
  737. type
  738.   _NSP_ROUTINE = record
  739.     (* Structure version information: *)
  740.     cbSize: DWORD;
  741.     dwMajorVersion: DWORD;
  742.     dwMinorVersion: DWORD;
  743.     (* Procedure-pointer table: *)
  744.     NSPCleanup: LPNSPCLEANUP;
  745.     NSPLookupServiceBegin: LPNSPLOOKUPSERVICEBEGIN;
  746.     NSPLookupServiceNext: LPNSPLOOKUPSERVICENEXT;
  747.     NSPLookupServiceEnd: LPNSPLOOKUPSERVICEEND;
  748.     NSPSetService: LPNSPSETSERVICE;
  749.     NSPInstallServiceClass: LPNSPINSTALLSERVICECLASS;
  750.     NSPRemoveServiceClass: LPNSPREMOVESERVICECLASS;
  751.     NSPGetServiceClassInfo: LPNSPGETSERVICECLASSINFO;
  752.     // These APIs were added later, so must appear here
  753.     // to keep the pointers in the structure in order.
  754.     // Namespaces unaware of these APIs will set cbSize
  755.     // to match the size of FIELD_OFFSET(NSP_ROUTINE, NSPIoctl).
  756.     NSPIoctl: LPNSPIOCTL;
  757.   end;
  758.   {$EXTERNALSYM _NSP_ROUTINE}
  759.   NSP_ROUTINE = _NSP_ROUTINE;
  760.   {$EXTERNALSYM NSP_ROUTINE}
  761.   LPNSP_ROUTINE = ^NSP_ROUTINE;
  762.   {$EXTERNALSYM LPNSP_ROUTINE}
  763.   TNspRoutines = NSP_ROUTINE;
  764.   PNspRoutines = LPNSP_ROUTINE;
  766. (*
  767.  * Startup procedures.
  768.  *)
  770. //function NSPStartup(const lpProviderId: TGUID; lpnspRoutines:  LPNSP_ROUTINE): Integer; stdcall;
  771. //{$EXTERNALSYM NSPStartup}
  773. type
  774.   LPNSPSTARTUP = function (const lpProviderId: TGUID; lpnspRoutines:  LPNSP_ROUTINE): Integer; stdcall;
  775.   {$EXTERNALSYM LPNSPSTARTUP}
  776.   TNspStartup = LPNSPSTARTUP;
  778. implementation
  780. const
  781.   ws2_32 = 'ws2_32.dll';
  782.   qosname = 'qosname.dll';
  785. {$IFDEF DYNAMIC_LINK}
  786. var
  787.   _WSCEnumProtocols: Pointer;
  789. function WSCEnumProtocols;
  790. begin
  791.   GetProcedureAddress(_WSCEnumProtocols, ws2_32, 'WSCEnumProtocols');
  792.   asm
  793.     mov esp, ebp
  794.     pop ebp
  795.     jmp [_WSCEnumProtocols]
  796.   end;
  797. end;
  798. {$ELSE}
  799. function WSCEnumProtocols; external ws2_32 name 'WSCEnumProtocols';
  800. {$ENDIF DYNAMIC_LINK}
  801. {$IFDEF _WIN64}
  803. {$IFDEF DYNAMIC_LINK}
  804. var
  805.   _WSCEnumProtocols32: Pointer;
  807. function WSCEnumProtocols32;
  808. begin
  809.   GetProcedureAddress(_WSCEnumProtocols32, ws2_32, 'WSCEnumProtocols32');
  810.   asm
  811.     mov esp, ebp
  812.     pop ebp
  813.     jmp [_WSCEnumProtocols32]
  814.   end;
  815. end;
  816. {$ELSE}
  817. function WSCEnumProtocols32; external ws2_32 name 'WSCEnumProtocols32';
  818. {$ENDIF DYNAMIC_LINK}
  819. {$ENDIF}
  821. {$IFDEF DYNAMIC_LINK}
  822. var
  823.   _WSCDeinstallProvider: Pointer;
  825. function WSCDeinstallProvider;
  826. begin
  827.   GetProcedureAddress(_WSCDeinstallProvider, ws2_32, 'WSCDeinstallProvider');
  828.   asm
  829.     mov esp, ebp
  830.     pop ebp
  831.     jmp [_WSCDeinstallProvider]
  832.   end;
  833. end;
  834. {$ELSE}
  835. function WSCDeinstallProvider; external ws2_32 name 'WSCDeinstallProvider';
  836. {$ENDIF DYNAMIC_LINK}
  837. {$IFDEF _WIN64}
  839. {$IFDEF DYNAMIC_LINK}
  840. var
  841.   _WSCDeinstallProvider32: Pointer;
  843. function WSCDeinstallProvider32;
  844. begin
  845.   GetProcedureAddress(_WSCDeinstallProvider32, ws2_32, 'WSCDeinstallProvider32');
  846.   asm
  847.     mov esp, ebp
  848.     pop ebp
  849.     jmp [_WSCDeinstallProvider32]
  850.   end;
  851. end;
  852. {$ELSE}
  853. function WSCDeinstallProvider32; external ws2_32 name 'WSCDeinstallProvider32';
  854. {$ENDIF DYNAMIC_LINK}
  855. {$ENDIF _WIN64}
  857. {$IFDEF DYNAMIC_LINK}
  858. var
  859.   _WSCInstallProvider: Pointer;
  861. function WSCInstallProvider;
  862. begin
  863.   GetProcedureAddress(_WSCInstallProvider, ws2_32, 'WSCInstallProvider');
  864.   asm
  865.     mov esp, ebp
  866.     pop ebp
  867.     jmp [_WSCInstallProvider]
  868.   end;
  869. end;
  870. {$ELSE}
  871. function WSCInstallProvider; external ws2_32 name 'WSCInstallProvider';
  872. {$ENDIF DYNAMIC_LINK}
  873. {$IFDEF _WIN64}
  875. {$IFDEF DYNAMIC_LINK}
  876. var
  877.   _WSCInstallProvider64_32: Pointer;
  879. function WSCInstallProvider64_32;
  880. begin
  881.   GetProcedureAddress(_WSCInstallProvider64_32, ws2_32, 'WSCInstallProvider64_32');
  882.   asm
  883.     mov esp, ebp
  884.     pop ebp
  885.     jmp [_WSCInstallProvider64_32]
  886.   end;
  887. end;
  888. {$ELSE}
  889. function WSCInstallProvider64_32; external ws2_32 name 'WSCInstallProvider64_32';
  890. {$ENDIF DYNAMIC_LINK}
  891. {$ENDIF _WIN64}
  893. {$IFDEF DYNAMIC_LINK}
  894. var
  895.   _WSCGetProviderPath: Pointer;
  897. function WSCGetProviderPath;
  898. begin
  899.   GetProcedureAddress(_WSCGetProviderPath, ws2_32, 'WSCGetProviderPath');
  900.   asm
  901.     mov esp, ebp
  902.     pop ebp
  903.     jmp [_WSCGetProviderPath]
  904.   end;
  905. end;
  906. {$ELSE}
  907. function WSCGetProviderPath; external ws2_32 name 'WSCGetProviderPath';
  908. {$ENDIF DYNAMIC_LINK}
  909. {$IFDEF _WIN64}
  911. {$IFDEF DYNAMIC_LINK}
  912. var
  913.   _WSCGetProviderPath32: Pointer;
  915. function WSCGetProviderPath32;
  916. begin
  917.   GetProcedureAddress(_WSCGetProviderPath32, ws2_32, 'WSCGetProviderPath32');
  918.   asm
  919.     mov esp, ebp
  920.     pop ebp
  921.     jmp [_WSCGetProviderPath32]
  922.   end;
  923. end;
  924. {$ELSE}
  925. function WSCGetProviderPath32; external ws2_32 name 'WSCGetProviderPath32';
  926. {$ENDIF DYNAMIC_LINK}
  927. {$ENDIF _WIN64}
  929. {$IFDEF DYNAMIC_LINK}
  930. var
  931.   _WSCUpdateProvider: Pointer;
  933. function WSCUpdateProvider;
  934. begin
  935.   GetProcedureAddress(_WSCUpdateProvider, ws2_32, 'WSCUpdateProvider');
  936.   asm
  937.     mov esp, ebp
  938.     pop ebp
  939.     jmp [_WSCUpdateProvider]
  940.   end;
  941. end;
  942. {$ELSE}
  943. function WSCUpdateProvider; external ws2_32 name 'WSCUpdateProvider';
  944. {$ENDIF DYNAMIC_LINK}
  945. {$IFDEF _WIN64}
  947. {$IFDEF DYNAMIC_LINK}
  948. var
  949.   _WSCUpdateProvider32: Pointer;
  951. function WSCUpdateProvider32;
  952. begin
  953.   GetProcedureAddress(_WSCUpdateProvider32, ws2_32, 'WSCUpdateProvider32');
  954.   asm
  955.     mov esp, ebp
  956.     pop ebp
  957.     jmp [_WSCUpdateProvider32]
  958.   end;
  959. end;
  960. {$ELSE}
  961. function WSCUpdateProvider32; external ws2_32 name 'WSCUpdateProvider32';
  962. {$ENDIF DYNAMIC_LINK}
  963. {$ENDIF _WIN64}
  965. {$IFDEF DYNAMIC_LINK}
  966. var
  967.   _WSCInstallQOSTemplate: Pointer;
  969. function WSCInstallQOSTemplate;
  970. begin
  971.   GetProcedureAddress(_WSCInstallQOSTemplate, JwaWs2spi.qosname, 'WSCInstallQOSTemplate');
  972.   asm
  973.     mov esp, ebp
  974.     pop ebp
  975.     jmp [_WSCInstallQOSTemplate]
  976.   end;
  977. end;
  978. {$ELSE}
  979. function WSCInstallQOSTemplate; external qosname name 'WSCInstallQOSTemplate';
  980. {$ENDIF DYNAMIC_LINK}
  982. {$IFDEF DYNAMIC_LINK}
  983. var
  984.   _WSCRemoveQOSTemplate: Pointer;
  986. function WSCRemoveQOSTemplate;
  987. begin
  988.   GetProcedureAddress(_WSCRemoveQOSTemplate, JwaWs2spi.qosname, 'WSCRemoveQOSTemplate');
  989.   asm
  990.     mov esp, ebp
  991.     pop ebp
  992.     jmp [_WSCRemoveQOSTemplate]
  993.   end;
  994. end;
  995. {$ELSE}
  996. function WSCRemoveQOSTemplate; external qosname name 'WSCRemoveQOSTemplate';
  997. {$ENDIF DYNAMIC_LINK}
  998. {$IFDEF _WIN64}
  1000. {$IFDEF DYNAMIC_LINK}
  1001. var
  1002.   _WSCEnumNameSpaceProviders32: Pointer;
  1004. function WSCEnumNameSpaceProviders32;
  1005. begin
  1006.   GetProcedureAddress(_WSCEnumNameSpaceProviders32, ws2_32, 'WSCEnumNameSpaceProviders32');
  1007.   asm
  1008.     mov esp, ebp
  1009.     pop ebp
  1010.     jmp [_WSCEnumNameSpaceProviders32]
  1011.   end;
  1012. end;
  1013. {$ELSE}
  1014. function WSCEnumNameSpaceProviders32; external ws2_32 name 'WSCEnumNameSpaceProviders32';
  1015. {$ENDIF DYNAMIC_LINK}
  1016. {$ENDIF _WIN64}
  1018. {$IFDEF DYNAMIC_LINK}
  1019. var
  1020.   _WSCInstallNameSpace: Pointer;
  1022. function WSCInstallNameSpace;
  1023. begin
  1024.   GetProcedureAddress(_WSCInstallNameSpace, ws2_32, 'WSCInstallNameSpace');
  1025.   asm
  1026.     mov esp, ebp
  1027.     pop ebp
  1028.     jmp [_WSCInstallNameSpace]
  1029.   end;
  1030. end;
  1031. {$ELSE}
  1032. function WSCInstallNameSpace; external ws2_32 name 'WSCInstallNameSpace';
  1033. {$ENDIF DYNAMIC_LINK}
  1034. {$IFDEF _WIN64}
  1036. {$IFDEF DYNAMIC_LINK}
  1037. var
  1038.   _WSCInstallNameSpace32: Pointer;
  1040. function WSCInstallNameSpace32;
  1041. begin
  1042.   GetProcedureAddress(_WSCInstallNameSpace32, ws2_32, 'WSCInstallNameSpace32');
  1043.   asm
  1044.     mov esp, ebp
  1045.     pop ebp
  1046.     jmp [_WSCInstallNameSpace32]
  1047.   end;
  1048. end;
  1049. {$ELSE}
  1050. function WSCInstallNameSpace32; external ws2_32 name 'WSCInstallNameSpace32';
  1051. {$ENDIF DYNAMIC_LINK}
  1052. {$ENDIF _WIN64}
  1054. {$IFDEF DYNAMIC_LINK}
  1055. var
  1056.   _WSCUnInstallNameSpace: Pointer;
  1058. function WSCUnInstallNameSpace;
  1059. begin
  1060.   GetProcedureAddress(_WSCUnInstallNameSpace, ws2_32, 'WSCUnInstallNameSpace');
  1061.   asm
  1062.     mov esp, ebp
  1063.     pop ebp
  1064.     jmp [_WSCUnInstallNameSpace]
  1065.   end;
  1066. end;
  1067. {$ELSE}
  1068. function WSCUnInstallNameSpace; external ws2_32 name 'WSCUnInstallNameSpace';
  1069. {$ENDIF DYNAMIC_LINK}
  1070. {$IFDEF _WIN64}
  1072. {$IFDEF DYNAMIC_LINK}
  1073. var
  1074.   _WSCUnInstallNameSpace32: Pointer;
  1076. function WSCUnInstallNameSpace32;
  1077. begin
  1078.   GetProcedureAddress(_WSCUnInstallNameSpace32, ws2_32, 'WSCUnInstallNameSpace32');
  1079.   asm
  1080.     mov esp, ebp
  1081.     pop ebp
  1082.     jmp [_WSCUnInstallNameSpace32]
  1083.   end;
  1084. end;
  1085. {$ELSE}
  1086. function WSCUnInstallNameSpace32; external ws2_32 name 'WSCUnInstallNameSpace32';
  1087. {$ENDIF DYNAMIC_LINK}
  1088. {$ENDIF _WIN64}
  1090. {$IFDEF DYNAMIC_LINK}
  1091. var
  1092.   _WSCEnableNSProvider: Pointer;
  1094. function WSCEnableNSProvider;
  1095. begin
  1096.   GetProcedureAddress(_WSCEnableNSProvider, ws2_32, 'WSCEnableNSProvider');
  1097.   asm
  1098.     mov esp, ebp
  1099.     pop ebp
  1100.     jmp [_WSCEnableNSProvider]
  1101.   end;
  1102. end;
  1103. {$ELSE}
  1104. function WSCEnableNSProvider; external ws2_32 name 'WSCEnableNSProvider';
  1105. {$ENDIF DYNAMIC_LINK}
  1106. {$IFDEF _WIN64}
  1108. {$IFDEF DYNAMIC_LINK}
  1109. var
  1110.   _WSCEnableNSProvider32: Pointer;
  1112. function WSCEnableNSProvider32;
  1113. begin
  1114.   GetProcedureAddress(_WSCEnableNSProvider32, ws2_32, 'WSCEnableNSProvider32');
  1115.   asm
  1116.     mov esp, ebp
  1117.     pop ebp
  1118.     jmp [_WSCEnableNSProvider32]
  1119.   end;
  1120. end;
  1121. {$ELSE}
  1122. function WSCEnableNSProvider32; external ws2_32 name 'WSCEnableNSProvider32';
  1123. {$ENDIF DYNAMIC_LINK}
  1124. {$ENDIF _WIN64}
  1126. end.