var NTEContext: Cardinal; var NTEInstance: Cardinal);
var
  Res: DWORD;
begin
  if @AddIPAddress = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['AddIPAddress']);
  Res := AddIPAddress(Address, IpMask, IfIndex, NTEContext, NTEInstance);
  if Res <> NO_ERROR then
    IpHlpError('AddIPAddress', Res);
end;

procedure VVDeleteIPAddress(NTEContext: Cardinal);
var
  Res: DWORD;
begin
  if @DeleteIPAddress = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['DeleteIPAddress']);
  Res := DeleteIPAddress(NTEContext);
  if Res <> NO_ERROR then
    IpHlpError('DeleteIPAddress', Res);
end;

procedure VVIpReleaseAddress(AdapterInfo: TIpAdapterIndexMap);
var
  Res: DWORD;
begin
  if @IpReleaseAddress = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['IpReleaseAddress']);
  Res := IpReleaseAddress(AdapterInfo);  //
  if Res <> NO_ERROR then
    IpHlpError('IpReleaseAddress', Res);
end;

procedure VVIpRenewAddress(AdapterInfo: TIpAdapterIndexMap);
var
  Res: DWORD;
begin
  if @IpRenewAddress = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['IpRenewAddress']);
  Res := IpRenewAddress(AdapterInfo);    //
  if Res <> NO_ERROR then
    IpHlpError('IpRenewAddress', Res);
end;

procedure VVGetIpNetTable(var p: PMibIpNetTable; var Size: Cardinal;
  const bOrder: BOOL);
var
  Res: DWORD;
begin
  p := Nil;
  Size := 0;
  if @GetIpNetTable = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['GetIpNetTable']);
  Res := GetIpNetTable(p, Size, bOrder);
  if Res = ERROR_INSUFFICIENT_BUFFER then
  begin
    Getmem(p,Size);
// Caller must free this buffer when it is no longer used
    FillChar(p^, Size, #0);
    Res := GetIpNetTable(p, Size, bOrder);
  end;
  if Res <> NO_ERROR then
    IpHlpError('GetIpNetTable', Res);
end;

procedure VVCreateIpNetEntry(ArpEntry: TMibIpNetRow);
var
  Res: DWORD;
begin
  if @CreateIpNetEntry = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['CreateIpNetEntry']);
  Res := CreateIpNetEntry(ArpEntry);   //
  if Res <> NO_ERROR then
    IpHlpError('CreateIpNetEntry', Res);
end;

procedure VVDeleteIpNetEntry(ArpEntry: TMibIpNetRow);
var
  Res: DWORD;
begin
  if @DeleteIpNetEntry = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['DeleteIpNetEntry']);
  Res := DeleteIpNetEntry(ArpEntry);    //
  if Res <> NO_ERROR then
    IpHlpError('DeleteIpNetEntry', Res);
end;

procedure VVFlushIpNetTable(dwIfIndex: DWORD);
var
  Res: DWORD;
begin
  if @FlushIpNetTable = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['FlushIpNetTable']);
  Res := FlushIpNetTable(dwIfIndex);
  if Res <> NO_ERROR then
    IpHlpError('FlushIpNetTable', Res);
end;

procedure VVCreateProxyArpEntry(dwAddress, dwMask, dwIfIndex: DWORD);
var
  Res: DWORD;
begin
  if @CreateProxyArpEntry = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['CreateProxyArpEntry']);
  Res := CreateProxyArpEntry(dwAddress, dwMask, dwIfIndex);
  if Res <> NO_ERROR then
    IpHlpError('CreateProxyArpEntry', Res);
end;

procedure VVDeleteProxyArpEntry(dwAddress, dwMask, dwIfIndex: DWORD);
var
  Res: DWORD;
begin
  if @DeleteProxyArpEntry = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['DeleteProxyArpEntry']);
  Res := DeleteProxyArpEntry(dwAddress, dwMask, dwIfIndex);
  if Res <> NO_ERROR then
    IpHlpError('DeleteProxyArpEntry', Res);
end;

procedure VVSendARP(const DestIP, SrcIP: IPAddr;
          PMacAddr :PULong; var PhyAddrLen: ULong);
var
  Res: DWORD;
begin
  if @SendARP = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['SendARP']);
  Res := SendARP(DestIP, SrcIP, PMacAddr, PhyAddrLen);
  if Res <> NO_ERROR then
    IpHlpError('SendARP', Res);
end;

procedure VVGetIpStatistics(var Stats: TMibIpStats);
var
  Res: DWORD;
begin
  if @GetIpStatistics = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['GetIpStatistics']);
  Res := GetIpStatistics(Stats);         //
  if Res <> NO_ERROR then
    IpHlpError('GetIpStatistics', Res);
end;

procedure VVGetIcmpStatistics(var Stats: TMibIcmp);
var
  Res: DWORD;
begin
  if @GetIcmpStatistics = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['GetIcmpStatistics']);
  Res := GetIcmpStatistics(Stats);       //
  if Res <> NO_ERROR then
    IpHlpError('GetIcmpStatistics', Res);
end;

procedure VVSetIpStatistics(var IpStats: TMibIpStats);
var
  Res: DWORD;
begin
  if @SetIpStatistics = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['SetIpStatistics']);
  Res := SetIpStatistics(IpStats);       //
  if Res <> NO_ERROR then
    IpHlpError('SetIpStatistics', Res);
end;

procedure VVSetIpTTL(nTTL: UINT);
var
  Res: DWORD;
begin
  if @SetIpTTL = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['SetIpTTL']);
  Res := SetIpTTL(nTTL);
  if Res <> NO_ERROR then
    IpHlpError('SetIpTTL', Res);
end;

procedure VVGetIpForwardTable(var pIpForwardTable: PMibIpForwardTable;
  var dwSize: Cardinal; const bOrder: BOOL);
var
  Res: DWORD;
begin
  pIpForwardTable := Nil;
  dwSize := 0;
  if @GetIpForwardTable = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['GetIpForwardTable']);
  Res := GetIpForwardTable(pIpForwardTable,dwSize,bOrder);
  if (Res <> NO_ERROR) and (dwSize>0) then
  begin
    Getmem(pIpForwardTable,dwSize);
// Caller must free this buffer when it is no longer used
    FillChar(pIpForwardTable^,dwSize,#0);
    Res := GetIpForwardTable(pIpForwardTable,dwSize,bOrder);
  end;
  if Res <> 0 then
    IpHlpError('GetIpForwardTable', Res);
end;

procedure VVCreateIpForwardEntry(pRoute: PMibIpForwardRow);
var
  Res: DWORD;
begin
  if @CreateIpForwardEntry = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['CreateIpForwardEntry']);
  Res := CreateIpForwardEntry(pRoute^);   //To test
  if Res <> NO_ERROR then
    IpHlpError('CreateIpForwardEntry', Res);
end;

procedure VVDeleteIpForwardEntry(Route: TMibIpForwardRow);
var
  Res: DWORD;
begin
  if @DeleteIpForwardEntry = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['DeleteIpForwardEntry']);
  Res := DeleteIpForwardEntry(Route);   //
  if Res <> NO_ERROR then
    IpHlpError('DeleteIpForwardEntry', Res);
end;

procedure VVSetIpForwardEntry(Route: TMibIpForwardRow);
var
  Res: DWORD;
begin
  if @SetIpForwardEntry = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['SetIpForwardEntry']);
  Res := SetIpForwardEntry(Route);      //
  if Res <> NO_ERROR then
    IpHlpError('SetIpForwardEntry', Res);
end;

procedure VVGetBestRoute(dwDestAddr, dwSourceAddr: DWORD;
  pBestRoute: PMibIpForwardRow);
var
  Res: DWORD;
begin
  if @GetBestRoute = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['GetBestRoute']);
  Res := GetBestRoute(dwDestAddr, dwSourceAddr, pBestRoute);
  if Res <> NO_ERROR then
    IpHlpError('GetBestRoute', Res);
end;

procedure VVGetBestInterface(dwDestAddr: IPAddr; var dwBestIfIndex: DWORD);
var
  Res: DWORD;
begin
  if @GetBestInterface = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['GetBestInterface']);
  Res := GetBestInterface(dwDestAddr, dwBestIfIndex);
  if Res <> NO_ERROR then
    IpHlpError('GetBestInterface', Res);
end;

procedure VVGetRTTAndHopCount(const DestIpAddress: IPAddr; var HopCount: ULONG;
  const MaxHops: ULONG; var RTT: ULONG);
var
  Res:BOOL;
begin
  if @GetRTTAndHopCount = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['GetRTTAndHopCount']);
  Res := GetRTTAndHopCount(DestIpAddress, HopCount, MaxHops, RTT);
  if not Res then
    RaiseLastWin32Error;
end;

procedure VVNotifyAddrChange(var Handle: THandle; Overlapped: POverlapped);
var
  Res: DWORD;
begin
  if @NotifyAddrChange = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['NotifyAddrChange']);
  Res := NotifyAddrChange(Handle, Overlapped);     //
  if Res <> ERROR_IO_PENDING then
    IpHlpError('NotifyAddrChange', Res);
end;

procedure VVNotifyRouteChange(var Handle: THandle; Overlapped: POverlapped);
var
  Res: DWORD;
begin
  if @NotifyRouteChange = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['NotifyRouteChange']);
  Res := NotifyRouteChange(Handle, Overlapped); //
  if Res <> ERROR_IO_PENDING then
    IpHlpError('NotifyRouteChange', Res);
end;

procedure VVGetTcpStatistics(var Stats: TMibTcpStats);
var
  Res: DWORD;
begin
  if @GetTcpStatistics = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['GetTcpStatistics']);
  Res := GetTcpStatistics(Stats);       //
  if Res <> NO_ERROR then
    IpHlpError('GetTcpStatistics', Res);
end;

procedure VVGetUdpStatistics(var Stats: TMibUdpStats);
var
  Res: DWORD;
begin
  if @GetUdpStatistics = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['GetUdpStatistics']);
  Res := GetUdpStatistics(Stats);       //
  if Res <> NO_ERROR then
    IpHlpError('GetUdpStatistics', Res);
end;

procedure VVGetTcpTable(var pTcpTable: PMibTcpTable; var dwSize: DWORD;
          const bOrder: BOOL);
var
  Res: DWORD;
begin
  pTcpTable := Nil;
  dwSize := 0;
  if @GetTcpTable = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['GetTcpTable']);
  Res := GetTcpTable(pTcpTable, dwSize, bOrder);
  if Res = ERROR_INSUFFICIENT_BUFFER then
  begin
   Getmem(pTcpTable, dwSize);
// Caller must free this buffer when it is no longer used
   FillChar(pTcpTable^, dwSize, #0);
   Res := GetTcpTable(pTcpTable, dwSize, bOrder);
  end;
  if Res <> NO_ERROR then
    IpHlpError('GetTcpTable', Res);
end;

procedure VVGetUdpTable(var pUdpTable: PMibUdpTable; var dwSize: DWORD;
  bOrder: BOOL);
var
  Res: DWORD;
begin
  pUdpTable := Nil;
  dwSize := 0;
  if @GetUdpTable = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['GetUdpTable']);
  Res := GetUdpTable(pUdpTable, dwSize, bOrder);
  if Res = ERROR_INSUFFICIENT_BUFFER then
  begin
    Getmem(pUdpTable, dwSize);
// Caller must free this buffer when it is no longer used
    FillChar(pUdpTable^, dwSize, #0);
    Res := GetUdpTable(pUdpTable, dwSize, bOrder);
  end;
  if Res <> NO_ERROR then
    IpHlpError('GetUdpTable', Res);
end;

procedure VVSetTcpEntry(TcpRow: TMibTcpRow);
var
  Res: DWORD;
begin
 if @SetTcpEntry = Nil then
  raise EIpHlpError.CreateFmt(sNotImplemented, ['SetTcpEntry']);
  Res := SetTcpEntry(TcpRow);   //
 if Res <> NO_ERROR then
   IpHlpError('SetTcpEntry', Res);
end;

procedure VVEnableRouter(var Handle: THandle; var Overlapped: TOverlapped);
var
  Res: DWORD;
begin
  if @EnableRouter = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['EnableRouter']);
  Res := EnableRouter(Handle, @Overlapped);     //
  if Res <> ERROR_IO_PENDING then
    RaiseLastWin32Error;
end;

procedure VVUnenableRouter(var Overlapped: TOverlapped;
  lpdwEnableCount: LPDWORD = Nil);
var
  Res: DWORD;
begin
  if @UnEnableRouter = Nil then
    raise EIpHlpError.CreateFmt(sNotImplemented, ['UnEnableRouter']);
  Res := UnEnableRouter(@Overlapped, lpdwEnableCount);            //
  if Res <> NO_ERROR then
    RaiseLastWin32Error;
end;

end.