1 {******************************************************************************}
2 { }
3 { Traffic Control 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: traffic.h, released June 2000. The original Pascal }
9 { code is: Traffic.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: JwaTraffic.pas,v 1.11 2007/09/05 11:58:52 dezipaitor Exp $
44 {$IFNDEF JWA_OMIT_SECTIONS}
45 unit JwaTraffic;
46
47 {$WEAKPACKAGEUNIT}
48 {$ENDIF JWA_OMIT_SECTIONS}
49
50 {$HPPEMIT ''}
51 {$HPPEMIT '#include "traffic.h"'}
52 {$HPPEMIT ''}
53
54 {$IFNDEF JWA_OMIT_SECTIONS}
55 {$I jediapilib.inc}
56
57 interface
58
59 uses
60 JwaWinType, JwaQos;
61
62 {$ENDIF JWA_OMIT_SECTIONS}
63
64 {$IFNDEF JWA_IMPLEMENTATIONSECTION}
65
66 //---------------------------------------------------------------------------
67 //
68 // Define's
69 //
70
71 const
72 CURRENT_TCI_VERSION = $0002;
73 {$EXTERNALSYM CURRENT_TCI_VERSION}
74
75 //
76 // Definitions of notification events. These may be passed
77 // to the client's notification handler, to identify the
78 // notification type
79 //
80
81 //
82 // A TC interface has come up
83 //
84
85 TC_NOTIFY_IFC_UP = 1;
86 {$EXTERNALSYM TC_NOTIFY_IFC_UP}
87
88 //
89 // A TC interface has come down
90 //
91
92 TC_NOTIFY_IFC_CLOSE = 2;
93 {$EXTERNALSYM TC_NOTIFY_IFC_CLOSE}
94
95 //
96 // A change on a TC interface, typically a change in the
97 // list of supported network addresses
98 //
99
100 TC_NOTIFY_IFC_CHANGE = 3;
101 {$EXTERNALSYM TC_NOTIFY_IFC_CHANGE}
102
103 //
104 // A TC parameter has changed
105 //
106
107 TC_NOTIFY_PARAM_CHANGED = 4;
108 {$EXTERNALSYM TC_NOTIFY_PARAM_CHANGED}
109
110 //
111 // A flow has been closed by the TC interface
112 // for example: after a remote call close, or the whole interface
113 // is going down
114 //
115
116 TC_NOTIFY_FLOW_CLOSE = 5;
117 {$EXTERNALSYM TC_NOTIFY_FLOW_CLOSE}
118
119 TC_INVALID_HANDLE = HANDLE(0);
120 {$EXTERNALSYM TC_INVALID_HANDLE}
121
122 MAX_STRING_LENGTH = 256;
123 {$EXTERNALSYM MAX_STRING_LENGTH}
124
125 //---------------------------------------------------------------------------
126 //
127 // Typedef's and structures
128 //
129
130 //
131 // Handlers registered by the TCI client
132 //
133
134 type
135 TCI_NOTIFY_HANDLER = procedure(ClRegCtx, ClIfcCtx: HANDLE; Event: ULONG;
136 SubCode: HANDLE; BufSize: ULONG; Buffer: PVOID); stdcall;
137 {$EXTERNALSYM TCI_NOTIFY_HANDLER}
138 TTciNotifyHandler = TCI_NOTIFY_HANDLER;
139
140 TCI_ADD_FLOW_COMPLETE_HANDLER = procedure(ClFlowCtx: HANDLE; Status: ULONG); stdcall;
141 {$EXTERNALSYM TCI_ADD_FLOW_COMPLETE_HANDLER}
142 TTciAddFlowCompleteHandler = TCI_ADD_FLOW_COMPLETE_HANDLER;
143
144 TCI_MOD_FLOW_COMPLETE_HANDLER = procedure(ClFlowCtx: HANDLE; Status: ULONG); stdcall;
145 {$EXTERNALSYM TCI_MOD_FLOW_COMPLETE_HANDLER}
146 TTciModFlowCompleteHandler = TCI_MOD_FLOW_COMPLETE_HANDLER;
147
148 TCI_DEL_FLOW_COMPLETE_HANDLER = procedure(ClFlowCtx: HANDLE; Status: ULONG); stdcall;
149 {$EXTERNALSYM TCI_DEL_FLOW_COMPLETE_HANDLER}
150 TTciDelFlowComlpeteHandler = TCI_DEL_FLOW_COMPLETE_HANDLER;
151
152 type
153 PTCI_CLIENT_FUNC_LIST = ^TCI_CLIENT_FUNC_LIST;
154 {$EXTERNALSYM PTCI_CLIENT_FUNC_LIST}
155 _TCI_CLIENT_FUNC_LIST = record
156 ClNotifyHandler: TCI_NOTIFY_HANDLER;
157 ClAddFlowCompleteHandler: TCI_ADD_FLOW_COMPLETE_HANDLER;
158 ClModifyFlowCompleteHandler: TCI_MOD_FLOW_COMPLETE_HANDLER;
159 ClDeleteFlowCompleteHandler: TCI_DEL_FLOW_COMPLETE_HANDLER;
160 end;
161 {$EXTERNALSYM _TCI_CLIENT_FUNC_LIST}
162 TCI_CLIENT_FUNC_LIST = _TCI_CLIENT_FUNC_LIST;
163 {$EXTERNALSYM TCI_CLIENT_FUNC_LIST}
164 TTciClientFuncList = TCI_CLIENT_FUNC_LIST;
165 PTciClientFuncList = PTCI_CLIENT_FUNC_LIST;
166
167 // TODO NETWORD_ADDRESS and NETWORK_ADDRESS_LIST are from NtDDNdis.h
168
169 _NETWORK_ADDRESS = record
170 AddressLength: USHORT; // length in bytes of Address[] in this
171 AddressType: USHORT; // type of this address (NDIS_PROTOCOL_ID_XXX above)
172 Address: array [0..0] of UCHAR; // actually AddressLength bytes long
173 end;
174 NETWORK_ADDRESS = _NETWORK_ADDRESS;
175 PNETWORK_ADDRESS = ^NETWORK_ADDRESS;
176
177 _NETWORK_ADDRESS_LIST = record
178 AddressCount: LONG; // number of addresses following
179 AddressType: USHORT; // type of this address (NDIS_PROTOCOL_ID_XXX above)
180 Address: array [0..0] of NETWORK_ADDRESS; // actually AddressCount elements long
181 end;
182 NETWORK_ADDRESS_LIST = _NETWORK_ADDRESS_LIST;
183 PNETWORK_ADDRESS_LIST = ^NETWORK_ADDRESS_LIST;
184
185 //
186 // Network address descriptor
187 //
188
189 PADDRESS_LIST_DESCRIPTOR = ^ADDRESS_LIST_DESCRIPTOR;
190 {$EXTERNALSYM PADDRESS_LIST_DESCRIPTOR}
191 _ADDRESS_LIST_DESCRIPTOR = record
192 MediaType: ULONG;
193 AddressList: NETWORK_ADDRESS_LIST;
194 end;
195 {$EXTERNALSYM _ADDRESS_LIST_DESCRIPTOR}
196 ADDRESS_LIST_DESCRIPTOR = _ADDRESS_LIST_DESCRIPTOR;
197 {$EXTERNALSYM ADDRESS_LIST_DESCRIPTOR}
198 TAddressListDescriptor = ADDRESS_LIST_DESCRIPTOR;
199 PAddressListDescriptor = PADDRESS_LIST_DESCRIPTOR;
200
201 //
202 // An interface ID that is returned by the enumerator
203 //
204
205 PTC_IFC_DESCRIPTOR = ^TC_IFC_DESCRIPTOR;
206 {$EXTERNALSYM PTC_IFC_DESCRIPTOR}
207 _TC_IFC_DESCRIPTOR = record
208 Length: ULONG;
209 pInterfaceName: LPWSTR;
210 pInterfaceID: LPWSTR;
211 AddressListDesc: ADDRESS_LIST_DESCRIPTOR;
212 end;
213 {$EXTERNALSYM _TC_IFC_DESCRIPTOR}
214 TC_IFC_DESCRIPTOR = _TC_IFC_DESCRIPTOR;
215 {$EXTERNALSYM TC_IFC_DESCRIPTOR}
216 TTcIfcDescriptor = TC_IFC_DESCRIPTOR;
217 PTcIfcDescriptor = PTC_IFC_DESCRIPTOR;
218
219 //
220 // This structure is returned by a QoS data provider in reply to
221 // GUID_QOS_SUPPORTED query or with an interface UP notification
222 //
223
224 PTC_SUPPORTED_INFO_BUFFER = ^TC_SUPPORTED_INFO_BUFFER;
225 {$EXTERNALSYM PTC_SUPPORTED_INFO_BUFFER}
226 _TC_SUPPORTED_INFO_BUFFER = record
227 InstanceIDLength: USHORT;
228 // device or interface ID
229 InstanceID: array [0..MAX_STRING_LENGTH - 1] of WCHAR;
230 // address list
231 AddrListDesc: ADDRESS_LIST_DESCRIPTOR;
232 end;
233 {$EXTERNALSYM _TC_SUPPORTED_INFO_BUFFER}
234 TC_SUPPORTED_INFO_BUFFER = _TC_SUPPORTED_INFO_BUFFER;
235 {$EXTERNALSYM TC_SUPPORTED_INFO_BUFFER}
236 TTcSupportedInfoBuffer = TC_SUPPORTED_INFO_BUFFER;
237 PTcSupportedInfoBuffer = PTC_SUPPORTED_INFO_BUFFER;
238
239 //
240 // Filters are used to match packets. The Pattern field
241 // indicates the values to which bits in corresponding
242 // positions in candidate packets should be compared. The
243 // Mask field indicates which bits are to be compared and
244 // which bits are don't cares.
245 //
246 // Different filters can be submitted on the TCI interface.
247 // The generic filter structure is defined to include an
248 // AddressType, which indicates the specific type of filter to
249 // follow.
250 //
251
252 PTC_GEN_FILTER = ^TC_GEN_FILTER;
253 {$EXTERNALSYM PTC_GEN_FILTER}
254 _TC_GEN_FILTER = record
255 AddressType: USHORT; // IP, IPX, etc.
256 PatternSize: ULONG; // byte count of the pattern
257 Pattern: PVOID; // specific format, e.g. IP_PATTERN
258 Mask: PVOID; // same type as Pattern
259 end;
260 {$EXTERNALSYM _TC_GEN_FILTER}
261 TC_GEN_FILTER = _TC_GEN_FILTER;
262 {$EXTERNALSYM TC_GEN_FILTER}
263 TTcGenFilter = TC_GEN_FILTER;
264 PTcGenFilter = PTC_GEN_FILTER;
265
266 //
267 // A generic flow includes two flowspecs and a freeform
268 // buffer which contains flow specific TC objects.
269 //
270
271 PTC_GEN_FLOW = ^TC_GEN_FLOW;
272 {$EXTERNALSYM PTC_GEN_FLOW}
273 _TC_GEN_FLOW = record
274 SendingFlowspec: FLOWSPEC;
275 ReceivingFlowspec: FLOWSPEC;
276 TcObjectsLength: ULONG; // number of optional bytes
277 TcObjects: array [0..0] of QOS_OBJECT_HDR;
278 end;
279 {$EXTERNALSYM _TC_GEN_FLOW}
280 TC_GEN_FLOW = _TC_GEN_FLOW;
281 {$EXTERNALSYM TC_GEN_FLOW}
282 TTcGenFlow = TC_GEN_FLOW;
283 PTcGenFlow = PTC_GEN_FLOW;
284
285 //
286 // Format of specific pattern or mask used by GPC for the IP protocol
287 //
288
289 PIP_PATTERN = ^IP_PATTERN;
290 {$EXTERNALSYM PIP_PATTERN}
291 _IP_PATTERN = record
292 Reserved1: ULONG;
293 Reserved2: ULONG;
294 SrcAddr: ULONG;
295 DstAddr: ULONG;
296 S_un: record
297 case Integer of
298 0: (
299 s_srcport: USHORT;
300 s_dstport: USHORT);
301 1: (
302 s_type: UCHAR;
303 s_code: UCHAR;
304 filler: USHORT);
305 2: (
306 S_Spi: ULONG);
307 end;
308 ProtocolId: UCHAR;
309 Reserved3: array [0..3 - 1] of UCHAR;
310 end;
311 {$EXTERNALSYM _IP_PATTERN}
312 IP_PATTERN = _IP_PATTERN;
313 {$EXTERNALSYM IP_PATTERN}
314 TIpPattern = IP_PATTERN;
315 PIpPattern = PIP_PATTERN;
316
317 //
318 // Format of specific pattern or mask used by GPC for the IPX protocol
319 //
320
321 TIpxPatternAddress = record
322 NetworkAddress: ULONG;
323 NodeAddress: array [0..5] of UCHAR;
324 Socket: USHORT;
325 end;
326
327 PIPX_PATTERN = ^IPX_PATTERN;
328 {$EXTERNALSYM PIPX_PATTERN}
329 _IPX_PATTERN = record
330 Src: TIpxPatternAddress;
331 Dest: TIpxPatternAddress;
332 end;
333 {$EXTERNALSYM _IPX_PATTERN}
334 IPX_PATTERN = _IPX_PATTERN;
335 {$EXTERNALSYM IPX_PATTERN}
336 TIpxPattern = IPX_PATTERN;
337 PIpxPattern = PIPX_PATTERN;
338
339 //
340 // The enumeration buffer is the flow parameters + a list of filters
341 //
342
343 PENUMERATION_BUFFER = ^ENUMERATION_BUFFER;
344 {$EXTERNALSYM PENUMERATION_BUFFER}
345 _ENUMERATION_BUFFER = record
346 Length: ULONG;
347 OwnerProcessId: ULONG;
348 FlowNameLength: USHORT;
349 FlowName: array [0..MAX_STRING_LENGTH - 1] of WCHAR;
350 pFlow: PTC_GEN_FLOW;
351 NumberOfFilters: ULONG;
352 GenericFilter: array [0..0] of TC_GEN_FILTER; // one for each filter
353 end;
354 {$EXTERNALSYM _ENUMERATION_BUFFER}
355 ENUMERATION_BUFFER = _ENUMERATION_BUFFER;
356 {$EXTERNALSYM ENUMERATION_BUFFER}
357 TEnumerationBuffer = ENUMERATION_BUFFER;
358 PEnumerationBuffer = PENUMERATION_BUFFER;
359
360 //
361 // QoS objects supported by traffic
362 //
363
364 const
365 QOS_TRAFFIC_GENERAL_ID_BASE = 4000;
366 {$EXTERNALSYM QOS_TRAFFIC_GENERAL_ID_BASE}
367
368 QOS_OBJECT_DS_CLASS = $00000001 + QOS_TRAFFIC_GENERAL_ID_BASE;
369 {$EXTERNALSYM QOS_OBJECT_DS_CLASS}
370 QOS_OBJECT_TRAFFIC_CLASS = $00000002 + QOS_TRAFFIC_GENERAL_ID_BASE;
371 {$EXTERNALSYM QOS_OBJECT_TRAFFIC_CLASS}
372 QOS_OBJECT_DIFFSERV = $00000003 + QOS_TRAFFIC_GENERAL_ID_BASE;
373 {$EXTERNALSYM QOS_OBJECT_DIFFSERV}
374 QOS_OBJECT_TCP_TRAFFIC = $00000004 + QOS_TRAFFIC_GENERAL_ID_BASE;
375 {$EXTERNALSYM QOS_OBJECT_TCP_TRAFFIC}
376 QOS_OBJECT_FRIENDLY_NAME = $00000005 + QOS_TRAFFIC_GENERAL_ID_BASE;
377 {$EXTERNALSYM QOS_OBJECT_FRIENDLY_NAME}
378
379 //
380 // This structure is used to associate a friendly name with the flow
381 //
382
383 type
384 LPQOS_FRIENDLY_NAME = ^QOS_FRIENDLY_NAME;
385 {$EXTERNALSYM LPQOS_FRIENDLY_NAME}
386 _QOS_FRIENDLY_NAME = record
387 ObjectHdr: QOS_OBJECT_HDR;
388 FriendlyName: array [0..MAX_STRING_LENGTH - 1] of WCHAR;
389 end;
390 {$EXTERNALSYM _QOS_FRIENDLY_NAME}
391 QOS_FRIENDLY_NAME = _QOS_FRIENDLY_NAME;
392 {$EXTERNALSYM QOS_FRIENDLY_NAME}
393 TQosFriendlyName = QOS_FRIENDLY_NAME;
394 PQosFriendlyName = LPQOS_FRIENDLY_NAME;
395
396 //
397 // This structure may carry an 802.1 TrafficClass parameter which
398 // has been provided to the host by a layer 2 network, for example,
399 // in an 802.1 extended RSVP RESV message. If this object is obtained
400 // from the network, hosts will stamp the MAC headers of corresponding
401 // transmitted packets, with the value in the object. Otherwise, hosts
402 // may select a value based on the standard Intserv mapping of
403 // ServiceType to 802.1 TrafficClass.
404 //
405 //
406
407 LPQOS_TRAFFIC_CLASS = ^QOS_TRAFFIC_CLASS;
408 {$EXTERNALSYM LPQOS_TRAFFIC_CLASS}
409 _QOS_TRAFFIC_CLASS = record
410 ObjectHdr: QOS_OBJECT_HDR;
411 TrafficClass: ULONG;
412 end;
413 {$EXTERNALSYM _QOS_TRAFFIC_CLASS}
414 QOS_TRAFFIC_CLASS = _QOS_TRAFFIC_CLASS;
415 {$EXTERNALSYM QOS_TRAFFIC_CLASS}
416 TQosTrafficClass = QOS_TRAFFIC_CLASS;
417 PQosTrafficClass = LPQOS_TRAFFIC_CLASS;
418
419 //
420 // This structure may carry an DSField parameter which has been provided to
421 // the host by a layer 3 network, for example, in an extended RSVP RESV message.
422 // If this object is obtained from the network, hosts will stamp the DS Field on the
423 // IP header of transmitted packets, with the value in the object. Otherwise, hosts
424 // may select a value based on the standard Intserv mapping of ServiceType to DS Field
425 //
426
427 LPQOS_DS_CLASS = ^QOS_DS_CLASS;
428 {$EXTERNALSYM LPQOS_DS_CLASS}
429 _QOS_DS_CLASS = record
430 ObjectHdr: QOS_OBJECT_HDR;
431 DSField: ULONG;
432 end;
433 {$EXTERNALSYM _QOS_DS_CLASS}
434 QOS_DS_CLASS = _QOS_DS_CLASS;
435 {$EXTERNALSYM QOS_DS_CLASS}
436 TQosDsClass = QOS_DS_CLASS;
437 PQosDsClass = LPQOS_DS_CLASS;
438
439 //
440 // This structure is used to create DiffServ Flows. This creates flows in the packet scheduler
441 // and allows it to classify to packets based on a particular DS field. This structure takes
442 // a variable length array of QOS_DIFFSERV_RULE, where each DS field is specified by a
443 // QOS_DIFFSERV_RULE
444 //
445 LPQOS_DIFFSERV = ^QOS_DIFFSERV;
446 {$EXTERNALSYM LPQOS_DIFFSERV}
447 _QOS_DIFFSERV = record
448 ObjectHdr: QOS_OBJECT_HDR;
449 DSFieldCount: ULONG;
450 DiffservRule: array [0..0] of UCHAR;
451 end;
452 {$EXTERNALSYM _QOS_DIFFSERV}
453 QOS_DIFFSERV = _QOS_DIFFSERV;
454 {$EXTERNALSYM QOS_DIFFSERV}
455 TQosDiffserv = QOS_DIFFSERV;
456 PQosDiffserv = LPQOS_DIFFSERV;
457
458 //
459 // The rule for a Diffserv DS codepoint.
460 //
461
462 LPQOS_DIFFSERV_RULE = ^QOS_DIFFSERV_RULE;
463 {$EXTERNALSYM LPQOS_DIFFSERV_RULE}
464 _QOS_DIFFSERV_RULE = record
465 InboundDSField: UCHAR;
466 ConformingOutboundDSField: UCHAR;
467 NonConformingOutboundDSField: UCHAR;
468 ConformingUserPriority: UCHAR;
469 NonConformingUserPriority: UCHAR;
470 end;
471 {$EXTERNALSYM _QOS_DIFFSERV_RULE}
472 QOS_DIFFSERV_RULE = _QOS_DIFFSERV_RULE;
473 {$EXTERNALSYM QOS_DIFFSERV_RULE}
474 TQosDiffservRule = QOS_DIFFSERV_RULE;
475 PQosDiffservRule = LPQOS_DIFFSERV_RULE;
476
477 //
478 // This structure is passed to indicate that the IP Precedence and UserPriority mappings for the flow
479 // have to be set to the system defaults for TCP traffic. If this object is passed,
480 // the ServiceType ==> DSField mapping, ServiceType ==> UserPriorityMapping, QOS_OBJECT_DS_CLASS
481 // and QOS_OBJECT_TRAFFIC_CLASS will be ignored.
482 //
483
484 LPQOS_TCP_TRAFFIC = ^QOS_TCP_TRAFFIC;
485 {$EXTERNALSYM LPQOS_TCP_TRAFFIC}
486 _QOS_TCP_TRAFFIC = record
487 ObjectHdr: QOS_OBJECT_HDR;
488 end;
489 {$EXTERNALSYM _QOS_TCP_TRAFFIC}
490 QOS_TCP_TRAFFIC = _QOS_TCP_TRAFFIC;
491 {$EXTERNALSYM QOS_TCP_TRAFFIC}
492 TQosTcpTraffic = QOS_TCP_TRAFFIC;
493 PQosTcpTraffic = LPQOS_TCP_TRAFFIC;
494
495 //---------------------------------------------------------------------------
496 //
Definitionsnull497 // Interface Function Definitions
498 //
499
500 function TcRegisterClient(TciVersion: ULONG; ClRegCtx: HANDLE; const ClientHandlerList: TCI_CLIENT_FUNC_LIST; var pClientHandle: HANDLE): ULONG; stdcall;
501 {$EXTERNALSYM TcRegisterClient}
TcEnumerateInterfacesnull502 function TcEnumerateInterfaces(ClientHandle: HANDLE; var pBufferSize: ULONG; var InterfaceBuffer: TC_IFC_DESCRIPTOR): ULONG; stdcall;
503 {$EXTERNALSYM TcEnumerateInterfaces}
TcOpenInterfaceAnull504 function TcOpenInterfaceA(pInterfaceName: LPSTR; ClientHandle, ClIfcCtx: HANDLE; var pIfcHandle: HANDLE): ULONG; stdcall;
505 {$EXTERNALSYM TcOpenInterfaceA}
TcOpenInterfaceWnull506 function TcOpenInterfaceW(pInterfaceName: LPWSTR; ClientHandle, ClIfcCtx: HANDLE; var pIfcHandle: HANDLE): ULONG; stdcall;
507 {$EXTERNALSYM TcOpenInterfaceW}
TcCloseInterfacenull508 function TcCloseInterface(IfcHandle: HANDLE): ULONG; stdcall;
509 {$EXTERNALSYM TcCloseInterface}
TcQueryInterfacenull510 function TcQueryInterface(IfcHandle: HANDLE; const pGuidParam: GUID; NotifyChange: Longbool; var pBufferSize: ULONG; Buffer: PVOID): ULONG; stdcall;
511 {$EXTERNALSYM TcQueryInterface}
TcSetInterfacenull512 function TcSetInterface(IfcHandle: HANDLE; const pGuidParam: GUID; BufferSize: ULONG; Buffer: PVOID): ULONG; stdcall;
513 {$EXTERNALSYM TcSetInterface}
TcQueryFlowAnull514 function TcQueryFlowA(pFlowName: LPSTR; const pGuidParam: GUID; var pBufferSize: ULONG; Buffer: PVOID): ULONG; stdcall;
515 {$EXTERNALSYM TcQueryFlowA}
TcQueryFlowWnull516 function TcQueryFlowW(pFlowName: LPWSTR; const pGuidParam: GUID; var pBufferSize: ULONG; Buffer: PVOID): ULONG; stdcall;
517 {$EXTERNALSYM TcQueryFlowW}
TcSetFlowAnull518 function TcSetFlowA(pFlowName: LPSTR; const pGuidParam: GUID; BufferSize: GUID; Buffer: PVOID): ULONG; stdcall;
519 {$EXTERNALSYM TcSetFlowA}
TcSetFlowWnull520 function TcSetFlowW(pFlowName: LPWSTR; const pGuidParam: GUID; BufferSize: GUID; Buffer: PVOID): ULONG; stdcall;
521 {$EXTERNALSYM TcSetFlowW}
TcAddFlownull522 function TcAddFlow(IfcHandle, ClFlowCtx: HANDLE; Flags: ULONG; const pGenericFlow: TC_GEN_FLOW; var pFlowHandle: HANDLE): ULONG; stdcall;
523 {$EXTERNALSYM TcAddFlow}
TcGetFlowNameAnull524 function TcGetFlowNameA(FlowHandle: HANDLE; StrSize: ULONG; pFlowName: LPSTR): ULONG; stdcall;
525 {$EXTERNALSYM TcGetFlowNameA}
TcGetFlowNameWnull526 function TcGetFlowNameW(FlowHandle: HANDLE; StrSize: ULONG; pFlowName: LPWSTR): ULONG; stdcall;
527 {$EXTERNALSYM TcGetFlowNameW}
TcModifyFlownull528 function TcModifyFlow(FlowHandle: HANDLE; const pGenericFlow: TC_GEN_FLOW): ULONG; stdcall;
529 {$EXTERNALSYM TcModifyFlow}
TcAddFilternull530 function TcAddFilter(FlowHandle: HANDLE; const pGenericFilter: TC_GEN_FILTER; var pFilterHandle: HANDLE): ULONG; stdcall;
531 {$EXTERNALSYM TcAddFilter}
TcDeregisterClientnull532 function TcDeregisterClient(ClientHandle: HANDLE): ULONG; stdcall;
533 {$EXTERNALSYM TcDeregisterClient}
TcDeleteFlownull534 function TcDeleteFlow(FlowHandle: HANDLE): ULONG; stdcall;
535 {$EXTERNALSYM TcDeleteFlow}
TcDeleteFilternull536 function TcDeleteFilter(FilterHandle: HANDLE): ULONG; stdcall;
537 {$EXTERNALSYM TcDeleteFilter}
TcEnumerateFlowsnull538 function TcEnumerateFlows(IfcHandle: HANDLE; var pEnumHandle: HANDLE; var pFlowCount, pBufSize: ULONG; var Buffer: ENUMERATION_BUFFER): ULONG; stdcall;
539 {$EXTERNALSYM TcEnumerateFlows}
540
TcOpenInterfacenull541 function TcOpenInterface(pInterfaceName: LPTSTR; ClientHandle, ClIfcCtx: HANDLE; var pIfcHandle: HANDLE): ULONG; stdcall;
542 {$EXTERNALSYM TcOpenInterface}
TcQueryFlownull543 function TcQueryFlow(pFlowName: LPTSTR; const pGuidParam: GUID; var pBufferSize: ULONG; Buffer: PVOID): ULONG; stdcall;
544 {$EXTERNALSYM TcQueryFlow}
TcSetFlownull545 function TcSetFlow(pFlowName: LPTSTR; const pGuidParam: GUID; BufferSize: GUID; Buffer: PVOID): ULONG; stdcall;
546 {$EXTERNALSYM TcSetFlow}
TcGetFlowNamenull547 function TcGetFlowName(FlowHandle: HANDLE; StrSize: ULONG; pFlowName: LPTSTR): ULONG; stdcall;
548 {$EXTERNALSYM TcGetFlowName}
549
550 {$ENDIF JWA_IMPLEMENTATIONSECTION}
551
552
553
554 {$IFNDEF JWA_OMIT_SECTIONS}
555 implementation
556 //uses ...
557 {$ENDIF JWA_OMIT_SECTIONS}
558
559
560
561 {$IFNDEF JWA_INTERFACESECTION}
562
563 {$IFNDEF JWA_INCLUDEMODE}
564 const
565 trafficlib = 'traffic.dll';
566 {$IFDEF UNICODE}
567 AWSuffix = 'W';
568 {$ELSE}
569 AWSuffix = 'A';
570 {$ENDIF UNICODE}
571 {$ENDIF JWA_INCLUDEMODE}
572
573 {$IFDEF DYNAMIC_LINK}
574
575 var
576 _TcRegisterClient: Pointer;
577
TcRegisterClientnull578 function TcRegisterClient;
579 begin
580 GetProcedureAddress(_TcRegisterClient, trafficlib, 'TcRegisterClient');
581 asm
582 MOV ESP, EBP
583 POP EBP
584 JMP [_TcRegisterClient]
585 end;
586 end;
587
588 var
589 _TcEnumerateInterfaces: Pointer;
590
TcEnumerateInterfacesnull591 function TcEnumerateInterfaces;
592 begin
593 GetProcedureAddress(_TcEnumerateInterfaces, trafficlib, 'TcEnumerateInterfaces');
594 asm
595 MOV ESP, EBP
596 POP EBP
597 JMP [_TcEnumerateInterfaces]
598 end;
599 end;
600
601 var
602 _TcOpenInterfaceA: Pointer;
603
TcOpenInterfaceAnull604 function TcOpenInterfaceA;
605 begin
606 GetProcedureAddress(_TcOpenInterfaceA, trafficlib, 'TcOpenInterfaceA');
607 asm
608 MOV ESP, EBP
609 POP EBP
610 JMP [_TcOpenInterfaceA]
611 end;
612 end;
613
614 var
615 _TcOpenInterfaceW: Pointer;
616
TcOpenInterfaceWnull617 function TcOpenInterfaceW;
618 begin
619 GetProcedureAddress(_TcOpenInterfaceW, trafficlib, 'TcOpenInterfaceW');
620 asm
621 MOV ESP, EBP
622 POP EBP
623 JMP [_TcOpenInterfaceW]
624 end;
625 end;
626
627 var
628 _TcCloseInterface: Pointer;
629
TcCloseInterfacenull630 function TcCloseInterface;
631 begin
632 GetProcedureAddress(_TcCloseInterface, trafficlib, 'TcCloseInterface');
633 asm
634 MOV ESP, EBP
635 POP EBP
636 JMP [_TcCloseInterface]
637 end;
638 end;
639
640 var
641 _TcQueryInterface: Pointer;
642
TcQueryInterfacenull643 function TcQueryInterface;
644 begin
645 GetProcedureAddress(_TcQueryInterface, trafficlib, 'TcQueryInterface');
646 asm
647 MOV ESP, EBP
648 POP EBP
649 JMP [_TcQueryInterface]
650 end;
651 end;
652
653 var
654 _TcSetInterface: Pointer;
655
TcSetInterfacenull656 function TcSetInterface;
657 begin
658 GetProcedureAddress(_TcSetInterface, trafficlib, 'TcSetInterface');
659 asm
660 MOV ESP, EBP
661 POP EBP
662 JMP [_TcSetInterface]
663 end;
664 end;
665
666 var
667 _TcQueryFlowA: Pointer;
668
TcQueryFlowAnull669 function TcQueryFlowA;
670 begin
671 GetProcedureAddress(_TcQueryFlowA, trafficlib, 'TcQueryFlowA');
672 asm
673 MOV ESP, EBP
674 POP EBP
675 JMP [_TcQueryFlowA]
676 end;
677 end;
678
679 var
680 _TcQueryFlowW: Pointer;
681
TcQueryFlowWnull682 function TcQueryFlowW;
683 begin
684 GetProcedureAddress(_TcQueryFlowW, trafficlib, 'TcQueryFlowW');
685 asm
686 MOV ESP, EBP
687 POP EBP
688 JMP [_TcQueryFlowW]
689 end;
690 end;
691
692 var
693 _TcSetFlowA: Pointer;
694
TcSetFlowAnull695 function TcSetFlowA;
696 begin
697 GetProcedureAddress(_TcSetFlowA, trafficlib, 'TcSetFlowA');
698 asm
699 MOV ESP, EBP
700 POP EBP
701 JMP [_TcSetFlowA]
702 end;
703 end;
704
705 var
706 _TcSetFlowW: Pointer;
707
TcSetFlowWnull708 function TcSetFlowW;
709 begin
710 GetProcedureAddress(_TcSetFlowW, trafficlib, 'TcSetFlowW');
711 asm
712 MOV ESP, EBP
713 POP EBP
714 JMP [_TcSetFlowW]
715 end;
716 end;
717
718 var
719 _TcAddFlow: Pointer;
720
TcAddFlownull721 function TcAddFlow;
722 begin
723 GetProcedureAddress(_TcAddFlow, trafficlib, 'TcAddFlow');
724 asm
725 MOV ESP, EBP
726 POP EBP
727 JMP [_TcAddFlow]
728 end;
729 end;
730
731 var
732 _TcGetFlowNameA: Pointer;
733
TcGetFlowNameAnull734 function TcGetFlowNameA;
735 begin
736 GetProcedureAddress(_TcGetFlowNameA, trafficlib, 'TcGetFlowNameA');
737 asm
738 MOV ESP, EBP
739 POP EBP
740 JMP [_TcGetFlowNameA]
741 end;
742 end;
743
744 var
745 _TcGetFlowNameW: Pointer;
746
TcGetFlowNameWnull747 function TcGetFlowNameW;
748 begin
749 GetProcedureAddress(_TcGetFlowNameW, trafficlib, 'TcGetFlowNameW');
750 asm
751 MOV ESP, EBP
752 POP EBP
753 JMP [_TcGetFlowNameW]
754 end;
755 end;
756
757 var
758 _TcModifyFlow: Pointer;
759
TcModifyFlownull760 function TcModifyFlow;
761 begin
762 GetProcedureAddress(_TcModifyFlow, trafficlib, 'TcModifyFlow');
763 asm
764 MOV ESP, EBP
765 POP EBP
766 JMP [_TcModifyFlow]
767 end;
768 end;
769
770 var
771 _TcAddFilter: Pointer;
772
TcAddFilternull773 function TcAddFilter;
774 begin
775 GetProcedureAddress(_TcAddFilter, trafficlib, 'TcAddFilter');
776 asm
777 MOV ESP, EBP
778 POP EBP
779 JMP [_TcAddFilter]
780 end;
781 end;
782
783 var
784 _TcDeregisterClient: Pointer;
785
TcDeregisterClientnull786 function TcDeregisterClient;
787 begin
788 GetProcedureAddress(_TcDeregisterClient, trafficlib, 'TcDeregisterClient');
789 asm
790 MOV ESP, EBP
791 POP EBP
792 JMP [_TcDeregisterClient]
793 end;
794 end;
795
796 var
797 _TcDeleteFlow: Pointer;
798
TcDeleteFlownull799 function TcDeleteFlow;
800 begin
801 GetProcedureAddress(_TcDeleteFlow, trafficlib, 'TcDeleteFlow');
802 asm
803 MOV ESP, EBP
804 POP EBP
805 JMP [_TcDeleteFlow]
806 end;
807 end;
808
809 var
810 _TcDeleteFilter: Pointer;
811
TcDeleteFilternull812 function TcDeleteFilter;
813 begin
814 GetProcedureAddress(_TcDeleteFilter, trafficlib, 'TcDeleteFilter');
815 asm
816 MOV ESP, EBP
817 POP EBP
818 JMP [_TcDeleteFilter]
819 end;
820 end;
821
822 var
823 _TcEnumerateFlows: Pointer;
824
TcEnumerateFlowsnull825 function TcEnumerateFlows;
826 begin
827 GetProcedureAddress(_TcEnumerateFlows, trafficlib, 'TcEnumerateFlows');
828 asm
829 MOV ESP, EBP
830 POP EBP
831 JMP [_TcEnumerateFlows]
832 end;
833 end;
834
835 var
836 _TcOpenInterface: Pointer;
837
TcOpenInterfacenull838 function TcOpenInterface;
839 begin
840 GetProcedureAddress(_TcOpenInterface, trafficlib, 'TcOpenInterface' + AWSuffix);
841 asm
842 MOV ESP, EBP
843 POP EBP
844 JMP [_TcOpenInterface]
845 end;
846 end;
847
848 var
849 _TcQueryFlow: Pointer;
850
TcQueryFlownull851 function TcQueryFlow;
852 begin
853 GetProcedureAddress(_TcQueryFlow, trafficlib, 'TcQueryFlow' + AWSuffix);
854 asm
855 MOV ESP, EBP
856 POP EBP
857 JMP [_TcQueryFlow]
858 end;
859 end;
860
861 var
862 _TcSetFlow: Pointer;
863
TcSetFlownull864 function TcSetFlow;
865 begin
866 GetProcedureAddress(_TcSetFlow, trafficlib, 'TcSetFlow' + AWSuffix);
867 asm
868 MOV ESP, EBP
869 POP EBP
870 JMP [_TcSetFlow]
871 end;
872 end;
873
874 var
875 _TcGetFlowName: Pointer;
876
TcGetFlowNamenull877 function TcGetFlowName;
878 begin
879 GetProcedureAddress(_TcGetFlowName, trafficlib, 'TcGetFlowName' + AWSuffix);
880 asm
881 MOV ESP, EBP
882 POP EBP
883 JMP [_TcGetFlowName]
884 end;
885 end;
886
887 {$ELSE}
888
TcRegisterClientnull889 function TcRegisterClient; external trafficlib name 'TcRegisterClient';
TcEnumerateInterfacesnull890 function TcEnumerateInterfaces; external trafficlib name 'TcEnumerateInterfaces';
TcOpenInterfaceAnull891 function TcOpenInterfaceA; external trafficlib name 'TcOpenInterfaceA';
TcOpenInterfaceWnull892 function TcOpenInterfaceW; external trafficlib name 'TcOpenInterfaceW';
TcCloseInterfacenull893 function TcCloseInterface; external trafficlib name 'TcCloseInterface';
TcQueryInterfacenull894 function TcQueryInterface; external trafficlib name 'TcQueryInterface';
TcSetInterfacenull895 function TcSetInterface; external trafficlib name 'TcSetInterface';
TcQueryFlowAnull896 function TcQueryFlowA; external trafficlib name 'TcQueryFlowA';
TcQueryFlowWnull897 function TcQueryFlowW; external trafficlib name 'TcQueryFlowW';
TcSetFlowAnull898 function TcSetFlowA; external trafficlib name 'TcSetFlowA';
TcSetFlowWnull899 function TcSetFlowW; external trafficlib name 'TcSetFlowW';
TcAddFlownull900 function TcAddFlow; external trafficlib name 'TcAddFlow';
TcGetFlowNameAnull901 function TcGetFlowNameA; external trafficlib name 'TcGetFlowNameA';
TcGetFlowNameWnull902 function TcGetFlowNameW; external trafficlib name 'TcGetFlowNameW';
TcModifyFlownull903 function TcModifyFlow; external trafficlib name 'TcModifyFlow';
TcAddFilternull904 function TcAddFilter; external trafficlib name 'TcAddFilter';
TcDeregisterClientnull905 function TcDeregisterClient; external trafficlib name 'TcDeregisterClient';
TcDeleteFlownull906 function TcDeleteFlow; external trafficlib name 'TcDeleteFlow';
TcDeleteFilternull907 function TcDeleteFilter; external trafficlib name 'TcDeleteFilter';
TcEnumerateFlowsnull908 function TcEnumerateFlows; external trafficlib name 'TcEnumerateFlows';
TcOpenInterfacenull909 function TcOpenInterface; external trafficlib name 'TcOpenInterface' + AWSuffix;
TcQueryFlownull910 function TcQueryFlow; external trafficlib name 'TcQueryFlow' + AWSuffix;
TcSetFlownull911 function TcSetFlow; external trafficlib name 'TcSetFlow' + AWSuffix;
TcGetFlowNamenull912 function TcGetFlowName; external trafficlib name 'TcGetFlowName' + AWSuffix;
913
914 {$ENDIF DYNAMIC_LINK}
915
916 {$ENDIF JWA_INTERFACESECTION}
917
918
919
920 {$IFNDEF JWA_OMIT_SECTIONS}
921 end.
922 {$ENDIF JWA_OMIT_SECTIONS}
923