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

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

Windows编程

开发平台：

Delphi

JwaIpHlpApi.pas：源码内容
  1. {******************************************************************************}
  2. {                                                                       }
  3. { Internet Protocol Helper 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: iphlpapi.h, released August 2000. The original Pascal  }
  9. { code is: IpHlpApi.pas, released September 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. { Contributor(s): John C. Penman (jcp@craiglockhart.com)                       }
  16. {                 Vladimir Vassiliev (voldemarv@hotpop.com)                    }
  17. {                 }
  18. { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
  19. {                }
  20. { You may retrieve the latest version of this file at the Project JEDI home    }
  21. { page, located at http://delphi-jedi.org or my personal homepage located at   }
  22. { http://members.chello.nl/m.vanbrakel2                                        }
  23. {                }
  24. { The contents of this file are used with permission, subject to the Mozilla   }
  25. { Public License Version 1.1 (the "License"); you may not use this file except }
  26. { in compliance with the License. You may obtain a copy of the License at      }
  27. { http://www.mozilla.org/MPL/MPL-1.1.html                                      }
  28. {                                                                              }
  29. { Software distributed under the License is distributed on an "AS IS" basis,   }
  30. { WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
  31. { the specific language governing rights and limitations under the License.    }
  32. {                                                                              }
  33. { Alternatively, the contents of this file may be used under the terms of the  }
  34. { GNU Lesser General Public License (the  "LGPL License"), in which case the   }
  35. { provisions of the LGPL License are applicable instead of those above.        }
  36. { If you wish to allow use of your version of this file only under the terms   }
  37. { of the LGPL License and not to allow others to use your version of this file }
  38. { under the MPL, indicate your decision by deleting  the provisions above and  }
  39. { replace  them with the notice and other provisions required by the LGPL      }
  40. { License.  If you do not delete the provisions above, a recipient may use     }
  41. { your version of this file under either the MPL or the LGPL License.          }
  42. {                 }
  43. { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
  44. {                 }
  45. {******************************************************************************}
  47. unit JwaIpHlpApi;
  49. {$WEAKPACKAGEUNIT}
  51. {$HPPEMIT ''}
  52. {$HPPEMIT '#include "iphlpapi.h"'}
  53. {$HPPEMIT ''}
  55. {$I WINDEFINES.INC}
  57. interface
  59. uses
  60.   JwaIpExport, JwaIpRtrMib, JwaIpTypes, JwaWinType, JwaWinBase, JwaWinSock;
  62. //////////////////////////////////////////////////////////////////////////////
  63. //                                                                          //
  64. // IPRTRMIB.H has the definitions of the strcutures used to set and get     //
  65. // information                                                              //
  66. //                                                                          //
  67. //////////////////////////////////////////////////////////////////////////////
  69. // #include <iprtrmib.h>
  70. // #include <ipexport.h>
  71. // #include <iptypes.h>
  73. //////////////////////////////////////////////////////////////////////////////
  74. //                                                                          //
  75. // The GetXXXTable APIs take a buffer and a size of buffer.  If the buffer  //
  76. // is not large enough, the APIs return ERROR_INSUFFICIENT_BUFFER  and      //
  77. // *pdwSize is the required buffer size                                     //
  78. // The bOrder is a BOOLEAN, which if TRUE sorts the table according to      //
  79. // MIB-II (RFC XXXX)                                                        //
  80. //                                                                          //
  81. //////////////////////////////////////////////////////////////////////////////
  84. //////////////////////////////////////////////////////////////////////////////
  85. //                                                                          //
  86. // Retrieves the number of interfaces in the system. These include LAN and  //
  87. // WAN interfaces                                                           //
  88. //                                                                          //
  89. //////////////////////////////////////////////////////////////////////////////
  91. function GetNumberOfInterfaces(var pdwNumIf: DWORD): DWORD; stdcall;
  92. {$EXTERNALSYM GetNumberOfInterfaces}
  94. //////////////////////////////////////////////////////////////////////////////
  95. //                                                                          //
  96. // Gets the MIB-II ifEntry                                                  //
  97. // The dwIndex field of the MIB_IFROW should be set to the index of the     //
  98. // interface being queried                                                  //
  99. //                                                                          //
  100. //////////////////////////////////////////////////////////////////////////////
  102. function GetIfEntry(pIfRow: PMIB_IFROW): DWORD; stdcall;
  103. {$EXTERNALSYM GetIfEntry}
  105. //////////////////////////////////////////////////////////////////////////////
  106. //                                                                          //
  107. // Gets the MIB-II IfTable                                                  //
  108. //                                                                          //
  109. //////////////////////////////////////////////////////////////////////////////
  111. function GetIfTable(pIfTable: PMIB_IFTABLE; var pdwSize: ULONG; bOrder: BOOL): DWORD; stdcall;
  112. {$EXTERNALSYM GetIfTable}
  114. //////////////////////////////////////////////////////////////////////////////
  115. //                                                                          //
  116. // Gets the Interface to IP Address mapping                                 //
  117. //                                                                          //
  118. //////////////////////////////////////////////////////////////////////////////
  120. function GetIpAddrTable(pIpAddrTable: PMIB_IPADDRTABLE; var pdwSize: ULONG; bOrder: BOOL): DWORD; stdcall;
  121. {$EXTERNALSYM GetIpAddrTable}
  123. //////////////////////////////////////////////////////////////////////////////
  124. //                                                                          //
  125. // Gets the current IP Address to Physical Address (ARP) mapping            //
  126. //                                                                          //
  127. //////////////////////////////////////////////////////////////////////////////
  129. function GetIpNetTable(pIpNetTable: PMIB_IPNETTABLE; var pdwSize: ULONG; bOrder: BOOL): DWORD; stdcall;
  130. {$EXTERNALSYM GetIpNetTable}
  132. //////////////////////////////////////////////////////////////////////////////
  133. //                                                                          //
  134. // Gets the IP Routing Table  (RFX XXXX)                                    //
  135. //                                                                          //
  136. //////////////////////////////////////////////////////////////////////////////
  138. function GetIpForwardTable(pIpForwardTable: PMIB_IPFORWARDTABLE; var pdwSize: ULONG;
  139.   bOrder: BOOL): DWORD; stdcall;
  140. {$EXTERNALSYM GetIpForwardTable}
  142. //////////////////////////////////////////////////////////////////////////////
  143. //                                                                          //
  144. // Gets TCP Connection/UDP Listener Table                                   //
  145. //                                                                          //
  146. //////////////////////////////////////////////////////////////////////////////
  148. function GetTcpTable(pTcpTable: PMIB_TCPTABLE; var pdwSize: DWORD; bOrder: BOOL): DWORD; stdcall;
  149. {$EXTERNALSYM GetTcpTable}
  151. function GetUdpTable(pUdpTable: PMIB_UDPTABLE; var pdwSize: DWORD; bOrder: BOOL): DWORD; stdcall;
  152. {$EXTERNALSYM GetUdpTable}
  154. //////////////////////////////////////////////////////////////////////////////
  155. //                                                                          //
  156. // Gets IP/ICMP/TCP/UDP Statistics                                          //
  157. //                                                                          //
  158. //////////////////////////////////////////////////////////////////////////////
  160. function GetIpStatistics(var pStats: MIB_IPSTATS): DWORD; stdcall;
  161. {$EXTERNALSYM GetIpStatistics}
  163. function GetIpStatisticsEx(pStats: PMIB_IPSTATS; dwFamily: DWORD): DWORD; stdcall;
  164. {$EXTERNALSYM GetIpStatisticsEx}
  166. function GetIcmpStatistics(var pStats: MIB_ICMP): DWORD; stdcall;
  167. {$EXTERNALSYM GetIcmpStatistics}
  169. function GetIcmpStatisticsEx(pStats: PMIB_ICMP_EX; dwFamily: DWORD): DWORD; stdcall;
  170. {$EXTERNALSYM GetIcmpStatisticsEx}
  172. function GetTcpStatistics(var pStats: MIB_TCPSTATS): DWORD; stdcall;
  173. {$EXTERNALSYM GetTcpStatistics}
  175. function GetTcpStatisticsEx(pStats: PMIB_TCPSTATS; dwFamily: DWORD): DWORD; stdcall;
  176. {$EXTERNALSYM GetTcpStatisticsEx}
  178. function GetUdpStatistics(var pStats: MIB_UDPSTATS): DWORD; stdcall;
  179. {$EXTERNALSYM GetUdpStatistics}
  181. function GetUdpStatisticsEx(pStats: PMIB_UDPSTATS; dwFamily: DWORD): DWORD; stdcall;
  182. {$EXTERNALSYM GetUdpStatisticsEx}
  184. //////////////////////////////////////////////////////////////////////////////
  185. //                                                                          //
  186. // Used to set the ifAdminStatus on an interface.  The only fields of the   //
  187. // MIB_IFROW that are relevant are the dwIndex (index of the interface      //
  188. // whose status needs to be set) and the dwAdminStatus which can be either  //
  189. // MIB_IF_ADMIN_STATUS_UP or MIB_IF_ADMIN_STATUS_DOWN                       //
  190. //                                                                          //
  191. //////////////////////////////////////////////////////////////////////////////
  193. function SetIfEntry(const pIfRow: MIB_IFROW): DWORD; stdcall;
  194. {$EXTERNALSYM SetIfEntry}
  196. //////////////////////////////////////////////////////////////////////////////
  197. //                                                                          //
  198. // Used to create, modify or delete a route.  In all cases the              //
  199. // dwForwardIfIndex, dwForwardDest, dwForwardMask, dwForwardNextHop and     //
  200. // dwForwardPolicy MUST BE SPECIFIED. Currently dwForwardPolicy is unused   //
  201. // and MUST BE 0.                                                           //
  202. // For a set, the complete MIB_IPFORWARDROW structure must be specified     //
  203. //                                                                          //
  204. //////////////////////////////////////////////////////////////////////////////
  206. function CreateIpForwardEntry(const pRoute: MIB_IPFORWARDROW): DWORD; stdcall;
  207. {$EXTERNALSYM CreateIpForwardEntry}
  209. function SetIpForwardEntry(const pRoute: MIB_IPFORWARDROW): DWORD; stdcall;
  210. {$EXTERNALSYM SetIpForwardEntry}
  212. function DeleteIpForwardEntry(const pRoute: MIB_IPFORWARDROW): DWORD; stdcall;
  213. {$EXTERNALSYM DeleteIpForwardEntry}
  215. //////////////////////////////////////////////////////////////////////////////
  216. //                                                                          //
  217. // Used to set the ipForwarding to ON or OFF (currently only ON->OFF is     //
  218. // allowed) and to set the defaultTTL.  If only one of the fields needs to  //
  219. // be modified and the other needs to be the same as before the other field //
  220. // needs to be set to MIB_USE_CURRENT_TTL or MIB_USE_CURRENT_FORWARDING as  //
  221. // the case may be                                                          //
  222. //                                                                          //
  223. //////////////////////////////////////////////////////////////////////////////
  225. function SetIpStatistics(const pIpStats: MIB_IPSTATS): DWORD; stdcall;
  226. {$EXTERNALSYM SetIpStatistics}
  228. //////////////////////////////////////////////////////////////////////////////
  229. //                                                                          //
  230. // Used to set the defaultTTL.                                              //
  231. //                                                                          //
  232. //////////////////////////////////////////////////////////////////////////////
  234. function SetIpTTL(nTTL: UINT): DWORD; stdcall;
  235. {$EXTERNALSYM SetIpTTL}
  237. //////////////////////////////////////////////////////////////////////////////
  238. //                                                                          //
  239. // Used to create, modify or delete an ARP entry.  In all cases the dwIndex //
  240. // dwAddr field MUST BE SPECIFIED.                                          //
  241. // For a set, the complete MIB_IPNETROW structure must be specified         //
  242. //                                                                          //
  243. //////////////////////////////////////////////////////////////////////////////
  245. function CreateIpNetEntry(const pArpEntry: MIB_IPNETROW): DWORD; stdcall;
  246. {$EXTERNALSYM CreateIpNetEntry}
  248. function SetIpNetEntry(const pArpEntry: MIB_IPNETROW): DWORD; stdcall;
  249. {$EXTERNALSYM SetIpNetEntry}
  251. function DeleteIpNetEntry(const pArpEntry: MIB_IPNETROW): DWORD; stdcall;
  252. {$EXTERNALSYM DeleteIpNetEntry}
  254. function FlushIpNetTable(dwIfIndex: DWORD): DWORD; stdcall;
  255. {$EXTERNALSYM FlushIpNetTable}
  257. //////////////////////////////////////////////////////////////////////////////
  258. //                                                                          //
  259. // Used to create or delete a Proxy ARP entry. The dwIndex is the index of  //
  260. // the interface on which to PARP for the dwAddress.  If the interface is   //
  261. // of a type that doesnt support ARP, e.g. PPP, then the call will fail     //
  262. //                                                                          //
  263. //////////////////////////////////////////////////////////////////////////////
  265. function CreateProxyArpEntry(dwAddress, dwMask, dwIfIndex: DWORD): DWORD; stdcall;
  266. {$EXTERNALSYM CreateProxyArpEntry}
  268. function DeleteProxyArpEntry(dwAddress, dwMask, dwIfIndex: DWORD): DWORD; stdcall;
  269. {$EXTERNALSYM DeleteProxyArpEntry}
  271. //////////////////////////////////////////////////////////////////////////////
  272. //                                                                          //
  273. // Used to set the state of a TCP Connection. The only state that it can be //
  274. // set to is MIB_TCP_STATE_DELETE_TCB.  The complete MIB_TCPROW structure   //
  275. // MUST BE SPECIFIED                                                        //
  276. //                                                                          //
  277. //////////////////////////////////////////////////////////////////////////////
  279. function SetTcpEntry(const pTcpRow: MIB_TCPROW): DWORD; stdcall;
  280. {$EXTERNALSYM SetTcpEntry}
  282. function GetInterfaceInfo(pIfTable: PIP_INTERFACE_INFO; var dwOutBufLen: ULONG): DWORD; stdcall;
  283. {$EXTERNALSYM GetInterfaceInfo}
  285. function GetUniDirectionalAdapterInfo(pIPIfInfo: PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS;
  286.   var dwOutBufLen: ULONG): DWORD; stdcall;
  287. {$EXTERNALSYM GetUniDirectionalAdapterInfo(OUT PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo}
  289. //////////////////////////////////////////////////////////////////////////////
  290. //                                                                          //
  291. // Gets the "best" outgoing interface for the specified destination address //
  292. //                                                                          //
  293. //////////////////////////////////////////////////////////////////////////////
  295. function GetBestInterface(dwDestAddr: IPAddr; var pdwBestIfIndex: DWORD): DWORD; stdcall;
  296. {$EXTERNALSYM GetBestInterface}
  298. function GetBestInterfaceEx(pDestAddr: PSockAddr; var pdwBestIfIndex: DWORD): DWORD; stdcall;
  299. {$EXTERNALSYM GetBestInterfaceEx}
  301. //////////////////////////////////////////////////////////////////////////////
  302. //                                                                          //
  303. // Gets the best (longest matching prefix) route for the given destination  //
  304. // If the source address is also specified (i.e. is not 0x00000000), and    //
  305. // there are multiple "best" routes to the given destination, the returned  //
  306. // route will be one that goes out over the interface which has an address  //
  307. // that matches the source address                                          //
  308. //                                                                          //
  309. //////////////////////////////////////////////////////////////////////////////
  311. function GetBestRoute(dwDestAddr, dwSourceAddr: DWORD; pBestRoute: PMIB_IPFORWARDROW): DWORD; stdcall;
  312. {$EXTERNALSYM GetBestRoute}
  314. function NotifyAddrChange(var Handle: THandle; overlapped: POVERLAPPED): DWORD; stdcall;
  315. {$EXTERNALSYM NotifyAddrChange}
  317. function NotifyRouteChange(var Handle: THandle; overlapped: POVERLAPPED): DWORD; stdcall;
  318. {$EXTERNALSYM NotifyRouteChange}
  320. function GetAdapterIndex(AdapterName: LPWSTR; var IfIndex: ULONG): DWORD; stdcall;
  321. {$EXTERNALSYM GetAdapterIndex}
  323. function AddIPAddress(Address: IPAddr; IpMask: IPMask; IfIndex: DWORD;
  324.   var NTEContext, NTEInstance: ULONG): DWORD; stdcall;
  325. {$EXTERNALSYM AddIPAddress}
  327. function DeleteIPAddress(NTEContext: ULONG): DWORD; stdcall;
  328. {$EXTERNALSYM DeleteIPAddress}
  330. function GetNetworkParams(pFixedInfo: PFIXED_INFO; var pOutBufLen: ULONG): DWORD; stdcall;
  331. {$EXTERNALSYM GetNetworkParams}
  333. function GetAdaptersInfo(pAdapterInfo: PIP_ADAPTER_INFO; var pOutBufLen: ULONG): DWORD; stdcall;
  334. {$EXTERNALSYM GetAdaptersInfo}
  336. //
  337. // The following functions require Winsock2.
  338. //
  340. function GetAdaptersAddresses(Family: ULONG; Flags: DWORD; Reserved: PVOID;
  341.   pAdapterAddresses: PIP_ADAPTER_ADDRESSES; pOutBufLen: PULONG): DWORD; stdcall;
  342. {$EXTERNALSYM GetAdaptersAddresses}
  344. function GetPerAdapterInfo(IfIndex: ULONG; pPerAdapterInfo: PIP_PER_ADAPTER_INFO;
  345.   var pOutBufLen: ULONG): DWORD; stdcall;
  346. {$EXTERNALSYM GetPerAdapterInfo}
  348. function IpReleaseAddress(const AdapterInfo: IP_ADAPTER_INDEX_MAP): DWORD; stdcall;
  349. {$EXTERNALSYM IpReleaseAddress}
  351. function IpRenewAddress(const AdapterInfo: IP_ADAPTER_INDEX_MAP): DWORD; stdcall;
  352. {$EXTERNALSYM IpRenewAddress}
  354. function SendARP(const DestIP, SrcIP: IPAddr; pMacAddr: PULONG; var PhyAddrLen: ULONG): DWORD; stdcall;
  355. {$EXTERNALSYM SendARP}
  357. function GetRTTAndHopCount(DestIpAddress: IPAddr; var HopCount: ULONG;
  358.   MaxHops: ULONG; var RTT: ULONG): BOOL; stdcall;
  359. {$EXTERNALSYM GetRTTAndHopCount}
  361. function GetFriendlyIfIndex(IfIndex: DWORD): DWORD; stdcall;
  362. {$EXTERNALSYM GetFriendlyIfIndex}
  364. function EnableRouter(var pHandle: THandle; pOverlapped: POVERLAPPED): DWORD; stdcall;
  365. {$EXTERNALSYM EnableRouter}
  367. function UnenableRouter(pOverlapped: POVERLAPPED; lpdwEnableCount: LPDWORD): DWORD; stdcall;
  368. {$EXTERNALSYM UnenableRouter}
  370. function DisableMediaSense(var pHandle: HANDLE; pOverLapped: POVERLAPPED): DWORD; stdcall;
  371. {$EXTERNALSYM DisableMediaSense}
  373. function RestoreMediaSense(pOverlapped: POVERLAPPED; lpdwEnableCount: LPDWORD): DWORD; stdcall;
  374. {$EXTERNALSYM RestoreMediaSense}
  376. function GetIpErrorString(ErrorCode: IP_STATUS; Buffer: PWCHAR; var Size: DWORD): DWORD; stdcall;
  377. {$EXTERNALSYM GetIpErrorString}
  379. implementation
  381. const
  382.   iphlpapilib = 'iphlpapi.dll';
  385. {$IFDEF DYNAMIC_LINK}
  386. var
  387.   _GetNumberOfInterfaces: Pointer;
  389. function GetNumberOfInterfaces;
  390. begin
  391.   GetProcedureAddress(_GetNumberOfInterfaces, iphlpapilib, 'GetNumberOfInterfaces');
  392.   asm
  393.     mov esp, ebp
  394.     pop ebp
  395.     jmp [_GetNumberOfInterfaces]
  396.   end;
  397. end;
  398. {$ELSE}
  399. function GetNumberOfInterfaces; external iphlpapilib name 'GetNumberOfInterfaces';
  400. {$ENDIF DYNAMIC_LINK}
  402. {$IFDEF DYNAMIC_LINK}
  403. var
  404.   _GetIfEntry: Pointer;
  406. function GetIfEntry;
  407. begin
  408.   GetProcedureAddress(_GetIfEntry, iphlpapilib, 'GetIfEntry');
  409.   asm
  410.     mov esp, ebp
  411.     pop ebp
  412.     jmp [_GetIfEntry]
  413.   end;
  414. end;
  415. {$ELSE}
  416. function GetIfEntry; external iphlpapilib name 'GetIfEntry';
  417. {$ENDIF DYNAMIC_LINK}
  419. {$IFDEF DYNAMIC_LINK}
  420. var
  421.   _GetIfTable: Pointer;
  423. function GetIfTable;
  424. begin
  425.   GetProcedureAddress(_GetIfTable, iphlpapilib, 'GetIfTable');
  426.   asm
  427.     mov esp, ebp
  428.     pop ebp
  429.     jmp [_GetIfTable]
  430.   end;
  431. end;
  432. {$ELSE}
  433. function GetIfTable; external iphlpapilib name 'GetIfTable';
  434. {$ENDIF DYNAMIC_LINK}
  436. {$IFDEF DYNAMIC_LINK}
  437. var
  438.   _GetIpAddrTable: Pointer;
  440. function GetIpAddrTable;
  441. begin
  442.   GetProcedureAddress(_GetIpAddrTable, iphlpapilib, 'GetIpAddrTable');
  443.   asm
  444.     mov esp, ebp
  445.     pop ebp
  446.     jmp [_GetIpAddrTable]
  447.   end;
  448. end;
  449. {$ELSE}
  450. function GetIpAddrTable; external iphlpapilib name 'GetIpAddrTable';
  451. {$ENDIF DYNAMIC_LINK}
  453. {$IFDEF DYNAMIC_LINK}
  454. var
  455.   _GetIpNetTable: Pointer;
  457. function GetIpNetTable;
  458. begin
  459.   GetProcedureAddress(_GetIpNetTable, iphlpapilib, 'GetIpNetTable');
  460.   asm
  461.     mov esp, ebp
  462.     pop ebp
  463.     jmp [_GetIpNetTable]
  464.   end;
  465. end;
  466. {$ELSE}
  467. function GetIpNetTable; external iphlpapilib name 'GetIpNetTable';
  468. {$ENDIF DYNAMIC_LINK}
  470. {$IFDEF DYNAMIC_LINK}
  471. var
  472.   _GetIpForwardTable: Pointer;
  474. function GetIpForwardTable;
  475. begin
  476.   GetProcedureAddress(_GetIpForwardTable, iphlpapilib, 'GetIpForwardTable');
  477.   asm
  478.     mov esp, ebp
  479.     pop ebp
  480.     jmp [_GetIpForwardTable]
  481.   end;
  482. end;
  483. {$ELSE}
  484. function GetIpForwardTable; external iphlpapilib name 'GetIpForwardTable';
  485. {$ENDIF DYNAMIC_LINK}
  487. {$IFDEF DYNAMIC_LINK}
  488. var
  489.   _GetTcpTable: Pointer;
  491. function GetTcpTable;
  492. begin
  493.   GetProcedureAddress(_GetTcpTable, iphlpapilib, 'GetTcpTable');
  494.   asm
  495.     mov esp, ebp
  496.     pop ebp
  497.     jmp [_GetTcpTable]
  498.   end;
  499. end;
  500. {$ELSE}
  501. function GetTcpTable; external iphlpapilib name 'GetTcpTable';
  502. {$ENDIF DYNAMIC_LINK}
  504. {$IFDEF DYNAMIC_LINK}
  505. var
  506.   _GetUdpTable: Pointer;
  508. function GetUdpTable;
  509. begin
  510.   GetProcedureAddress(_GetUdpTable, iphlpapilib, 'GetUdpTable');
  511.   asm
  512.     mov esp, ebp
  513.     pop ebp
  514.     jmp [_GetUdpTable]
  515.   end;
  516. end;
  517. {$ELSE}
  518. function GetUdpTable; external iphlpapilib name 'GetUdpTable';
  519. {$ENDIF DYNAMIC_LINK}
  521. {$IFDEF DYNAMIC_LINK}
  522. var
  523.   _GetIpStatistics: Pointer;
  525. function GetIpStatistics;
  526. begin
  527.   GetProcedureAddress(_GetIpStatistics, iphlpapilib, 'GetIpStatistics');
  528.   asm
  529.     mov esp, ebp
  530.     pop ebp
  531.     jmp [_GetIpStatistics]
  532.   end;
  533. end;
  534. {$ELSE}
  535. function GetIpStatistics; external iphlpapilib name 'GetIpStatistics';
  536. {$ENDIF DYNAMIC_LINK}
  538. {$IFDEF DYNAMIC_LINK}
  539. var
  540.   _GetIpStatisticsEx: Pointer;
  542. function GetIpStatisticsEx;
  543. begin
  544.   GetProcedureAddress(_GetIpStatisticsEx, iphlpapilib, 'GetIpStatisticsEx');
  545.   asm
  546.     mov esp, ebp
  547.     pop ebp
  548.     jmp [_GetIpStatisticsEx]
  549.   end;
  550. end;
  551. {$ELSE}
  552. function GetIpStatisticsEx; external iphlpapilib name 'GetIpStatisticsEx';
  553. {$ENDIF DYNAMIC_LINK}
  555. {$IFDEF DYNAMIC_LINK}
  556. var
  557.   _GetIcmpStatistics: Pointer;
  559. function GetIcmpStatistics;
  560. begin
  561.   GetProcedureAddress(_GetIcmpStatistics, iphlpapilib, 'GetIcmpStatistics');
  562.   asm
  563.     mov esp, ebp
  564.     pop ebp
  565.     jmp [_GetIcmpStatistics]
  566.   end;
  567. end;
  568. {$ELSE}
  569. function GetIcmpStatistics; external iphlpapilib name 'GetIcmpStatistics';
  570. {$ENDIF DYNAMIC_LINK}
  572. {$IFDEF DYNAMIC_LINK}
  573. var
  574.   _GetIcmpStatisticsEx: Pointer;
  576. function GetIcmpStatisticsEx;
  577. begin
  578.   GetProcedureAddress(_GetIcmpStatisticsEx, iphlpapilib, 'GetIcmpStatisticsEx');
  579.   asm
  580.     mov esp, ebp
  581.     pop ebp
  582.     jmp [_GetIcmpStatisticsEx]
  583.   end;
  584. end;
  585. {$ELSE}
  586. function GetIcmpStatisticsEx; external iphlpapilib name 'GetIcmpStatisticsEx';
  587. {$ENDIF DYNAMIC_LINK}
  589. {$IFDEF DYNAMIC_LINK}
  590. var
  591.   _GetTcpStatistics: Pointer;
  593. function GetTcpStatistics;
  594. begin
  595.   GetProcedureAddress(_GetTcpStatistics, iphlpapilib, 'GetTcpStatistics');
  596.   asm
  597.     mov esp, ebp
  598.     pop ebp
  599.     jmp [_GetTcpStatistics]
  600.   end;
  601. end;
  602. {$ELSE}
  603. function GetTcpStatistics; external iphlpapilib name 'GetTcpStatistics';
  604. {$ENDIF DYNAMIC_LINK}
  606. {$IFDEF DYNAMIC_LINK}
  607. var
  608.   _GetTcpStatisticsEx: Pointer;
  610. function GetTcpStatisticsEx;
  611. begin
  612.   GetProcedureAddress(_GetTcpStatisticsEx, iphlpapilib, 'GetTcpStatisticsEx');
  613.   asm
  614.     mov esp, ebp
  615.     pop ebp
  616.     jmp [_GetTcpStatisticsEx]
  617.   end;
  618. end;
  619. {$ELSE}
  620. function GetTcpStatisticsEx; external iphlpapilib name 'GetTcpStatisticsEx';
  621. {$ENDIF DYNAMIC_LINK}
  623. {$IFDEF DYNAMIC_LINK}
  624. var
  625.   _GetUdpStatistics: Pointer;
  627. function GetUdpStatistics;
  628. begin
  629.   GetProcedureAddress(_GetUdpStatistics, iphlpapilib, 'GetUdpStatistics');
  630.   asm
  631.     mov esp, ebp
  632.     pop ebp
  633.     jmp [_GetUdpStatistics]
  634.   end;
  635. end;
  636. {$ELSE}
  637. function GetUdpStatistics; external iphlpapilib name 'GetUdpStatistics';
  638. {$ENDIF DYNAMIC_LINK}
  640. {$IFDEF DYNAMIC_LINK}
  641. var
  642.   _GetUdpStatisticsEx: Pointer;
  644. function GetUdpStatisticsEx;
  645. begin
  646.   GetProcedureAddress(_GetUdpStatisticsEx, iphlpapilib, 'GetUdpStatisticsEx');
  647.   asm
  648.     mov esp, ebp
  649.     pop ebp
  650.     jmp [_GetUdpStatisticsEx]
  651.   end;
  652. end;
  653. {$ELSE}
  654. function GetUdpStatisticsEx; external iphlpapilib name 'GetUdpStatisticsEx';
  655. {$ENDIF DYNAMIC_LINK}
  657. {$IFDEF DYNAMIC_LINK}
  658. var
  659.   _SetIfEntry: Pointer;
  661. function SetIfEntry;
  662. begin
  663.   GetProcedureAddress(_SetIfEntry, iphlpapilib, 'SetIfEntry');
  664.   asm
  665.     mov esp, ebp
  666.     pop ebp
  667.     jmp [_SetIfEntry]
  668.   end;
  669. end;
  670. {$ELSE}
  671. function SetIfEntry; external iphlpapilib name 'SetIfEntry';
  672. {$ENDIF DYNAMIC_LINK}
  674. {$IFDEF DYNAMIC_LINK}
  675. var
  676.   _CreateIpForwardEntry: Pointer;
  678. function CreateIpForwardEntry;
  679. begin
  680.   GetProcedureAddress(_CreateIpForwardEntry, iphlpapilib, 'CreateIpForwardEntry');
  681.   asm
  682.     mov esp, ebp
  683.     pop ebp
  684.     jmp [_CreateIpForwardEntry]
  685.   end;
  686. end;
  687. {$ELSE}
  688. function CreateIpForwardEntry; external iphlpapilib name 'CreateIpForwardEntry';
  689. {$ENDIF DYNAMIC_LINK}
  691. {$IFDEF DYNAMIC_LINK}
  692. var
  693.   _SetIpForwardEntry: Pointer;
  695. function SetIpForwardEntry;
  696. begin
  697.   GetProcedureAddress(_SetIpForwardEntry, iphlpapilib, 'SetIpForwardEntry');
  698.   asm
  699.     mov esp, ebp
  700.     pop ebp
  701.     jmp [_SetIpForwardEntry]
  702.   end;
  703. end;
  704. {$ELSE}
  705. function SetIpForwardEntry; external iphlpapilib name 'SetIpForwardEntry';
  706. {$ENDIF DYNAMIC_LINK}
  708. {$IFDEF DYNAMIC_LINK}
  709. var
  710.   _DeleteIpForwardEntry: Pointer;
  712. function DeleteIpForwardEntry;
  713. begin
  714.   GetProcedureAddress(_DeleteIpForwardEntry, iphlpapilib, 'DeleteIpForwardEntry');
  715.   asm
  716.     mov esp, ebp
  717.     pop ebp
  718.     jmp [_DeleteIpForwardEntry]
  719.   end;
  720. end;
  721. {$ELSE}
  722. function DeleteIpForwardEntry; external iphlpapilib name 'DeleteIpForwardEntry';
  723. {$ENDIF DYNAMIC_LINK}
  725. {$IFDEF DYNAMIC_LINK}
  726. var
  727.   _SetIpStatistics: Pointer;
  729. function SetIpStatistics;
  730. begin
  731.   GetProcedureAddress(_SetIpStatistics, iphlpapilib, 'SetIpStatistics');
  732.   asm
  733.     mov esp, ebp
  734.     pop ebp
  735.     jmp [_SetIpStatistics]
  736.   end;
  737. end;
  738. {$ELSE}
  739. function SetIpStatistics; external iphlpapilib name 'SetIpStatistics';
  740. {$ENDIF DYNAMIC_LINK}
  742. {$IFDEF DYNAMIC_LINK}
  743. var
  744.   _SetIpTTL: Pointer;
  746. function SetIpTTL;
  747. begin
  748.   GetProcedureAddress(_SetIpTTL, iphlpapilib, 'SetIpTTL');
  749.   asm
  750.     mov esp, ebp
  751.     pop ebp
  752.     jmp [_SetIpTTL]
  753.   end;
  754. end;
  755. {$ELSE}
  756. function SetIpTTL; external iphlpapilib name 'SetIpTTL';
  757. {$ENDIF DYNAMIC_LINK}
  759. {$IFDEF DYNAMIC_LINK}
  760. var
  761.   _CreateIpNetEntry: Pointer;
  763. function CreateIpNetEntry;
  764. begin
  765.   GetProcedureAddress(_CreateIpNetEntry, iphlpapilib, 'CreateIpNetEntry');
  766.   asm
  767.     mov esp, ebp
  768.     pop ebp
  769.     jmp [_CreateIpNetEntry]
  770.   end;
  771. end;
  772. {$ELSE}
  773. function CreateIpNetEntry; external iphlpapilib name 'CreateIpNetEntry';
  774. {$ENDIF DYNAMIC_LINK}
  776. {$IFDEF DYNAMIC_LINK}
  777. var
  778.   _SetIpNetEntry: Pointer;
  780. function SetIpNetEntry;
  781. begin
  782.   GetProcedureAddress(_SetIpNetEntry, iphlpapilib, 'SetIpNetEntry');
  783.   asm
  784.     mov esp, ebp
  785.     pop ebp
  786.     jmp [_SetIpNetEntry]
  787.   end;
  788. end;
  789. {$ELSE}
  790. function SetIpNetEntry; external iphlpapilib name 'SetIpNetEntry';
  791. {$ENDIF DYNAMIC_LINK}
  793. {$IFDEF DYNAMIC_LINK}
  794. var
  795.   _DeleteIpNetEntry: Pointer;
  797. function DeleteIpNetEntry;
  798. begin
  799.   GetProcedureAddress(_DeleteIpNetEntry, iphlpapilib, 'DeleteIpNetEntry');
  800.   asm
  801.     mov esp, ebp
  802.     pop ebp
  803.     jmp [_DeleteIpNetEntry]
  804.   end;
  805. end;
  806. {$ELSE}
  807. function DeleteIpNetEntry; external iphlpapilib name 'DeleteIpNetEntry';
  808. {$ENDIF DYNAMIC_LINK}
  810. {$IFDEF DYNAMIC_LINK}
  811. var
  812.   _FlushIpNetTable: Pointer;
  814. function FlushIpNetTable;
  815. begin
  816.   GetProcedureAddress(_FlushIpNetTable, iphlpapilib, 'FlushIpNetTable');
  817.   asm
  818.     mov esp, ebp
  819.     pop ebp
  820.     jmp [_FlushIpNetTable]
  821.   end;
  822. end;
  823. {$ELSE}
  824. function FlushIpNetTable; external iphlpapilib name 'FlushIpNetTable';
  825. {$ENDIF DYNAMIC_LINK}
  827. {$IFDEF DYNAMIC_LINK}
  828. var
  829.   _CreateProxyArpEntry: Pointer;
  831. function CreateProxyArpEntry;
  832. begin
  833.   GetProcedureAddress(_CreateProxyArpEntry, iphlpapilib, 'CreateProxyArpEntry');
  834.   asm
  835.     mov esp, ebp
  836.     pop ebp
  837.     jmp [_CreateProxyArpEntry]
  838.   end;
  839. end;
  840. {$ELSE}
  841. function CreateProxyArpEntry; external iphlpapilib name 'CreateProxyArpEntry';
  842. {$ENDIF DYNAMIC_LINK}
  844. {$IFDEF DYNAMIC_LINK}
  845. var
  846.   _DeleteProxyArpEntry: Pointer;
  848. function DeleteProxyArpEntry;
  849. begin
  850.   GetProcedureAddress(_DeleteProxyArpEntry, iphlpapilib, 'DeleteProxyArpEntry');
  851.   asm
  852.     mov esp, ebp
  853.     pop ebp
  854.     jmp [_DeleteProxyArpEntry]
  855.   end;
  856. end;
  857. {$ELSE}
  858. function DeleteProxyArpEntry; external iphlpapilib name 'DeleteProxyArpEntry';
  859. {$ENDIF DYNAMIC_LINK}
  861. {$IFDEF DYNAMIC_LINK}
  862. var
  863.   _SetTcpEntry: Pointer;
  865. function SetTcpEntry;
  866. begin
  867.   GetProcedureAddress(_SetTcpEntry, iphlpapilib, 'SetTcpEntry');
  868.   asm
  869.     mov esp, ebp
  870.     pop ebp
  871.     jmp [_SetTcpEntry]
  872.   end;
  873. end;
  874. {$ELSE}
  875. function SetTcpEntry; external iphlpapilib name 'SetTcpEntry';
  876. {$ENDIF DYNAMIC_LINK}
  878. {$IFDEF DYNAMIC_LINK}
  879. var
  880.   _GetInterfaceInfo: Pointer;
  882. function GetInterfaceInfo;
  883. begin
  884.   GetProcedureAddress(_GetInterfaceInfo, iphlpapilib, 'GetInterfaceInfo');
  885.   asm
  886.     mov esp, ebp
  887.     pop ebp
  888.     jmp [_GetInterfaceInfo]
  889.   end;
  890. end;
  891. {$ELSE}
  892. function GetInterfaceInfo; external iphlpapilib name 'GetInterfaceInfo';
  893. {$ENDIF DYNAMIC_LINK}
  895. {$IFDEF DYNAMIC_LINK}
  896. var
  897.   _GetUniDirectionalAdapterInfo: Pointer;
  899. function GetUniDirectionalAdapterInfo;
  900. begin
  901.   GetProcedureAddress(_GetUniDirectionalAdapterInfo, iphlpapilib, 'GetUniDirectionalAdapterInfo');
  902.   asm
  903.     mov esp, ebp
  904.     pop ebp
  905.     jmp [_GetUniDirectionalAdapterInfo]
  906.   end;
  907. end;
  908. {$ELSE}
  909. function GetUniDirectionalAdapterInfo; external iphlpapilib name 'GetUniDirectionalAdapterInfo';
  910. {$ENDIF DYNAMIC_LINK}
  912. {$IFDEF DYNAMIC_LINK}
  913. var
  914.   _GetBestInterface: Pointer;
  916. function GetBestInterface;
  917. begin
  918.   GetProcedureAddress(_GetBestInterface, iphlpapilib, 'GetBestInterface');
  919.   asm
  920.     mov esp, ebp
  921.     pop ebp
  922.     jmp [_GetBestInterface]
  923.   end;
  924. end;
  925. {$ELSE}
  926. function GetBestInterface; external iphlpapilib name 'GetBestInterface';
  927. {$ENDIF DYNAMIC_LINK}
  929. {$IFDEF DYNAMIC_LINK}
  930. var
  931.   _GetBestInterfaceEx: Pointer;
  933. function GetBestInterfaceEx;
  934. begin
  935.   GetProcedureAddress(_GetBestInterfaceEx, iphlpapilib, 'GetBestInterfaceEx');
  936.   asm
  937.     mov esp, ebp
  938.     pop ebp
  939.     jmp [_GetBestInterfaceEx]
  940.   end;
  941. end;
  942. {$ELSE}
  943. function GetBestInterfaceEx; external iphlpapilib name 'GetBestInterfaceEx';
  944. {$ENDIF DYNAMIC_LINK}
  946. {$IFDEF DYNAMIC_LINK}
  947. var
  948.   _GetBestRoute: Pointer;
  950. function GetBestRoute;
  951. begin
  952.   GetProcedureAddress(_GetBestRoute, iphlpapilib, 'GetBestRoute');
  953.   asm
  954.     mov esp, ebp
  955.     pop ebp
  956.     jmp [_GetBestRoute]
  957.   end;
  958. end;
  959. {$ELSE}
  960. function GetBestRoute; external iphlpapilib name 'GetBestRoute';
  961. {$ENDIF DYNAMIC_LINK}
  963. {$IFDEF DYNAMIC_LINK}
  964. var
  965.   _NotifyAddrChange: Pointer;
  967. function NotifyAddrChange;
  968. begin
  969.   GetProcedureAddress(_NotifyAddrChange, iphlpapilib, 'NotifyAddrChange');
  970.   asm
  971.     mov esp, ebp
  972.     pop ebp
  973.     jmp [_NotifyAddrChange]
  974.   end;
  975. end;
  976. {$ELSE}
  977. function NotifyAddrChange; external iphlpapilib name 'NotifyAddrChange';
  978. {$ENDIF DYNAMIC_LINK}
  980. {$IFDEF DYNAMIC_LINK}
  981. var
  982.   _NotifyRouteChange: Pointer;
  984. function NotifyRouteChange;
  985. begin
  986.   GetProcedureAddress(_NotifyRouteChange, iphlpapilib, 'NotifyRouteChange');
  987.   asm
  988.     mov esp, ebp
  989.     pop ebp
  990.     jmp [_NotifyRouteChange]
  991.   end;
  992. end;
  993. {$ELSE}
  994. function NotifyRouteChange; external iphlpapilib name 'NotifyRouteChange';
  995. {$ENDIF DYNAMIC_LINK}
  997. {$IFDEF DYNAMIC_LINK}
  998. var
  999.   _GetAdapterIndex: Pointer;
  1001. function GetAdapterIndex;
  1002. begin
  1003.   GetProcedureAddress(_GetAdapterIndex, iphlpapilib, 'GetAdapterIndex');
  1004.   asm
  1005.     mov esp, ebp
  1006.     pop ebp
  1007.     jmp [_GetAdapterIndex]
  1008.   end;
  1009. end;
  1010. {$ELSE}
  1011. function GetAdapterIndex; external iphlpapilib name 'GetAdapterIndex';
  1012. {$ENDIF DYNAMIC_LINK}
  1014. {$IFDEF DYNAMIC_LINK}
  1015. var
  1016.   _AddIPAddress: Pointer;
  1018. function AddIPAddress;
  1019. begin
  1020.   GetProcedureAddress(_AddIPAddress, iphlpapilib, 'AddIPAddress');
  1021.   asm
  1022.     mov esp, ebp
  1023.     pop ebp
  1024.     jmp [_AddIPAddress]
  1025.   end;
  1026. end;
  1027. {$ELSE}
  1028. function AddIPAddress; external iphlpapilib name 'AddIPAddress';
  1029. {$ENDIF DYNAMIC_LINK}
  1031. {$IFDEF DYNAMIC_LINK}
  1032. var
  1033.   _DeleteIPAddress: Pointer;
  1035. function DeleteIPAddress;
  1036. begin
  1037.   GetProcedureAddress(_DeleteIPAddress, iphlpapilib, 'DeleteIPAddress');
  1038.   asm
  1039.     mov esp, ebp
  1040.     pop ebp
  1041.     jmp [_DeleteIPAddress]
  1042.   end;
  1043. end;
  1044. {$ELSE}
  1045. function DeleteIPAddress; external iphlpapilib name 'DeleteIPAddress';
  1046. {$ENDIF DYNAMIC_LINK}
  1048. {$IFDEF DYNAMIC_LINK}
  1049. var
  1050.   _GetNetworkParams: Pointer;
  1052. function GetNetworkParams;
  1053. begin
  1054.   GetProcedureAddress(_GetNetworkParams, iphlpapilib, 'GetNetworkParams');
  1055.   asm
  1056.     mov esp, ebp
  1057.     pop ebp
  1058.     jmp [_GetNetworkParams]
  1059.   end;
  1060. end;
  1061. {$ELSE}
  1062. function GetNetworkParams; external iphlpapilib name 'GetNetworkParams';
  1063. {$ENDIF DYNAMIC_LINK}
  1065. {$IFDEF DYNAMIC_LINK}
  1066. var
  1067.   _GetAdaptersInfo: Pointer;
  1069. function GetAdaptersInfo;
  1070. begin
  1071.   GetProcedureAddress(_GetAdaptersInfo, iphlpapilib, 'GetAdaptersInfo');
  1072.   asm
  1073.     mov esp, ebp
  1074.     pop ebp
  1075.     jmp [_GetAdaptersInfo]
  1076.   end;
  1077. end;
  1078. {$ELSE}
  1079. function GetAdaptersInfo; external iphlpapilib name 'GetAdaptersInfo';
  1080. {$ENDIF DYNAMIC_LINK}
  1082. {$IFDEF DYNAMIC_LINK}
  1083. var
  1084.   _GetAdaptersAddresses: Pointer;
  1086. function GetAdaptersAddresses;
  1087. begin
  1088.   GetProcedureAddress(_GetAdaptersAddresses, iphlpapilib, 'GetAdaptersAddresses');
  1089.   asm
  1090.     mov esp, ebp
  1091.     pop ebp
  1092.     jmp [_GetAdaptersAddresses]
  1093.   end;
  1094. end;
  1095. {$ELSE}
  1096. function GetAdaptersAddresses; external iphlpapilib name 'GetAdaptersAddresses';
  1097. {$ENDIF DYNAMIC_LINK}
  1099. {$IFDEF DYNAMIC_LINK}
  1100. var
  1101.   _GetPerAdapterInfo: Pointer;
  1103. function GetPerAdapterInfo;
  1104. begin
  1105.   GetProcedureAddress(_GetPerAdapterInfo, iphlpapilib, 'GetPerAdapterInfo');
  1106.   asm
  1107.     mov esp, ebp
  1108.     pop ebp
  1109.     jmp [_GetPerAdapterInfo]
  1110.   end;
  1111. end;
  1112. {$ELSE}
  1113. function GetPerAdapterInfo; external iphlpapilib name 'GetPerAdapterInfo';
  1114. {$ENDIF DYNAMIC_LINK}
  1116. {$IFDEF DYNAMIC_LINK}
  1117. var
  1118.   _IpReleaseAddress: Pointer;
  1120. function IpReleaseAddress;
  1121. begin
  1122.   GetProcedureAddress(_IpReleaseAddress, iphlpapilib, 'IpReleaseAddress');
  1123.   asm
  1124.     mov esp, ebp
  1125.     pop ebp
  1126.     jmp [_IpReleaseAddress]
  1127.   end;
  1128. end;
  1129. {$ELSE}
  1130. function IpReleaseAddress; external iphlpapilib name 'IpReleaseAddress';
  1131. {$ENDIF DYNAMIC_LINK}
  1133. {$IFDEF DYNAMIC_LINK}
  1134. var
  1135.   _IpRenewAddress: Pointer;
  1137. function IpRenewAddress;
  1138. begin
  1139.   GetProcedureAddress(_IpRenewAddress, iphlpapilib, 'IpRenewAddress');
  1140.   asm
  1141.     mov esp, ebp
  1142.     pop ebp
  1143.     jmp [_IpRenewAddress]
  1144.   end;
  1145. end;
  1146. {$ELSE}
  1147. function IpRenewAddress; external iphlpapilib name 'IpRenewAddress';
  1148. {$ENDIF DYNAMIC_LINK}
  1150. {$IFDEF DYNAMIC_LINK}
  1151. var
  1152.   _SendARP: Pointer;
  1154. function SendARP;
  1155. begin
  1156.   GetProcedureAddress(_SendARP, iphlpapilib, 'SendARP');
  1157.   asm
  1158.     mov esp, ebp
  1159.     pop ebp
  1160.     jmp [_SendARP]
  1161.   end;
  1162. end;
  1163. {$ELSE}
  1164. function SendARP; external iphlpapilib name 'SendARP';
  1165. {$ENDIF DYNAMIC_LINK}
  1167. {$IFDEF DYNAMIC_LINK}
  1168. var
  1169.   _GetRTTAndHopCount: Pointer;
  1171. function GetRTTAndHopCount;
  1172. begin
  1173.   GetProcedureAddress(_GetRTTAndHopCount, iphlpapilib, 'GetRTTAndHopCount');
  1174.   asm
  1175.     mov esp, ebp
  1176.     pop ebp
  1177.     jmp [_GetRTTAndHopCount]
  1178.   end;
  1179. end;
  1180. {$ELSE}
  1181. function GetRTTAndHopCount; external iphlpapilib name 'GetRTTAndHopCount';
  1182. {$ENDIF DYNAMIC_LINK}
  1184. {$IFDEF DYNAMIC_LINK}
  1185. var
  1186.   _GetFriendlyIfIndex: Pointer;
  1188. function GetFriendlyIfIndex;
  1189. begin
  1190.   GetProcedureAddress(_GetFriendlyIfIndex, iphlpapilib, 'GetFriendlyIfIndex');
  1191.   asm
  1192.     mov esp, ebp
  1193.     pop ebp
  1194.     jmp [_GetFriendlyIfIndex]
  1195.   end;
  1196. end;
  1197. {$ELSE}
  1198. function GetFriendlyIfIndex; external iphlpapilib name 'GetFriendlyIfIndex';
  1199. {$ENDIF DYNAMIC_LINK}
  1201. {$IFDEF DYNAMIC_LINK}
  1202. var
  1203.   _EnableRouter: Pointer;
  1205. function EnableRouter;
  1206. begin
  1207.   GetProcedureAddress(_EnableRouter, iphlpapilib, 'EnableRouter');
  1208.   asm
  1209.     mov esp, ebp
  1210.     pop ebp
  1211.     jmp [_EnableRouter]
  1212.   end;
  1213. end;
  1214. {$ELSE}
  1215. function EnableRouter; external iphlpapilib name 'EnableRouter';
  1216. {$ENDIF DYNAMIC_LINK}
  1218. {$IFDEF DYNAMIC_LINK}
  1219. var
  1220.   _UnenableRouter: Pointer;
  1222. function UnenableRouter;
  1223. begin
  1224.   GetProcedureAddress(_UnenableRouter, iphlpapilib, 'UnenableRouter');
  1225.   asm
  1226.     mov esp, ebp
  1227.     pop ebp
  1228.     jmp [_UnenableRouter]
  1229.   end;
  1230. end;
  1231. {$ELSE}
  1232. function UnenableRouter; external iphlpapilib name 'UnenableRouter';
  1233. {$ENDIF DYNAMIC_LINK}
  1235. {$IFDEF DYNAMIC_LINK}
  1236. var
  1237.   _DisableMediaSense: Pointer;
  1239. function DisableMediaSense;
  1240. begin
  1241.   GetProcedureAddress(_DisableMediaSense, iphlpapilib, 'DisableMediaSense');
  1242.   asm
  1243.     mov esp, ebp
  1244.     pop ebp
  1245.     jmp [_DisableMediaSense]
  1246.   end;
  1247. end;
  1248. {$ELSE}
  1249. function DisableMediaSense; external iphlpapilib name 'DisableMediaSense';
  1250. {$ENDIF DYNAMIC_LINK}
  1252. {$IFDEF DYNAMIC_LINK}
  1253. var
  1254.   _RestoreMediaSense: Pointer;
  1256. function RestoreMediaSense;
  1257. begin
  1258.   GetProcedureAddress(_RestoreMediaSense, iphlpapilib, 'RestoreMediaSense');
  1259.   asm
  1260.     mov esp, ebp
  1261.     pop ebp
  1262.     jmp [_RestoreMediaSense]
  1263.   end;
  1264. end;
  1265. {$ELSE}
  1266. function RestoreMediaSense; external iphlpapilib name 'RestoreMediaSense';
  1267. {$ENDIF DYNAMIC_LINK}
  1269. {$IFDEF DYNAMIC_LINK}
  1270. var
  1271.   _GetIpErrorString: Pointer;
  1273. function GetIpErrorString;
  1274. begin
  1275.   GetProcedureAddress(_GetIpErrorString, iphlpapilib, 'GetIpErrorString');
  1276.   asm
  1277.     mov esp, ebp
  1278.     pop ebp
  1279.     jmp [_GetIpErrorString]
  1280.   end;
  1281. end;
  1282. {$ELSE}
  1283. function GetIpErrorString; external iphlpapilib name 'GetIpErrorString';
  1284. {$ENDIF DYNAMIC_LINK}
  1286. end.