← Back to branch summary

~ubuntu-branches/debian/lenny/fpc/lenny

« back to all changes in this revision

Viewing changes to fpcsrc/packages/base/winunits/jwaws2spi.pas

  • Committer: Bazaar Package Importer
  • Author(s): Mazen Neifer, Torsten Werner, Mazen Neifer
  • Date: 2008-05-17 17:12:11 UTC
  • mfrom: (3.1.9 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080517171211-9qi33xhd9evfa0kg
Tags: 2.2.0-dfsg1-9
http://bugs.debian.org/477743
[ Torsten Werner ]
* Add Mazen Neifer to Uploaders field.

[ Mazen Neifer ]
* Moved FPC sources into a version dependent directory from /usr/share/fpcsrc
  to /usr/share/fpcsrc/${FPCVERSION}. This allow installing more than on FPC
  release.
* Fixed far call issue in compiler preventing building huge binearies.
  (closes: #477743)
* Updated building dependencies, recomennded and suggested packages.
* Moved fppkg to fp-utils as it is just a helper tool and is not required by
  compiler.

Show diffs side-by-side

added added

removed removed

Lines of Context:
fpcsrc/packages/base/winunits/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 att chello dott 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         }
 
18
{ APILIB home page, located at http://jedi-apilib.sourceforge.net              }
 
19
{                                                                              }
 
20
{ The contents of this file are used with permission, subject to the Mozilla   }
 
21
{ Public License Version 1.1 (the "License"); you may not use this file except }
 
22
{ in compliance with the License. You may obtain a copy of the License at      }
 
23
{ http://www.mozilla.org/MPL/MPL-1.1.html                                      }
 
24
{                                                                              }
 
25
{ Software distributed under the License is distributed on an "AS IS" basis,   }
 
26
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
 
27
{ the specific language governing rights and limitations under the License.    }
 
28
{                                                                              }
 
29
{ Alternatively, the contents of this file may be used under the terms of the  }
 
30
{ GNU Lesser General Public License (the  "LGPL License"), in which case the   }
 
31
{ provisions of the LGPL License are applicable instead of those above.        }
 
32
{ If you wish to allow use of your version of this file only under the terms   }
 
33
{ of the LGPL License and not to allow others to use your version of this file }
 
34
{ under the MPL, indicate your decision by deleting  the provisions above and  }
 
35
{ replace  them with the notice and other provisions required by the LGPL      }
 
36
{ License.  If you do not delete the provisions above, a recipient may use     }
 
37
{ your version of this file under either the MPL or the LGPL License.          }
 
38
{                                                                              }
 
39
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
 
40
{                                                                              }
 
41
{******************************************************************************}
 
42
 
 
43
// $Id: JwaWS2spi.pas,v 1.9 2005/09/06 16:36:50 marquardt Exp $
 
44
 
 
45
unit JwaWS2spi;
 
46
 
 
47
{$WEAKPACKAGEUNIT}
 
48
 
 
49
{$HPPEMIT ''}
 
50
{$HPPEMIT '#include "ws2spi.h"'}
 
51
{$HPPEMIT ''}
 
52
 
 
53
{$I jediapilib.inc}
 
54
 
 
55
interface
 
56
 
 
57
uses
 
58
  JwaWindows, JwaWinSock2;
 
59
 
 
60
(*
 
61
 * Ensure structures are packed consistently.
 
62
 *)
 
63
 
 
64
{$IFDEF _WIN64}
 
65
{$ALIGN OFF}
 
66
{$ELSE}
 
67
{$ALIGN ON}
 
68
{$ENDIF _WIN64}
 
69
 
 
70
const
 
71
  WSPDESCRIPTION_LEN = 255;
 
72
  {$EXTERNALSYM WSPDESCRIPTION_LEN}
 
73
 
 
74
  WSS_OPERATION_IN_PROGRESS = $00000103;
 
75
  {$EXTERNALSYM WSS_OPERATION_IN_PROGRESS}
 
76
 
 
77
type
 
78
  WSPData = record
 
79
    wVersion: WORD;
 
80
    wHighVersion: WORD;
 
81
    szDescription: array [0..WSPDESCRIPTION_LEN] of WCHAR;
 
82
  end;
 
83
  {$EXTERNALSYM WSPData}
 
84
  LPWSPDATA = ^WSPData;
 
85
  {$EXTERNALSYM LPWSPDATA}
 
86
  TWSPData = WSPDATA;
 
87
  PWSPData = LPWSPDATA;
 
88
 
 
89
  _WSATHREADID = record
 
90
    ThreadHandle: HANDLE;
 
91
    Reserved: DWORD;
 
92
  end;
 
93
  {$EXTERNALSYM _WSATHREADID}
 
94
  WSATHREADID = _WSATHREADID;
 
95
  {$EXTERNALSYM WSATHREADID}
 
96
  LPWSATHREADID = ^WSATHREADID;
 
97
  {$EXTERNALSYM LPWSATHREADID}
 
98
  TWSAThreadID = WSATHREADID;
 
99
  PWSAThreadID = LPWSATHREADID;
 
100
 
 
101
(*
 
102
 * Pointer to a blocking callback. A pointer to a blocking callback is
 
103
 * returned from the WPUQueryBlockingCallback() upcall. Note that this
 
104
 * function's signature is not identical to an application's blocking
 
105
 * hook function.
 
106
 *)
 
107
 
 
108
type
 
109
  LPBLOCKINGCALLBACK = function(dwContext: DWORD): BOOL; stdcall;
 
110
  {$EXTERNALSYM LPBLOCKINGCALLBACK}
 
111
  TBlockingCallback = LPBLOCKINGCALLBACK;
 
112
 
 
113
(*
 
114
 * Pointer to a user APC function. This is used as a parameter to the
 
115
 * WPUQueueUserApc() upcall. Note that this function's signature is not
 
116
 * identical to an application's completion routine.
 
117
 *)
 
118
 
 
119
  LPWSAUSERAPC = procedure(dwContext: DWORD); stdcall;
 
120
  {$EXTERNALSYM LPWSAUSERAPC}
 
121
  TWsaUserApc = LPWSAUSERAPC;
 
122
 
 
123
(*
 
124
 * Pointers to the individual entries in a service provider's proc table.
 
125
 *)
 
126
 
 
127
  LPWSPACCEPT = function(s: TSocket; addr: PSockAddr; addrlen: PINT;
 
128
    lpfnCondition: LPCONDITIONPROC; dwCallbackData: DWORD; var Errno: Integer): TSocket; stdcall;
 
129
  {$EXTERNALSYM LPWSPACCEPT}
 
130
  TWspAccept = LPWSPACCEPT;
 
131
 
 
132
  LPWSPADDRESSTOSTRING = function(lpsaAddress: LPSOCKADDR; dwAddressLength: DWORD;
 
133
    lpProtocolInfo: LPWSAPROTOCOL_INFOW; lpszAddressString: LPWSTR;
 
134
    var lpdwAddressStringLength: DWORD; var lpErrno: Integer): Integer; stdcall;
 
135
  {$EXTERNALSYM LPWSPADDRESSTOSTRING}
 
136
  TWspAddressToString = LPWSPADDRESSTOSTRING;
 
137
 
 
138
  LPWSPASYNCSELECT = function(s: TSocket; hWnd: HWND; wMsg: u_int; lEvent: Longint; var lpErrno: Integer): Integer; stdcall;
 
139
  {$EXTERNALSYM LPWSPASYNCSELECT}
 
140
  TWspASyncSelect = LPWSPASYNCSELECT;
 
141
 
 
142
  LPWSPBIND = function(s: TSocket; var name: sockaddr; namelen: Integer; var lpErrno: Integer): Integer; stdcall;
 
143
  {$EXTERNALSYM LPWSPBIND}
 
144
  TWspBind = LPWSPBIND;
 
145
 
 
146
  LPWSPCANCELBLOCKINGCALL = function(var lpErrno: Integer): Integer; stdcall;
 
147
  {$EXTERNALSYM LPWSPCANCELBLOCKINGCALL}
 
148
  TWspCancelBlockingCall = LPWSPCANCELBLOCKINGCALL;
 
149
 
 
150
  LPWSPCLEANUP = function(var lpErrno: Integer): Integer; stdcall;
 
151
  {$EXTERNALSYM LPWSPCLEANUP}
 
152
  TWspCleanup = LPWSPCLEANUP;
 
153
 
 
154
  LPWSPCLOSESOCKET = function(s: TSocket; var lpErrno: Integer): Integer; stdcall;
 
155
  {$EXTERNALSYM LPWSPCLOSESOCKET}
 
156
  TWspCloseSocket = LPWSPCLOSESOCKET;
 
157
 
 
158
  LPWSPCONNECT = function(s: TSocket; name: PSockAddr; namelen: Integer; lpCallerData: LPWSABUF;
 
159
    lpCalleeData: LPWSABUF; lpSQOS: LPQOS; lpGQOS: LPQOS; var lpErrno: Integer): Integer; stdcall;
 
160
  {$EXTERNALSYM LPWSPCONNECT}
 
161
  TWspConnect = LPWSPCONNECT;
 
162
 
 
163
  LPWSPDUPLICATESOCKET = function(s: TSocket; dwProcessId: DWORD; lpProtocolInfo: LPWSAPROTOCOL_INFOW; var lpErrno: Integer): Integer; stdcall;
 
164
  {$EXTERNALSYM LPWSPDUPLICATESOCKET}
 
165
  TWspDuplicateSocket = LPWSPDUPLICATESOCKET;
 
166
 
 
167
  LPWSPENUMNETWORKEVENTS = function(s: TSocket; hEventObject: WSAEVENT; lpNetworkEvents: LPWSANETWORKEVENTS; var lpErrno: Integer): Integer; stdcall;
 
168
  {$EXTERNALSYM LPWSPENUMNETWORKEVENTS}
 
169
  TWspEnumNetworkEvents = LPWSPENUMNETWORKEVENTS;
 
170
 
 
171
  LPWSPEVENTSELECT = function(s: TSocket; hEventObject: WSAEVENT; lNetworkEvents: Longint; var lpErrno: Integer): Integer; stdcall;
 
172
  {$EXTERNALSYM LPWSPEVENTSELECT}
 
173
  TWspEventSelect = LPWSPEVENTSELECT;
 
174
 
 
175
  LPWSPGETOVERLAPPEDRESULT = function(s: TSocket; lpOverlapped: LPWSAOVERLAPPED;
 
176
    var lpcbTransfer: DWORD; fWait: BOOL; lpdwFlags: DWORD; var lpErrno: Integer): BOOL; stdcall;
 
177
  {$EXTERNALSYM LPWSPGETOVERLAPPEDRESULT}
 
178
  TWspGetOverlappedResult = LPWSPGETOVERLAPPEDRESULT;
 
179
 
 
180
  LPWSPGETPEERNAME = function(s: TSocket; var name: sockaddr; var namelen, lpErrno: Integer): Integer; stdcall;
 
181
  {$EXTERNALSYM LPWSPGETPEERNAME}
 
182
  TWspGetPeerName = LPWSPGETPEERNAME;
 
183
 
 
184
  LPWSPGETSOCKNAME = function(s: TSocket; var name: sockaddr; var namelen, lpErrno: Integer): Integer; stdcall;
 
185
  {$EXTERNALSYM LPWSPGETSOCKNAME}
 
186
  TWspGetSockName = LPWSPGETSOCKNAME;
 
187
 
 
188
  LPWSPGETSOCKOPT = function(s: TSocket; level, optname: Integer; optval: PChar; var optlen, lpErrno: Integer): Integer; stdcall;
 
189
  {$EXTERNALSYM LPWSPGETSOCKOPT}
 
190
  TWspGetSockOpt = LPWSPGETSOCKOPT;
 
191
 
 
192
  LPWSPGETQOSBYNAME = function(s: TSocket; var lpQOSName: WSABUF; lpQOS: LPQOS; lpErrno: Integer): BOOL; stdcall;
 
193
  {$EXTERNALSYM LPWSPGETQOSBYNAME}
 
194
  TWspGetQosByName = LPWSPGETQOSBYNAME;
 
195
 
 
196
  LPWSPIOCTL = function(s: TSocket; dwIoControlCode: DWORD; lpvInBuffer: LPVOID; cbInBuffer: DWORD;
 
197
    lpvOutBuffer: LPVOID; cbOutBuffer: DWORD; var lpcbBytesReturned: DWORD;
 
198
    lpOverlapped: LPWSAOVERLAPPED; lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE;
 
199
    lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
 
200
  {$EXTERNALSYM LPWSPIOCTL}
 
201
  TWspIoctl = LPWSPIOCTL;
 
202
 
 
203
  LPWSPJOINLEAF = function(s: TSocket; name: sockaddr; namelen: Integer; lpCallerData: LPWSABUF;
 
204
    lpCalleeData: LPWSABUF; lpSQOS, lpGQOS: LPQOS; dwFlags: DWORD; var lpErrno: Integer): TSocket; stdcall;
 
205
  {$EXTERNALSYM LPWSPJOINLEAF}
 
206
  TWspJoinLeaf = LPWSPJOINLEAF;
 
207
 
 
208
  LPWSPLISTEN = function(s: TSocket; backlog: Integer; var lpErrno: Integer): Integer; stdcall;
 
209
  {$EXTERNALSYM LPWSPLISTEN}
 
210
  TWspListen = LPWSPLISTEN;
 
211
 
 
212
  LPWSPRECV = function(s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD;
 
213
    var lpNumberOfBytesRecvd, lpFlags: DWORD; lpOverlapped: LPWSAOVERLAPPED;
 
214
    lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE; lpThreadId: LPWSATHREADID;
 
215
    var lpErrno: Integer): Integer; stdcall;
 
216
  {$EXTERNALSYM LPWSPRECV}
 
217
  TWspRecv = LPWSPRECV;
 
218
 
 
219
  LPWSPRECVDISCONNECT = function(s: TSocket; lpInboundDisconnectData: LPWSABUF; var lpErrno: Integer): Integer; stdcall;
 
220
  {$EXTERNALSYM LPWSPRECVDISCONNECT}
 
221
  TWspRecvDisconnect = LPWSPRECVDISCONNECT;
 
222
 
 
223
  LPWSPRECVFROM = function(s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD;
 
224
    var lpNumberOfBytesRecvd, lpFlags: DWORD; lpFrom: PSockAddr; lpFromlen: PINT;
 
225
    lpOverlapped: LPWSAOVERLAPPED; lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE;
 
226
    lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
 
227
  {$EXTERNALSYM LPWSPRECVFROM}
 
228
  TWspRecvFrom = LPWSPRECVFROM;
 
229
 
 
230
  LPWSPSELECT = function(nfds: Integer; readfds, writefds, exceptfds: PFdSet; timeout: PTimeVal; var lpErrno: Integer): Integer; stdcall;
 
231
  {$EXTERNALSYM LPWSPSELECT}
 
232
  TWspSelect = LPWSPSELECT;
 
233
 
 
234
  LPWSPSEND = function(s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD;
 
235
    var lpNumberOfBytesSent: DWORD; dwFlags: DWORD; lpOverlapped: LPWSAOVERLAPPED;
 
236
    lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE;
 
237
    lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
 
238
  {$EXTERNALSYM LPWSPSEND}
 
239
  TWspSend = LPWSPSEND;
 
240
 
 
241
  LPWSPSENDDISCONNECT = function(s: TSocket; lpOutboundDisconnectData: LPWSABUF; var lpErrno: Integer): Integer; stdcall;
 
242
  {$EXTERNALSYM LPWSPSENDDISCONNECT}
 
243
  TWspSendDisconnect = LPWSPSENDDISCONNECT;
 
244
 
 
245
  LPWSPSENDTO = function(s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD;
 
246
    var lpNumberOfBytesSent: DWORD; dwFlags: DWORD; lpTo: PSockAddr; iTolen: Integer;
 
247
    lpOverlapped: LPWSAOVERLAPPED; lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE;
 
248
    lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
 
249
  {$EXTERNALSYM LPWSPSENDTO}
 
250
  TWspSendTo = LPWSPSENDTO;
 
251
 
 
252
  LPWSPSETSOCKOPT = function(s: TSocket; level, optname: Integer; optval: PChar; optlen: Integer; var lpErrno: Integer): Integer; stdcall;
 
253
  {$EXTERNALSYM LPWSPSETSOCKOPT}
 
254
  TWspSetSockOpt = LPWSPSETSOCKOPT;
 
255
 
 
256
  LPWSPSHUTDOWN = function(s: TSocket; how: Integer; var lpErrno: Integer): Integer; stdcall;
 
257
  {$EXTERNALSYM LPWSPSHUTDOWN}
 
258
  TWspShutdown = LPWSPSHUTDOWN;
 
259
 
 
260
  LPWSPSOCKET = function(af, type_, protocol: Integer; lpProtocolInfo: LPWSAPROTOCOL_INFOW;
 
261
    g: GROUP; dwFlags: DWORD; var lpErrno: Integer): TSocket; stdcall;
 
262
  {$EXTERNALSYM LPWSPSOCKET}
 
263
  TWspSocket = LPWSPSOCKET;
 
264
 
 
265
  LPWSPSTRINGTOADDRESS = function(AddressString: LPWSTR; AddressFamily: Integer;
 
266
    lpProtocolInfo: LPWSAPROTOCOL_INFOW; lpAddress: LPSOCKADDR;
 
267
    var lpAddressLength, lpErrno: Integer): Integer; stdcall;
 
268
  {$EXTERNALSYM LPWSPSTRINGTOADDRESS}
 
269
  TWspStringToAddress = LPWSPSTRINGTOADDRESS;
 
270
 
 
271
(*
 
272
 * A service provider proc table. This structure is returned by value
 
273
 * from the service provider's WSPStartup() entrypoint.
 
274
 *)
 
275
 
 
276
type
 
277
  _WSPPROC_TABLE = record
 
278
    lpWSPAccept: LPWSPACCEPT;
 
279
    lpWSPAddressToString: LPWSPADDRESSTOSTRING;
 
280
    lpWSPAsyncSelect: LPWSPASYNCSELECT;
 
281
    lpWSPBind: LPWSPBIND;
 
282
    lpWSPCancelBlockingCall: LPWSPCANCELBLOCKINGCALL;
 
283
    lpWSPCleanup: LPWSPCLEANUP;
 
284
    lpWSPCloseSocket: LPWSPCLOSESOCKET;
 
285
    lpWSPConnect: LPWSPCONNECT;
 
286
    lpWSPDuplicateSocket: LPWSPDUPLICATESOCKET;
 
287
    lpWSPEnumNetworkEvents: LPWSPENUMNETWORKEVENTS;
 
288
    lpWSPEventSelect: LPWSPEVENTSELECT;
 
289
    lpWSPGetOverlappedResult: LPWSPGETOVERLAPPEDRESULT;
 
290
    lpWSPGetPeerName: LPWSPGETPEERNAME;
 
291
    lpWSPGetSockName: LPWSPGETSOCKNAME;
 
292
    lpWSPGetSockOpt: LPWSPGETSOCKOPT;
 
293
    lpWSPGetQOSByName: LPWSPGETQOSBYNAME;
 
294
    lpWSPIoctl: LPWSPIOCTL;
 
295
    lpWSPJoinLeaf: LPWSPJOINLEAF;
 
296
    lpWSPListen: LPWSPLISTEN;
 
297
    lpWSPRecv: LPWSPRECV;
 
298
    lpWSPRecvDisconnect: LPWSPRECVDISCONNECT;
 
299
    lpWSPRecvFrom: LPWSPRECVFROM;
 
300
    lpWSPSelect: LPWSPSELECT;
 
301
    lpWSPSend: LPWSPSEND;
 
302
    lpWSPSendDisconnect: LPWSPSENDDISCONNECT;
 
303
    lpWSPSendTo: LPWSPSENDTO;
 
304
    lpWSPSetSockOpt: LPWSPSETSOCKOPT;
 
305
    lpWSPShutdown: LPWSPSHUTDOWN;
 
306
    lpWSPSocket: LPWSPSOCKET;
 
307
    lpWSPStringToAddress: LPWSPSTRINGTOADDRESS;
 
308
  end;
 
309
  {$EXTERNALSYM _WSPPROC_TABLE}
 
310
  WSPPROC_TABLE = _WSPPROC_TABLE;
 
311
  {$EXTERNALSYM WSPPROC_TABLE}
 
312
  LPWSPPROC_TABLE = ^WSPPROC_TABLE;
 
313
  {$EXTERNALSYM LPWSPPROC_TABLE}
 
314
  TWspProcTable = WSPPROC_TABLE;
 
315
  PWspProcTable = LPWSPPROC_TABLE;
 
316
 
 
317
(*
 
318
 * Pointers to the individual entries in the upcall table.
 
319
 *)
 
320
 
 
321
type
 
322
  LPWPUCLOSEEVENT = function(hEvent: WSAEVENT; var lpErrno: Integer): BOOL; stdcall;
 
323
  {$EXTERNALSYM LPWPUCLOSEEVENT}
 
324
  TWpuCloseEvent = LPWPUCLOSEEVENT;
 
325
 
 
326
  LPWPUCLOSESOCKETHANDLE = function(s: TSocket; var lpErrno: Integer): Integer; stdcall;
 
327
  {$EXTERNALSYM LPWPUCLOSESOCKETHANDLE}
 
328
  TWpuCloseSocketHandle = LPWPUCLOSESOCKETHANDLE;
 
329
 
 
330
  LPWPUCREATEEVENT = function(var lpErrno: Integer): WSAEVENT; stdcall;
 
331
  {$EXTERNALSYM LPWPUCREATEEVENT}
 
332
  TWpuCreateEvent = LPWPUCREATEEVENT;
 
333
 
 
334
  LPWPUCREATESOCKETHANDLE = function(dwCatalogEntryId, dwContext: DWORD;
 
335
    var lpErrno: Integer): TSocket; stdcall;
 
336
  {$EXTERNALSYM LPWPUCREATESOCKETHANDLE}
 
337
  TWpuCreateSocketHandle = LPWPUCREATESOCKETHANDLE;
 
338
 
 
339
  LPWPUFDISSET = function(s: TSocket; fdset: PFdSet): Integer; stdcall;
 
340
  {$EXTERNALSYM LPWPUFDISSET}
 
341
  TWpuFdIsSet = LPWPUFDISSET;
 
342
 
 
343
  LPWPUGETPROVIDERPATH = function(const lpProviderId: TGUID;
 
344
    lpszProviderDllPath: PWCHAR; var lpProviderDllPathLen, lpErrno: Integer): Integer; stdcall;
 
345
  {$EXTERNALSYM LPWPUGETPROVIDERPATH}
 
346
  TWpuGetProviderPath = LPWPUGETPROVIDERPATH;
 
347
 
 
348
  LPWPUMODIFYIFSHANDLE = function(dwCatalogEntryId: DWORD; ProposedHandle: TSocket;
 
349
    var lpErrno: Integer): TSocket; stdcall;
 
350
  {$EXTERNALSYM LPWPUMODIFYIFSHANDLE}
 
351
  TWpuMoifyIfsHandle = LPWPUMODIFYIFSHANDLE;
 
352
 
 
353
  LPWPUPOSTMESSAGE = function(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): BOOL; stdcall;
 
354
  {$EXTERNALSYM LPWPUPOSTMESSAGE}
 
355
  TWpuPostMessage = LPWPUPOSTMESSAGE;
 
356
 
 
357
  LPWPUQUERYBLOCKINGCALLBACK = function(dwCatalogEntryId: DWORD; var lplpfnCallback: LPBLOCKINGCALLBACK;
 
358
    lpdwContext: LPDWORD; var lpErrno: Integer): Integer; stdcall;
 
359
  {$EXTERNALSYM LPWPUQUERYBLOCKINGCALLBACK}
 
360
  TWpuQueryBlockingCallback = LPWPUQUERYBLOCKINGCALLBACK;
 
361
 
 
362
  LPWPUQUERYSOCKETHANDLECONTEXT = function(s: TSocket; lpContext: LPDWORD;
 
363
    var lpErrno: Integer): Integer; stdcall;
 
364
  {$EXTERNALSYM LPWPUQUERYSOCKETHANDLECONTEXT}
 
365
  TWpuQuerySocketHandleContext = LPWPUQUERYSOCKETHANDLECONTEXT;
 
366
 
 
367
  LPWPUQUEUEAPC = function(lpThreadId: LPWSATHREADID; lpfnUserApc: LPWSAUSERAPC;
 
368
    dwContext: DWORD; var lpErrno: Integer): Integer; stdcall;
 
369
  {$EXTERNALSYM LPWPUQUEUEAPC}
 
370
  TWpuQueueApc = LPWPUQUEUEAPC;
 
371
 
 
372
  LPWPURESETEVENT = function(hEvent: WSAEVENT; var lpErrno: Integer): BOOL; stdcall;
 
373
  {$EXTERNALSYM LPWPURESETEVENT}
 
374
  TWpuResetEvent = LPWPURESETEVENT;
 
375
 
 
376
  LPWPUSETEVENT = function(hEvent: WSAEVENT; var lpErrno: Integer): BOOL; stdcall;
 
377
  {$EXTERNALSYM LPWPUSETEVENT}
 
378
  TWpuSetEvent = LPWPUSETEVENT;
 
379
 
 
380
  LPWPUOPENCURRENTTHREAD = function(lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
 
381
  {$EXTERNALSYM LPWPUOPENCURRENTTHREAD}
 
382
  TWpuOpenCurrentThread = LPWPUOPENCURRENTTHREAD;
 
383
 
 
384
  LPWPUCLOSETHREAD = function(lpThreadId: LPWSATHREADID; var lpErrno: Integer): Integer; stdcall;
 
385
  {$EXTERNALSYM LPWPUCLOSETHREAD}
 
386
  TWpuCloseThread = LPWPUCLOSETHREAD;
 
387
 
 
388
// Available only directly from ws2_32.dll
 
389
 
 
390
  LPWPUCOMPLETEOVERLAPPEDREQUEST = function(s: TSocket; lpOverlapped: LPWSAOVERLAPPED;
 
391
    dwError: DWORD; cbTransferred: DWORD; var lpErrno: Integer): Integer; stdcall;
 
392
  {$EXTERNALSYM LPWPUCOMPLETEOVERLAPPEDREQUEST}
 
393
  TWpuCompleteOverlappedRequest = LPWPUCOMPLETEOVERLAPPEDREQUEST;
 
394
 
 
395
(*
 
396
 * The upcall table. This structure is passed by value to the service
 
397
 * provider's WSPStartup() entrypoint.
 
398
 *)
 
399
 
 
400
  _WSPUPCALLTABLE = record
 
401
    lpWPUCloseEvent: LPWPUCLOSEEVENT;
 
402
    lpWPUCloseSocketHandle: LPWPUCLOSESOCKETHANDLE;
 
403
    lpWPUCreateEvent: LPWPUCREATEEVENT;
 
404
    lpWPUCreateSocketHandle: LPWPUCREATESOCKETHANDLE;
 
405
    lpWPUFDIsSet: LPWPUFDISSET;
 
406
    lpWPUGetProviderPath: LPWPUGETPROVIDERPATH;
 
407
    lpWPUModifyIFSHandle: LPWPUMODIFYIFSHANDLE;
 
408
    lpWPUPostMessage: LPWPUPOSTMESSAGE;
 
409
    lpWPUQueryBlockingCallback: LPWPUQUERYBLOCKINGCALLBACK;
 
410
    lpWPUQuerySocketHandleContext: LPWPUQUERYSOCKETHANDLECONTEXT;
 
411
    lpWPUQueueApc: LPWPUQUEUEAPC;
 
412
    lpWPUResetEvent: LPWPURESETEVENT;
 
413
    lpWPUSetEvent: LPWPUSETEVENT;
 
414
    lpWPUOpenCurrentThread: LPWPUOPENCURRENTTHREAD;
 
415
    lpWPUCloseThread: LPWPUCLOSETHREAD;
 
416
  end;
 
417
  {$EXTERNALSYM _WSPUPCALLTABLE}
 
418
  WSPUPCALLTABLE = _WSPUPCALLTABLE;
 
419
  {$EXTERNALSYM WSPUPCALLTABLE}
 
420
  LPWSPUPCALLTABLE = ^WSPUPCALLTABLE;
 
421
  {$EXTERNALSYM LPWSPUPCALLTABLE}
 
422
  TWspUpCallTable = WSPUPCALLTABLE;
 
423
  PWspUpCallTable = LPWSPUPCALLTABLE;  
 
424
 
 
425
(*
 
426
 *  WinSock 2 SPI socket function prototypes
 
427
 *)
 
428
 
 
429
//function WSPStartup(wVersionRequested: WORD; lpWSPData: LPWSPDATA;
 
430
//  lpProtocolInfo: LPWSAPROTOCOL_INFOW; UpcallTable: WSPUPCALLTABLE;
 
431
//  lpProcTable: LPWSPPROC_TABLE): Integer; stdcall;
 
432
//{$EXTERNALSYM WSPStartup}
 
433
 
 
434
type
 
435
  LPWSPSTARTUP = function(wVersionRequested: WORD; lpWSPData: LPWSPDATA;
 
436
    lpProtocolInfo: LPWSAPROTOCOL_INFOW; UpcallTable: WSPUPCALLTABLE;
 
437
    lpProcTable: LPWSPPROC_TABLE): Integer; stdcall;
 
438
  {$EXTERNALSYM LPWSPSTARTUP}
 
439
  TWspStartUp = LPWSPSTARTUP;
 
440
 
 
441
(*
 
442
 * Installation and configuration entrypoints.
 
443
 *)
 
444
 
 
445
function WSCEnumProtocols(lpiProtocols: PINT; lpProtocolBuffer: LPWSAPROTOCOL_INFOW;
 
446
  var lpdwBufferLength: DWORD; var lpErrno: Integer): Integer; stdcall;
 
447
{$EXTERNALSYM WSCEnumProtocols}
 
448
 
 
449
type
 
450
  LPWSCENUMPROTOCOLS = function(lpiProtocols: PINT; lpProtocolBuffer: LPWSAPROTOCOL_INFOW;
 
451
    var lpdwBufferLength: DWORD; var lpErrno: Integer): Integer; stdcall;
 
452
  {$EXTERNALSYM LPWSCENUMPROTOCOLS}
 
453
  TWscEnumProtocols = LPWSCENUMPROTOCOLS;
 
454
 
 
455
{$IFDEF _WIN64}
 
456
 
 
457
//
 
458
// 64-bit architectures capable of running 32-bit code have
 
459
// separate 64-bit and 32-bit catalogs.  API with '32' prefix
 
460
// allow 32 bit catalog manipulations by 64 bit process.
 
461
//
 
462
 
 
463
function WSCEnumProtocols32(lpiProtocols: PINT; lpProtocolBuffer: LPWSAPROTOCOL_INFOW; lpdwBufferLength: LPDWORD; lpErrno: PINT): Integer; stdcall;
 
464
{$EXTERNALSYM WSCEnumProtocols32}
 
465
 
 
466
{$ENDIF _WIN64}
 
467
 
 
468
function WSCDeinstallProvider(const lpProviderId: TGUID; var lpErrno: Integer): Integer; stdcall;
 
469
{$EXTERNALSYM WSCDeinstallProvider}
 
470
 
 
471
type
 
472
  LPWSCDEINSTALLPROVIDER = function(const lpProviderId: TGUID; var lpErrno: Integer): Integer; stdcall;
 
473
  {$EXTERNALSYM LPWSCDEINSTALLPROVIDER}
 
474
  TWscDeinstallProvider = LPWSCDEINSTALLPROVIDER;
 
475
 
 
476
{$IFDEF _WIN64}
 
477
 
 
478
function WSCDeinstallProvider32(lpProviderId: PGUID; lpErrno: PINT): Integer; stdcall;
 
479
{$EXTERNALSYM WSCDeinstallProvider32}
 
480
 
 
481
{$ENDIF _WIN64}
 
482
 
 
483
function WSCInstallProvider(const lpProviderId: TGUID; lpszProviderDllPath: PWCHAR;
 
484
  lpProtocolInfoList: LPWSAPROTOCOL_INFOW; dwNumberOfEntries: DWORD; var lpErrno: Integer): Integer; stdcall;
 
485
{$EXTERNALSYM WSCInstallProvider}
 
486
 
 
487
type
 
488
  LPWSCINSTALLPROVIDER = function(const lpProviderId: TGUID; lpszProviderDllPath: PWCHAR;
 
489
    lpProtocolInfoList: LPWSAPROTOCOL_INFOW; dwNumberOfEntries: DWORD; var lpErrno: Integer): Integer; stdcall;
 
490
  {$EXTERNALSYM LPWSCINSTALLPROVIDER}
 
491
  TWscInstallProvider = LPWSCINSTALLPROVIDER;
 
492
 
 
493
{$IFDEF _WIN64}
 
494
 
 
495
//
 
496
// This API manipulates 64-bit and 32-bit catalogs simulteneously.
 
497
// It is needed to guarantee the same catalog IDs for provider catalog
 
498
// entries in both 64-bit and 32-bit catalogs.
 
499
//
 
500
 
 
501
function WSCInstallProvider64_32(lpProviderId: PGUID; lpszProviderDllPath: PWCHAR; lpProtocolInfoList: LPWSAPROTOCOL_INFOW;
 
502
  dwNumberOfEntries: DWORD; lpErrno: PINT): Integer; stdcall;
 
503
{$EXTERNALSYM WSCInstallProvider64_32}
 
504
 
 
505
{$ENDIF _WIN64}
 
506
 
 
507
function WSCGetProviderPath(const lpProviderId: TGUID; lpszProviderDllPath: PWCHAR;
 
508
  var lpProviderDllPathLen, lpErrno: Integer): Integer; stdcall;
 
509
{$EXTERNALSYM WSCGetProviderPath}
 
510
 
 
511
type
 
512
  LPWSCGETPROVIDERPATH = function(const lpProviderId: TGUID; lpszProviderDllPath: PWCHAR;
 
513
  var lpProviderDllPathLen, lpErrno: Integer): Integer; stdcall;
 
514
  {$EXTERNALSYM LPWSCGETPROVIDERPATH}
 
515
  TWscGetProviderPath = LPWSCGETPROVIDERPATH;
 
516
 
 
517
{$IFDEF _WIN64}
 
518
 
 
519
function WSCGetProviderPath32(lpProviderId: PGUID; lpszProviderDllPath: PWCHAR; lpProviderDllPathLen: PINT; lpErrno: PINT): Integer; stdcall;
 
520
{$EXTERNALSYM WSCGetProviderPath32}
 
521
 
 
522
{$ENDIF _WIN64}
 
523
 
 
524
function WSCUpdateProvider(lpProviderId: PGUID; lpszProviderDllPath: PWCHAR; lpProtocolInfoList: LPWSAPROTOCOL_INFOW;
 
525
  dwNumberOfEntries: DWORD; lpErrno: PINT): Integer; stdcall;
 
526
{$EXTERNALSYM WSCUpdateProvider}
 
527
 
 
528
type
 
529
  LPWSCUPDATEPROVIDER = function(lpProviderId: PGUID; lpszProviderDllPath: PWCHAR; lpProtocolInfoList: LPWSAPROTOCOL_INFOW;
 
530
    dwNumberOfEntries: DWORD; lpErrno: PINT): Integer; stdcall;
 
531
  {$EXTERNALSYM LPWSCUPDATEPROVIDER}
 
532
 
 
533
{$IFDEF _WIN64}
 
534
 
 
535
function WSCUpdateProvider32(lpProviderId: PGUID; lpszProviderDllPath: PWCHAR; lpProtocolInfoList: LPWSAPROTOCOL_INFOW;
 
536
  dwNumberOfEntries: DWORD; lpErrno: PINT): Integer; stdcall;
 
537
{$EXTERNALSYM WSCUpdateProvider32}
 
538
 
 
539
{$ENDIF _WIN64}
 
540
 
 
541
function WSCInstallQOSTemplate(const Guid: TGUID; QosName: LPWSABUF; Qos: LPQOS): Integer; stdcall;
 
542
{$EXTERNALSYM WSCInstallQOSTemplate}
 
543
 
 
544
type
 
545
  LPWSCINSTALLQOSTEMPLATE = function(const Guid: TGUID; QosName: LPWSABUF; Qos: LPQOS): Integer; stdcall;
 
546
  {$EXTERNALSYM LPWSCINSTALLQOSTEMPLATE}
 
547
  TWscInstallQosTemplate = LPWSCINSTALLQOSTEMPLATE;
 
548
 
 
549
function WSCRemoveQOSTemplate(const Guid: TGUID; QosName: LPWSABUF): Integer; stdcall;
 
550
{$EXTERNALSYM WSCRemoveQOSTemplate}
 
551
 
 
552
type
 
553
  LPWSCREMOVEQOSTEMPLATE = function(const Guid: TGUID; QosName: LPWSABUF): Integer; stdcall;
 
554
  {$EXTERNALSYM LPWSCREMOVEQOSTEMPLATE}
 
555
  TWscRemoveQosTemplate = LPWSCREMOVEQOSTEMPLATE;
 
556
 
 
557
(*
 
558
 *  The following upcall function prototypes are only used by WinSock 2 DLL and
 
559
 *  should not be used by any service providers.
 
560
 *
 
561
 
 
562
function WPUCloseEvent(hEvent: WSAEVENT; var lpErrno: Integer): BOOL; stdcall;
 
563
{$EXTERNALSYM WPUCloseEvent}
 
564
 
 
565
function WPUCloseSocketHandle(s: TSocket; var lpErrno: Integer): Integer; stdcall;
 
566
{$EXTERNALSYM WPUCloseSocketHandle}
 
567
 
 
568
function WPUCreateEvent(var lpErrno: Integer): WSAEVENT; stdcall;
 
569
{$EXTERNALSYM WPUCreateEvent}
 
570
 
 
571
function WPUCreateSocketHandle(dwCatalogEntryId, dwContext: DWORD; var lpErrno: Integer): SOCKET; stdcall;
 
572
{$EXTERNALSYM WPUCreateSocketHandle}
 
573
 
 
574
function WPUFDIsSet(s: TSocket; const fdset: fd_set): Integer; stdcall;
 
575
{$EXTERNALSYM WPUFDIsSet}
 
576
 
 
577
function WPUGetProviderPath(const lpProviderId: TGUID; lpszProviderDllPath: PWCHAR;
 
578
  var lpProviderDllPathLen, lpErrno: : Integer): Integer; stdcall;
 
579
{$EXTERNALSYM WPUGetProviderPath}
 
580
 
 
581
function WPUModifyIFSHandle(dwCatalogEntryId: DWORD; ProposedHandle: SOCKET; var lpErrno: Integer): SOCKET; stdcall;
 
582
{$EXTERNALSYM WPUModifyIFSHandle}
 
583
 
 
584
function WPUPostMessage(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): BOOL; stdcall;
 
585
{$EXTERNALSYM WPUPostMessage}
 
586
 
 
587
function WPUQueryBlockingCallback(dwCatalogEntryId: DWORD; var lplpfnCallback: LPBLOCKINGCALLBACK;
 
588
  var lpdwContext: DWORD_PTR; var lpErrno: Integer): Integer; stdcall;
 
589
{$EXTERNALSYM WPUQueryBlockingCallback}
 
590
 
 
591
function WPUQuerySocketHandleContext(s: SOCKET; var lpContext: DWORD_PTR; lpErrno: Integer): Integer; stdcall;
 
592
{$EXTERNALSYM WPUQuerySocketHandleContext}
 
593
 
 
594
function WPUQueueApc(lpThreadId: LPWSATHREADID; lpfnUserApc: LPWSAUSERAPC;
 
595
  dwContext: DWORD_PTR; var lpErrno: Integer): Integer; stdcall;
 
596
{$EXTERNALSYM WPUQueueApc}
 
597
 
 
598
function WPUResetEvent(hEvent: WSAEVENT; var lpErrno: Integer): BOOL; stcall;
 
599
{$EXTERNALSYM WPUResetEvent}
 
600
 
 
601
function WPUSetEvent(hEvent: WSAEVENT; var lpErrno: Integer): BOOL; stdcall;
 
602
{$EXTERNALSYM WPUSetEvent}
 
603
 
 
604
function WPUCompleteOverlappedRequest(s: SOCKET; lpOverlapped: LPWSAOVERLAPPED;
 
605
  dwError, cbTransferred: DWORD; var lpErrno: Integer): Integerl stdcall;
 
606
{$EXTERNALSYM WPUCompleteOverlappedRequest}
 
607
 
 
608
function WPUOpenCurrentThread(lpThreadId: LPWSATHREADID; lpErrno: PINT): Integer; stdcall;
 
609
{$EXTERNALSYM WPUOpenCurrentThread}
 
610
 
 
611
function WPUCloseThread(lpThreadId: LPWSATHREADID; lpErrno: PINT): Integer; stdcall;
 
612
{$EXTERNALSYM WPUCloseThread}
 
613
 
 
614
*)
 
615
 
 
616
(*
 
617
 * Installing and uninstalling name space providers.
 
618
 *)
 
619
 
 
620
//
 
621
// SPI and API for enumerating name space providers are
 
622
// currently equivalent since there is no concept of a hidden
 
623
// name space provider
 
624
//
 
625
 
 
626
//TODO
 
627
//#define WSCEnumNameSpaceProviders WSAEnumNameSpaceProvidersW
 
628
//#define LPFN_WSCENUMNAMESPACEPROVIDERS LPFN_WSAENUMNAMESPACEPROVIDERSW
 
629
 
 
630
{$IFDEF _WIN64}
 
631
 
 
632
function WSCEnumNameSpaceProviders32(lpdwBufferLength: LPDWORD; lpnspBuffer: LPWSANAMESPACE_INFOW): Integer; stdcall;
 
633
{$EXTERNALSYM WSCEnumNameSpaceProviders32}
 
634
 
 
635
{$ENDIF _WIN64}
 
636
 
 
637
function WSCInstallNameSpace(lpszIdentifier, lpszPathName: LPWSTR; dwNameSpace,
 
638
  dwVersion: DWORD; const lpProviderId: TGUID): Integer; stdcall;
 
639
{$EXTERNALSYM WSCInstallNameSpace}
 
640
 
 
641
type
 
642
  LPWSCINSTALLNAMESPACE = function(lpszIdentifier, lpszPathName: LPWSTR;
 
643
    dwNameSpace, dwVersion: DWORD; const lpProviderId: TGUID): Integer; stdcall;
 
644
  {$EXTERNALSYM LPWSCINSTALLNAMESPACE}
 
645
  TWscInstallNamespace = LPWSCINSTALLNAMESPACE;
 
646
 
 
647
{$IFDEF _WIN64}
 
648
 
 
649
function WSCInstallNameSpace32(lpszIdentifier, lpszPathName: LPWSTR; dwNameSpace, dwVersion: DWORD; lpProviderId: PGUID): Integer; stdcall;
 
650
{$EXTERNALSYM WSCInstallNameSpace32}
 
651
 
 
652
{$ENDIF _WIN64}
 
653
 
 
654
function WSCUnInstallNameSpace(const lpProviderId: TGUID): Integer; stdcall;
 
655
{$EXTERNALSYM WSCUnInstallNameSpace}
 
656
 
 
657
type
 
658
  LPWSCUNINSTALLNAMESPACE = function(const lpProviderId: TGUID): Integer; stdcall;
 
659
  {$EXTERNALSYM LPWSCUNINSTALLNAMESPACE}
 
660
  TWscUninstallNamespace = LPWSCUNINSTALLNAMESPACE;
 
661
 
 
662
{$IFDEF _WIN64}
 
663
 
 
664
function WSCUnInstallNameSpace32(lpProviderId: PGUID): Integer; stdcall;
 
665
{$EXTERNALSYM WSCUnInstallNameSpace32}
 
666
 
 
667
{$ENDIF _WIN64}
 
668
 
 
669
function WSCEnableNSProvider(const lpProviderId: TGUID; fEnable: BOOL): Integer; stdcall;
 
670
{$EXTERNALSYM WSCEnableNSProvider}
 
671
 
 
672
type
 
673
  LPWSCENABLENSPROVIDER = function(const lpProviderId: TGUID; fEnable: BOOL): Integer; stdcall;
 
674
  {$EXTERNALSYM LPWSCENABLENSPROVIDER}
 
675
  TWscEnableNsProvider = LPWSCENABLENSPROVIDER;
 
676
 
 
677
{$IFDEF _WIN64}
 
678
 
 
679
function WSCEnableNSProvider32(lpProviderId: PGUID; fEnable: BOOL): Integer; stdcall;
 
680
{$EXTERNALSYM WSCEnableNSProvider32}
 
681
 
 
682
{$ENDIF _WIN64}
 
683
 
 
684
(*
 
685
 * Pointers to the individual entries in the namespace proc table.
 
686
 *)
 
687
 
 
688
type
 
689
  LPNSPCLEANUP = function(const lpProviderId: TGUID): Integer; stdcall;
 
690
  {$EXTERNALSYM LPNSPCLEANUP}
 
691
  TNspCleanup = LPNSPCLEANUP;
 
692
 
 
693
  LPNSPLOOKUPSERVICEBEGIN = function(const lpProviderId: TGUID;
 
694
    lpqsRestrictions: LPWSAQUERYSETW; lpServiceClassInfo: LPWSASERVICECLASSINFOW;
 
695
    dwControlFlags: DWORD; lphLookup: LPHANDLE): Integer; stdcall;
 
696
  {$EXTERNALSYM LPNSPLOOKUPSERVICEBEGIN}
 
697
  TNspLookupServiceBegin = LPNSPLOOKUPSERVICEBEGIN;
 
698
 
 
699
  LPNSPLOOKUPSERVICENEXT = function(hLookup: HANDLE; dwControlFlags: DWORD;
 
700
    lpdwBufferLength: LPDWORD; lpqsResults: LPWSAQUERYSETW): Integer; stdcall;
 
701
  {$EXTERNALSYM LPNSPLOOKUPSERVICENEXT}
 
702
  TNspLookupServiceNext = LPNSPLOOKUPSERVICENEXT;
 
703
 
 
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}
 
708
 
 
709
  LPNSPLOOKUPSERVICEEND = function(hLookup: HANDLE): Integer; stdcall;
 
710
  {$EXTERNALSYM LPNSPLOOKUPSERVICEEND}
 
711
  TNspLookupServiceEnd = LPNSPLOOKUPSERVICEEND;
 
712
 
 
713
  LPNSPSETSERVICE = function(const lpProviderId: TGUID;
 
714
    lpServiceClassInfo: LPWSASERVICECLASSINFOW; lpqsRegInfo: LPWSAQUERYSETW;
 
715
    essOperation: WSAESETSERVICEOP; dwControlFlags: DWORD): Integer; stdcall;
 
716
  {$EXTERNALSYM LPNSPSETSERVICE}
 
717
  TNspSetService = LPNSPSETSERVICE;
 
718
 
 
719
  LPNSPINSTALLSERVICECLASS = function(const lpProviderId: TGUID;
 
720
    lpServiceClassInfo: LPWSASERVICECLASSINFOW): Integer; stdcall;
 
721
  {$EXTERNALSYM LPNSPINSTALLSERVICECLASS}
 
722
  TNspInstallServiceClass = LPNSPINSTALLSERVICECLASS;
 
723
 
 
724
  LPNSPREMOVESERVICECLASS = function(const lpProviderId, lpServiceClassId: TGUID): Integer; stdcall;
 
725
  {$EXTERNALSYM LPNSPREMOVESERVICECLASS}
 
726
  TNspRemoveServiceClass = LPNSPREMOVESERVICECLASS;
 
727
 
 
728
  LPNSPGETSERVICECLASSINFO = function(const lpProviderId: TGUID; lpdwBufSize: LPDWORD;
 
729
    lpServiceClassInfo: LPWSASERVICECLASSINFOW): Integer; stdcall;
 
730
  {$EXTERNALSYM LPNSPGETSERVICECLASSINFO}
 
731
  TNspGetServiceClassInfo = LPNSPGETSERVICECLASSINFO;
 
732
 
 
733
(*
 
734
 * The name space service provider procedure table.
 
735
 *)
 
736
 
 
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;
 
765
 
 
766
(*
 
767
 * Startup procedures.
 
768
 *)
 
769
 
 
770
//function NSPStartup(const lpProviderId: TGUID; lpnspRoutines:  LPNSP_ROUTINE): Integer; stdcall;
 
771
//{$EXTERNALSYM NSPStartup}
 
772
 
 
773
type
 
774
  LPNSPSTARTUP = function(const lpProviderId: TGUID; lpnspRoutines:  LPNSP_ROUTINE): Integer; stdcall;
 
775
  {$EXTERNALSYM LPNSPSTARTUP}
 
776
  TNspStartup = LPNSPSTARTUP;
 
777
 
 
778
implementation
 
779
 
 
780
uses
 
781
  JwaWinDLLNames;
 
782
 
 
783
{$IFDEF DYNAMIC_LINK}
 
784
 
 
785
var
 
786
  _WSCEnumProtocols: Pointer;
 
787
 
 
788
function WSCEnumProtocols;
 
789
begin
 
790
  GetProcedureAddress(_WSCEnumProtocols, ws2_32, 'WSCEnumProtocols');
 
791
  asm
 
792
        MOV     ESP, EBP
 
793
        POP     EBP
 
794
        JMP     [_WSCEnumProtocols]
 
795
  end;
 
796
end;
 
797
 
 
798
{$IFDEF _WIN64}
 
799
 
 
800
var
 
801
  _WSCEnumProtocols32: Pointer;
 
802
 
 
803
function WSCEnumProtocols32;
 
804
begin
 
805
  GetProcedureAddress(_WSCEnumProtocols32, ws2_32, 'WSCEnumProtocols32');
 
806
  asm
 
807
        MOV     ESP, EBP
 
808
        POP     EBP
 
809
        JMP     [_WSCEnumProtocols32]
 
810
  end;
 
811
end;
 
812
 
 
813
{$ENDIF _WIN64}
 
814
 
 
815
var
 
816
  _WSCDeinstallProvider: Pointer;
 
817
 
 
818
function WSCDeinstallProvider;
 
819
begin
 
820
  GetProcedureAddress(_WSCDeinstallProvider, ws2_32, 'WSCDeinstallProvider');
 
821
  asm
 
822
        MOV     ESP, EBP
 
823
        POP     EBP
 
824
        JMP     [_WSCDeinstallProvider]
 
825
  end;
 
826
end;
 
827
 
 
828
{$IFDEF _WIN64}
 
829
 
 
830
var
 
831
  _WSCDeinstallProvider32: Pointer;
 
832
 
 
833
function WSCDeinstallProvider32;
 
834
begin
 
835
  GetProcedureAddress(_WSCDeinstallProvider32, ws2_32, 'WSCDeinstallProvider32');
 
836
  asm
 
837
        MOV     ESP, EBP
 
838
        POP     EBP
 
839
        JMP     [_WSCDeinstallProvider32]
 
840
  end;
 
841
end;
 
842
 
 
843
{$ENDIF _WIN64}
 
844
 
 
845
var
 
846
  _WSCInstallProvider: Pointer;
 
847
 
 
848
function WSCInstallProvider;
 
849
begin
 
850
  GetProcedureAddress(_WSCInstallProvider, ws2_32, 'WSCInstallProvider');
 
851
  asm
 
852
        MOV     ESP, EBP
 
853
        POP     EBP
 
854
        JMP     [_WSCInstallProvider]
 
855
  end;
 
856
end;
 
857
 
 
858
{$IFDEF _WIN64}
 
859
 
 
860
var
 
861
  _WSCInstallProvider64_32: Pointer;
 
862
 
 
863
function WSCInstallProvider64_32;
 
864
begin
 
865
  GetProcedureAddress(_WSCInstallProvider64_32, ws2_32, 'WSCInstallProvider64_32');
 
866
  asm
 
867
        MOV     ESP, EBP
 
868
        POP     EBP
 
869
        JMP     [_WSCInstallProvider64_32]
 
870
  end;
 
871
end;
 
872
 
 
873
{$ENDIF _WIN64}
 
874
 
 
875
var
 
876
  _WSCGetProviderPath: Pointer;
 
877
 
 
878
function WSCGetProviderPath;
 
879
begin
 
880
  GetProcedureAddress(_WSCGetProviderPath, ws2_32, 'WSCGetProviderPath');
 
881
  asm
 
882
        MOV     ESP, EBP
 
883
        POP     EBP
 
884
        JMP     [_WSCGetProviderPath]
 
885
  end;
 
886
end;
 
887
 
 
888
{$IFDEF _WIN64}
 
889
 
 
890
var
 
891
  _WSCGetProviderPath32: Pointer;
 
892
 
 
893
function WSCGetProviderPath32;
 
894
begin
 
895
  GetProcedureAddress(_WSCGetProviderPath32, ws2_32, 'WSCGetProviderPath32');
 
896
  asm
 
897
        MOV     ESP, EBP
 
898
        POP     EBP
 
899
        JMP     [_WSCGetProviderPath32]
 
900
  end;
 
901
end;
 
902
 
 
903
{$ENDIF _WIN64}
 
904
 
 
905
var
 
906
  _WSCUpdateProvider: Pointer;
 
907
 
 
908
function WSCUpdateProvider;
 
909
begin
 
910
  GetProcedureAddress(_WSCUpdateProvider, ws2_32, 'WSCUpdateProvider');
 
911
  asm
 
912
        MOV     ESP, EBP
 
913
        POP     EBP
 
914
        JMP     [_WSCUpdateProvider]
 
915
  end;
 
916
end;
 
917
 
 
918
{$IFDEF _WIN64}
 
919
 
 
920
var
 
921
  _WSCUpdateProvider32: Pointer;
 
922
 
 
923
function WSCUpdateProvider32;
 
924
begin
 
925
  GetProcedureAddress(_WSCUpdateProvider32, ws2_32, 'WSCUpdateProvider32');
 
926
  asm
 
927
        MOV     ESP, EBP
 
928
        POP     EBP
 
929
        JMP     [_WSCUpdateProvider32]
 
930
  end;
 
931
end;
 
932
 
 
933
{$ENDIF _WIN64}
 
934
 
 
935
var
 
936
  _WSCInstallQOSTemplate: Pointer;
 
937
 
 
938
function WSCInstallQOSTemplate;
 
939
begin
 
940
  GetProcedureAddress(_WSCInstallQOSTemplate, JwaWs2spi.qosname, 'WSCInstallQOSTemplate');
 
941
  asm
 
942
        MOV     ESP, EBP
 
943
        POP     EBP
 
944
        JMP     [_WSCInstallQOSTemplate]
 
945
  end;
 
946
end;
 
947
 
 
948
var
 
949
  _WSCRemoveQOSTemplate: Pointer;
 
950
 
 
951
function WSCRemoveQOSTemplate;
 
952
begin
 
953
  GetProcedureAddress(_WSCRemoveQOSTemplate, JwaWs2spi.qosname, 'WSCRemoveQOSTemplate');
 
954
  asm
 
955
        MOV     ESP, EBP
 
956
        POP     EBP
 
957
        JMP     [_WSCRemoveQOSTemplate]
 
958
  end;
 
959
end;
 
960
 
 
961
{$IFDEF _WIN64}
 
962
 
 
963
var
 
964
  _WSCEnumNameSpaceProviders32: Pointer;
 
965
 
 
966
function WSCEnumNameSpaceProviders32;
 
967
begin
 
968
  GetProcedureAddress(_WSCEnumNameSpaceProviders32, ws2_32, 'WSCEnumNameSpaceProviders32');
 
969
  asm
 
970
        MOV     ESP, EBP
 
971
        POP     EBP
 
972
        JMP     [_WSCEnumNameSpaceProviders32]
 
973
  end;
 
974
end;
 
975
 
 
976
{$ENDIF _WIN64}
 
977
 
 
978
var
 
979
  _WSCInstallNameSpace: Pointer;
 
980
 
 
981
function WSCInstallNameSpace;
 
982
begin
 
983
  GetProcedureAddress(_WSCInstallNameSpace, ws2_32, 'WSCInstallNameSpace');
 
984
  asm
 
985
        MOV     ESP, EBP
 
986
        POP     EBP
 
987
        JMP     [_WSCInstallNameSpace]
 
988
  end;
 
989
end;
 
990
 
 
991
{$IFDEF _WIN64}
 
992
 
 
993
var
 
994
  _WSCInstallNameSpace32: Pointer;
 
995
 
 
996
function WSCInstallNameSpace32;
 
997
begin
 
998
  GetProcedureAddress(_WSCInstallNameSpace32, ws2_32, 'WSCInstallNameSpace32');
 
999
  asm
 
1000
        MOV     ESP, EBP
 
1001
        POP     EBP
 
1002
        JMP     [_WSCInstallNameSpace32]
 
1003
  end;
 
1004
end;
 
1005
 
 
1006
{$ENDIF _WIN64}
 
1007
 
 
1008
var
 
1009
  _WSCUnInstallNameSpace: Pointer;
 
1010
 
 
1011
function WSCUnInstallNameSpace;
 
1012
begin
 
1013
  GetProcedureAddress(_WSCUnInstallNameSpace, ws2_32, 'WSCUnInstallNameSpace');
 
1014
  asm
 
1015
        MOV     ESP, EBP
 
1016
        POP     EBP
 
1017
        JMP     [_WSCUnInstallNameSpace]
 
1018
  end;
 
1019
end;
 
1020
 
 
1021
{$IFDEF _WIN64}
 
1022
 
 
1023
var
 
1024
  _WSCUnInstallNameSpace32: Pointer;
 
1025
 
 
1026
function WSCUnInstallNameSpace32;
 
1027
begin
 
1028
  GetProcedureAddress(_WSCUnInstallNameSpace32, ws2_32, 'WSCUnInstallNameSpace32');
 
1029
  asm
 
1030
        MOV     ESP, EBP
 
1031
        POP     EBP
 
1032
        JMP     [_WSCUnInstallNameSpace32]
 
1033
  end;
 
1034
end;
 
1035
 
 
1036
{$ENDIF _WIN64}
 
1037
 
 
1038
var
 
1039
  _WSCEnableNSProvider: Pointer;
 
1040
 
 
1041
function WSCEnableNSProvider;
 
1042
begin
 
1043
  GetProcedureAddress(_WSCEnableNSProvider, ws2_32, 'WSCEnableNSProvider');
 
1044
  asm
 
1045
        MOV     ESP, EBP
 
1046
        POP     EBP
 
1047
        JMP     [_WSCEnableNSProvider]
 
1048
  end;
 
1049
end;
 
1050
 
 
1051
{$IFDEF _WIN64}
 
1052
 
 
1053
var
 
1054
  _WSCEnableNSProvider32: Pointer;
 
1055
 
 
1056
function WSCEnableNSProvider32;
 
1057
begin
 
1058
  GetProcedureAddress(_WSCEnableNSProvider32, ws2_32, 'WSCEnableNSProvider32');
 
1059
  asm
 
1060
        MOV     ESP, EBP
 
1061
        POP     EBP
 
1062
        JMP     [_WSCEnableNSProvider32]
 
1063
  end;
 
1064
end;
 
1065
 
 
1066
{$ENDIF _WIN64}
 
1067
 
 
1068
{$ELSE}
 
1069
 
 
1070
function WSCEnumProtocols; external ws2_32 name 'WSCEnumProtocols';
 
1071
function WSCDeinstallProvider; external ws2_32 name 'WSCDeinstallProvider';
 
1072
function WSCInstallProvider; external ws2_32 name 'WSCInstallProvider';
 
1073
function WSCGetProviderPath; external ws2_32 name 'WSCGetProviderPath';
 
1074
function WSCUpdateProvider; external ws2_32 name 'WSCUpdateProvider';
 
1075
function WSCInstallQOSTemplate; external qosname name 'WSCInstallQOSTemplate';
 
1076
function WSCRemoveQOSTemplate; external qosname name 'WSCRemoveQOSTemplate';
 
1077
function WSCInstallNameSpace; external ws2_32 name 'WSCInstallNameSpace';
 
1078
function WSCUnInstallNameSpace; external ws2_32 name 'WSCUnInstallNameSpace';
 
1079
function WSCEnableNSProvider; external ws2_32 name 'WSCEnableNSProvider';
 
1080
{$IFDEF _WIN64}
 
1081
function WSCEnumProtocols32; external ws2_32 name 'WSCEnumProtocols32';
 
1082
function WSCDeinstallProvider32; external ws2_32 name 'WSCDeinstallProvider32';
 
1083
function WSCInstallProvider64_32; external ws2_32 name 'WSCInstallProvider64_32';
 
1084
function WSCGetProviderPath32; external ws2_32 name 'WSCGetProviderPath32';
 
1085
function WSCUpdateProvider32; external ws2_32 name 'WSCUpdateProvider32';
 
1086
function WSCEnumNameSpaceProviders32; external ws2_32 name 'WSCEnumNameSpaceProviders32';
 
1087
function WSCInstallNameSpace32; external ws2_32 name 'WSCInstallNameSpace32';
 
1088
function WSCUnInstallNameSpace32; external ws2_32 name 'WSCUnInstallNameSpace32';
 
1089
function WSCEnableNSProvider32; external ws2_32 name 'WSCEnableNSProvider32';
 
1090
{$ENDIF _WIN64}
 
1091
 
 
1092
{$ENDIF DYNAMIC_LINK}
 
1093
 
 
1094
end.