← Back to branch summary

~ubuntu-branches/ubuntu/dapper/fpc/dapper

« back to all changes in this revision

Viewing changes to packages/extra/winunits/jwanspapi.pas

  • Committer: Bazaar Package Importer
  • Author(s): Carlos Laviola
  • Date: 2005-05-30 11:59:10 UTC
  • mfrom: (1.2.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20050530115910-x5pbzm4qqta4i94h
Tags: 2.0.0-2
http://bugs.debian.org/310907
debian/fp-compiler.postinst.in: forgot to reapply the patch that
correctly creates the slave link to pc(1).  (Closes: #310907)

Show diffs side-by-side

added added

removed removed

Lines of Context:
packages/extra/winunits/jwanspapi.pas
 
1
{******************************************************************************}
 
2
{                                                                              }
 
3
{ Winsock2 Namespace 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: nspapi.h, released June 2000. The original Pascal      }
 
9
{ code is: NspApi.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: jwanspapi.pas,v 1.1 2005/04/04 07:56:10 marco Exp $
 
44
 
 
45
unit JwaNspAPI;
 
46
 
 
47
{$WEAKPACKAGEUNIT}
 
48
 
 
49
{$HPPEMIT ''}
 
50
{$HPPEMIT '#include "nspapi.h"'}
 
51
{$HPPEMIT ''}
 
52
 
 
53
{$I jediapilib.inc}
 
54
 
 
55
interface
 
56
 
 
57
uses
 
58
  JwaWinType, JwaWinSock2;
 
59
 
 
60
//
 
61
// Service categories
 
62
//
 
63
 
 
64
const
 
65
  SERVICE_RESOURCE = $00000001;
 
66
  {$EXTERNALSYM SERVICE_RESOURCE}
 
67
  SERVICE_SERVICE  = $00000002;
 
68
  {$EXTERNALSYM SERVICE_SERVICE}
 
69
  SERVICE_LOCAL    = $00000004;
 
70
  {$EXTERNALSYM SERVICE_LOCAL}
 
71
 
 
72
//
 
73
// Operation used when calling SetService()
 
74
//
 
75
 
 
76
  SERVICE_REGISTER    = $00000001;
 
77
  {$EXTERNALSYM SERVICE_REGISTER}
 
78
  SERVICE_DEREGISTER  = $00000002;
 
79
  {$EXTERNALSYM SERVICE_DEREGISTER}
 
80
  SERVICE_FLUSH       = $00000003;
 
81
  {$EXTERNALSYM SERVICE_FLUSH}
 
82
  SERVICE_ADD_TYPE    = $00000004;
 
83
  {$EXTERNALSYM SERVICE_ADD_TYPE}
 
84
  SERVICE_DELETE_TYPE = $00000005;
 
85
  {$EXTERNALSYM SERVICE_DELETE_TYPE}
 
86
 
 
87
//
 
88
// Flags that affect the operations above
 
89
//
 
90
 
 
91
  SERVICE_FLAG_DEFER = $00000001;
 
92
  {$EXTERNALSYM SERVICE_FLAG_DEFER}
 
93
  SERVICE_FLAG_HARD  = $00000002;
 
94
  {$EXTERNALSYM SERVICE_FLAG_HARD}
 
95
 
 
96
//
 
97
// Used as input to GetService() for setting the dwProps parameter
 
98
//
 
99
 
 
100
  PROP_COMMENT      = $00000001;
 
101
  {$EXTERNALSYM PROP_COMMENT}
 
102
  PROP_LOCALE       = $00000002;
 
103
  {$EXTERNALSYM PROP_LOCALE}
 
104
  PROP_DISPLAY_HINT = $00000004;
 
105
  {$EXTERNALSYM PROP_DISPLAY_HINT}
 
106
  PROP_VERSION      = $00000008;
 
107
  {$EXTERNALSYM PROP_VERSION}
 
108
  PROP_START_TIME   = $00000010;
 
109
  {$EXTERNALSYM PROP_START_TIME}
 
110
  PROP_MACHINE      = $00000020;
 
111
  {$EXTERNALSYM PROP_MACHINE}
 
112
  PROP_ADDRESSES    = $00000100;
 
113
  {$EXTERNALSYM PROP_ADDRESSES}
 
114
  PROP_SD           = $00000200;
 
115
  {$EXTERNALSYM PROP_SD}
 
116
  PROP_ALL          = DWORD($80000000);
 
117
  {$EXTERNALSYM PROP_ALL}
 
118
 
 
119
//
 
120
// Flags that describe attributes of Service Addresses
 
121
//
 
122
 
 
123
  SERVICE_ADDRESS_FLAG_RPC_CN = $00000001;
 
124
  {$EXTERNALSYM SERVICE_ADDRESS_FLAG_RPC_CN}
 
125
  SERVICE_ADDRESS_FLAG_RPC_DG = $00000002;
 
126
  {$EXTERNALSYM SERVICE_ADDRESS_FLAG_RPC_DG}
 
127
  SERVICE_ADDRESS_FLAG_RPC_NB = $00000004;
 
128
  {$EXTERNALSYM SERVICE_ADDRESS_FLAG_RPC_NB}
 
129
 
 
130
//
 
131
// Name Spaces
 
132
//
 
133
 
 
134
  NS_DEFAULT = 0;
 
135
  {$EXTERNALSYM NS_DEFAULT}
 
136
 
 
137
  NS_SAP         = 1;
 
138
  {$EXTERNALSYM NS_SAP}
 
139
  NS_NDS         = 2;
 
140
  {$EXTERNALSYM NS_NDS}
 
141
  NS_PEER_BROWSE = 3;
 
142
  {$EXTERNALSYM NS_PEER_BROWSE}
 
143
 
 
144
  NS_TCPIP_LOCAL = 10;
 
145
  {$EXTERNALSYM NS_TCPIP_LOCAL}
 
146
  NS_TCPIP_HOSTS = 11;
 
147
  {$EXTERNALSYM NS_TCPIP_HOSTS}
 
148
  NS_DNS         = 12;
 
149
  {$EXTERNALSYM NS_DNS}
 
150
  NS_NETBT       = 13;
 
151
  {$EXTERNALSYM NS_NETBT}
 
152
  NS_WINS        = 14;
 
153
  {$EXTERNALSYM NS_WINS}
 
154
 
 
155
  NS_NBP = 20;
 
156
  {$EXTERNALSYM NS_NBP}
 
157
 
 
158
  NS_MS   = 30;
 
159
  {$EXTERNALSYM NS_MS}
 
160
  NS_STDA = 31;
 
161
  {$EXTERNALSYM NS_STDA}
 
162
  NS_NTDS = 32;
 
163
  {$EXTERNALSYM NS_NTDS}
 
164
 
 
165
  NS_X500 = 40;
 
166
  {$EXTERNALSYM NS_X500}
 
167
  NS_NIS  = 41;
 
168
  {$EXTERNALSYM NS_NIS}
 
169
 
 
170
  NS_VNS = 50;
 
171
  {$EXTERNALSYM NS_VNS}
 
172
 
 
173
//
 
174
// Name space attributes.
 
175
//
 
176
 
 
177
  NSTYPE_HIERARCHICAL = $00000001;
 
178
  {$EXTERNALSYM NSTYPE_HIERARCHICAL}
 
179
  NSTYPE_DYNAMIC      = $00000002;
 
180
  {$EXTERNALSYM NSTYPE_DYNAMIC}
 
181
  NSTYPE_ENUMERABLE   = $00000004;
 
182
  {$EXTERNALSYM NSTYPE_ENUMERABLE}
 
183
  NSTYPE_WORKGROUP    = $00000008;
 
184
  {$EXTERNALSYM NSTYPE_WORKGROUP}
 
185
 
 
186
//
 
187
// Transport attributes.
 
188
//
 
189
 
 
190
  XP_CONNECTIONLESS       = $00000001;
 
191
  {$EXTERNALSYM XP_CONNECTIONLESS}
 
192
  XP_GUARANTEED_DELIVERY  = $00000002;
 
193
  {$EXTERNALSYM XP_GUARANTEED_DELIVERY}
 
194
  XP_GUARANTEED_ORDER     = $00000004;
 
195
  {$EXTERNALSYM XP_GUARANTEED_ORDER}
 
196
  XP_MESSAGE_ORIENTED     = $00000008;
 
197
  {$EXTERNALSYM XP_MESSAGE_ORIENTED}
 
198
  XP_PSEUDO_STREAM        = $00000010;
 
199
  {$EXTERNALSYM XP_PSEUDO_STREAM}
 
200
  XP_GRACEFUL_CLOSE       = $00000020;
 
201
  {$EXTERNALSYM XP_GRACEFUL_CLOSE}
 
202
  XP_EXPEDITED_DATA       = $00000040;
 
203
  {$EXTERNALSYM XP_EXPEDITED_DATA}
 
204
  XP_CONNECT_DATA         = $00000080;
 
205
  {$EXTERNALSYM XP_CONNECT_DATA}
 
206
  XP_DISCONNECT_DATA      = $00000100;
 
207
  {$EXTERNALSYM XP_DISCONNECT_DATA}
 
208
  XP_SUPPORTS_BROADCAST   = $00000200;
 
209
  {$EXTERNALSYM XP_SUPPORTS_BROADCAST}
 
210
  XP_SUPPORTS_MULTICAST   = $00000400;
 
211
  {$EXTERNALSYM XP_SUPPORTS_MULTICAST}
 
212
  XP_BANDWIDTH_ALLOCATION = $00000800;
 
213
  {$EXTERNALSYM XP_BANDWIDTH_ALLOCATION}
 
214
  XP_FRAGMENTATION        = $00001000;
 
215
  {$EXTERNALSYM XP_FRAGMENTATION}
 
216
  XP_ENCRYPTS             = $00002000;
 
217
  {$EXTERNALSYM XP_ENCRYPTS}
 
218
 
 
219
//
 
220
// Resolution flags for GetAddressByName().
 
221
//
 
222
 
 
223
  RES_SOFT_SEARCH   = $00000001;
 
224
  {$EXTERNALSYM RES_SOFT_SEARCH}
 
225
  RES_FIND_MULTIPLE = $00000002;
 
226
  {$EXTERNALSYM RES_FIND_MULTIPLE}
 
227
  RES_SERVICE       = $00000004;
 
228
  {$EXTERNALSYM RES_SERVICE}
 
229
 
 
230
//
 
231
// Well known value names for Service Types
 
232
//
 
233
 
 
234
  SERVICE_TYPE_VALUE_SAPIDA = 'SapId';
 
235
  {$EXTERNALSYM SERVICE_TYPE_VALUE_SAPIDA}
 
236
  SERVICE_TYPE_VALUE_SAPIDW = WideString('SapId');
 
237
  {$EXTERNALSYM SERVICE_TYPE_VALUE_SAPIDW}
 
238
 
 
239
  SERVICE_TYPE_VALUE_CONNA = 'ConnectionOriented';
 
240
  {$EXTERNALSYM SERVICE_TYPE_VALUE_CONNA}
 
241
  SERVICE_TYPE_VALUE_CONNW = WideString('ConnectionOriented');
 
242
  {$EXTERNALSYM SERVICE_TYPE_VALUE_CONNW}
 
243
 
 
244
  SERVICE_TYPE_VALUE_TCPPORTA = 'TcpPort';
 
245
  {$EXTERNALSYM SERVICE_TYPE_VALUE_TCPPORTA}
 
246
  SERVICE_TYPE_VALUE_TCPPORTW = WideString('TcpPort');
 
247
  {$EXTERNALSYM SERVICE_TYPE_VALUE_TCPPORTW}
 
248
 
 
249
  SERVICE_TYPE_VALUE_UDPPORTA = 'UdpPort';
 
250
  {$EXTERNALSYM SERVICE_TYPE_VALUE_UDPPORTA}
 
251
  SERVICE_TYPE_VALUE_UDPPORTW = WideString('UdpPort');
 
252
  {$EXTERNALSYM SERVICE_TYPE_VALUE_UDPPORTW}
 
253
 
 
254
  {$IFDEF UNICODE}
 
255
  SERVICE_TYPE_VALUE_SAPID   = SERVICE_TYPE_VALUE_SAPIDW;
 
256
  {$EXTERNALSYM SERVICE_TYPE_VALUE_SAPID}
 
257
  SERVICE_TYPE_VALUE_CONN    = SERVICE_TYPE_VALUE_CONNW;
 
258
  {$EXTERNALSYM SERVICE_TYPE_VALUE_CONN}
 
259
  SERVICE_TYPE_VALUE_TCPPORT = SERVICE_TYPE_VALUE_TCPPORTW;
 
260
  {$EXTERNALSYM SERVICE_TYPE_VALUE_TCPPORT}
 
261
  SERVICE_TYPE_VALUE_UDPPORT = SERVICE_TYPE_VALUE_UDPPORTW;
 
262
  {$EXTERNALSYM SERVICE_TYPE_VALUE_UDPPORT}
 
263
  {$ELSE}
 
264
  SERVICE_TYPE_VALUE_SAPID   = SERVICE_TYPE_VALUE_SAPIDA;
 
265
  {$EXTERNALSYM SERVICE_TYPE_VALUE_SAPID}
 
266
  SERVICE_TYPE_VALUE_CONN    = SERVICE_TYPE_VALUE_CONNA;
 
267
  {$EXTERNALSYM SERVICE_TYPE_VALUE_CONN}
 
268
  SERVICE_TYPE_VALUE_TCPPORT = SERVICE_TYPE_VALUE_TCPPORTA;
 
269
  {$EXTERNALSYM SERVICE_TYPE_VALUE_TCPPORT}
 
270
  SERVICE_TYPE_VALUE_UDPPORT = SERVICE_TYPE_VALUE_UDPPORTA;
 
271
  {$EXTERNALSYM SERVICE_TYPE_VALUE_UDPPORT}
 
272
  {$ENDIF UNICODE}
 
273
 
 
274
//
 
275
// status flags returned by SetService
 
276
//
 
277
 
 
278
  SET_SERVICE_PARTIAL_SUCCESS = $00000001;
 
279
  {$EXTERNALSYM SET_SERVICE_PARTIAL_SUCCESS}
 
280
 
 
281
//
 
282
// Name Space Information
 
283
//
 
284
 
 
285
type
 
286
  _NS_INFOA = record
 
287
    dwNameSpace: DWORD;
 
288
    dwNameSpaceFlags: DWORD;
 
289
    lpNameSpace: LPSTR;
 
290
  end;
 
291
  {$EXTERNALSYM _NS_INFOA}
 
292
  NS_INFOA = _NS_INFOA;
 
293
  {$EXTERNALSYM NS_INFOA}
 
294
  PNS_INFOA = ^NS_INFOA;
 
295
  {$EXTERNALSYM PNS_INFOA}
 
296
  LPNS_INFOA = ^NS_INFOA;
 
297
  {$EXTERNALSYM LPNS_INFOA}
 
298
  TNsInfoA = NS_INFOA;
 
299
  PNsInfoA = LPNS_INFOA;
 
300
 
 
301
//
 
302
// Name Space Information
 
303
//
 
304
 
 
305
  _NS_INFOW = record
 
306
    dwNameSpace: DWORD;
 
307
    dwNameSpaceFlags: DWORD;
 
308
    lpNameSpace: LPWSTR;
 
309
  end;
 
310
  {$EXTERNALSYM _NS_INFOW}
 
311
  NS_INFOW = _NS_INFOW;
 
312
  {$EXTERNALSYM NS_INFOW}
 
313
  PNS_INFOW = ^NS_INFOW;
 
314
  {$EXTERNALSYM PNS_INFOW}
 
315
  LPNS_INFOW = ^NS_INFOW;
 
316
  {$EXTERNALSYM LPNS_INFOW}
 
317
  TNsInfoW = NS_INFOW;
 
318
  PNsInfoW = LPNS_INFOW;
 
319
 
 
320
  {$IFDEF UNICODE}
 
321
  NS_INFO = NS_INFOW;
 
322
  {$EXTERNALSYM NS_INFO}
 
323
  PNS_INFO = PNS_INFOW;
 
324
  {$EXTERNALSYM PNS_INFO}
 
325
  LPNS_INFO = LPNS_INFOW;
 
326
  {$EXTERNALSYM LPNS_INFO}
 
327
  TNsInfo = TNsInfoW;
 
328
  PNsInfo = PNsInfoW;
 
329
  {$ELSE}
 
330
  NS_INFO = NS_INFOA;
 
331
  {$EXTERNALSYM NS_INFO}
 
332
  PNS_INFO = PNS_INFOA;
 
333
  {$EXTERNALSYM PNS_INFO}
 
334
  LPNS_INFO = LPNS_INFOA;
 
335
  {$EXTERNALSYM LPNS_INFO}
 
336
  TNsInfo = TNsInfoA;
 
337
  PNsInfo = PNsInfoA;
 
338
  {$ENDIF UNICODE}
 
339
 
 
340
//
 
341
// Service Type Values. The structures are used to define named Service
 
342
// Type specific values. This structure is self relative and has no pointers.
 
343
//
 
344
 
 
345
  LPSERVICE_TYPE_VALUE = ^SERVICE_TYPE_VALUE;
 
346
  {$EXTERNALSYM LPSERVICE_TYPE_VALUE}
 
347
  PSERVICE_TYPE_VALUE = ^SERVICE_TYPE_VALUE;
 
348
  {$EXTERNALSYM PSERVICE_TYPE_VALUE}
 
349
  _SERVICE_TYPE_VALUE = record
 
350
    dwNameSpace: DWORD;
 
351
    dwValueType: DWORD;
 
352
    dwValueSize: DWORD;
 
353
    dwValueNameOffset: DWORD;
 
354
    dwValueOffset: DWORD;
 
355
  end;
 
356
  {$EXTERNALSYM _SERVICE_TYPE_VALUE}
 
357
  SERVICE_TYPE_VALUE = _SERVICE_TYPE_VALUE;
 
358
  {$EXTERNALSYM SERVICE_TYPE_VALUE}
 
359
  TServiceTypeValue = SERVICE_TYPE_VALUE;
 
360
  PServiceTypeValue = LPSERVICE_TYPE_VALUE;
 
361
 
 
362
//
 
363
// An absolute version of above. This structure does contain pointers.
 
364
//
 
365
 
 
366
  LPSERVICE_TYPE_VALUE_ABSA = ^SERVICE_TYPE_VALUE_ABSA;
 
367
  {$EXTERNALSYM LPSERVICE_TYPE_VALUE_ABSA}
 
368
  PSERVICE_TYPE_VALUE_ABSA = ^SERVICE_TYPE_VALUE_ABSA;
 
369
  {$EXTERNALSYM PSERVICE_TYPE_VALUE_ABSA}
 
370
  _SERVICE_TYPE_VALUE_ABSA = record
 
371
    dwNameSpace: DWORD;
 
372
    dwValueType: DWORD;
 
373
    dwValueSize: DWORD;
 
374
    lpValueName: LPSTR;
 
375
    lpValue: LPVOID;
 
376
  end;
 
377
  {$EXTERNALSYM _SERVICE_TYPE_VALUE_ABSA}
 
378
  SERVICE_TYPE_VALUE_ABSA = _SERVICE_TYPE_VALUE_ABSA;
 
379
  {$EXTERNALSYM SERVICE_TYPE_VALUE_ABSA}
 
380
  TServiceTypeValueAbsA = SERVICE_TYPE_VALUE_ABSA;
 
381
  PServiceTypeValueAbsA = LPSERVICE_TYPE_VALUE_ABSA;
 
382
 
 
383
//
 
384
// An absolute version of above. This structure does contain pointers.
 
385
//
 
386
 
 
387
  LPSERVICE_TYPE_VALUE_ABSW = ^SERVICE_TYPE_VALUE_ABSW;
 
388
  {$EXTERNALSYM LPSERVICE_TYPE_VALUE_ABSW}
 
389
  PSERVICE_TYPE_VALUE_ABSW = ^SERVICE_TYPE_VALUE_ABSW;
 
390
  {$EXTERNALSYM PSERVICE_TYPE_VALUE_ABSW}
 
391
  _SERVICE_TYPE_VALUE_ABSW = record
 
392
    dwNameSpace: DWORD;
 
393
    dwValueType: DWORD;
 
394
    dwValueSize: DWORD;
 
395
    lpValueName: LPWSTR;
 
396
    lpValue: LPVOID;
 
397
  end;
 
398
  {$EXTERNALSYM _SERVICE_TYPE_VALUE_ABSW}
 
399
  SERVICE_TYPE_VALUE_ABSW = _SERVICE_TYPE_VALUE_ABSW;
 
400
  {$EXTERNALSYM SERVICE_TYPE_VALUE_ABSW}
 
401
  TServiceTypeValueAbsW = SERVICE_TYPE_VALUE_ABSW;
 
402
  PServiceTypeValueAbsW = LPSERVICE_TYPE_VALUE_ABSW;
 
403
 
 
404
  {$IFDEF UNICODE}
 
405
  SERVICE_TYPE_VALUE_ABS = SERVICE_TYPE_VALUE_ABSW;
 
406
  {$EXTERNALSYM SERVICE_TYPE_VALUE_ABS}
 
407
  PSERVICE_TYPE_VALUE_ABS = PSERVICE_TYPE_VALUE_ABSW;
 
408
  {$EXTERNALSYM PSERVICE_TYPE_VALUE_ABS}
 
409
  LPSERVICE_TYPE_VALUE_ABS = LPSERVICE_TYPE_VALUE_ABSW;
 
410
  {$EXTERNALSYM LPSERVICE_TYPE_VALUE_ABS}
 
411
  TServiceTypeValueAbs = TServiceTypeValueAbsW;
 
412
  PServiceTypeValueAbs = PServiceTypeValueAbsW;
 
413
  {$ELSE}
 
414
  SERVICE_TYPE_VALUE_ABS = SERVICE_TYPE_VALUE_ABSA;
 
415
  {$EXTERNALSYM SERVICE_TYPE_VALUE_ABS}
 
416
  PSERVICE_TYPE_VALUE_ABS = PSERVICE_TYPE_VALUE_ABSA;
 
417
  {$EXTERNALSYM PSERVICE_TYPE_VALUE_ABS}
 
418
  LPSERVICE_TYPE_VALUE_ABS = LPSERVICE_TYPE_VALUE_ABSA;
 
419
  {$EXTERNALSYM LPSERVICE_TYPE_VALUE_ABS}
 
420
  TServiceTypeValueAbs = TServiceTypeValueAbsA;
 
421
  PServiceTypeValueAbs = PServiceTypeValueAbsA;
 
422
  {$ENDIF UNICODE}
 
423
 
 
424
//
 
425
// Service Type Information. Contains the name of the Service Type and
 
426
// and an array of SERVICE_NS_TYPE_VALUE structures. This structure is self
 
427
// relative and has no pointers in it.
 
428
//
 
429
 
 
430
  LPSERVICE_TYPE_INFO = ^SERVICE_TYPE_INFO;
 
431
  {$EXTERNALSYM LPSERVICE_TYPE_INFO}
 
432
  PSERVICE_TYPE_INFO = ^SERVICE_TYPE_INFO;
 
433
  {$EXTERNALSYM PSERVICE_TYPE_INFO}
 
434
  _SERVICE_TYPE_INFO = record
 
435
    dwTypeNameOffset: DWORD;
 
436
    dwValueCount: DWORD;
 
437
    Values: array [0..0] of SERVICE_TYPE_VALUE;
 
438
  end;
 
439
  {$EXTERNALSYM _SERVICE_TYPE_INFO}
 
440
  SERVICE_TYPE_INFO = _SERVICE_TYPE_INFO;
 
441
  {$EXTERNALSYM SERVICE_TYPE_INFO}
 
442
  TServiceTypeInfo = SERVICE_TYPE_INFO;
 
443
  PServiceTypeInfo = LPSERVICE_TYPE_INFO;
 
444
 
 
445
  LPSERVICE_TYPE_INFO_ABSA = ^SERVICE_TYPE_INFO_ABSA;
 
446
  {$EXTERNALSYM LPSERVICE_TYPE_INFO_ABSA}
 
447
  PSERVICE_TYPE_INFO_ABSA = ^SERVICE_TYPE_INFO_ABSA;
 
448
  {$EXTERNALSYM PSERVICE_TYPE_INFO_ABSA}
 
449
  _SERVICE_TYPE_INFO_ABSA = record
 
450
    lpTypeName: LPSTR;
 
451
    dwValueCount: DWORD;
 
452
    Values: array [0..0] of SERVICE_TYPE_VALUE_ABSA;
 
453
  end;
 
454
  {$EXTERNALSYM _SERVICE_TYPE_INFO_ABSA}
 
455
  SERVICE_TYPE_INFO_ABSA = _SERVICE_TYPE_INFO_ABSA;
 
456
  {$EXTERNALSYM SERVICE_TYPE_INFO_ABSA}
 
457
  TServiceTypeInfoAbsA = SERVICE_TYPE_INFO_ABSA;
 
458
  PServiceTypeInfoAbsA = PSERVICE_TYPE_INFO_ABSA;
 
459
 
 
460
  LPSERVICE_TYPE_INFO_ABSW = ^SERVICE_TYPE_INFO_ABSW;
 
461
  {$EXTERNALSYM LPSERVICE_TYPE_INFO_ABSW}
 
462
  PSERVICE_TYPE_INFO_ABSW = ^SERVICE_TYPE_INFO_ABSW;
 
463
  {$EXTERNALSYM PSERVICE_TYPE_INFO_ABSW}
 
464
  _SERVICE_TYPE_INFO_ABSW = record
 
465
    lpTypeName: LPWSTR;
 
466
    dwValueCount: DWORD;
 
467
    Values: array [0..0] of SERVICE_TYPE_VALUE_ABSW;
 
468
  end;
 
469
  {$EXTERNALSYM _SERVICE_TYPE_INFO_ABSW}
 
470
  SERVICE_TYPE_INFO_ABSW = _SERVICE_TYPE_INFO_ABSW;
 
471
  {$EXTERNALSYM SERVICE_TYPE_INFO_ABSW}
 
472
  TServiceTypeInfoAbsW = SERVICE_TYPE_INFO_ABSW;
 
473
  PServiceTypeInfoAbsW = LPSERVICE_TYPE_INFO_ABSW;
 
474
 
 
475
  {$IFDEF UNICODE}
 
476
  SERVICE_TYPE_INFO_ABS = SERVICE_TYPE_INFO_ABSW;
 
477
  {$EXTERNALSYM SERVICE_TYPE_INFO_ABS}
 
478
  PSERVICE_TYPE_INFO_ABS = PSERVICE_TYPE_INFO_ABSW;
 
479
  {$EXTERNALSYM PSERVICE_TYPE_INFO_ABS}
 
480
  LPSERVICE_TYPE_INFO_ABS = LPSERVICE_TYPE_INFO_ABSW;
 
481
  {$EXTERNALSYM LPSERVICE_TYPE_INFO_ABS}
 
482
  TServiceTypeInfoAbs = TServiceTypeInfoAbsW;
 
483
  PServiceTypeInfoAbs = PServiceTypeInfoAbsW;
 
484
  {$ELSE}
 
485
  SERVICE_TYPE_INFO_ABS = SERVICE_TYPE_INFO_ABSA;
 
486
  {$EXTERNALSYM SERVICE_TYPE_INFO_ABS}
 
487
  PSERVICE_TYPE_INFO_ABS = PSERVICE_TYPE_INFO_ABSA;
 
488
  {$EXTERNALSYM PSERVICE_TYPE_INFO_ABS}
 
489
  LPSERVICE_TYPE_INFO_ABS = LPSERVICE_TYPE_INFO_ABSA;
 
490
  {$EXTERNALSYM LPSERVICE_TYPE_INFO_ABS}
 
491
  TServiceTypeInfoAbs = TServiceTypeInfoAbsA;
 
492
  PServiceTypeInfoAbs = PServiceTypeInfoAbsA;
 
493
  {$ENDIF UNICODE}
 
494
 
 
495
//
 
496
// A Single Address definition.
 
497
//
 
498
 
 
499
  LPSERVICE_ADDRESS = ^SERVICE_ADDRESS;
 
500
  {$EXTERNALSYM LPSERVICE_ADDRESS}
 
501
  PSERVICE_ADDRESS = ^SERVICE_ADDRESS;
 
502
  {$EXTERNALSYM PSERVICE_ADDRESS}
 
503
  _SERVICE_ADDRESS = record
 
504
    dwAddressType: DWORD;
 
505
    dwAddressFlags: DWORD;
 
506
    dwAddressLength: DWORD;
 
507
    dwPrincipalLength: DWORD;
 
508
    lpAddress: LPBYTE;
 
509
    lpPrincipal: LPBYTE;
 
510
  end;
 
511
  {$EXTERNALSYM _SERVICE_ADDRESS}
 
512
  SERVICE_ADDRESS = _SERVICE_ADDRESS;
 
513
  {$EXTERNALSYM SERVICE_ADDRESS}
 
514
  TServiceAddress = SERVICE_ADDRESS;
 
515
  PServiceAddress = LPSERVICE_ADDRESS;
 
516
 
 
517
//
 
518
// Addresses used by the service. Contains array of SERVICE_ADDRESS.
 
519
//
 
520
 
 
521
  LPSERVICE_ADDRESSES = ^SERVICE_ADDRESSES;
 
522
  {$EXTERNALSYM LPSERVICE_ADDRESSES}
 
523
  PSERVICE_ADDRESSES = ^SERVICE_ADDRESSES;
 
524
  {$EXTERNALSYM PSERVICE_ADDRESSES}
 
525
  _SERVICE_ADDRESSES = record
 
526
    dwAddressCount: DWORD;
 
527
    Addresses: array [0..0] of SERVICE_ADDRESS;
 
528
  end;
 
529
  {$EXTERNALSYM _SERVICE_ADDRESSES}
 
530
  SERVICE_ADDRESSES = _SERVICE_ADDRESSES;
 
531
  {$EXTERNALSYM SERVICE_ADDRESSES}
 
532
  TServiceAddresses = SERVICE_ADDRESSES;
 
533
  PServiceAddresses = PSERVICE_ADDRESSES;
 
534
 
 
535
//
 
536
// Service Information.
 
537
//
 
538
 
 
539
  LPSERVICE_INFOA = ^SERVICE_INFOA;
 
540
  {$EXTERNALSYM LPSERVICE_INFOA}
 
541
  PSERVICE_INFOA = ^SERVICE_INFOA;
 
542
  {$EXTERNALSYM PSERVICE_INFOA}
 
543
  _SERVICE_INFOA = record
 
544
    lpServiceType: PGUID;
 
545
    lpServiceName: LPSTR;
 
546
    lpComment: LPSTR;
 
547
    lpLocale: LPSTR;
 
548
    dwDisplayHint: DWORD;
 
549
    dwVersion: DWORD;
 
550
    dwTime: DWORD;
 
551
    lpMachineName: LPSTR;
 
552
    lpServiceAddress: LPSERVICE_ADDRESSES;
 
553
    ServiceSpecificInfo: BLOB;
 
554
  end;
 
555
  {$EXTERNALSYM _SERVICE_INFOA}
 
556
  SERVICE_INFOA = _SERVICE_INFOA;
 
557
  {$EXTERNALSYM SERVICE_INFOA}
 
558
  TServiceInfoA = SERVICE_INFOA;
 
559
  PServiceInfoA = PSERVICE_INFOA;
 
560
 
 
561
//
 
562
// Service Information.
 
563
//
 
564
 
 
565
  LPSERVICE_INFOW = ^SERVICE_INFOW;
 
566
  {$EXTERNALSYM LPSERVICE_INFOW}
 
567
  PSERVICE_INFOW = ^SERVICE_INFOW;
 
568
  {$EXTERNALSYM PSERVICE_INFOW}
 
569
  _SERVICE_INFOW = record
 
570
    lpServiceType: PGUID;
 
571
    lpServiceName: LPWSTR;
 
572
    lpComment: LPWSTR;
 
573
    lpLocale: LPWSTR;
 
574
    dwDisplayHint: DWORD;
 
575
    dwVersion: DWORD;
 
576
    dwTime: DWORD;
 
577
    lpMachineName: LPWSTR;
 
578
    lpServiceAddress: LPSERVICE_ADDRESSES;
 
579
    ServiceSpecificInfo: BLOB;
 
580
  end;
 
581
  {$EXTERNALSYM _SERVICE_INFOW}
 
582
  SERVICE_INFOW = _SERVICE_INFOW;
 
583
  {$EXTERNALSYM SERVICE_INFOW}
 
584
  TServiceInfoW = SERVICE_INFOW;
 
585
  PServiceInfoW = PSERVICE_INFOW;
 
586
 
 
587
  {$IFDEF UNICODE}
 
588
  SERVICE_INFO = SERVICE_INFOW;
 
589
  {$EXTERNALSYM SERVICE_INFO}
 
590
  PSERVICE_INFO = PSERVICE_INFOW;
 
591
  {$EXTERNALSYM PSERVICE_INFO}
 
592
  LPSERVICE_INFO = LPSERVICE_INFOW;
 
593
  {$EXTERNALSYM LPSERVICE_INFO}
 
594
  TServiceInfo = TServiceInfoW;
 
595
  PServiceInfo = PServiceInfoW;
 
596
  {$ELSE}
 
597
  SERVICE_INFO = SERVICE_INFOA;
 
598
  {$EXTERNALSYM SERVICE_INFO}
 
599
  PSERVICE_INFO = PSERVICE_INFOA;
 
600
  {$EXTERNALSYM PSERVICE_INFO}
 
601
  LPSERVICE_INFO = LPSERVICE_INFOA;
 
602
  {$EXTERNALSYM LPSERVICE_INFO}
 
603
  TServiceInfo = TServiceInfoA;
 
604
  PServiceInfo = PServiceInfoA;
 
605
  {$ENDIF UNICODE}
 
606
 
 
607
//
 
608
// Name Space & Service Information
 
609
//
 
610
 
 
611
  LPNS_SERVICE_INFOA = ^NS_SERVICE_INFOA;
 
612
  {$EXTERNALSYM LPNS_SERVICE_INFOA}
 
613
  PNS_SERVICE_INFOA = ^NS_SERVICE_INFOA;
 
614
  {$EXTERNALSYM PNS_SERVICE_INFOA}
 
615
  _NS_SERVICE_INFOA = record
 
616
    dwNameSpace: DWORD;
 
617
    ServiceInfo: SERVICE_INFOA;
 
618
  end;
 
619
  {$EXTERNALSYM _NS_SERVICE_INFOA}
 
620
  NS_SERVICE_INFOA = _NS_SERVICE_INFOA;
 
621
  {$EXTERNALSYM NS_SERVICE_INFOA}
 
622
  TNsServiceInfoA = NS_SERVICE_INFOA;
 
623
  PNsServiceInfoA = LPNS_SERVICE_INFOA;
 
624
 
 
625
//
 
626
// Name Space & Service Information
 
627
//
 
628
 
 
629
  LPNS_SERVICE_INFOW = ^NS_SERVICE_INFOW;
 
630
  {$EXTERNALSYM LPNS_SERVICE_INFOW}
 
631
  PNS_SERVICE_INFOW = ^NS_SERVICE_INFOW;
 
632
  {$EXTERNALSYM PNS_SERVICE_INFOW}
 
633
  _NS_SERVICE_INFOW = record
 
634
    dwNameSpace: DWORD;
 
635
    ServiceInfo: SERVICE_INFOW;
 
636
  end;
 
637
  {$EXTERNALSYM _NS_SERVICE_INFOW}
 
638
  NS_SERVICE_INFOW = _NS_SERVICE_INFOW;
 
639
  {$EXTERNALSYM NS_SERVICE_INFOW}
 
640
  TNsServiceInfoW = NS_SERVICE_INFOW;
 
641
  PNsServiceInfoW = LPNS_SERVICE_INFOW;
 
642
 
 
643
  {$IFDEF UNICODE}
 
644
  NS_SERVICE_INFO = NS_SERVICE_INFOW;
 
645
  {$EXTERNALSYM NS_SERVICE_INFO}
 
646
  PNS_SERVICE_INFO = PNS_SERVICE_INFOW;
 
647
  {$EXTERNALSYM PNS_SERVICE_INFO}
 
648
  LPNS_SERVICE_INFO = LPNS_SERVICE_INFOW;
 
649
  {$EXTERNALSYM LPNS_SERVICE_INFO}
 
650
  TNsServiceInfo = TNsServiceInfoW;
 
651
  PNsServiceInfo = PNsServiceInfoW;
 
652
  {$ELSE}
 
653
  NS_SERVICE_INFO = NS_SERVICE_INFOA;
 
654
  {$EXTERNALSYM NS_SERVICE_INFO}
 
655
  PNS_SERVICE_INFO = PNS_SERVICE_INFOA;
 
656
  {$EXTERNALSYM PNS_SERVICE_INFO}
 
657
  LPNS_SERVICE_INFO = LPNS_SERVICE_INFOA;
 
658
  {$EXTERNALSYM LPNS_SERVICE_INFO}
 
659
  TNsServiceInfo = TNsServiceInfoA;
 
660
  PNsServiceInfo = PNsServiceInfoA;
 
661
  {$ENDIF UNICODE}
 
662
 
 
663
//
 
664
// SockAddr Information
 
665
//
 
666
 
 
667
  LPSOCKET_ADDRESS = ^SOCKET_ADDRESS;
 
668
  {$EXTERNALSYM LPSOCKET_ADDRESS}
 
669
  PSOCKET_ADDRESS = ^SOCKET_ADDRESS;
 
670
  {$EXTERNALSYM PSOCKET_ADDRESS}
 
671
  _SOCKET_ADDRESS = record
 
672
    lpSockaddr: LPSOCKADDR;
 
673
    iSockaddrLength: Integer;
 
674
  end;
 
675
  {$EXTERNALSYM _SOCKET_ADDRESS}
 
676
  SOCKET_ADDRESS = _SOCKET_ADDRESS;
 
677
  {$EXTERNALSYM SOCKET_ADDRESS}
 
678
  TSocketAddress = SOCKET_ADDRESS;
 
679
  PSocketAddress = PSOCKET_ADDRESS;
 
680
 
 
681
//
 
682
// CSAddr Information
 
683
//
 
684
 
 
685
  LPCSADDR_INFO = ^CSADDR_INFO;
 
686
  {$EXTERNALSYM LPCSADDR_INFO}
 
687
  PCSADDR_INFO = ^CSADDR_INFO;
 
688
  {$EXTERNALSYM PCSADDR_INFO}
 
689
  _CSADDR_INFO = record
 
690
    LocalAddr: SOCKET_ADDRESS;
 
691
    RemoteAddr: SOCKET_ADDRESS;
 
692
    iSocketType: Integer;
 
693
    iProtocol: Integer;
 
694
  end;
 
695
  {$EXTERNALSYM _CSADDR_INFO}
 
696
  CSADDR_INFO = _CSADDR_INFO;
 
697
  {$EXTERNALSYM CSADDR_INFO}
 
698
  TCsAddrInfo = CSADDR_INFO;
 
699
  PCsAddrInfo = LPCSADDR_INFO;
 
700
 
 
701
//
 
702
// Protocol Information
 
703
//
 
704
 
 
705
  LPPROTOCOL_INFOA = ^PROTOCOL_INFOA;
 
706
  {$EXTERNALSYM LPPROTOCOL_INFOA}
 
707
  PPROTOCOL_INFOA = ^PROTOCOL_INFOA;
 
708
  {$EXTERNALSYM PPROTOCOL_INFOA}
 
709
  _PROTOCOL_INFOA = record
 
710
    dwServiceFlags: DWORD;
 
711
    iAddressFamily: Integer;
 
712
    iMaxSockAddr: Integer;
 
713
    iMinSockAddr: Integer;
 
714
    iSocketType: Integer;
 
715
    iProtocol: Integer;
 
716
    dwMessageSize: DWORD;
 
717
    lpProtocol: LPSTR;
 
718
  end;
 
719
  {$EXTERNALSYM _PROTOCOL_INFOA}
 
720
  PROTOCOL_INFOA = _PROTOCOL_INFOA;
 
721
  {$EXTERNALSYM PROTOCOL_INFOA}
 
722
  TProtocolInfoA = PROTOCOL_INFOA;
 
723
  PProtocolInfoA = LPPROTOCOL_INFOA;
 
724
 
 
725
//
 
726
// Protocol Information
 
727
//
 
728
 
 
729
  LPPROTOCOL_INFOW = ^PROTOCOL_INFOW;
 
730
  {$EXTERNALSYM LPPROTOCOL_INFOW}
 
731
  PPROTOCOL_INFOW = ^PROTOCOL_INFOW;
 
732
  {$EXTERNALSYM PPROTOCOL_INFOW}
 
733
  _PROTOCOL_INFOW = record
 
734
    dwServiceFlags: DWORD;
 
735
    iAddressFamily: Integer;
 
736
    iMaxSockAddr: Integer;
 
737
    iMinSockAddr: Integer;
 
738
    iSocketType: Integer;
 
739
    iProtocol: Integer;
 
740
    dwMessageSize: DWORD;
 
741
    lpProtocol: LPWSTR;
 
742
  end;
 
743
  {$EXTERNALSYM _PROTOCOL_INFOW}
 
744
  PROTOCOL_INFOW = _PROTOCOL_INFOW;
 
745
  {$EXTERNALSYM PROTOCOL_INFOW}
 
746
  TProtocolInfoW = PROTOCOL_INFOW;
 
747
  PProtocolInfoW = LPPROTOCOL_INFOW;
 
748
 
 
749
  {$IFDEF UNICODE}
 
750
  PROTOCOL_INFO = PROTOCOL_INFOW;
 
751
  {$EXTERNALSYM PROTOCOL_INFO}
 
752
  PPROTOCOL_INFO = PPROTOCOL_INFOW;
 
753
  {$EXTERNALSYM PPROTOCOL_INFO}
 
754
  LPPROTOCOL_INFO = LPPROTOCOL_INFOW;
 
755
  {$EXTERNALSYM LPPROTOCOL_INFO}
 
756
  TProtocolInfo = TProtocolInfoW;
 
757
  PProtocolInfo = PProtocolInfoW;
 
758
  {$ELSE}
 
759
  PROTOCOL_INFO = PROTOCOL_INFOA;
 
760
  {$EXTERNALSYM PROTOCOL_INFO}
 
761
  PPROTOCOL_INFO = PPROTOCOL_INFOA;
 
762
  {$EXTERNALSYM PPROTOCOL_INFO}
 
763
  LPPROTOCOL_INFO = LPPROTOCOL_INFOA;
 
764
  {$EXTERNALSYM LPPROTOCOL_INFO}
 
765
  TProtocolInfo = TProtocolInfoA;
 
766
  PProtocolInfo = PProtocolInfoA;
 
767
  {$ENDIF UNICODE}
 
768
 
 
769
//
 
770
// NETRESOURCE2 Structure
 
771
//
 
772
 
 
773
  LPNETRESOURCE2A = ^NETRESOURCE2A;
 
774
  {$EXTERNALSYM LPNETRESOURCE2A}
 
775
  PNETRESOURCE2A = ^NETRESOURCE2A;
 
776
  {$EXTERNALSYM PNETRESOURCE2A}
 
777
  _NETRESOURCE2A = record
 
778
    dwScope: DWORD;
 
779
    dwType: DWORD;
 
780
    dwUsage: DWORD;
 
781
    dwDisplayType: DWORD;
 
782
    lpLocalName: LPSTR;
 
783
    lpRemoteName: LPSTR;
 
784
    lpComment: LPSTR;
 
785
    ns_info: NS_INFO;
 
786
    ServiceType: TGUID;
 
787
    dwProtocols: DWORD;
 
788
    lpiProtocols: PINT;
 
789
  end;
 
790
  {$EXTERNALSYM _NETRESOURCE2A}
 
791
  NETRESOURCE2A = _NETRESOURCE2A;
 
792
  {$EXTERNALSYM NETRESOURCE2A}
 
793
  TNetResource2A = NETRESOURCE2A;
 
794
 
 
795
//
 
796
// NETRESOURCE2 Structure
 
797
//
 
798
 
 
799
  LPNETRESOURCE2W = ^NETRESOURCE2W;
 
800
  {$EXTERNALSYM LPNETRESOURCE2W}
 
801
  PNETRESOURCE2W = ^NETRESOURCE2W;
 
802
  {$EXTERNALSYM PNETRESOURCE2W}
 
803
  _NETRESOURCE2W = record
 
804
    dwScope: DWORD;
 
805
    dwType: DWORD;
 
806
    dwUsage: DWORD;
 
807
    dwDisplayType: DWORD;
 
808
    lpLocalName: LPWSTR;
 
809
    lpRemoteName: LPWSTR;
 
810
    lpComment: LPWSTR;
 
811
    ns_info: NS_INFO;
 
812
    ServiceType: TGUID;
 
813
    dwProtocols: DWORD;
 
814
    lpiProtocols: PINT;
 
815
  end;
 
816
  {$EXTERNALSYM _NETRESOURCE2W}
 
817
  NETRESOURCE2W = _NETRESOURCE2W;
 
818
  {$EXTERNALSYM NETRESOURCE2W}
 
819
  TNetResource2W = NETRESOURCE2W;
 
820
 
 
821
  {$IFDEF UNICODE}
 
822
  NETRESOURCE2 = NETRESOURCE2W;
 
823
  {$EXTERNALSYM NETRESOURCE2}
 
824
  PNETRESOURCE2 = PNETRESOURCE2W;
 
825
  {$EXTERNALSYM PNETRESOURCE2}
 
826
  LPNETRESOURCE2 = LPNETRESOURCE2W;
 
827
  {$EXTERNALSYM LPNETRESOURCE2}
 
828
  TNetResource2 = TNetResource2W;
 
829
  {$ELSE}
 
830
  NETRESOURCE2 = NETRESOURCE2A;
 
831
  {$EXTERNALSYM NETRESOURCE2}
 
832
  PNETRESOURCE2 = PNETRESOURCE2A;
 
833
  {$EXTERNALSYM PNETRESOURCE2}
 
834
  LPNETRESOURCE2 = LPNETRESOURCE2A;
 
835
  {$EXTERNALSYM LPNETRESOURCE2}
 
836
  TNetResource2 = TNetResource2A;
 
837
  {$ENDIF UNICODE}
 
838
 
 
839
  LPFN_NSPAPI = function: DWORD; stdcall;
 
840
  {$EXTERNALSYM LPFN_NSPAPI}
 
841
  TFnNspApi = LPFN_NSPAPI;
 
842
 
 
843
//
 
844
// Structures for using the service routines asynchronously.
 
845
//
 
846
 
 
847
type
 
848
  LPSERVICE_CALLBACK_PROC = procedure(lParam: LPARAM; hAsyncTaskHandle: HANDLE); stdcall;
 
849
  {$EXTERNALSYM LPSERVICE_CALLBACK_PROC}
 
850
  TServiceCallbackProc = LPSERVICE_CALLBACK_PROC;
 
851
 
 
852
type
 
853
  LPSERVICE_ASYNC_INFO = ^SERVICE_ASYNC_INFO;
 
854
  {$EXTERNALSYM LPSERVICE_ASYNC_INFO}
 
855
  PSERVICE_ASYNC_INFO = ^SERVICE_ASYNC_INFO;
 
856
  {$EXTERNALSYM PSERVICE_ASYNC_INFO}
 
857
  _SERVICE_ASYNC_INFO = record
 
858
    lpServiceCallbackProc: LPSERVICE_CALLBACK_PROC;
 
859
    lParam: LPARAM;
 
860
    hAsyncTaskHandle: HANDLE;
 
861
  end;
 
862
  {$EXTERNALSYM _SERVICE_ASYNC_INFO}
 
863
  SERVICE_ASYNC_INFO = _SERVICE_ASYNC_INFO;
 
864
  {$EXTERNALSYM SERVICE_ASYNC_INFO}
 
865
  TServiceAsyncInfo = SERVICE_ASYNC_INFO;
 
866
  PServiceAsyncInfo = LPSERVICE_ASYNC_INFO;
 
867
 
 
868
//
 
869
// Public NSP API prototypes.
 
870
//
 
871
 
 
872
function EnumProtocolsA(lpiProtocols: PINT; lpProtocolBuffer: LPVOID; lpdwBufferLength: LPDWORD): Integer; stdcall;
 
873
{$EXTERNALSYM EnumProtocolsA}
 
874
function EnumProtocolsW(lpiProtocols: PINT; lpProtocolBuffer: LPVOID; lpdwBufferLength: LPDWORD): Integer; stdcall;
 
875
{$EXTERNALSYM EnumProtocolsW}
 
876
function EnumProtocols(lpiProtocols: PINT; lpProtocolBuffer: LPVOID; lpdwBufferLength: LPDWORD): Integer; stdcall;
 
877
{$EXTERNALSYM EnumProtocols}
 
878
 
 
879
function GetAddressByNameA(dwNameSpace: DWORD; const lpServiceType: TGUID;
 
880
  lpServiceName: LPSTR; lpiProtocols: PINT; dwResolution: DWORD;
 
881
  lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO; lpCsaddrBuffer: LPVOID;
 
882
  var lpdwBufferLength: DWORD; lpAliasBuffer: LPSTR; lpdwAliasBufferLength: LPDWORD): Integer; stdcall;
 
883
{$EXTERNALSYM GetAddressByNameA}
 
884
function GetAddressByNameW(dwNameSpace: DWORD; const lpServiceType: TGUID;
 
885
  lpServiceName: LPWSTR; lpiProtocols: PINT; dwResolution: DWORD;
 
886
  lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO; lpCsaddrBuffer: LPVOID;
 
887
  var lpdwBufferLength: DWORD; lpAliasBuffer: LPWSTR; lpdwAliasBufferLength: LPDWORD): Integer; stdcall;
 
888
{$EXTERNALSYM GetAddressByNameW}
 
889
function GetAddressByName(dwNameSpace: DWORD; const lpServiceType: TGUID;
 
890
  lpServiceName: LPTSTR; lpiProtocols: PINT; dwResolution: DWORD;
 
891
  lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO; lpCsaddrBuffer: LPVOID;
 
892
  var lpdwBufferLength: DWORD; lpAliasBuffer: LPTSTR; lpdwAliasBufferLength: LPDWORD): Integer; stdcall;
 
893
{$EXTERNALSYM GetAddressByName}
 
894
 
 
895
function GetTypeByNameA(lpServiceName: LPSTR; var lpServiceType: TGUID): Integer; stdcall;
 
896
{$EXTERNALSYM GetTypeByNameA}
 
897
function GetTypeByNameW(lpServiceName: LPWSTR; var lpServiceType: TGUID): Integer; stdcall;
 
898
{$EXTERNALSYM GetTypeByNameW}
 
899
function GetTypeByName(lpServiceName: LPTSTR; var lpServiceType: TGUID): Integer; stdcall;
 
900
{$EXTERNALSYM GetTypeByName}
 
901
 
 
902
function GetNameByTypeA(const lpServiceType: TGUID; lpServiceName: LPSTR; dwNameLength: DWORD): Integer; stdcall;
 
903
{$EXTERNALSYM GetNameByTypeA}
 
904
function GetNameByTypeW(const lpServiceType: TGUID; lpServiceName: LPWSTR; dwNameLength: DWORD): Integer; stdcall;
 
905
{$EXTERNALSYM GetNameByTypeW}
 
906
function GetNameByType(const lpServiceType: TGUID; lpServiceName: LPTSTR; dwNameLength: DWORD): Integer; stdcall;
 
907
{$EXTERNALSYM GetNameByType}
 
908
 
 
909
function SetServiceA(dwNameSpace, dwOperation, dwFlags: DWORD;
 
910
  const lpServiceInfo: SERVICE_INFOA; lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO;
 
911
  var lpdwStatusFlags: DWORD): Integer; stdcall;
 
912
{$EXTERNALSYM SetServiceA}
 
913
function SetServiceW(dwNameSpace, dwOperation, dwFlags: DWORD;
 
914
  const lpServiceInfo: SERVICE_INFOW; lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO;
 
915
  var lpdwStatusFlags: DWORD): Integer; stdcall;
 
916
{$EXTERNALSYM SetServiceW}
 
917
function SetService(dwNameSpace, dwOperation, dwFlags: DWORD;
 
918
  const lpServiceInfo: SERVICE_INFO; lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO;
 
919
  var lpdwStatusFlags: DWORD): Integer; stdcall;
 
920
{$EXTERNALSYM SetService}
 
921
 
 
922
function GetServiceA(dwNameSpace: DWORD; const lpGuid: TGUID; lpServiceName: LPSTR;
 
923
  dwProperties: DWORD; lpBuffer: LPVOID; var lpdwBufferSize: DWORD;
 
924
  lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO): Integer; stdcall;
 
925
{$EXTERNALSYM GetServiceA}
 
926
function GetServiceW(dwNameSpace: DWORD; const lpGuid: TGUID; lpServiceName: LPWSTR;
 
927
  dwProperties: DWORD; lpBuffer: LPVOID; var lpdwBufferSize: DWORD;
 
928
  lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO): Integer; stdcall;
 
929
{$EXTERNALSYM GetServiceW}
 
930
function GetService(dwNameSpace: DWORD; const lpGuid: TGUID; lpServiceName: LPTSTR;
 
931
  dwProperties: DWORD; lpBuffer: LPVOID; var lpdwBufferSize: DWORD;
 
932
  lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO): Integer; stdcall;
 
933
{$EXTERNALSYM GetService}
 
934
 
 
935
implementation
 
936
 
 
937
const
 
938
  nsplib = 'wsock32.dll';
 
939
  {$IFDEF UNICODE}
 
940
  AWSuffix = 'W';
 
941
  {$ELSE}
 
942
  AWSuffix = 'A';
 
943
  {$ENDIF UNICODE}
 
944
 
 
945
{$IFDEF DYNAMIC_LINK}
 
946
 
 
947
var
 
948
  _EnumProtocolsA: Pointer;
 
949
 
 
950
function EnumProtocolsA;
 
951
begin
 
952
  GetProcedureAddress(_EnumProtocolsA, nsplib, 'EnumProtocolsA');
 
953
  asm
 
954
        MOV     ESP, EBP
 
955
        POP     EBP
 
956
        JMP     [_EnumProtocolsA]
 
957
  end;
 
958
end;
 
959
 
 
960
var
 
961
  _EnumProtocolsW: Pointer;
 
962
 
 
963
function EnumProtocolsW;
 
964
begin
 
965
  GetProcedureAddress(_EnumProtocolsW, nsplib, 'EnumProtocolsW');
 
966
  asm
 
967
        MOV     ESP, EBP
 
968
        POP     EBP
 
969
        JMP     [_EnumProtocolsW]
 
970
  end;
 
971
end;
 
972
 
 
973
var
 
974
  _EnumProtocols: Pointer;
 
975
 
 
976
function EnumProtocols;
 
977
begin
 
978
  GetProcedureAddress(_EnumProtocols, nsplib, 'EnumProtocols' + AWSuffix);
 
979
  asm
 
980
        MOV     ESP, EBP
 
981
        POP     EBP
 
982
        JMP     [_EnumProtocols]
 
983
  end;
 
984
end;
 
985
 
 
986
var
 
987
  _GetAddressByNameA: Pointer;
 
988
 
 
989
function GetAddressByNameA;
 
990
begin
 
991
  GetProcedureAddress(_GetAddressByNameA, nsplib, 'GetAddressByNameA');
 
992
  asm
 
993
        MOV     ESP, EBP
 
994
        POP     EBP
 
995
        JMP     [_GetAddressByNameA]
 
996
  end;
 
997
end;
 
998
 
 
999
var
 
1000
  _GetAddressByNameW: Pointer;
 
1001
 
 
1002
function GetAddressByNameW;
 
1003
begin
 
1004
  GetProcedureAddress(_GetAddressByNameW, nsplib, 'GetAddressByNameW');
 
1005
  asm
 
1006
        MOV     ESP, EBP
 
1007
        POP     EBP
 
1008
        JMP     [_GetAddressByNameW]
 
1009
  end;
 
1010
end;
 
1011
 
 
1012
var
 
1013
  _GetAddressByName: Pointer;
 
1014
 
 
1015
function GetAddressByName;
 
1016
begin
 
1017
  GetProcedureAddress(_GetAddressByName, nsplib, 'GetAddressByName' + AWSuffix);
 
1018
  asm
 
1019
        MOV     ESP, EBP
 
1020
        POP     EBP
 
1021
        JMP     [_GetAddressByName]
 
1022
  end;
 
1023
end;
 
1024
 
 
1025
var
 
1026
  _GetTypeByNameA: Pointer;
 
1027
 
 
1028
function GetTypeByNameA;
 
1029
begin
 
1030
  GetProcedureAddress(_GetTypeByNameA, nsplib, 'GetTypeByNameA');
 
1031
  asm
 
1032
        MOV     ESP, EBP
 
1033
        POP     EBP
 
1034
        JMP     [_GetTypeByNameA]
 
1035
  end;
 
1036
end;
 
1037
 
 
1038
var
 
1039
  _GetTypeByNameW: Pointer;
 
1040
 
 
1041
function GetTypeByNameW;
 
1042
begin
 
1043
  GetProcedureAddress(_GetTypeByNameW, nsplib, 'GetTypeByNameW');
 
1044
  asm
 
1045
        MOV     ESP, EBP
 
1046
        POP     EBP
 
1047
        JMP     [_GetTypeByNameW]
 
1048
  end;
 
1049
end;
 
1050
 
 
1051
var
 
1052
  _GetTypeByName: Pointer;
 
1053
 
 
1054
function GetTypeByName;
 
1055
begin
 
1056
  GetProcedureAddress(_GetTypeByName, nsplib, 'GetTypeByName' + AWSuffix);
 
1057
  asm
 
1058
        MOV     ESP, EBP
 
1059
        POP     EBP
 
1060
        JMP     [_GetTypeByName]
 
1061
  end;
 
1062
end;
 
1063
 
 
1064
var
 
1065
  _GetNameByTypeA: Pointer;
 
1066
 
 
1067
function GetNameByTypeA;
 
1068
begin
 
1069
  GetProcedureAddress(_GetNameByTypeA, nsplib, 'GetNameByTypeA');
 
1070
  asm
 
1071
        MOV     ESP, EBP
 
1072
        POP     EBP
 
1073
        JMP     [_GetNameByTypeA]
 
1074
  end;
 
1075
end;
 
1076
 
 
1077
var
 
1078
  _GetNameByTypeW: Pointer;
 
1079
 
 
1080
function GetNameByTypeW;
 
1081
begin
 
1082
  GetProcedureAddress(_GetNameByTypeW, nsplib, 'GetNameByTypeW');
 
1083
  asm
 
1084
        MOV     ESP, EBP
 
1085
        POP     EBP
 
1086
        JMP     [_GetNameByTypeW]
 
1087
  end;
 
1088
end;
 
1089
 
 
1090
var
 
1091
  _GetNameByType: Pointer;
 
1092
 
 
1093
function GetNameByType;
 
1094
begin
 
1095
  GetProcedureAddress(_GetNameByType, nsplib, 'GetNameByType' + AWSuffix);
 
1096
  asm
 
1097
        MOV     ESP, EBP
 
1098
        POP     EBP
 
1099
        JMP     [_GetNameByType]
 
1100
  end;
 
1101
end;
 
1102
 
 
1103
var
 
1104
  _SetServiceA: Pointer;
 
1105
 
 
1106
function SetServiceA;
 
1107
begin
 
1108
  GetProcedureAddress(_SetServiceA, nsplib, 'SetServiceA');
 
1109
  asm
 
1110
        MOV     ESP, EBP
 
1111
        POP     EBP
 
1112
        JMP     [_SetServiceA]
 
1113
  end;
 
1114
end;
 
1115
 
 
1116
var
 
1117
  _SetServiceW: Pointer;
 
1118
 
 
1119
function SetServiceW;
 
1120
begin
 
1121
  GetProcedureAddress(_SetServiceW, nsplib, 'SetServiceW');
 
1122
  asm
 
1123
        MOV     ESP, EBP
 
1124
        POP     EBP
 
1125
        JMP     [_SetServiceW]
 
1126
  end;
 
1127
end;
 
1128
 
 
1129
var
 
1130
  _SetService: Pointer;
 
1131
 
 
1132
function SetService;
 
1133
begin
 
1134
  GetProcedureAddress(_SetService, nsplib, 'SetService' + AWSuffix);
 
1135
  asm
 
1136
        MOV     ESP, EBP
 
1137
        POP     EBP
 
1138
        JMP     [_SetService]
 
1139
  end;
 
1140
end;
 
1141
 
 
1142
var
 
1143
  _GetServiceA: Pointer;
 
1144
 
 
1145
function GetServiceA;
 
1146
begin
 
1147
  GetProcedureAddress(_GetServiceA, nsplib, 'GetServiceA');
 
1148
  asm
 
1149
        MOV     ESP, EBP
 
1150
        POP     EBP
 
1151
        JMP     [_GetServiceA]
 
1152
  end;
 
1153
end;
 
1154
 
 
1155
var
 
1156
  _GetServiceW: Pointer;
 
1157
 
 
1158
function GetServiceW;
 
1159
begin
 
1160
  GetProcedureAddress(_GetServiceW, nsplib, 'GetServiceW');
 
1161
  asm
 
1162
        MOV     ESP, EBP
 
1163
        POP     EBP
 
1164
        JMP     [_GetServiceW]
 
1165
  end;
 
1166
end;
 
1167
 
 
1168
var
 
1169
  _GetService: Pointer;
 
1170
 
 
1171
function GetService;
 
1172
begin
 
1173
  GetProcedureAddress(_GetService, nsplib, 'GetService' + AWSuffix);
 
1174
  asm
 
1175
        MOV     ESP, EBP
 
1176
        POP     EBP
 
1177
        JMP     [_GetService]
 
1178
  end;
 
1179
end;
 
1180
 
 
1181
{$ELSE}
 
1182
 
 
1183
function EnumProtocolsA; external nsplib name 'EnumProtocolsA';
 
1184
function EnumProtocolsW; external nsplib name 'EnumProtocolsW';
 
1185
function EnumProtocols; external nsplib name 'EnumProtocols' + AWSuffix;
 
1186
function GetAddressByNameA; external nsplib name 'GetAddressByNameA';
 
1187
function GetAddressByNameW; external nsplib name 'GetAddressByNameW';
 
1188
function GetAddressByName; external nsplib name 'GetAddressByName' + AWSuffix;
 
1189
function GetTypeByNameA; external nsplib name 'GetTypeByNameA';
 
1190
function GetTypeByNameW; external nsplib name 'GetTypeByNameW';
 
1191
function GetTypeByName; external nsplib name 'GetTypeByName' + AWSuffix;
 
1192
function GetNameByTypeA; external nsplib name 'GetNameByTypeA';
 
1193
function GetNameByTypeW; external nsplib name 'GetNameByTypeW';
 
1194
function GetNameByType; external nsplib name 'GetNameByType' + AWSuffix;
 
1195
function SetServiceA; external nsplib name 'SetServiceA';
 
1196
function SetServiceW; external nsplib name 'SetServiceW';
 
1197
function SetService; external nsplib name 'SetService' + AWSuffix;
 
1198
function GetServiceA; external nsplib name 'GetServiceA';
 
1199
function GetServiceW; external nsplib name 'GetServiceW';
 
1200
function GetService; external nsplib name 'GetService' + AWSuffix;
 
1201
 
 
1202
{$ENDIF DYNAMIC_LINK}
 
1203
 
 
1204
end.