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

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

Windows编程

开发平台：

Delphi

JwaTraffic.pas：源码内容
  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@chello.nl).                        }
  11. {                                                                              }
  12. { Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
  13. { Marcel van Brakel. All Rights Reserved.                                      }
  14. {                 }
  15. { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
  16. {                }
  17. { You may retrieve the latest version of this file at the Project JEDI home    }
  18. { page, located at http://delphi-jedi.org or my personal homepage located at   }
  19. { http://members.chello.nl/m.vanbrakel2                                        }
  20. {                }
  21. { The contents of this file are used with permission, subject to the Mozilla   }
  22. { Public License Version 1.1 (the "License"); you may not use this file except }
  23. { in compliance with the License. You may obtain a copy of the License at      }
  24. { http://www.mozilla.org/MPL/MPL-1.1.html                                      }
  25. {                                                                              }
  26. { Software distributed under the License is distributed on an "AS IS" basis,   }
  27. { WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
  28. { the specific language governing rights and limitations under the License.    }
  29. {                                                                              }
  30. { Alternatively, the contents of this file may be used under the terms of the  }
  31. { GNU Lesser General Public License (the  "LGPL License"), in which case the   }
  32. { provisions of the LGPL License are applicable instead of those above.        }
  33. { If you wish to allow use of your version of this file only under the terms   }
  34. { of the LGPL License and not to allow others to use your version of this file }
  35. { under the MPL, indicate your decision by deleting  the provisions above and  }
  36. { replace  them with the notice and other provisions required by the LGPL      }
  37. { License.  If you do not delete the provisions above, a recipient may use     }
  38. { your version of this file under either the MPL or the LGPL License.          }
  39. {                 }
  40. { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
  41. {                 }
  42. {******************************************************************************}
  44. unit JwaTraffic;
  46. {$WEAKPACKAGEUNIT}
  48. {$HPPEMIT ''}
  49. {$HPPEMIT '#include "traffic.h"'}
  50. {$HPPEMIT ''}
  52. {$I WINDEFINES.INC}
  54. interface
  56. uses
  57.   JwaWinType, JwaQos;
  59. //---------------------------------------------------------------------------
  60. //
  61. // Define's
  62. //
  64. const
  65.   CURRENT_TCI_VERSION = $0002;
  66.   {$EXTERNALSYM CURRENT_TCI_VERSION}
  68. //
  69. // Definitions of notification events. These may be passed
  70. // to the client's notification handler, to identify the
  71. // notification type
  72. //
  74. //
  75. // A TC interface has come up
  76. //
  78.   TC_NOTIFY_IFC_UP = 1;
  79.   {$EXTERNALSYM TC_NOTIFY_IFC_UP}
  81. //
  82. // A TC interface has come down
  83. //
  85.   TC_NOTIFY_IFC_CLOSE = 2;
  86.   {$EXTERNALSYM TC_NOTIFY_IFC_CLOSE}
  88. //
  89. // A change on a TC interface, typically a change in the
  90. // list of supported network addresses
  91. //
  93.   TC_NOTIFY_IFC_CHANGE = 3;
  94.   {$EXTERNALSYM TC_NOTIFY_IFC_CHANGE}
  96. //
  97. // A TC parameter has changed
  98. //
  100.   TC_NOTIFY_PARAM_CHANGED = 4;
  101.   {$EXTERNALSYM TC_NOTIFY_PARAM_CHANGED}
  103. //
  104. // A flow has been closed by the TC interface
  105. // for example: after a remote call close, or the whole interface
  106. // is going down
  107. //
  109.   TC_NOTIFY_FLOW_CLOSE = 5;
  110.   {$EXTERNALSYM TC_NOTIFY_FLOW_CLOSE}
  112.   TC_INVALID_HANDLE = HANDLE(0);
  113.   {$EXTERNALSYM TC_INVALID_HANDLE}
  115.   MAX_STRING_LENGTH = 256;
  116.   {$EXTERNALSYM MAX_STRING_LENGTH}
  118. //---------------------------------------------------------------------------
  119. //
  120. // Typedef's and structures
  121. //
  123. //
  124. // Handlers registered by the TCI client
  125. //
  127. type
  128.   TCI_NOTIFY_HANDLER = procedure (ClRegCtx, ClIfcCtx: HANDLE; Event: ULONG;
  129.     SubCode: HANDLE; BufSize: ULONG; Buffer: PVOID); stdcall;
  130.   {$EXTERNALSYM TCI_NOTIFY_HANDLER}
  131.   TTciNotifyHandler = TCI_NOTIFY_HANDLER;
  133.   TCI_ADD_FLOW_COMPLETE_HANDLER = procedure (ClFlowCtx: HANDLE; Status: ULONG); stdcall;
  134.   {$EXTERNALSYM TCI_ADD_FLOW_COMPLETE_HANDLER}
  135.   TTciAddFlowCompleteHandler = TCI_ADD_FLOW_COMPLETE_HANDLER;
  137.   TCI_MOD_FLOW_COMPLETE_HANDLER = procedure (ClFlowCtx: HANDLE; Status: ULONG); stdcall;
  138.   {$EXTERNALSYM TCI_MOD_FLOW_COMPLETE_HANDLER}
  139.   TTciModFlowCompleteHandler = TCI_MOD_FLOW_COMPLETE_HANDLER;
  141.   TCI_DEL_FLOW_COMPLETE_HANDLER = procedure (ClFlowCtx: HANDLE; Status: ULONG); stdcall;
  142.   {$EXTERNALSYM TCI_DEL_FLOW_COMPLETE_HANDLER}
  143.   TTciDelFlowComlpeteHandler = TCI_DEL_FLOW_COMPLETE_HANDLER;
  145. type
  146.   PTCI_CLIENT_FUNC_LIST = ^TCI_CLIENT_FUNC_LIST;
  147.   {$EXTERNALSYM PTCI_CLIENT_FUNC_LIST}
  148.   _TCI_CLIENT_FUNC_LIST = record
  149.     ClNotifyHandler: TCI_NOTIFY_HANDLER;
  150.     ClAddFlowCompleteHandler: TCI_ADD_FLOW_COMPLETE_HANDLER;
  151.     ClModifyFlowCompleteHandler: TCI_MOD_FLOW_COMPLETE_HANDLER;
  152.     ClDeleteFlowCompleteHandler: TCI_DEL_FLOW_COMPLETE_HANDLER;
  153.   end;
  154.   {$EXTERNALSYM _TCI_CLIENT_FUNC_LIST}
  155.   TCI_CLIENT_FUNC_LIST = _TCI_CLIENT_FUNC_LIST;
  156.   {$EXTERNALSYM TCI_CLIENT_FUNC_LIST}
  157.   TTciClientFuncList = TCI_CLIENT_FUNC_LIST;
  158.   PTciClientFuncList = PTCI_CLIENT_FUNC_LIST;
  160.   // TODO NETWORD_ADDRESS and NETWORK_ADDRESS_LIST are from NtDDNdis.h
  162.   _NETWORK_ADDRESS = record
  163.     AddressLength: USHORT; // length in bytes of Address[] in this
  164.     AddressType: USHORT; // type of this address (NDIS_PROTOCOL_ID_XXX above)
  165.     Address: array [0..0] of UCHAR; // actually AddressLength bytes long
  166.   end;
  167.   NETWORK_ADDRESS = _NETWORK_ADDRESS;
  168.   PNETWORK_ADDRESS = ^NETWORK_ADDRESS;
  170.   _NETWORK_ADDRESS_LIST = record
  171.     AddressCount: LONG;   // number of addresses following
  172.     AddressType: USHORT; // type of this address (NDIS_PROTOCOL_ID_XXX above)
  173.     Address: array [0..0] of NETWORK_ADDRESS; // actually AddressCount elements long
  174.   end;
  175.   NETWORK_ADDRESS_LIST = _NETWORK_ADDRESS_LIST;
  176.   PNETWORK_ADDRESS_LIST = ^NETWORK_ADDRESS_LIST;
  178. //
  179. // Network address descriptor
  180. //
  182.   PADDRESS_LIST_DESCRIPTOR = ^ADDRESS_LIST_DESCRIPTOR;
  183.   {$EXTERNALSYM PADDRESS_LIST_DESCRIPTOR}
  184.   _ADDRESS_LIST_DESCRIPTOR = record
  185.     MediaType: ULONG;
  186.     AddressList: NETWORK_ADDRESS_LIST;
  187.   end;
  188.   {$EXTERNALSYM _ADDRESS_LIST_DESCRIPTOR}
  189.   ADDRESS_LIST_DESCRIPTOR = _ADDRESS_LIST_DESCRIPTOR;
  190.   {$EXTERNALSYM ADDRESS_LIST_DESCRIPTOR}
  191.   TAddressListDescriptor = ADDRESS_LIST_DESCRIPTOR;
  192.   PAddressListDescriptor = PADDRESS_LIST_DESCRIPTOR;
  194. //
  195. // An interface ID that is returned by the enumerator
  196. //
  198.   PTC_IFC_DESCRIPTOR = ^TC_IFC_DESCRIPTOR;
  199.   {$EXTERNALSYM PTC_IFC_DESCRIPTOR}
  200.   _TC_IFC_DESCRIPTOR = record
  201.     Length: ULONG;
  202.     pInterfaceName: LPWSTR;
  203.     pInterfaceID: LPWSTR;
  204.     AddressListDesc: ADDRESS_LIST_DESCRIPTOR;
  205.   end;
  206.   {$EXTERNALSYM _TC_IFC_DESCRIPTOR}
  207.   TC_IFC_DESCRIPTOR = _TC_IFC_DESCRIPTOR;
  208.   {$EXTERNALSYM TC_IFC_DESCRIPTOR}
  209.   TTcIfcDescriptor = TC_IFC_DESCRIPTOR;
  210.   PTcIfcDescriptor = PTC_IFC_DESCRIPTOR;
  212. //
  213. // This structure is returned by a QoS data provider in reply to
  214. // GUID_QOS_SUPPORTED query or with an interface UP notification
  215. //
  217.   PTC_SUPPORTED_INFO_BUFFER = ^TC_SUPPORTED_INFO_BUFFER;
  218.   {$EXTERNALSYM PTC_SUPPORTED_INFO_BUFFER}
  219.   _TC_SUPPORTED_INFO_BUFFER = record
  220.     InstanceIDLength: USHORT;
  221.     // device or interface ID
  222.     InstanceID: array [0..MAX_STRING_LENGTH - 1] of WCHAR;
  223.     // address list
  224.     AddrListDesc: ADDRESS_LIST_DESCRIPTOR;
  225.   end;
  226.   {$EXTERNALSYM _TC_SUPPORTED_INFO_BUFFER}
  227.   TC_SUPPORTED_INFO_BUFFER = _TC_SUPPORTED_INFO_BUFFER;
  228.   {$EXTERNALSYM TC_SUPPORTED_INFO_BUFFER}
  229.   TTcSupportedInfoBuffer = TC_SUPPORTED_INFO_BUFFER;
  230.   PTcSupportedInfoBuffer = PTC_SUPPORTED_INFO_BUFFER;
  232. //
  233. // Filters are used to match packets. The Pattern field
  234. // indicates the values to which bits in corresponding
  235. // positions in candidate packets should be compared. The
  236. // Mask field indicates which bits are to be compared and
  237. // which bits are don't cares.
  238. //
  239. // Different filters can be submitted on the TCI interface.
  240. // The generic filter structure is defined to include an
  241. // AddressType, which indicates the specific type of filter to
  242. // follow.
  243. //
  245.   PTC_GEN_FILTER = ^TC_GEN_FILTER;
  246.   {$EXTERNALSYM PTC_GEN_FILTER}
  247.   _TC_GEN_FILTER = record
  248.     AddressType: USHORT; // IP, IPX, etc.
  249.     PatternSize: ULONG; // byte count of the pattern
  250.     Pattern: PVOID; // specific format, e.g. IP_PATTERN
  251.     Mask: PVOID; // same type as Pattern
  252.   end;
  253.   {$EXTERNALSYM _TC_GEN_FILTER}
  254.   TC_GEN_FILTER = _TC_GEN_FILTER;
  255.   {$EXTERNALSYM TC_GEN_FILTER}
  256.   TTcGenFilter = TC_GEN_FILTER;
  257.   PTcGenFilter = PTC_GEN_FILTER;
  259. //
  260. // A generic flow includes two flowspecs and a freeform
  261. // buffer which contains flow specific TC objects.
  262. //
  264.   PTC_GEN_FLOW = ^TC_GEN_FLOW;
  265.   {$EXTERNALSYM PTC_GEN_FLOW}
  266.   _TC_GEN_FLOW = record
  267.     SendingFlowspec: FLOWSPEC;
  268.     ReceivingFlowspec: FLOWSPEC;
  269.     TcObjectsLength: ULONG; // number of optional bytes
  270.     TcObjects: array [0..0] of QOS_OBJECT_HDR;
  271.   end;
  272.   {$EXTERNALSYM _TC_GEN_FLOW}
  273.   TC_GEN_FLOW = _TC_GEN_FLOW;
  274.   {$EXTERNALSYM TC_GEN_FLOW}
  275.   TTcGenFlow = TC_GEN_FLOW;
  276.   PTcGenFlow = PTC_GEN_FLOW;
  278. //
  279. // Format of specific pattern or mask used by GPC for the IP protocol
  280. //
  282.   PIP_PATTERN = ^IP_PATTERN;
  283.   {$EXTERNALSYM PIP_PATTERN}
  284.   _IP_PATTERN = record
  285.     Reserved1: ULONG;
  286.     Reserved2: ULONG;
  287.     SrcAddr: ULONG;
  288.     DstAddr: ULONG;
  289.     S_un: record
  290.     case Integer of
  291.       0: (
  292.         s_srcport: USHORT;
  293.         s_dstport: USHORT);
  294.       1: (
  295.         s_type: UCHAR;
  296.         s_code: UCHAR;
  297.         filler: USHORT);
  298.       2: (
  299.         S_Spi: ULONG);
  300.     end;
  301.     ProtocolId: UCHAR;
  302.     Reserved3: array [0..3 - 1] of UCHAR;
  303.   end;
  304.   {$EXTERNALSYM _IP_PATTERN}
  305.   IP_PATTERN = _IP_PATTERN;
  306.   {$EXTERNALSYM IP_PATTERN}
  307.   TIpPattern = IP_PATTERN;
  308.   PIpPattern = PIP_PATTERN;
  310. //
  311. // Format of specific pattern or mask used by GPC for the IPX protocol
  312. //
  314.   TIpxPatternAddress = record
  315.     NetworkAddress: ULONG;
  316.     NodeAddress: array [0..5] of UCHAR;
  317.     Socket: USHORT;
  318.   end;
  320.   PIPX_PATTERN = ^IPX_PATTERN;
  321.   {$EXTERNALSYM PIPX_PATTERN}
  322.   _IPX_PATTERN = record
  323.     Src: TIpxPatternAddress;
  324.     Dest: TIpxPatternAddress;
  325.   end;
  326.   {$EXTERNALSYM _IPX_PATTERN}
  327.   IPX_PATTERN = _IPX_PATTERN;
  328.   {$EXTERNALSYM IPX_PATTERN}
  329.   TIpxPattern = IPX_PATTERN;
  330.   PIpxPattern = PIPX_PATTERN;
  332. //
  333. // The enumeration buffer is the flow parameters + a list of filters
  334. //
  336.   PENUMERATION_BUFFER = ^ENUMERATION_BUFFER;
  337.   {$EXTERNALSYM PENUMERATION_BUFFER}
  338.   _ENUMERATION_BUFFER = record
  339.     Length: ULONG;
  340.     OwnerProcessId: ULONG;
  341.     FlowNameLength: USHORT;
  342.     FlowName: array [0..MAX_STRING_LENGTH - 1] of WCHAR;
  343.     pFlow: PTC_GEN_FLOW;
  344.     NumberOfFilters: ULONG;
  345.     GenericFilter: array [0..0] of TC_GEN_FILTER; // one for each filter
  346.   end;
  347.   {$EXTERNALSYM _ENUMERATION_BUFFER}
  348.   ENUMERATION_BUFFER = _ENUMERATION_BUFFER;
  349.   {$EXTERNALSYM ENUMERATION_BUFFER}
  350.   TEnumerationBuffer = ENUMERATION_BUFFER;
  351.   PEnumerationBuffer = PENUMERATION_BUFFER;
  353. //
  354. // QoS objects supported by traffic
  355. //
  357. const
  358.   QOS_TRAFFIC_GENERAL_ID_BASE = 4000;
  359.   {$EXTERNALSYM QOS_TRAFFIC_GENERAL_ID_BASE}
  361.   QOS_OBJECT_DS_CLASS      = ($00000001 + QOS_TRAFFIC_GENERAL_ID_BASE);
  362.   {$EXTERNALSYM QOS_OBJECT_DS_CLASS}
  363.   QOS_OBJECT_TRAFFIC_CLASS = ($00000002 + QOS_TRAFFIC_GENERAL_ID_BASE);
  364.   {$EXTERNALSYM QOS_OBJECT_TRAFFIC_CLASS}
  365.   QOS_OBJECT_DIFFSERV      = ($00000003 + QOS_TRAFFIC_GENERAL_ID_BASE);
  366.   {$EXTERNALSYM QOS_OBJECT_DIFFSERV}
  367.   QOS_OBJECT_TCP_TRAFFIC   = ($00000004 + QOS_TRAFFIC_GENERAL_ID_BASE);
  368.   {$EXTERNALSYM QOS_OBJECT_TCP_TRAFFIC}
  369.   QOS_OBJECT_FRIENDLY_NAME = ($00000005 + QOS_TRAFFIC_GENERAL_ID_BASE);
  370.   {$EXTERNALSYM QOS_OBJECT_FRIENDLY_NAME}
  372. //
  373. // This structure is used to associate a friendly name with the flow
  374. // 
  376. type
  377.   LPQOS_FRIENDLY_NAME = ^QOS_FRIENDLY_NAME;
  378.   {$EXTERNALSYM LPQOS_FRIENDLY_NAME}
  379.   _QOS_FRIENDLY_NAME = record
  380.     ObjectHdr: QOS_OBJECT_HDR;
  381.     FriendlyName: array [0..MAX_STRING_LENGTH - 1] of WCHAR;
  382.   end;
  383.   {$EXTERNALSYM _QOS_FRIENDLY_NAME}
  384.   QOS_FRIENDLY_NAME = _QOS_FRIENDLY_NAME;
  385.   {$EXTERNALSYM QOS_FRIENDLY_NAME}
  386.   TQosFriendlyName = QOS_FRIENDLY_NAME;
  387.   PQosFriendlyName = LPQOS_FRIENDLY_NAME;
  389. //
  390. // This structure may carry an 802.1 TrafficClass parameter which 
  391. // has been provided to the host by a layer 2 network, for example, 
  392. // in an 802.1 extended RSVP RESV message. If this object is obtained
  393. // from the network, hosts will stamp the MAC headers of corresponding
  394. // transmitted packets, with the value in the object. Otherwise, hosts
  395. // may select a value based on the standard Intserv mapping of 
  396. // ServiceType to 802.1 TrafficClass.
  397. //
  398. //
  400.   LPQOS_TRAFFIC_CLASS = ^QOS_TRAFFIC_CLASS;
  401.   {$EXTERNALSYM LPQOS_TRAFFIC_CLASS}
  402.   _QOS_TRAFFIC_CLASS = record
  403.     ObjectHdr: QOS_OBJECT_HDR;
  404.     TrafficClass: ULONG;
  405.   end;
  406.   {$EXTERNALSYM _QOS_TRAFFIC_CLASS}
  407.   QOS_TRAFFIC_CLASS = _QOS_TRAFFIC_CLASS;
  408.   {$EXTERNALSYM QOS_TRAFFIC_CLASS}
  409.   TQosTrafficClass = QOS_TRAFFIC_CLASS;
  410.   PQosTrafficClass = LPQOS_TRAFFIC_CLASS;
  412. //
  413. // This structure may carry an DSField parameter which  has been provided to 
  414. // the host by a layer 3 network, for example, in an extended RSVP RESV message. 
  415. // If this object is obtained from the network, hosts will stamp the DS Field on the
  416. // IP header of transmitted packets, with the value in the object. Otherwise, hosts
  417. // may select a value based on the standard Intserv mapping of ServiceType to DS Field 
  418. //
  420.   LPQOS_DS_CLASS = ^QOS_DS_CLASS;
  421.   {$EXTERNALSYM LPQOS_DS_CLASS}
  422.   _QOS_DS_CLASS = record
  423.     ObjectHdr: QOS_OBJECT_HDR;
  424.     DSField: ULONG;
  425.   end;
  426.   {$EXTERNALSYM _QOS_DS_CLASS}
  427.   QOS_DS_CLASS = _QOS_DS_CLASS;
  428.   {$EXTERNALSYM QOS_DS_CLASS}
  429.   TQosDsClass = QOS_DS_CLASS;
  430.   PQosDsClass = LPQOS_DS_CLASS;
  433. //
  434. // This structure is used to create DiffServ Flows. This creates flows in the packet scheduler
  435. // and allows it to classify to packets based on a particular DS field. This structure takes
  436. // a variable length array of QOS_DIFFSERV_RULE, where each DS field is specified by a 
  437. // QOS_DIFFSERV_RULE
  438. //
  439.   LPQOS_DIFFSERV = ^QOS_DIFFSERV;
  440.   {$EXTERNALSYM LPQOS_DIFFSERV}
  441.   _QOS_DIFFSERV = record
  442.     ObjectHdr: QOS_OBJECT_HDR;
  443.     DSFieldCount: ULONG;
  444.     DiffservRule: array [0..0] of UCHAR;
  445.   end;
  446.   {$EXTERNALSYM _QOS_DIFFSERV}
  447.   QOS_DIFFSERV = _QOS_DIFFSERV;
  448.   {$EXTERNALSYM QOS_DIFFSERV}
  449.   TQosDiffserv = QOS_DIFFSERV;
  450.   PQosDiffserv = LPQOS_DIFFSERV;
  452. //
  453. // The rule for a Diffserv DS codepoint. 
  454. //
  456.   LPQOS_DIFFSERV_RULE = ^QOS_DIFFSERV_RULE;
  457.   {$EXTERNALSYM LPQOS_DIFFSERV_RULE}
  458.   _QOS_DIFFSERV_RULE = record
  459.     InboundDSField: UCHAR;
  460.     ConformingOutboundDSField: UCHAR;
  461.     NonConformingOutboundDSField: UCHAR;
  462.     ConformingUserPriority: UCHAR;
  463.     NonConformingUserPriority: UCHAR;
  464.   end;
  465.   {$EXTERNALSYM _QOS_DIFFSERV_RULE}
  466.   QOS_DIFFSERV_RULE = _QOS_DIFFSERV_RULE;
  467.   {$EXTERNALSYM QOS_DIFFSERV_RULE}
  468.   TQosDiffservRule = QOS_DIFFSERV_RULE;
  469.   PQosDiffservRule = LPQOS_DIFFSERV_RULE;
  471. // 
  472. // This structure is passed to indicate that the IP Precedence and UserPriority mappings for the flow
  473. // have to be set to the system defaults for TCP traffic. If this object is passed, 
  474. // the ServiceType ==> DSField mapping, ServiceType ==> UserPriorityMapping, QOS_OBJECT_DS_CLASS
  475. // and QOS_OBJECT_TRAFFIC_CLASS will be ignored.
  476. //
  478.   LPQOS_TCP_TRAFFIC = ^QOS_TCP_TRAFFIC;
  479.   {$EXTERNALSYM LPQOS_TCP_TRAFFIC}
  480.   _QOS_TCP_TRAFFIC = record
  481.     ObjectHdr: QOS_OBJECT_HDR;
  482.   end;
  483.   {$EXTERNALSYM _QOS_TCP_TRAFFIC}
  484.   QOS_TCP_TRAFFIC = _QOS_TCP_TRAFFIC;
  485.   {$EXTERNALSYM QOS_TCP_TRAFFIC}
  486.   TQosTcpTraffic = QOS_TCP_TRAFFIC;
  487.   PQosTcpTraffic = LPQOS_TCP_TRAFFIC;
  489. //---------------------------------------------------------------------------
  490. //
  491. // Interface Function Definitions
  492. //
  494. function TcRegisterClient(TciVersion: ULONG; ClRegCtx: HANDLE; const ClientHandlerList: TCI_CLIENT_FUNC_LIST; var pClientHandle: HANDLE): ULONG; stdcall;
  495. {$EXTERNALSYM TcRegisterClient}
  496. function TcEnumerateInterfaces(ClientHandle: HANDLE; var pBufferSize: ULONG; var InterfaceBuffer: TC_IFC_DESCRIPTOR): ULONG; stdcall;
  497. {$EXTERNALSYM TcEnumerateInterfaces}
  498. function TcOpenInterfaceA(pInterfaceName: LPSTR; ClientHandle, ClIfcCtx: HANDLE; var pIfcHandle: HANDLE): ULONG; stdcall;
  499. {$EXTERNALSYM TcOpenInterfaceA}
  500. function TcOpenInterfaceW(pInterfaceName: LPWSTR; ClientHandle, ClIfcCtx: HANDLE; var pIfcHandle: HANDLE): ULONG; stdcall;
  501. {$EXTERNALSYM TcOpenInterfaceW}
  502. function TcCloseInterface(IfcHandle: HANDLE): ULONG; stdcall;
  503. {$EXTERNALSYM TcCloseInterface}
  504. function TcQueryInterface(IfcHandle: HANDLE; const pGuidParam: GUID; NotifyChange: Longbool; var pBufferSize: ULONG; Buffer: PVOID): ULONG; stdcall;
  505. {$EXTERNALSYM TcQueryInterface}
  506. function TcSetInterface(IfcHandle: HANDLE; const pGuidParam: GUID; BufferSize: ULONG; Buffer: PVOID): ULONG; stdcall;
  507. {$EXTERNALSYM TcSetInterface}
  508. function TcQueryFlowA(pFlowName: LPSTR; const pGuidParam: GUID; var pBufferSize: ULONG; Buffer: PVOID): ULONG; stdcall;
  509. {$EXTERNALSYM TcQueryFlowA}
  510. function TcQueryFlowW(pFlowName: LPWSTR; const pGuidParam: GUID; var pBufferSize: ULONG; Buffer: PVOID): ULONG; stdcall;
  511. {$EXTERNALSYM TcQueryFlowW}
  512. function TcSetFlowA(pFlowName: LPSTR; const pGuidParam: GUID; BufferSize: GUID; Buffer: PVOID): ULONG; stdcall;
  513. {$EXTERNALSYM TcSetFlowA}
  514. function TcSetFlowW(pFlowName: LPWSTR; const pGuidParam: GUID; BufferSize: GUID; Buffer: PVOID): ULONG; stdcall;
  515. {$EXTERNALSYM TcSetFlowW}
  516. function TcAddFlow(IfcHandle, ClFlowCtx: HANDLE; Flags: ULONG; const pGenericFlow: TC_GEN_FLOW; var pFlowHandle: HANDLE): ULONG; stdcall;
  517. {$EXTERNALSYM TcAddFlow}
  518. function TcGetFlowNameA(FlowHandle: HANDLE; StrSize: ULONG; pFlowName: LPSTR): ULONG; stdcall;
  519. {$EXTERNALSYM TcGetFlowNameA}
  520. function TcGetFlowNameW(FlowHandle: HANDLE; StrSize: ULONG; pFlowName: LPWSTR): ULONG; stdcall;
  521. {$EXTERNALSYM TcGetFlowNameW}
  522. function TcModifyFlow(FlowHandle: HANDLE; const pGenericFlow: TC_GEN_FLOW): ULONG; stdcall;
  523. {$EXTERNALSYM TcModifyFlow}
  524. function TcAddFilter(FlowHandle: HANDLE; const pGenericFilter: TC_GEN_FILTER; var pFilterHandle: HANDLE): ULONG; stdcall;
  525. {$EXTERNALSYM TcAddFilter}
  526. function TcDeregisterClient(ClientHandle: HANDLE): ULONG; stdcall;
  527. {$EXTERNALSYM TcDeregisterClient}
  528. function TcDeleteFlow(FlowHandle: HANDLE): ULONG; stdcall;
  529. {$EXTERNALSYM TcDeleteFlow}
  530. function TcDeleteFilter(FilterHandle: HANDLE): ULONG; stdcall;
  531. {$EXTERNALSYM TcDeleteFilter}
  532. function TcEnumerateFlows(IfcHandle: HANDLE; var pEnumHandle: HANDLE; var pFlowCount, pBufSize: ULONG; var Buffer: ENUMERATION_BUFFER): ULONG; stdcall;
  533. {$EXTERNALSYM TcEnumerateFlows}
  535. {$IFDEF UNICODE}
  537. function TcOpenInterface(pInterfaceName: LPWSTR; ClientHandle, ClIfcCtx: HANDLE; var pIfcHandle: HANDLE): ULONG; stdcall;
  538. {$EXTERNALSYM TcOpenInterface}
  539. function TcQueryFlow(pFlowName: LPWSTR; const pGuidParam: GUID; var pBufferSize: ULONG; Buffer: PVOID): ULONG; stdcall;
  540. {$EXTERNALSYM TcQueryFlow}
  541. function TcSetFlow(pFlowName: LPWSTR; const pGuidParam: GUID; BufferSize: GUID; Buffer: PVOID): ULONG; stdcall;
  542. {$EXTERNALSYM TcSetFlow}
  543. function TcGetFlowName(FlowHandle: HANDLE; StrSize: ULONG; pFlowName: LPWSTR): ULONG; stdcall;
  544. {$EXTERNALSYM TcGetFlowName}
  546. {$ELSE}
  548. function TcOpenInterface(pInterfaceName: LPSTR; ClientHandle, ClIfcCtx: HANDLE; var pIfcHandle: HANDLE): ULONG; stdcall;
  549. {$EXTERNALSYM TcOpenInterface}
  550. function TcQueryFlow(pFlowName: LPSTR; const pGuidParam: GUID; var pBufferSize: ULONG; Buffer: PVOID): ULONG; stdcall;
  551. {$EXTERNALSYM TcQueryFlow}
  552. function TcSetFlow(pFlowName: LPSTR; const pGuidParam: GUID; BufferSize: GUID; Buffer: PVOID): ULONG; stdcall;
  553. {$EXTERNALSYM TcSetFlow}
  554. function TcGetFlowName(FlowHandle: HANDLE; StrSize: ULONG; pFlowName: LPSTR): ULONG; stdcall;
  555. {$EXTERNALSYM TcGetFlowName}
  557. {$ENDIF}
  559. implementation
  561. const
  562.   traffic_lib = 'traffic.dll';
  565. {$IFDEF DYNAMIC_LINK}
  566. var
  567.   _TcRegisterClient: Pointer;
  569. function TcRegisterClient;
  570. begin
  571.   GetProcedureAddress(_TcRegisterClient, traffic_lib, 'TcRegisterClient');
  572.   asm
  573.     mov esp, ebp
  574.     pop ebp
  575.     jmp [_TcRegisterClient]
  576.   end;
  577. end;
  578. {$ELSE}
  579. function TcRegisterClient; external traffic_lib name 'TcRegisterClient';
  580. {$ENDIF DYNAMIC_LINK}
  582. {$IFDEF DYNAMIC_LINK}
  583. var
  584.   _TcEnumerateInterfaces: Pointer;
  586. function TcEnumerateInterfaces;
  587. begin
  588.   GetProcedureAddress(_TcEnumerateInterfaces, traffic_lib, 'TcEnumerateInterfaces');
  589.   asm
  590.     mov esp, ebp
  591.     pop ebp
  592.     jmp [_TcEnumerateInterfaces]
  593.   end;
  594. end;
  595. {$ELSE}
  596. function TcEnumerateInterfaces; external traffic_lib name 'TcEnumerateInterfaces';
  597. {$ENDIF DYNAMIC_LINK}
  599. {$IFDEF DYNAMIC_LINK}
  600. var
  601.   _TcOpenInterfaceA: Pointer;
  603. function TcOpenInterfaceA;
  604. begin
  605.   GetProcedureAddress(_TcOpenInterfaceA, traffic_lib, 'TcOpenInterfaceA');
  606.   asm
  607.     mov esp, ebp
  608.     pop ebp
  609.     jmp [_TcOpenInterfaceA]
  610.   end;
  611. end;
  612. {$ELSE}
  613. function TcOpenInterfaceA; external traffic_lib name 'TcOpenInterfaceA';
  614. {$ENDIF DYNAMIC_LINK}
  616. {$IFDEF DYNAMIC_LINK}
  617. var
  618.   _TcOpenInterfaceW: Pointer;
  620. function TcOpenInterfaceW;
  621. begin
  622.   GetProcedureAddress(_TcOpenInterfaceW, traffic_lib, 'TcOpenInterfaceW');
  623.   asm
  624.     mov esp, ebp
  625.     pop ebp
  626.     jmp [_TcOpenInterfaceW]
  627.   end;
  628. end;
  629. {$ELSE}
  630. function TcOpenInterfaceW; external traffic_lib name 'TcOpenInterfaceW';
  631. {$ENDIF DYNAMIC_LINK}
  633. {$IFDEF DYNAMIC_LINK}
  634. var
  635.   _TcCloseInterface: Pointer;
  637. function TcCloseInterface;
  638. begin
  639.   GetProcedureAddress(_TcCloseInterface, traffic_lib, 'TcCloseInterface');
  640.   asm
  641.     mov esp, ebp
  642.     pop ebp
  643.     jmp [_TcCloseInterface]
  644.   end;
  645. end;
  646. {$ELSE}
  647. function TcCloseInterface; external traffic_lib name 'TcCloseInterface';
  648. {$ENDIF DYNAMIC_LINK}
  650. {$IFDEF DYNAMIC_LINK}
  651. var
  652.   _TcQueryInterface: Pointer;
  654. function TcQueryInterface;
  655. begin
  656.   GetProcedureAddress(_TcQueryInterface, traffic_lib, 'TcQueryInterface');
  657.   asm
  658.     mov esp, ebp
  659.     pop ebp
  660.     jmp [_TcQueryInterface]
  661.   end;
  662. end;
  663. {$ELSE}
  664. function TcQueryInterface; external traffic_lib name 'TcQueryInterface';
  665. {$ENDIF DYNAMIC_LINK}
  667. {$IFDEF DYNAMIC_LINK}
  668. var
  669.   _TcSetInterface: Pointer;
  671. function TcSetInterface;
  672. begin
  673.   GetProcedureAddress(_TcSetInterface, traffic_lib, 'TcSetInterface');
  674.   asm
  675.     mov esp, ebp
  676.     pop ebp
  677.     jmp [_TcSetInterface]
  678.   end;
  679. end;
  680. {$ELSE}
  681. function TcSetInterface; external traffic_lib name 'TcSetInterface';
  682. {$ENDIF DYNAMIC_LINK}
  684. {$IFDEF DYNAMIC_LINK}
  685. var
  686.   _TcQueryFlowA: Pointer;
  688. function TcQueryFlowA;
  689. begin
  690.   GetProcedureAddress(_TcQueryFlowA, traffic_lib, 'TcQueryFlowA');
  691.   asm
  692.     mov esp, ebp
  693.     pop ebp
  694.     jmp [_TcQueryFlowA]
  695.   end;
  696. end;
  697. {$ELSE}
  698. function TcQueryFlowA; external traffic_lib name 'TcQueryFlowA';
  699. {$ENDIF DYNAMIC_LINK}
  701. {$IFDEF DYNAMIC_LINK}
  702. var
  703.   _TcQueryFlowW: Pointer;
  705. function TcQueryFlowW;
  706. begin
  707.   GetProcedureAddress(_TcQueryFlowW, traffic_lib, 'TcQueryFlowW');
  708.   asm
  709.     mov esp, ebp
  710.     pop ebp
  711.     jmp [_TcQueryFlowW]
  712.   end;
  713. end;
  714. {$ELSE}
  715. function TcQueryFlowW; external traffic_lib name 'TcQueryFlowW';
  716. {$ENDIF DYNAMIC_LINK}
  718. {$IFDEF DYNAMIC_LINK}
  719. var
  720.   _TcSetFlowA: Pointer;
  722. function TcSetFlowA;
  723. begin
  724.   GetProcedureAddress(_TcSetFlowA, traffic_lib, 'TcSetFlowA');
  725.   asm
  726.     mov esp, ebp
  727.     pop ebp
  728.     jmp [_TcSetFlowA]
  729.   end;
  730. end;
  731. {$ELSE}
  732. function TcSetFlowA; external traffic_lib name 'TcSetFlowA';
  733. {$ENDIF DYNAMIC_LINK}
  735. {$IFDEF DYNAMIC_LINK}
  736. var
  737.   _TcSetFlowW: Pointer;
  739. function TcSetFlowW;
  740. begin
  741.   GetProcedureAddress(_TcSetFlowW, traffic_lib, 'TcSetFlowW');
  742.   asm
  743.     mov esp, ebp
  744.     pop ebp
  745.     jmp [_TcSetFlowW]
  746.   end;
  747. end;
  748. {$ELSE}
  749. function TcSetFlowW; external traffic_lib name 'TcSetFlowW';
  750. {$ENDIF DYNAMIC_LINK}
  752. {$IFDEF DYNAMIC_LINK}
  753. var
  754.   _TcAddFlow: Pointer;
  756. function TcAddFlow;
  757. begin
  758.   GetProcedureAddress(_TcAddFlow, traffic_lib, 'TcAddFlow');
  759.   asm
  760.     mov esp, ebp
  761.     pop ebp
  762.     jmp [_TcAddFlow]
  763.   end;
  764. end;
  765. {$ELSE}
  766. function TcAddFlow; external traffic_lib name 'TcAddFlow';
  767. {$ENDIF DYNAMIC_LINK}
  769. {$IFDEF DYNAMIC_LINK}
  770. var
  771.   _TcGetFlowNameA: Pointer;
  773. function TcGetFlowNameA;
  774. begin
  775.   GetProcedureAddress(_TcGetFlowNameA, traffic_lib, 'TcGetFlowNameA');
  776.   asm
  777.     mov esp, ebp
  778.     pop ebp
  779.     jmp [_TcGetFlowNameA]
  780.   end;
  781. end;
  782. {$ELSE}
  783. function TcGetFlowNameA; external traffic_lib name 'TcGetFlowNameA';
  784. {$ENDIF DYNAMIC_LINK}
  786. {$IFDEF DYNAMIC_LINK}
  787. var
  788.   _TcGetFlowNameW: Pointer;
  790. function TcGetFlowNameW;
  791. begin
  792.   GetProcedureAddress(_TcGetFlowNameW, traffic_lib, 'TcGetFlowNameW');
  793.   asm
  794.     mov esp, ebp
  795.     pop ebp
  796.     jmp [_TcGetFlowNameW]
  797.   end;
  798. end;
  799. {$ELSE}
  800. function TcGetFlowNameW; external traffic_lib name 'TcGetFlowNameW';
  801. {$ENDIF DYNAMIC_LINK}
  803. {$IFDEF DYNAMIC_LINK}
  804. var
  805.   _TcModifyFlow: Pointer;
  807. function TcModifyFlow;
  808. begin
  809.   GetProcedureAddress(_TcModifyFlow, traffic_lib, 'TcModifyFlow');
  810.   asm
  811.     mov esp, ebp
  812.     pop ebp
  813.     jmp [_TcModifyFlow]
  814.   end;
  815. end;
  816. {$ELSE}
  817. function TcModifyFlow; external traffic_lib name 'TcModifyFlow';
  818. {$ENDIF DYNAMIC_LINK}
  820. {$IFDEF DYNAMIC_LINK}
  821. var
  822.   _TcAddFilter: Pointer;
  824. function TcAddFilter;
  825. begin
  826.   GetProcedureAddress(_TcAddFilter, traffic_lib, 'TcAddFilter');
  827.   asm
  828.     mov esp, ebp
  829.     pop ebp
  830.     jmp [_TcAddFilter]
  831.   end;
  832. end;
  833. {$ELSE}
  834. function TcAddFilter; external traffic_lib name 'TcAddFilter';
  835. {$ENDIF DYNAMIC_LINK}
  837. {$IFDEF DYNAMIC_LINK}
  838. var
  839.   _TcDeregisterClient: Pointer;
  841. function TcDeregisterClient;
  842. begin
  843.   GetProcedureAddress(_TcDeregisterClient, traffic_lib, 'TcDeregisterClient');
  844.   asm
  845.     mov esp, ebp
  846.     pop ebp
  847.     jmp [_TcDeregisterClient]
  848.   end;
  849. end;
  850. {$ELSE}
  851. function TcDeregisterClient; external traffic_lib name 'TcDeregisterClient';
  852. {$ENDIF DYNAMIC_LINK}
  854. {$IFDEF DYNAMIC_LINK}
  855. var
  856.   _TcDeleteFlow: Pointer;
  858. function TcDeleteFlow;
  859. begin
  860.   GetProcedureAddress(_TcDeleteFlow, traffic_lib, 'TcDeleteFlow');
  861.   asm
  862.     mov esp, ebp
  863.     pop ebp
  864.     jmp [_TcDeleteFlow]
  865.   end;
  866. end;
  867. {$ELSE}
  868. function TcDeleteFlow; external traffic_lib name 'TcDeleteFlow';
  869. {$ENDIF DYNAMIC_LINK}
  871. {$IFDEF DYNAMIC_LINK}
  872. var
  873.   _TcDeleteFilter: Pointer;
  875. function TcDeleteFilter;
  876. begin
  877.   GetProcedureAddress(_TcDeleteFilter, traffic_lib, 'TcDeleteFilter');
  878.   asm
  879.     mov esp, ebp
  880.     pop ebp
  881.     jmp [_TcDeleteFilter]
  882.   end;
  883. end;
  884. {$ELSE}
  885. function TcDeleteFilter; external traffic_lib name 'TcDeleteFilter';
  886. {$ENDIF DYNAMIC_LINK}
  888. {$IFDEF DYNAMIC_LINK}
  889. var
  890.   _TcEnumerateFlows: Pointer;
  892. function TcEnumerateFlows;
  893. begin
  894.   GetProcedureAddress(_TcEnumerateFlows, traffic_lib, 'TcEnumerateFlows');
  895.   asm
  896.     mov esp, ebp
  897.     pop ebp
  898.     jmp [_TcEnumerateFlows]
  899.   end;
  900. end;
  901. {$ELSE}
  902. function TcEnumerateFlows; external traffic_lib name 'TcEnumerateFlows';
  903. {$ENDIF DYNAMIC_LINK}
  905. {$IFDEF UNICODE}
  908. {$IFDEF DYNAMIC_LINK}
  909. var
  910.   _TcOpenInterface: Pointer;
  912. function TcOpenInterface;
  913. begin
  914.   GetProcedureAddress(_TcOpenInterface, traffic_lib, 'TcOpenInterfaceW');
  915.   asm
  916.     mov esp, ebp
  917.     pop ebp
  918.     jmp [_TcOpenInterface]
  919.   end;
  920. end;
  921. {$ELSE}
  922. function TcOpenInterface; external traffic_lib name 'TcOpenInterfaceW';
  923. {$ENDIF DYNAMIC_LINK}
  925. {$IFDEF DYNAMIC_LINK}
  926. var
  927.   _TcQueryFlow: Pointer;
  929. function TcQueryFlow;
  930. begin
  931.   GetProcedureAddress(_TcQueryFlow, traffic_lib, 'TcQueryFlowW');
  932.   asm
  933.     mov esp, ebp
  934.     pop ebp
  935.     jmp [_TcQueryFlow]
  936.   end;
  937. end;
  938. {$ELSE}
  939. function TcQueryFlow; external traffic_lib name 'TcQueryFlowW';
  940. {$ENDIF DYNAMIC_LINK}
  942. {$IFDEF DYNAMIC_LINK}
  943. var
  944.   _TcSetFlow: Pointer;
  946. function TcSetFlow;
  947. begin
  948.   GetProcedureAddress(_TcSetFlow, traffic_lib, 'TcSetFlowW');
  949.   asm
  950.     mov esp, ebp
  951.     pop ebp
  952.     jmp [_TcSetFlow]
  953.   end;
  954. end;
  955. {$ELSE}
  956. function TcSetFlow; external traffic_lib name 'TcSetFlowW';
  957. {$ENDIF DYNAMIC_LINK}
  959. {$IFDEF DYNAMIC_LINK}
  960. var
  961.   _TcGetFlowName: Pointer;
  963. function TcGetFlowName;
  964. begin
  965.   GetProcedureAddress(_TcGetFlowName, traffic_lib, 'TcGetFlowNameW');
  966.   asm
  967.     mov esp, ebp
  968.     pop ebp
  969.     jmp [_TcGetFlowName]
  970.   end;
  971. end;
  972. {$ELSE}
  973. function TcGetFlowName; external traffic_lib name 'TcGetFlowNameW';
  974. {$ENDIF DYNAMIC_LINK}
  976. {$ELSE}
  979. {$IFDEF DYNAMIC_LINK}
  980. var
  981.   _TcOpenInterface: Pointer;
  983. function TcOpenInterface;
  984. begin
  985.   GetProcedureAddress(_TcOpenInterface, traffic_lib, 'TcOpenInterfaceA');
  986.   asm
  987.     mov esp, ebp
  988.     pop ebp
  989.     jmp [_TcOpenInterface]
  990.   end;
  991. end;
  992. {$ELSE}
  993. function TcOpenInterface; external traffic_lib name 'TcOpenInterfaceA';
  994. {$ENDIF DYNAMIC_LINK}
  996. {$IFDEF DYNAMIC_LINK}
  997. var
  998.   _TcQueryFlow: Pointer;
  1000. function TcQueryFlow;
  1001. begin
  1002.   GetProcedureAddress(_TcQueryFlow, traffic_lib, 'TcQueryFlowA');
  1003.   asm
  1004.     mov esp, ebp
  1005.     pop ebp
  1006.     jmp [_TcQueryFlow]
  1007.   end;
  1008. end;
  1009. {$ELSE}
  1010. function TcQueryFlow; external traffic_lib name 'TcQueryFlowA';
  1011. {$ENDIF DYNAMIC_LINK}
  1013. {$IFDEF DYNAMIC_LINK}
  1014. var
  1015.   _TcSetFlow: Pointer;
  1017. function TcSetFlow;
  1018. begin
  1019.   GetProcedureAddress(_TcSetFlow, traffic_lib, 'TcSetFlowA');
  1020.   asm
  1021.     mov esp, ebp
  1022.     pop ebp
  1023.     jmp [_TcSetFlow]
  1024.   end;
  1025. end;
  1026. {$ELSE}
  1027. function TcSetFlow; external traffic_lib name 'TcSetFlowA';
  1028. {$ENDIF DYNAMIC_LINK}
  1030. {$IFDEF DYNAMIC_LINK}
  1031. var
  1032.   _TcGetFlowName: Pointer;
  1034. function TcGetFlowName;
  1035. begin
  1036.   GetProcedureAddress(_TcGetFlowName, traffic_lib, 'TcGetFlowNameA');
  1037.   asm
  1038.     mov esp, ebp
  1039.     pop ebp
  1040.     jmp [_TcGetFlowName]
  1041.   end;
  1042. end;
  1043. {$ELSE}
  1044. function TcGetFlowName; external traffic_lib name 'TcGetFlowNameA';
  1045. {$ENDIF DYNAMIC_LINK}
  1047. {$ENDIF}
  1049. end.