archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/net/tcpip/snmp/mibfuncs.c

3596 lines
110 KiB
Raw Blame History

/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
Abstract:
Author:
Revision History:
--*/
#include "allinc.h"
#include "oid.h"
//
// Values of InetAddressType.
//
typedef enum {
INET_ADDRESS_TYPE_UNKNOWN = 0,
INET_ADDRESS_TYPE_IPv4 = 1,
INET_ADDRESS_TYPE_IPv6 = 2
} INET_ADDRESS_TYPE;
UINT
MibGetIfNumber(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PIF_NUMBER_GET pOutput;
TraceEnter("MibGetIfNumber");
dwResult = UpdateCache(MIB_II_IF);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update IF cache. Error %d", dwResult);
TraceLeave("MibGetIfNumber");
return dwResult;
}
pOutput = (PIF_NUMBER_GET)objectArray;
EnterReader(MIB_II_IF);
SetAsnInteger(&(pOutput->ifNumber),g_Cache.pRpcIfTable->dwNumEntries);
ReleaseLock(MIB_II_IF);
TraceLeave("MibGetIfNumber");
return MIB_S_SUCCESS;
}
UINT
MibGetIfEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PMIB_IFROW pRpcIf;
PIF_ENTRY_GET pOutput;
TraceEnter("MibGetIfEntry");
dwResult = UpdateCache(MIB_II_IF);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update IF cache. Error %d",dwResult);
TraceLeave("MibGetIfEntry");
return dwResult;
}
pOutput = (PIF_ENTRY_GET)objectArray;
EnterReader(MIB_II_IF);
pRpcIf = LocateIfRow(actionId,
&(pOutput->ifIndex));
if(pRpcIf is NULL)
{
ReleaseLock(MIB_II_IF);
TRACE2("Unable to locate IF Row. Action is %d. Index is %d",
actionId,
GetAsnInteger(&(pOutput->ifIndex),-1));
TraceLeave("MibGetIfEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
ForceSetAsnInteger(&(pOutput->ifIndex),pRpcIf->dwIndex);
// SetAsnDispString(&(pOutput->ifDescr),
SetAsnOctetString(&(pOutput->ifDescr),
pOutput->rgbyIfDescrInfo,
pRpcIf->bDescr,
min(pRpcIf->dwDescrLen,MAX_IF_DESCR_LEN));
SetAsnInteger(&(pOutput->ifType),pRpcIf->dwType);
SetAsnInteger(&(pOutput->ifMtu),pRpcIf->dwMtu);
SetAsnGauge(&(pOutput->ifSpeed),pRpcIf->dwSpeed);
SetAsnOctetString(&(pOutput->ifPhysAddress),
pOutput->rgbyIfPhysAddressInfo,
pRpcIf->bPhysAddr,
pRpcIf->dwPhysAddrLen);
/*if(!IsAsnTypeNull(&(pOutput->ifPhysAddress)))
{
pOutput->ifPhysAddress.asnValue.string.length = pRpcIf->dwPhysAddrLen;
pOutput->ifPhysAddress.asnValue.string.stream = pOutput->rgbyIfPhysAddressInfo;
CopyMemory(pOutput->rgbyIfPhysAddressInfo,
pRpcIf->rgbyPhysAddr,
pRpcIf->dwPhysAddrLen);
}*/
SetAsnInteger(&(pOutput->ifAdminStatus), pRpcIf->dwAdminStatus);
SetAsnInteger(&(pOutput->ifOperStatus), pRpcIf->dwOperStatus);
SetAsnTimeTicks(&(pOutput->ifLastChange), SnmpSvcGetUptimeFromTime(pRpcIf->dwLastChange));
SetAsnCounter(&(pOutput->ifInOctets), pRpcIf->dwInOctets);
SetAsnCounter(&(pOutput->ifInUcastPkts), pRpcIf->dwInUcastPkts);
SetAsnCounter(&(pOutput->ifInNUcastPkts), pRpcIf->dwInNUcastPkts);
SetAsnCounter(&(pOutput->ifInDiscards), pRpcIf->dwInDiscards);
SetAsnCounter(&(pOutput->ifInErrors), pRpcIf->dwInErrors);
SetAsnCounter(&(pOutput->ifInUnknownProtos), pRpcIf->dwInUnknownProtos);
SetAsnCounter(&(pOutput->ifOutOctets), pRpcIf->dwOutOctets);
SetAsnCounter(&(pOutput->ifOutUcastPkts), pRpcIf->dwOutUcastPkts);
SetAsnCounter(&(pOutput->ifOutNUcastPkts), pRpcIf->dwOutNUcastPkts);
SetAsnCounter(&(pOutput->ifOutDiscards), pRpcIf->dwOutDiscards);
SetAsnCounter(&(pOutput->ifOutErrors), pRpcIf->dwOutErrors);
SetAsnGauge(&(pOutput->ifOutQLen), pRpcIf->dwOutQLen);
SetToZeroOid(&(pOutput->ifSpecific));
ReleaseLock(MIB_II_IF);
TraceLeave("MibGetIfEntry");
return MIB_S_SUCCESS;
}
UINT
MibSetIfEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult,dwStatus;
PMIB_IFROW pRpcIf;
PIF_ENTRY_SET pInput;
PMIB_OPAQUE_INFO pInfo;
PMIB_IFROW pSetRow;
pInput = (PIF_ENTRY_SET)objectArray;
pInfo = (PMIB_OPAQUE_INFO)(pInput->rgdwSetBuffer);
pSetRow = (PMIB_IFROW)(pInfo->rgbyData);
switch(actionId)
{
case MIB_ACTION_VALIDATE:
{
TraceEnter("MibSetIfEntry - VALIDATE");
ASSERT(!(IsAsnTypeNull(&(pInput->ifIndex)) or
IsAsnTypeNull(&(pInput->ifAdminStatus))));
pInput->bLocked = FALSE;
dwStatus = GetAsnInteger(&(pInput->ifAdminStatus), 0);
if((dwStatus isnot IF_ADMIN_STATUS_UP) and
(dwStatus isnot IF_ADMIN_STATUS_DOWN))
{
TRACE0("Status must be UP or DOWN");
TraceLeave("MibSetIfEntry");
return MIB_S_INVALID_PARAMETER;
}
dwResult = UpdateCache(MIB_II_IF);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update IF cache. Error %d",dwResult);
TraceLeave("MibSetIfEntry");
return dwResult;
}
pInfo->dwId = IF_ROW;
//
// We take the lock here and then release it in the cleanup
// This ensures that things dont change between the two calls
//
EnterWriter(MIB_II_IF);
pInput->bLocked = TRUE;
pRpcIf = LocateIfRow(GET_EXACT,
&(pInput->ifIndex));
if(pRpcIf is NULL)
{
ReleaseLock(MIB_II_IF);
pInput->bLocked = FALSE;
TRACE1("Unable to locate IF Row. Index is %d",
GetAsnInteger(&(pInput->ifIndex),-1));
TraceLeave("MibSetIfEntry");
return MIB_S_ENTRY_NOT_FOUND;
}
if(pRpcIf->dwAdminStatus is dwStatus)
{
//
// Since the types are same, this is a NOP.
//
pInput->raAction = NOP;
TraceLeave("MibSetIfEntry - SET");
return MIB_S_SUCCESS;
}
pInput->raAction = SET_ROW;
pSetRow->dwIndex = pRpcIf->dwIndex;
pSetRow->dwAdminStatus = dwStatus;
TraceLeave("MibSetIfEntry - SET");
return MIB_S_SUCCESS;
}
case MIB_ACTION_SET:
{
TraceEnter("MibSetIfEntry - SET");
dwResult = NO_ERROR;
if(pInput->raAction is SET_ROW)
{
dwResult = InternalSetIfEntry(pInfo);
#ifdef MIB_DEBUG
if(dwResult isnot NO_ERROR)
{
TRACE1("Set failed!!. Error %d",
dwResult);
}
#endif
InvalidateCache(MIB_II_IF);
}
TraceLeave("MibSetIfEntry");
return dwResult;
}
case MIB_ACTION_CLEANUP:
{
if(pInput->bLocked)
{
ReleaseLock(MIB_II_IF);
}
TraceEnter("MibSetIfEntry - CLEANUP");
TraceLeave("MibSetIfEntry");
return MIB_S_SUCCESS;
}
default:
{
TraceEnter("MibSetIfEntry - WRONG ACTION");
TraceLeave("MibSetIfEntry");
return MIB_S_INVALID_PARAMETER;
}
}
}
UINT
MibGetIpGroup(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PIP_STATS_GET pOutput;
MIB_IPSTATS rpcIpStats;
TraceEnter("MibGetIpGroup");
dwResult = GetIpStatistics(&rpcIpStats);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt get IP stats. Error %d",dwResult);
TraceLeave("MibGetIpGroup");
return dwResult;
}
pOutput = (PIP_STATS_GET)objectArray;
SetAsnInteger(&(pOutput->ipForwarding), rpcIpStats.dwForwarding);
SetAsnInteger(&(pOutput->ipDefaultTTL), rpcIpStats.dwDefaultTTL);
SetAsnCounter(&(pOutput->ipInReceives), rpcIpStats.dwInReceives);
SetAsnCounter(&(pOutput->ipInHdrErrors), rpcIpStats.dwInHdrErrors);
SetAsnCounter(&(pOutput->ipInAddrErrors), rpcIpStats.dwInAddrErrors);
SetAsnCounter(&(pOutput->ipForwDatagrams), rpcIpStats.dwForwDatagrams);
SetAsnCounter(&(pOutput->ipInUnknownProtos), rpcIpStats.dwInUnknownProtos);
SetAsnCounter(&(pOutput->ipInDiscards), rpcIpStats.dwInDiscards);
SetAsnCounter(&(pOutput->ipInDelivers), rpcIpStats.dwInDelivers);
SetAsnCounter(&(pOutput->ipOutRequests), rpcIpStats.dwOutRequests);
SetAsnCounter(&(pOutput->ipOutDiscards), rpcIpStats.dwOutDiscards);
SetAsnCounter(&(pOutput->ipOutNoRoutes), rpcIpStats.dwOutNoRoutes);
SetAsnInteger(&(pOutput->ipReasmTimeout), rpcIpStats.dwReasmTimeout);
SetAsnCounter(&(pOutput->ipReasmReqds), rpcIpStats.dwReasmReqds);
SetAsnCounter(&(pOutput->ipReasmOKs), rpcIpStats.dwReasmOks);
SetAsnCounter(&(pOutput->ipReasmFails), rpcIpStats.dwReasmFails);
SetAsnCounter(&(pOutput->ipFragOKs), rpcIpStats.dwFragOks);
SetAsnCounter(&(pOutput->ipFragFails), rpcIpStats.dwFragFails);
SetAsnCounter(&(pOutput->ipFragCreates), rpcIpStats.dwFragCreates);
SetAsnCounter(&(pOutput->ipRoutingDiscards), rpcIpStats.dwRoutingDiscards);
TraceLeave("MibGetIpGroup");
return MIB_S_SUCCESS;
}
UINT
MibSetIpGroup(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
MIB_IPSTATS rpcIpStats;
DWORD dwResult,dwTTL,dwForw;
PIP_STATS_SET pInput;
PMIB_OPAQUE_INFO pInfo;
PMIB_IPSTATS pSetStats;
pInput = (PIP_STATS_SET)objectArray;
pInfo = (PMIB_OPAQUE_INFO)(pInput->rgdwSetBuffer);
pSetStats = (PMIB_IPSTATS)(pInfo->rgbyData);
switch(actionId)
{
case MIB_ACTION_VALIDATE:
{
TraceEnter("MibSetIpGroup- VALIDATE");
if(IsAsnTypeNull(&(pInput->ipDefaultTTL)) and
IsAsnTypeNull(&(pInput->ipForwarding)))
{
TRACE0("Can only set TTL and Forwarding");
TraceLeave("MibSetIpGroup");
return MIB_S_INVALID_PARAMETER;
}
dwResult = GetIpStatistics(&rpcIpStats);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt get IP stats. Error %d",dwResult);
TraceLeave("MibSetIpGroup");
return dwResult;
}
pInfo->dwId = IP_STATS;
dwTTL = GetAsnInteger(&(pInput->ipDefaultTTL), rpcIpStats.dwDefaultTTL);
dwForw = GetAsnInteger(&(pInput->ipForwarding), rpcIpStats.dwForwarding);
//
// Per RFC 2011, the valid range is [1..255].
//
if((dwTTL < 1) || (dwTTL > 255))
{
TRACE0("TTL must be in the range [1..255]");
TraceLeave("MibSetIpGroup");
return MIB_S_INVALID_PARAMETER;
}
if((dwForw isnot MIB_IP_FORWARDING) and
(dwForw isnot MIB_IP_NOT_FORWARDING))
{
TRACE0("Forwarding value wrong");
TraceLeave("MibSetIpGroup");
return MIB_S_INVALID_PARAMETER;
}
pSetStats->dwForwarding = dwForw;
pSetStats->dwDefaultTTL = dwTTL;
TraceLeave("MibSetIpGroup");
return MIB_S_SUCCESS;
}
case MIB_ACTION_SET:
{
TraceEnter("MibSetIpGroup - SET");
dwResult = InternalSetIpStats(pInfo);
#ifdef MIB_DEBUG
if(dwResult isnot NO_ERROR)
{
TRACE1("Set returned error %d!!",dwResult);
}
#endif
TraceLeave("MibSetIpGroup");
return dwResult;
}
case MIB_ACTION_CLEANUP:
{
TraceEnter("MibSetIpGroup - CLEANUP");
TraceLeave("MibSetIpGroup");
return MIB_S_SUCCESS;
}
default:
{
TraceEnter("MibSetIpGroup - WRONG ACTION");
TraceLeave("MibSetIpGroup");
return MIB_S_INVALID_PARAMETER;
}
}
}
UINT
MibGetIpAddressEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
PMIB_IPADDRROW pRpcIpAddr;
DWORD dwResult;
PIP_ADDRESS_ENTRY_GET pOutput;
TraceEnter("MibGetIpAddressEntry");
dwResult = UpdateCache(MIB_II_IPADDR);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update IP Addr cache. Error %d", dwResult);
TraceLeave("MibGetIpAddressEntry");
return dwResult;
}
pOutput = (PIP_ADDRESS_ENTRY_GET)objectArray;
EnterReader(MIB_II_IPADDR);
pRpcIpAddr = LocateIpAddrRow(actionId,
&(pOutput->ipAdEntAddr));
if(pRpcIpAddr is NULL)
{
ReleaseLock(MIB_II_IPADDR);
TRACE2("Unable to locate IP Addr Row. Action is %d, Address is %x",
actionId,
GetAsnIPAddress(&(pOutput->ipAdEntAddr),0xffffffff));
TraceLeave("MibGetIpAddressEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
ForceSetAsnIPAddress(&(pOutput->ipAdEntAddr),
&(pOutput->dwIpAdEntAddrInfo),
pRpcIpAddr->dwAddr);
SetAsnInteger(&(pOutput->ipAdEntIfIndex), pRpcIpAddr->dwIndex);
SetAsnIPAddress(&(pOutput->ipAdEntNetMask),
&(pOutput->dwIpAdEntNetMaskInfo),
pRpcIpAddr->dwMask);
SetAsnInteger(&(pOutput->ipAdEntBcastAddr), pRpcIpAddr->dwBCastAddr);
SetAsnInteger(&(pOutput->ipAdEntReasmMaxSize), pRpcIpAddr->dwReasmSize);
ReleaseLock(MIB_II_IPADDR);
TraceLeave("MibGetIpAddressEntry");
return MIB_S_SUCCESS;
}
UINT
MibGetIpRouteEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PMIB_IPFORWARDROW pRpcIpForw;
PIP_ROUTE_ENTRY_GET pOutput;
TraceEnter("MibGetIpRouteEntry");
dwResult = UpdateCache(FORWARD_MIB);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update IP Forward cache. Error %d", dwResult);
TraceLeave("MibGetIpRouteEntry");
return dwResult;
}
pOutput = (PIP_ROUTE_ENTRY_GET)objectArray;
EnterReader(FORWARD_MIB);
pRpcIpForw = LocateIpRouteRow(actionId,
&(pOutput->ipRouteDest));
if(pRpcIpForw is NULL)
{
ReleaseLock(FORWARD_MIB);
TRACE2("Unable to locate IP ROUTE Row. Action is %d. Dest is %x",
actionId,
GetAsnIPAddress(&(pOutput->ipRouteDest),0xffffffff));
TraceLeave("MibGetIpRouteEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
ForceSetAsnIPAddress(&(pOutput->ipRouteDest),
&(pOutput->dwIpRouteDestInfo),
pRpcIpForw->dwForwardDest);
SetAsnInteger(&(pOutput->ipRouteIfIndex), pRpcIpForw->dwForwardIfIndex);
SetAsnInteger(&(pOutput->ipRouteMetric1), pRpcIpForw->dwForwardMetric1);
SetAsnInteger(&(pOutput->ipRouteMetric2), pRpcIpForw->dwForwardMetric2);
SetAsnInteger(&(pOutput->ipRouteMetric3), pRpcIpForw->dwForwardMetric3);
SetAsnInteger(&(pOutput->ipRouteMetric4), pRpcIpForw->dwForwardMetric4);
SetAsnIPAddress(&(pOutput->ipRouteNextHop),
&(pOutput->dwIpRouteNextHopInfo),
pRpcIpForw->dwForwardNextHop);
SetAsnInteger(&(pOutput->ipRouteType), pRpcIpForw->dwForwardType);
SetAsnInteger(&(pOutput->ipRouteProto), pRpcIpForw->dwForwardProto);
SetAsnInteger(&(pOutput->ipRouteAge), pRpcIpForw->dwForwardAge);
SetAsnIPAddress(&(pOutput->ipRouteMask),
&(pOutput->dwIpRouteMaskInfo),
pRpcIpForw->dwForwardMask);
SetAsnInteger(&(pOutput->ipRouteMetric5), pRpcIpForw->dwForwardMetric5);
SetToZeroOid(&(pOutput->ipRouteInfo));
ReleaseLock(FORWARD_MIB);
TraceLeave("MibGetIpRouteEntry");
return MIB_S_SUCCESS;
}
UINT
MibSetIpRouteEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult,dwType,dwIfIndex,dwNextHop;
PMIB_IPFORWARDROW pRpcIpForw;
PIP_ROUTE_ENTRY_SET pInput;
PMIB_OPAQUE_INFO pInfo;
PMIB_IPFORWARDROW pSetRow;
pInput = (PIP_ROUTE_ENTRY_SET)objectArray;
pInfo = (PMIB_OPAQUE_INFO)(pInput->rgdwSetBuffer);
pSetRow = (PMIB_IPFORWARDROW)(pInfo->rgbyData);
switch(actionId)
{
case MIB_ACTION_VALIDATE:
{
TraceEnter("MibSetIpRouteEntry - VALIDATE");
ASSERT(!(IsAsnTypeNull(&(pInput->ipRouteDest))));
pInput->bLocked = FALSE;
dwResult = UpdateCache(FORWARD_MIB);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update IP Forward cache. Error %d", dwResult);
TraceLeave("MibGetIpRouteEntry");
return dwResult;
}
pInfo->dwId = IP_FORWARDROW;
EnterWriter(FORWARD_MIB);
pInput->bLocked = TRUE;
pRpcIpForw = LocateIpRouteRow(GET_EXACT,
&(pInput->ipRouteDest));
if(pRpcIpForw is NULL)
{
//
// So we are creating a row. We need the If index,
// the mask, next hop and metric 1. We will try to
// determine If index later if necessary.
//
if(IsAsnTypeNull(&(pInput->ipRouteMask)) or
IsAsnTypeNull(&(pInput->ipRouteNextHop)) or
IsAsnTypeNull(&(pInput->ipRouteMetric1)))
{
ReleaseLock(FORWARD_MIB);
pInput->bLocked = FALSE;
TRACE0("Not enough information to create a route");
TraceLeave("MibSetIpRouteEntry");
return MIB_S_INVALID_PARAMETER;
}
dwType = GetAsnInteger(&(pInput->ipRouteType),
MIB_IPROUTE_TYPE_OTHER);
if(dwType is MIB_IPROUTE_TYPE_INVALID)
{
//
// We couldnt be creating and deleting a row at the
// same time
//
ReleaseLock(FORWARD_MIB);
pInput->bLocked = FALSE;
TRACE0("Wrong type");
TraceLeave("MibSetIpRouteEntry");
return MIB_S_INVALID_PARAMETER;
}
dwIfIndex = GetAsnInteger(&(pInput->ipRouteIfIndex),0);
dwNextHop = GetAsnIPAddress(&(pInput->ipRouteNextHop),0x00000000);
if(dwIfIndex is 0)
{
//
// Attempt to determine the correct ifIndex
//
dwIfIndex = GetIfIndexFromAddr(dwNextHop);
if(dwIfIndex is INVALID_IFINDEX)
{
//
// We couldnt determine the correct ifIndex
//
ReleaseLock(FORWARD_MIB);
pInput->bLocked = FALSE;
TRACE0("Could not determine ifIndex");
TraceLeave("MibSetIpRouteEntry");
return MIB_S_INVALID_PARAMETER;
}
}
pInput->raAction = CREATE_ROW;
pSetRow->dwForwardType = dwType;
pSetRow->dwForwardIfIndex = dwIfIndex;
pSetRow->dwForwardNextHop = dwNextHop;
pSetRow->dwForwardDest =
GetAsnIPAddress(&(pInput->ipRouteDest),0xffffffff);
pSetRow->dwForwardMask =
GetAsnIPAddress(&(pInput->ipRouteMask),0x00000000);
pSetRow->dwForwardPolicy = 0;
pSetRow->dwForwardProto =
GetAsnInteger(&(pInput->ipRouteProto),MIB_IPPROTO_NETMGMT);
//
// We default to an age of INFINITE
//
pSetRow->dwForwardAge =
GetAsnInteger(&(pInput->ipRouteAge),INFINITE);
pSetRow->dwForwardNextHopAS = 0;
pSetRow->dwForwardMetric1 =
GetAsnInteger(&(pInput->ipRouteMetric1),0);
pSetRow->dwForwardMetric2 =
GetAsnInteger(&(pInput->ipRouteMetric2),-1);
pSetRow->dwForwardMetric3 =
GetAsnInteger(&(pInput->ipRouteMetric3),-1);
pSetRow->dwForwardMetric4 =
GetAsnInteger(&(pInput->ipRouteMetric4),-1);
pSetRow->dwForwardMetric5 =
GetAsnInteger(&(pInput->ipRouteMetric5),-1);
TraceLeave("MibSetIpRouteEntry");
return MIB_S_SUCCESS;
}
else
{
//
// Ok so we are only changing some stuff in the route
//
dwType = GetAsnInteger(&(pInput->ipRouteType),
pRpcIpForw->dwForwardType);
if(dwType is MIB_IPROUTE_TYPE_INVALID)
{
//
// Deleting a row
//
pInput->raAction = DELETE_ROW;
*pSetRow = *pRpcIpForw;
TraceLeave("MibSetIpRouteEntry");
return MIB_S_SUCCESS;
}
pInput->raAction = SET_ROW;
pSetRow->dwForwardDest =
GetAsnIPAddress(&(pInput->ipRouteDest),
pRpcIpForw->dwForwardDest);
pSetRow->dwForwardMask =
GetAsnIPAddress(&(pInput->ipRouteMask),
pRpcIpForw->dwForwardMask);
pSetRow->dwForwardPolicy = 0;
pSetRow->dwForwardNextHop =
GetAsnIPAddress(&(pInput->ipRouteNextHop),
pRpcIpForw->dwForwardNextHop);
pSetRow->dwForwardIfIndex =
GetAsnInteger(&(pInput->ipRouteIfIndex),
pRpcIpForw->dwForwardIfIndex);
//
// The type gets set by the router manager. But incase
// we are writing to the stack we need some kind of valid type
//
pSetRow->dwForwardType =
GetAsnInteger(&(pInput->ipRouteType),
pRpcIpForw->dwForwardType);
pSetRow->dwForwardProto =
GetAsnInteger(&(pInput->ipRouteProto),
pRpcIpForw->dwForwardProto);
pSetRow->dwForwardAge =
GetAsnInteger(&(pInput->ipRouteAge),
pRpcIpForw->dwForwardAge);
pSetRow->dwForwardNextHopAS = 0;
pSetRow->dwForwardMetric1 =
GetAsnInteger(&(pInput->ipRouteMetric1),
pRpcIpForw->dwForwardMetric1);
pSetRow->dwForwardMetric2 =
GetAsnInteger(&(pInput->ipRouteMetric2),
pRpcIpForw->dwForwardMetric2);
pSetRow->dwForwardMetric3 =
GetAsnInteger(&(pInput->ipRouteMetric3),
pRpcIpForw->dwForwardMetric3);
pSetRow->dwForwardMetric4 =
GetAsnInteger(&(pInput->ipRouteMetric4),
pRpcIpForw->dwForwardMetric4);
pSetRow->dwForwardMetric5 =
GetAsnInteger(&(pInput->ipRouteMetric5),
pRpcIpForw->dwForwardMetric5);
TraceLeave("MibSetIpRouteEntry");
return MIB_S_SUCCESS;
}
}
case MIB_ACTION_SET:
{
TraceEnter("MibSetIpRouteEntry - SET");
switch(pInput->raAction)
{
case CREATE_ROW:
{
dwResult = InternalCreateIpForwardEntry(pInfo);
#ifdef MIB_DEBUG
if(dwResult isnot NO_ERROR)
{
TRACE1("Create failed with error %d",dwResult);
}
#endif
InvalidateCache(FORWARD_MIB);
TraceLeave("MibSetIpRouteEntry");
return dwResult;
}
case SET_ROW:
{
dwResult = InternalSetIpForwardEntry(pInfo);
#ifdef MIB_DEBUG
if(dwResult isnot NO_ERROR)
{
TRACE1("MibSet failed with error %d",dwResult);
}
#endif
InvalidateCache(FORWARD_MIB);
TraceLeave("MibSetIpRouteEntry");
return dwResult;
}
case DELETE_ROW:
{
dwResult = InternalDeleteIpForwardEntry(pInfo);
#ifdef MIB_DEBUG
if(dwResult isnot NO_ERROR)
{
TRACE1("Delete failed with error %d",dwResult);
}
#endif
InvalidateCache(FORWARD_MIB);
TraceLeave("MibSetIpRouteEntry");
return dwResult;
}
default:
{
TRACE1("Wrong row action %d",pInput->raAction);
TraceLeave("MibSetIpRouteEntry");
return MIB_S_SUCCESS;
}
}
}
case MIB_ACTION_CLEANUP:
{
TraceEnter("MibSetIpRouteEntry - CLEANUP");
TraceLeave("MibSetIpRouteEntry");
if(pInput->bLocked)
{
ReleaseLock(FORWARD_MIB);
}
return MIB_S_SUCCESS;
}
default:
{
TraceEnter("MibSetIpRouteEntry - WRONG ACTION");
TraceLeave("MibSetIpRouteEntry");
return MIB_S_INVALID_PARAMETER;
}
}
}
UINT
MibGetIpNetToMediaEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
PMIB_IPNETROW pRpcIpNet;
DWORD dwResult;
PIP_NET_TO_MEDIA_ENTRY_GET pOutput;
TraceEnter("MibGetIpNetToMediaEntry");
dwResult = UpdateCache(MIB_II_IPNET);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update IP Net cache. Error %d", dwResult);
TraceLeave("MibGetIpNetToMediaEntry");
return dwResult;
}
pOutput = (PIP_NET_TO_MEDIA_ENTRY_GET)objectArray;
EnterReader(MIB_II_IPNET);
pRpcIpNet = LocateIpNetRow(actionId,
&(pOutput->ipNetToMediaIfIndex),
&(pOutput->ipNetToMediaNetAddress));
if(pRpcIpNet is NULL)
{
ReleaseLock(MIB_II_IPNET);
TRACE3("Unable to locateIP Net Row. Action is %d. IfIndex %d. Address %x",
actionId,
GetAsnInteger(&(pOutput->ipNetToMediaIfIndex), -1),
GetAsnIPAddress(&(pOutput->ipNetToMediaNetAddress),0xffffffff));
TraceLeave("MibGetIpNetToMediaEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
ForceSetAsnInteger(&(pOutput->ipNetToMediaIfIndex), pRpcIpNet->dwIndex);
SetAsnOctetString(&(pOutput->ipNetToMediaPhysAddress),
pOutput->rgbyIpNetToMediaPhysAddressInfo,
pRpcIpNet->bPhysAddr,
pRpcIpNet->dwPhysAddrLen);
ForceSetAsnIPAddress(&(pOutput->ipNetToMediaNetAddress),
&(pOutput->dwIpNetToMediaNetAddressInfo),
pRpcIpNet->dwAddr);
SetAsnInteger(&(pOutput->ipNetToMediaType), pRpcIpNet->dwType);
ReleaseLock(MIB_II_IPNET);
TraceLeave("MibGetIpNetToMediaEntry");
return MIB_S_SUCCESS;
}
UINT
MibSetIpNetToMediaEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
PMIB_IPNETROW pRpcIpNet;
DWORD dwResult,dwType;
PIP_NET_TO_MEDIA_ENTRY_SET pInput;
PMIB_OPAQUE_INFO pInfo;
PMIB_IPNETROW pSetRow;
pInput = (PIP_NET_TO_MEDIA_ENTRY_SET)objectArray;
pInfo = (PMIB_OPAQUE_INFO)(pInput->rgdwSetBuffer);
pSetRow = (PMIB_IPNETROW)(pInfo->rgbyData);
switch(actionId)
{
case MIB_ACTION_VALIDATE:
{
TraceEnter("MibSetIpNetToMediaEntry - VALIDATE");
ASSERT(!(IsAsnTypeNull(&(pInput->ipNetToMediaIfIndex)) or
IsAsnTypeNull(&(pInput->ipNetToMediaNetAddress))));
pInput->bLocked = FALSE;
dwResult = UpdateCache(MIB_II_IPNET);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update IP Net cache. Error %d", dwResult);
TraceLeave("MibSetIpNetToMediaEntry");
return dwResult;
}
pInfo->dwId = IP_NETROW;
EnterWriter(MIB_II_IPNET);
pInput->bLocked = TRUE;
pRpcIpNet = LocateIpNetRow(GET_EXACT,
&(pInput->ipNetToMediaIfIndex),
&(pInput->ipNetToMediaNetAddress));
if(pRpcIpNet is NULL)
{
//
// ok so we are creating an entry. We need to have all
// the fields
//
if(IsAsnTypeNull(&(pInput->ipNetToMediaPhysAddress)) or
IsAsnTypeNull(&(pInput->ipNetToMediaType)))
{
ReleaseLock(MIB_II_IPNET);
pInput->bLocked = FALSE;
TRACE0("Not enough info to create ARP entry");
TraceLeave("MibSetIpNetToMediaEntry");
return MIB_S_INVALID_PARAMETER;
}
dwType = GetAsnInteger(&(pInput->ipNetToMediaType), 0);
if((dwType isnot MIB_IPNET_TYPE_DYNAMIC) and
(dwType isnot MIB_IPNET_TYPE_STATIC))
{
ReleaseLock(MIB_II_IPNET);
pInput->bLocked = FALSE;
TRACE1("Type %d is wrong",dwType);
TraceLeave("MibSetIpNetToMediaEntry");
return MIB_S_INVALID_PARAMETER;
}
if(pInput->ipNetToMediaPhysAddress.asnValue.string.length > MAX_PHYS_ADDR_LEN)
{
ReleaseLock(MIB_II_IPNET);
pInput->bLocked = FALSE;
TRACE1("Length of phys addr (%d) is too large",
pInput->ipNetToMediaPhysAddress.asnValue.string.length);
TraceLeave("MibSetIpNetToMediaEntry");
return MIB_S_INVALID_PARAMETER;
}
pInput->raAction = CREATE_ROW;
pSetRow->dwIndex = GetAsnInteger(&(pInput->ipNetToMediaIfIndex),
0);
pSetRow->dwPhysAddrLen =
pInput->ipNetToMediaPhysAddress.asnValue.string.length;
CopyMemory(pSetRow->bPhysAddr,
pInput->ipNetToMediaPhysAddress.asnValue.string.stream,
pInput->ipNetToMediaPhysAddress.asnValue.string.length);
pSetRow->dwAddr =
GetAsnIPAddress(&(pInput->ipNetToMediaNetAddress),
0xffffffff);
pSetRow->dwType = dwType;
TraceLeave("MibSetIpNetToMediaEntry");
return MIB_S_SUCCESS;
}
else
{
//
// only changing stuff
//
dwType = GetAsnInteger(&(pInput->ipNetToMediaType),
pRpcIpNet->dwType);
if((dwType < 1) or
(dwType > 4))
{
ReleaseLock(MIB_II_IPNET);
pInput->bLocked = FALSE;
TRACE1("Type %d is wrong",dwType);
TraceLeave("MibSetIpNetToMediaEntry");
return MIB_S_INVALID_PARAMETER;
}
if(dwType is MIB_IPNET_TYPE_INVALID)
{
//
// We want to delete stuff
//
*pSetRow = *pRpcIpNet;
pInput->raAction = DELETE_ROW;
TraceLeave("MibSetIpNetToMediaEntry");
return MIB_S_SUCCESS;
}
if(pInput->ipNetToMediaPhysAddress.asnType isnot ASN_NULL)
{
if(pInput->ipNetToMediaPhysAddress.asnValue.string.length > MAX_PHYS_ADDR_LEN)
{
ReleaseLock(MIB_II_IPNET);
pInput->bLocked = FALSE;
TRACE1("Length of phys addr (%d) is too large",
pInput->ipNetToMediaPhysAddress.asnValue.string.length);
TraceLeave("MibSetIpNetToMediaEntry");
return MIB_S_INVALID_PARAMETER;
}
pSetRow->dwPhysAddrLen = pInput->ipNetToMediaPhysAddress.asnValue.string.length;
CopyMemory(pSetRow->bPhysAddr,
pInput->ipNetToMediaPhysAddress.asnValue.string.stream,
pInput->ipNetToMediaPhysAddress.asnValue.string.length);
}
else
{
pSetRow->dwPhysAddrLen = pRpcIpNet->dwPhysAddrLen;
CopyMemory(pSetRow->bPhysAddr,
pRpcIpNet->bPhysAddr,
pRpcIpNet->dwPhysAddrLen);
}
pInput->raAction = SET_ROW;
pSetRow->dwAddr =
GetAsnIPAddress(&(pInput->ipNetToMediaNetAddress),
pRpcIpNet->dwAddr);
pSetRow->dwType = dwType;
pSetRow->dwIndex = GetAsnInteger(&(pInput->ipNetToMediaIfIndex),0);
TraceLeave("MibSetIpNetToMediaEntry");
return MIB_S_SUCCESS;
}
}
case MIB_ACTION_SET:
{
TraceEnter("MibSetIpNetToMediaEntry- SET");
switch(pInput->raAction)
{
case CREATE_ROW:
{
dwResult = InternalCreateIpNetEntry(pInfo);
#ifdef MIB_DEBUG
if(dwResult isnot NO_ERROR)
{
TRACE1("Create failed with error %d!!",dwResult);
}
#endif
InvalidateCache(MIB_II_IPNET);
TraceLeave("MibSetIpNetToMediaEntry");
return dwResult;
}
case SET_ROW:
{
dwResult = InternalSetIpNetEntry(pInfo);
#ifdef MIB_DEBUG
if(dwResult isnot NO_ERROR)
{
TRACE1("Create failed with error %d!!",dwResult);
}
#endif
InvalidateCache(MIB_II_IPNET);
TraceLeave("MibSetIpNetToMediaEntry");
return dwResult;
}
case DELETE_ROW:
{
dwResult = InternalDeleteIpNetEntry(pInfo);
#ifdef MIB_DEBUG
if(dwResult isnot NO_ERROR)
{
TRACE1("Create failed with error %d!!",dwResult);
}
#endif
InvalidateCache(MIB_II_IPNET);
TraceLeave("MibSetIpNetToMediaEntry");
return dwResult;
}
default:
{
TRACE1("Wrong row action %d",pInput->raAction);
TraceLeave("MibSetIpNetToMediaEntry");
return MIB_S_SUCCESS;
}
}
}
case MIB_ACTION_CLEANUP:
{
TraceEnter("MibSetIpNetToMediaEntry - CLEANUP");
TraceLeave("MibSetIpNetToMediaEntry");
if(pInput->bLocked)
{
ReleaseLock(MIB_II_IPNET);
}
return MIB_S_SUCCESS;
}
default:
{
TraceEnter("MibSetIpNetToMediaEntry - WRONG ACTION");
TraceLeave("MibSetIpNetToMediaEntry");
return MIB_S_INVALID_PARAMETER;
}
}
}
UINT
MibGetIcmpGroup(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
MIB_ICMP rpcIcmp;
DWORD dwResult;
PICMP_GROUP_GET pOutput;
TraceEnter("MibGetIcmpGroup");
dwResult = GetIcmpStatistics(&rpcIcmp);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt get ICMP stats. Error %d",dwResult);
TraceLeave("MibGetIcmpGroup");
return dwResult;
}
pOutput = (PICMP_GROUP_GET)objectArray;
SetAsnCounter(&(pOutput->icmpInMsgs), rpcIcmp.stats.icmpInStats.dwMsgs);
SetAsnCounter(&(pOutput->icmpInErrors), rpcIcmp.stats.icmpInStats.dwErrors);
SetAsnCounter(&(pOutput->icmpInDestUnreachs), rpcIcmp.stats.icmpInStats.dwDestUnreachs);
SetAsnCounter(&(pOutput->icmpInTimeExcds), rpcIcmp.stats.icmpInStats.dwTimeExcds);
SetAsnCounter(&(pOutput->icmpInParmProbs), rpcIcmp.stats.icmpInStats.dwParmProbs);
SetAsnCounter(&(pOutput->icmpInSrcQuenchs), rpcIcmp.stats.icmpInStats.dwSrcQuenchs);
SetAsnCounter(&(pOutput->icmpInRedirects), rpcIcmp.stats.icmpInStats.dwRedirects);
SetAsnCounter(&(pOutput->icmpInEchos), rpcIcmp.stats.icmpInStats.dwEchos);
SetAsnCounter(&(pOutput->icmpInEchoReps), rpcIcmp.stats.icmpInStats.dwEchoReps);
SetAsnCounter(&(pOutput->icmpInTimestamps), rpcIcmp.stats.icmpInStats.dwTimestamps);
SetAsnCounter(&(pOutput->icmpInTimestampReps), rpcIcmp.stats.icmpInStats.dwTimestampReps);
SetAsnCounter(&(pOutput->icmpInAddrMasks), rpcIcmp.stats.icmpInStats.dwAddrMasks);
SetAsnCounter(&(pOutput->icmpInAddrMaskReps), rpcIcmp.stats.icmpInStats.dwAddrMaskReps);
SetAsnCounter(&(pOutput->icmpOutMsgs), rpcIcmp.stats.icmpOutStats.dwMsgs);
SetAsnCounter(&(pOutput->icmpOutErrors), rpcIcmp.stats.icmpOutStats.dwErrors);
SetAsnCounter(&(pOutput->icmpOutDestUnreachs), rpcIcmp.stats.icmpOutStats.dwDestUnreachs);
SetAsnCounter(&(pOutput->icmpOutTimeExcds), rpcIcmp.stats.icmpOutStats.dwTimeExcds);
SetAsnCounter(&(pOutput->icmpOutParmProbs), rpcIcmp.stats.icmpOutStats.dwParmProbs);
SetAsnCounter(&(pOutput->icmpOutSrcQuenchs), rpcIcmp.stats.icmpOutStats.dwSrcQuenchs);
SetAsnCounter(&(pOutput->icmpOutRedirects), rpcIcmp.stats.icmpOutStats.dwRedirects);
SetAsnCounter(&(pOutput->icmpOutEchos), rpcIcmp.stats.icmpOutStats.dwEchos);
SetAsnCounter(&(pOutput->icmpOutEchoReps), rpcIcmp.stats.icmpOutStats.dwEchoReps);
SetAsnCounter(&(pOutput->icmpOutTimestamps), rpcIcmp.stats.icmpOutStats.dwTimestamps);
SetAsnCounter(&(pOutput->icmpOutTimestampReps), rpcIcmp.stats.icmpOutStats.dwTimestampReps);
SetAsnCounter(&(pOutput->icmpOutAddrMasks), rpcIcmp.stats.icmpOutStats.dwAddrMasks);
SetAsnCounter(&(pOutput->icmpOutAddrMaskReps), rpcIcmp.stats.icmpOutStats.dwAddrMaskReps);
TraceLeave("MibGetIcmpGroup");
return MIB_S_SUCCESS;
}
UINT
MibGetTcpGroup(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
MIB_TCPSTATS rpcTcp4, rpcTcp6;
DWORD dwResult4, dwResult6;
PTCP_STATS_GET pOutput;
TraceEnter("MibGetTcpGroup");
ZeroMemory(&rpcTcp4, sizeof(rpcTcp4));
ZeroMemory(&rpcTcp6, sizeof(rpcTcp6));
dwResult4 = GetTcpStatisticsEx(&rpcTcp4, AF_INET);
dwResult6 = GetTcpStatisticsEx(&rpcTcp6, AF_INET6);
if ((dwResult4 isnot NO_ERROR) && (dwResult6 isnot NO_ERROR))
{
TRACE1("Couldnt get Tcp stats. Error %d",dwResult4);
TraceLeave("MibGetTcpGroup");
return dwResult4;
}
pOutput = (PTCP_STATS_GET)objectArray;
//
// The current MIB only has one object (per stat) for both IPv4 and IPv6.
// That is, it assumes a combination TCP stack). We can add together
// counters but for enumerated objects, we arbitrarily report the IPv4
// stack value.
//
SetAsnInteger(&(pOutput->tcpRtoAlgorithm), rpcTcp4.dwRtoAlgorithm);
SetAsnInteger(&(pOutput->tcpRtoMin), rpcTcp4.dwRtoMin);
SetAsnInteger(&(pOutput->tcpRtoMax), rpcTcp4.dwRtoMax);
SetAsnInteger(&(pOutput->tcpMaxConn), rpcTcp4.dwMaxConn);
SetAsnCounter(&(pOutput->tcpActiveOpens),
rpcTcp4.dwActiveOpens + rpcTcp6.dwActiveOpens);
SetAsnCounter(&(pOutput->tcpPassiveOpens),
rpcTcp4.dwPassiveOpens + rpcTcp6.dwPassiveOpens);
SetAsnCounter(&(pOutput->tcpAttemptFails),
rpcTcp4.dwAttemptFails + rpcTcp6.dwAttemptFails);
SetAsnCounter(&(pOutput->tcpEstabResets),
rpcTcp4.dwEstabResets + rpcTcp6.dwEstabResets);
SetAsnGauge(&(pOutput->tcpCurrEstab),
rpcTcp4.dwCurrEstab + rpcTcp6.dwCurrEstab);
SetAsnCounter(&(pOutput->tcpInSegs),
rpcTcp4.dwInSegs + rpcTcp6.dwInSegs);
SetAsnCounter(&(pOutput->tcpOutSegs),
rpcTcp4.dwOutSegs + rpcTcp6.dwOutSegs);
SetAsnCounter(&(pOutput->tcpRetransSegs),
rpcTcp4.dwRetransSegs + rpcTcp6.dwRetransSegs);
SetAsnCounter(&(pOutput->tcpInErrs),
rpcTcp4.dwInErrs + rpcTcp6.dwInErrs);
SetAsnCounter(&(pOutput->tcpOutRsts),
rpcTcp4.dwOutRsts + rpcTcp6.dwOutRsts);
TraceLeave("MibGetTcpGroup");
return MIB_S_SUCCESS;
}
UINT
MibGetTcpConnectionEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PMIB_TCPROW pRpcTcp;
PTCP_CONNECTION_ENTRY_GET pOutput;
TraceEnter("MibGetTcpConnectionEntry");
dwResult = UpdateCache(MIB_II_TCP);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update TCP Connection cache. Error %d", dwResult);
TraceLeave("MibGetTcpConnectionEntry");
return dwResult;
}
pOutput = (PTCP_CONNECTION_ENTRY_GET)objectArray;
EnterReader(MIB_II_TCP);
pRpcTcp = LocateTcpRow(actionId,
&(pOutput->tcpConnLocalAddress),
&(pOutput->tcpConnLocalPort),
&(pOutput->tcpConnRemAddress),
&(pOutput->tcpConnRemPort));
if(pRpcTcp is NULL)
{
ReleaseLock(MIB_II_TCP);
TRACE5("Couldnt find TCP Row. Action %d. LocalAddr %x, Localport %d, RemAddr %x, RemPort %d",
actionId,
GetAsnIPAddress(&(pOutput->tcpConnLocalAddress), 0xffffffff),
GetAsnInteger(&(pOutput->tcpConnLocalPort), -1),
GetAsnIPAddress(&(pOutput->tcpConnRemAddress), 0xffffffff),
GetAsnInteger(&(pOutput->tcpConnRemPort), -1));
TraceLeave("MibGetTcpConnectionEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
SetAsnInteger(&(pOutput->tcpConnState), pRpcTcp->dwState);
ForceSetAsnIPAddress(&(pOutput->tcpConnLocalAddress),
&(pOutput->dwTcpConnLocalAddressInfo),
pRpcTcp->dwLocalAddr);
ForceSetAsnInteger(&(pOutput->tcpConnLocalPort), pRpcTcp->dwLocalPort);
ForceSetAsnIPAddress(&(pOutput->tcpConnRemAddress),
&(pOutput->dwTcpConnRemAddressInfo),
pRpcTcp->dwRemoteAddr);
ForceSetAsnInteger(&(pOutput->tcpConnRemPort), pRpcTcp->dwRemotePort);
ReleaseLock(MIB_II_TCP);
TraceLeave("MibGetTcpConnectionEntry");
return MIB_S_SUCCESS;
}
UINT
MibGetTcpNewConnectionEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult = MIB_S_NO_MORE_ENTRIES;
PMIB_TCPROW pRpcTcp4;
PTCP6ConnTableEntry pRpcTcp6;
PTCP_NEW_CONNECTION_ENTRY_GET pOutput;
DWORD dwFamily;
TraceEnter("MibGetTcpNewConnectionEntry");
pOutput = (PTCP_NEW_CONNECTION_ENTRY_GET)objectArray;
dwFamily = GetAsnInteger(&pOutput->tcpNewConnLocalAddressType, INET_ADDRESS_TYPE_UNKNOWN);
if (dwFamily > INET_ADDRESS_TYPE_IPv6) {
return (actionId is MIB_ACTION_GETNEXT)?
MIB_S_NO_MORE_ENTRIES : MIB_S_ENTRY_NOT_FOUND;
}
//
// First try IPv4
//
if ((dwFamily == INET_ADDRESS_TYPE_UNKNOWN) ||
(dwFamily == INET_ADDRESS_TYPE_IPv4)) {
dwResult = UpdateCache(MIB_II_TCP);
if (dwResult isnot NO_ERROR) {
goto IPv4Done;
}
EnterReader(MIB_II_TCP);
pRpcTcp4 = LocateTcpRow(actionId,
&(pOutput->tcpNewConnLocalAddress),
&(pOutput->tcpNewConnLocalPort),
&(pOutput->tcpNewConnRemAddress),
&(pOutput->tcpNewConnRemPort));
if (pRpcTcp4 is NULL) {
dwResult = (actionId is MIB_ACTION_GETNEXT)?
MIB_S_NO_MORE_ENTRIES : MIB_S_ENTRY_NOT_FOUND;
goto IPv4Cleanup;
}
ForceSetAsnInteger(&(pOutput->tcpNewConnLocalAddressType), INET_ADDRESS_TYPE_IPv4);
ForceSetAsnOctetString(&(pOutput->tcpNewConnLocalAddress),
pOutput->rgbyTcpNewConnLocalAddressInfo,
&pRpcTcp4->dwLocalAddr,
sizeof(pRpcTcp4->dwLocalAddr));
ForceSetAsnInteger(&(pOutput->tcpNewConnLocalPort), pRpcTcp4->dwLocalPort);
ForceSetAsnInteger(&(pOutput->tcpNewConnRemAddressType), INET_ADDRESS_TYPE_IPv4);
ForceSetAsnOctetString(&(pOutput->tcpNewConnRemAddress),
pOutput->rgbyTcpNewConnRemAddressInfo,
&pRpcTcp4->dwRemoteAddr,
sizeof(pRpcTcp4->dwRemoteAddr));
ForceSetAsnInteger(&(pOutput->tcpNewConnRemPort), pRpcTcp4->dwRemotePort);
SetAsnInteger(&(pOutput->tcpNewConnState), pRpcTcp4->dwState);
dwResult = MIB_S_SUCCESS;
IPv4Cleanup:
ReleaseLock(MIB_II_TCP);
}
IPv4Done:
if (dwResult != MIB_S_NO_MORE_ENTRIES) {
return dwResult;
}
if ((dwFamily == INET_ADDRESS_TYPE_IPv4) && (actionId == MIB_ACTION_GETNEXT)) {
dwFamily = INET_ADDRESS_TYPE_IPv6;
actionId = MIB_ACTION_GETFIRST;
}
//
// Now try IPv6
//
if ((dwFamily == INET_ADDRESS_TYPE_UNKNOWN) ||
(dwFamily == INET_ADDRESS_TYPE_IPv6)) {
dwResult = UpdateCache(MIB_II_TCP6);
if (dwResult isnot NO_ERROR) {
goto IPv6Done;
}
EnterReader(MIB_II_TCP6);
pRpcTcp6 = LocateTcp6Row(actionId,
&(pOutput->tcpNewConnLocalAddress),
&(pOutput->tcpNewConnLocalPort),
&(pOutput->tcpNewConnRemAddress),
&(pOutput->tcpNewConnRemPort));
if (pRpcTcp6 is NULL) {
dwResult = (actionId is MIB_ACTION_GETNEXT)?
MIB_S_NO_MORE_ENTRIES : MIB_S_ENTRY_NOT_FOUND;
goto IPv6Cleanup;
}
ForceSetAsnInteger(&(pOutput->tcpNewConnLocalAddressType), INET_ADDRESS_TYPE_IPv6);
ForceSetAsnOctetString(&(pOutput->tcpNewConnLocalAddress),
pOutput->rgbyTcpNewConnLocalAddressInfo,
&pRpcTcp6->tct_localaddr,
(pRpcTcp6->tct_localscopeid)? 20 : 16);
ForceSetAsnInteger(&(pOutput->tcpNewConnLocalPort), pRpcTcp6->tct_localport);
ForceSetAsnInteger(&(pOutput->tcpNewConnRemAddressType), INET_ADDRESS_TYPE_IPv6);
ForceSetAsnOctetString(&(pOutput->tcpNewConnRemAddress),
pOutput->rgbyTcpNewConnRemAddressInfo,
&pRpcTcp6->tct_remoteaddr,
(pRpcTcp6->tct_remotescopeid)? 20 : 16);
ForceSetAsnInteger(&(pOutput->tcpNewConnRemPort), pRpcTcp6->tct_remoteport);
SetAsnInteger(&(pOutput->tcpNewConnState), pRpcTcp6->tct_state);
dwResult = MIB_S_SUCCESS;
IPv6Cleanup:
ReleaseLock(MIB_II_TCP6);
}
IPv6Done:
TraceLeave("MibGetTcpConnectionEntry");
return dwResult;
}
UINT
MibSetTcpConnectionEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult,dwState;
PMIB_TCPROW pRpcTcp;
PTCP_CONNECTION_ENTRY_SET pInput;
PMIB_OPAQUE_INFO pInfo;
PMIB_TCPROW pSetRow;
pInput = (PTCP_CONNECTION_ENTRY_SET)objectArray;
pInfo = (PMIB_OPAQUE_INFO)(pInput->rgdwSetBuffer);
pSetRow = (PMIB_TCPROW)(pInfo->rgbyData);
switch(actionId)
{
case MIB_ACTION_VALIDATE:
{
TraceEnter("MibSetTcpConnectionEntry - VALIDATE");
ASSERT(!(IsAsnTypeNull(&(pInput->tcpConnLocalAddress)) or
IsAsnTypeNull(&(pInput->tcpConnLocalPort)) or
IsAsnTypeNull(&(pInput->tcpConnRemAddress)) or
IsAsnTypeNull(&(pInput->tcpConnRemPort)) or
IsAsnTypeNull(&(pInput->tcpConnState))));
pInput->bLocked = FALSE;
dwState = GetAsnInteger(&(pInput->tcpConnState), 0);
if(dwState isnot MIB_TCP_STATE_DELETE_TCB)
{
TRACE1("State is %d. Only state allowed is DELETE",dwState);
return MIB_S_INVALID_PARAMETER;
}
dwResult = UpdateCache(MIB_II_TCP);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update TCP Connection cache. Error %d", dwResult);
TraceLeave("MibGetTcpConnectionEntry");
return dwResult;
}
EnterWriter(MIB_II_TCP);
pInput->bLocked = TRUE;
pRpcTcp = LocateTcpRow(GET_EXACT,
&(pInput->tcpConnLocalAddress),
&(pInput->tcpConnLocalPort),
&(pInput->tcpConnRemAddress),
&(pInput->tcpConnRemPort));
if(pRpcTcp is NULL)
{
ReleaseLock(MIB_II_TCP);
pInput->bLocked = FALSE;
TRACE5("Couldnt find TCP Row. Action %d. LocalAddr %x, Localport %d, RemAddr %x, RemPort %d",
actionId,
GetAsnIPAddress(&(pInput->tcpConnLocalAddress),
0xffffffff),
GetAsnInteger(&(pInput->tcpConnLocalPort),
-1),
GetAsnIPAddress(&(pInput->tcpConnRemAddress),
0xffffffff),
GetAsnInteger(&(pInput->tcpConnRemPort),
-1));
TraceLeave("MibSetTcpConnectionEntry");
return MIB_S_ENTRY_NOT_FOUND;
}
pInput->raAction = SET_ROW;
*pSetRow = *pRpcTcp;
pSetRow->dwState = MIB_TCP_STATE_DELETE_TCB;
//
// change port to network byte order
//
pSetRow->dwLocalPort = (DWORD)htons((WORD)pSetRow->dwLocalPort);
//
// chnage port to network byte order
//
pSetRow->dwRemotePort = (DWORD)htons((WORD)pSetRow->dwRemotePort);
return MIB_S_SUCCESS;
}
case MIB_ACTION_SET:
{
TraceEnter("MibSetTcpConnectionEntry - SET");
dwResult = NO_ERROR;
if(pInput->raAction is SET_ROW)
{
dwResult = InternalSetTcpEntry(pInfo);
#ifdef MIB_DEBUG
if(dwResult isnot NO_ERROR)
{
TRACE1("MibSet returned error %d!!",dwResult);
}
#endif
InvalidateCache(MIB_II_TCP);
}
TraceLeave("MibSetTcpConnectionEntry");
return dwResult;
}
case MIB_ACTION_CLEANUP:
{
TraceEnter("MibSetTcpConnectionEntry - CLEANUP");
if(pInput->bLocked)
{
ReleaseLock(MIB_II_TCP);
}
TraceLeave("MibSetTcpConnectionEntry");
return MIB_S_SUCCESS;
}
default:
{
TraceEnter("MibSetTcpConnectionEntry - WRONG ACTION");
TraceLeave("MibSetTcpConnectionEntry");
return MIB_S_INVALID_PARAMETER;
}
}
}
UINT
MibSetTcpNewConnectionEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult,dwState;
PMIB_TCPROW pRpcTcp4;
PTCP_NEW_CONNECTION_ENTRY_SET pInput;
PMIB_OPAQUE_INFO pInfo;
PMIB_TCPROW pSetRow;
pInput = (PTCP_NEW_CONNECTION_ENTRY_SET)objectArray;
pInfo = (PMIB_OPAQUE_INFO)(pInput->rgdwSetBuffer);
pSetRow = (PMIB_TCPROW)(pInfo->rgbyData);
switch(actionId)
{
case MIB_ACTION_VALIDATE:
{
TraceEnter("MibSetTcpNewConnectionEntry - VALIDATE");
ASSERT(!(IsAsnTypeNull(&(pInput->tcpNewConnLocalAddressType)) or
IsAsnTypeNull(&(pInput->tcpNewConnLocalAddress)) or
IsAsnTypeNull(&(pInput->tcpNewConnLocalPort)) or
IsAsnTypeNull(&(pInput->tcpNewConnRemAddressType)) or
IsAsnTypeNull(&(pInput->tcpNewConnRemAddress)) or
IsAsnTypeNull(&(pInput->tcpNewConnRemPort)) or
IsAsnTypeNull(&(pInput->tcpNewConnState))));
pInput->bLocked = FALSE;
dwState = GetAsnInteger(&(pInput->tcpNewConnState), 0);
if(dwState isnot MIB_TCP_STATE_DELETE_TCB)
{
TRACE1("State is %d. Only state allowed is DELETE",dwState);
return MIB_S_INVALID_PARAMETER;
}
dwResult = UpdateCache(MIB_II_TCP);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update TCP Connection cache. Error %d", dwResult);
TraceLeave("MibGetTcpNewConnectionEntry");
return dwResult;
}
EnterWriter(MIB_II_TCP);
pInput->bLocked = TRUE;
pRpcTcp4 = LocateTcpRow(GET_EXACT,
&(pInput->tcpNewConnLocalAddress),
&(pInput->tcpNewConnLocalPort),
&(pInput->tcpNewConnRemAddress),
&(pInput->tcpNewConnRemPort));
if(pRpcTcp4 is NULL)
{
ReleaseLock(MIB_II_TCP);
pInput->bLocked = FALSE;
TRACE5("Couldn't find TCP Row. Action %d. LocalAddr %x, Localport %d, RemAddr %x, RemPort %d",
actionId,
GetAsnIPAddress(&(pInput->tcpConnLocalAddress),
0xffffffff),
GetAsnInteger(&(pInput->tcpConnLocalPort),
-1),
GetAsnIPAddress(&(pInput->tcpConnRemAddress),
0xffffffff),
GetAsnInteger(&(pInput->tcpConnRemPort),
-1));
TraceLeave("MibSetTcpNewConnectionEntry");
return MIB_S_ENTRY_NOT_FOUND;
}
pInput->raAction = SET_ROW;
*pSetRow = *pRpcTcp4;
pSetRow->dwState = MIB_TCP_STATE_DELETE_TCB;
//
// change port to network byte order
//
pSetRow->dwLocalPort = (DWORD)htons((WORD)pSetRow->dwLocalPort);
//
// chnage port to network byte order
//
pSetRow->dwRemotePort = (DWORD)htons((WORD)pSetRow->dwRemotePort);
return MIB_S_SUCCESS;
}
case MIB_ACTION_SET:
{
TraceEnter("MibSetTcpNewConnectionEntry - SET");
dwResult = NO_ERROR;
if(pInput->raAction is SET_ROW)
{
dwResult = InternalSetTcpEntry(pInfo);
#ifdef MIB_DEBUG
if(dwResult isnot NO_ERROR)
{
TRACE1("MibSet returned error %d!!",dwResult);
}
#endif
InvalidateCache(MIB_II_TCP);
}
TraceLeave("MibSetTcpNewConnectionEntry");
return dwResult;
}
case MIB_ACTION_CLEANUP:
{
TraceEnter("MibSetTcpNewConnectionEntry - CLEANUP");
if(pInput->bLocked)
{
ReleaseLock(MIB_II_TCP);
}
TraceLeave("MibSetTcpNewConnectionEntry");
return MIB_S_SUCCESS;
}
default:
{
TraceEnter("MibSetTcpNewConnectionEntry - WRONG ACTION");
TraceLeave("MibSetTcpNewConnectionEntry");
return MIB_S_INVALID_PARAMETER;
}
}
}
UINT
MibGetUdpGroup(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
MIB_UDPSTATS rpcUdpStats;
PUDP_STATS_GET pOutput;
TraceEnter("MibGetUdpGroup");
dwResult = GetUdpStatistics(&rpcUdpStats);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt get Udp stats. Error %d",dwResult);
TraceLeave("MibGetUdpGroup");
return dwResult;
}
pOutput = (PUDP_STATS_GET)objectArray;
SetAsnCounter(&(pOutput->udpInDatagrams), rpcUdpStats.dwInDatagrams);
SetAsnCounter(&(pOutput->udpNoPorts), rpcUdpStats.dwNoPorts);
SetAsnCounter(&(pOutput->udpInErrors), rpcUdpStats.dwInErrors);
SetAsnCounter(&(pOutput->udpOutDatagrams), rpcUdpStats.dwOutDatagrams);
TraceLeave("MibGetUdpGroup");
return MIB_S_SUCCESS;
}
UINT
MibGetUdpEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PMIB_UDPROW pRpcUdp;
PUDP_ENTRY_GET pOutput;
TraceEnter("MibGetUdpEntry");
dwResult = UpdateCache(MIB_II_UDP);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update UDP Connection cache. Error %d", dwResult);
TraceLeave("MibGetUdpEntry");
return dwResult;
}
pOutput = (PUDP_ENTRY_GET)objectArray;
EnterReader(MIB_II_UDP);
pRpcUdp = LocateUdpRow(actionId,
&(pOutput->udpLocalAddress),
&(pOutput->udpLocalPort));
if(pRpcUdp is NULL)
{
ReleaseLock(MIB_II_UDP);
TRACE3("Couldnt find UDP Row. Action %d. LocalAddr %x, Localport %d",
actionId,
GetAsnIPAddress(&(pOutput->udpLocalAddress), 0xffffffff),
GetAsnInteger(&(pOutput->udpLocalPort), -1));
TraceLeave("MibGetUdpEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
ForceSetAsnIPAddress(&(pOutput->udpLocalAddress),
&(pOutput->dwUdpLocalAddressInfo),
pRpcUdp->dwLocalAddr);
ForceSetAsnInteger(&(pOutput->udpLocalPort), pRpcUdp->dwLocalPort);
ReleaseLock(MIB_II_UDP);
TraceLeave("MibGetUdpEntry");
return MIB_S_SUCCESS;
}
UINT
MibGetUdpListenerEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult = MIB_S_NO_MORE_ENTRIES;
PMIB_UDPROW pRpcUdp4;
PUDP6ListenerEntry pRpcUdp6;
PUDP_LISTENER_ENTRY_GET pOutput;
DWORD dwFamily;
TraceEnter("MibGetUdpListenerEntry");
pOutput = (PUDP_LISTENER_ENTRY_GET)objectArray;
dwFamily = GetAsnInteger(&pOutput->udpListenerLocalAddressType,
INET_ADDRESS_TYPE_UNKNOWN);
if (dwFamily > INET_ADDRESS_TYPE_IPv6) {
return (actionId is MIB_ACTION_GETNEXT)?
MIB_S_NO_MORE_ENTRIES : MIB_S_ENTRY_NOT_FOUND;
}
//
// First try IPv4
//
if ((dwFamily == INET_ADDRESS_TYPE_UNKNOWN) ||
(dwFamily == INET_ADDRESS_TYPE_IPv4)) {
dwResult = UpdateCache(MIB_II_UDP);
if(dwResult isnot NO_ERROR)
{
goto IPv4Done;
}
EnterReader(MIB_II_UDP);
pRpcUdp4 = LocateUdpRow(actionId,
&(pOutput->udpListenerLocalAddress),
&(pOutput->udpListenerLocalPort));
if(pRpcUdp4 is NULL)
{
dwResult = (actionId is MIB_ACTION_GETNEXT)?
MIB_S_NO_MORE_ENTRIES : MIB_S_ENTRY_NOT_FOUND;
goto IPv4Cleanup;
}
ForceSetAsnInteger(&(pOutput->udpListenerLocalAddressType),
INET_ADDRESS_TYPE_IPv4);
ForceSetAsnOctetString(&(pOutput->udpListenerLocalAddress),
pOutput->rgbyUdpLocalAddressInfo,
&pRpcUdp4->dwLocalAddr,
sizeof(pRpcUdp4->dwLocalAddr));
ForceSetAsnUnsigned32(&(pOutput->udpListenerLocalPort),
pRpcUdp4->dwLocalPort);
dwResult = MIB_S_SUCCESS;
IPv4Cleanup:
ReleaseLock(MIB_II_UDP);
}
IPv4Done:
if (dwResult != MIB_S_NO_MORE_ENTRIES) {
return dwResult;
}
if ((dwFamily == INET_ADDRESS_TYPE_IPv4) && (actionId == MIB_ACTION_GETNEXT)) {
dwFamily = INET_ADDRESS_TYPE_IPv6;
actionId = MIB_ACTION_GETFIRST;
}
//
// Now try IPv6
//
if ((dwFamily == INET_ADDRESS_TYPE_UNKNOWN) ||
(dwFamily == INET_ADDRESS_TYPE_IPv6)) {
dwResult = UpdateCache(MIB_II_UDP6_LISTENER);
if(dwResult isnot NO_ERROR)
{
goto IPv6Done;
}
EnterReader(MIB_II_UDP6_LISTENER);
pRpcUdp6 = LocateUdp6Row(actionId,
&(pOutput->udpListenerLocalAddress),
&(pOutput->udpListenerLocalPort));
if(pRpcUdp6 is NULL)
{
dwResult = (actionId is MIB_ACTION_GETNEXT)?
MIB_S_NO_MORE_ENTRIES : MIB_S_ENTRY_NOT_FOUND;
goto IPv6Cleanup;
}
ForceSetAsnInteger(&(pOutput->udpListenerLocalAddressType),
INET_ADDRESS_TYPE_IPv6);
ForceSetAsnOctetString(&(pOutput->udpListenerLocalAddress),
pOutput->rgbyUdpLocalAddressInfo,
&pRpcUdp6->ule_localaddr,
(pRpcUdp6->ule_localscopeid)? 20 : 16);
ForceSetAsnInteger(&(pOutput->udpListenerLocalPort),
pRpcUdp6->ule_localport);
dwResult = MIB_S_SUCCESS;
IPv6Cleanup:
ReleaseLock(MIB_II_UDP6_LISTENER);
}
IPv6Done:
TraceLeave("MibGetUdpEntry");
return dwResult;
}
UINT
MibGetIpForwardNumber(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PIP_FORWARD_NUMBER_GET pOutput;
TraceEnter("MibGetIpForwardNumber");
dwResult = UpdateCache(FORWARD_MIB);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update IP Forward cache",dwResult);
TraceLeave("MibGetIpForwardNumber");
return dwResult;
}
pOutput = (PIP_FORWARD_NUMBER_GET)objectArray;
EnterReader(FORWARD_MIB);
SetAsnGauge(&(pOutput->ipForwardNumber), g_Cache.pRpcIpForwardTable->dwNumEntries);
ReleaseLock(FORWARD_MIB);
TraceLeave("MibGetIpForwardNumber");
return MIB_S_SUCCESS;
}
UINT
MibGetIpForwardEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PMIB_IPFORWARDROW pRpcIpForw;
PIP_FORWARD_ENTRY_GET pOutput;
TraceEnter("MibGetIpForwardEntry");
dwResult = UpdateCache(FORWARD_MIB);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update IP Forward cache. Error %d", dwResult);
TraceLeave("MibGetIpForwardEntry");
return dwResult;
}
pOutput = (PIP_FORWARD_ENTRY_GET)objectArray;
EnterReader(FORWARD_MIB);
pRpcIpForw = LocateIpForwardRow(actionId,
&(pOutput->ipForwardDest),
&(pOutput->ipForwardProto),
&(pOutput->ipForwardPolicy),
&(pOutput->ipForwardNextHop));
if(pRpcIpForw is NULL)
{
ReleaseLock(FORWARD_MIB);
TRACE5("Unable to locateIP Forward Row. Action %d. Dest %x Proto %d Policy %d NextHop %x",
actionId,
GetAsnIPAddress(&(pOutput->ipForwardDest),0),
GetAsnInteger(&(pOutput->ipForwardProto),0),
GetAsnInteger(&(pOutput->ipForwardPolicy),0),
GetAsnIPAddress(&(pOutput->ipForwardNextHop),0));
TraceLeave("MibGetIpForwardEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
ForceSetAsnIPAddress(&(pOutput->ipForwardDest),
&(pOutput->dwIpForwardDestInfo),
pRpcIpForw->dwForwardDest);
SetAsnIPAddress(&(pOutput->ipForwardMask),
&(pOutput->dwIpForwardMaskInfo),
pRpcIpForw->dwForwardMask);
ForceSetAsnInteger(&(pOutput->ipForwardPolicy), pRpcIpForw->dwForwardPolicy);
ForceSetAsnIPAddress(&(pOutput->ipForwardNextHop),
&(pOutput->dwIpForwardNextHopInfo),
pRpcIpForw->dwForwardNextHop);
SetAsnInteger(&(pOutput->ipForwardIfIndex), pRpcIpForw->dwForwardIfIndex);
SetAsnInteger(&(pOutput->ipForwardType), pRpcIpForw->dwForwardType);
ForceSetAsnInteger(&(pOutput->ipForwardProto), pRpcIpForw->dwForwardProto);
SetAsnInteger(&(pOutput->ipForwardAge), pRpcIpForw->dwForwardAge);
SetToZeroOid(&(pOutput->ipForwardInfo));
SetAsnInteger(&(pOutput->ipForwardNextHopAS), pRpcIpForw->dwForwardNextHopAS);
SetAsnInteger(&(pOutput->ipForwardMetric1), pRpcIpForw->dwForwardMetric1);
SetAsnInteger(&(pOutput->ipForwardMetric2), pRpcIpForw->dwForwardMetric2);
SetAsnInteger(&(pOutput->ipForwardMetric3), pRpcIpForw->dwForwardMetric3);
SetAsnInteger(&(pOutput->ipForwardMetric4), pRpcIpForw->dwForwardMetric4);
SetAsnInteger(&(pOutput->ipForwardMetric5), pRpcIpForw->dwForwardMetric5);
ReleaseLock(FORWARD_MIB);
TraceLeave("MibGetIpForwardEntry");
return MIB_S_SUCCESS;
}
UINT
MibSetIpForwardEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult,dwType;
PMIB_IPFORWARDROW pRpcIpForw;
PIP_FORWARD_ENTRY_SET pInput;
PMIB_OPAQUE_INFO pInfo;
PMIB_IPFORWARDROW pSetRow;
pInput = (PIP_FORWARD_ENTRY_SET)objectArray;
pInfo = (PMIB_OPAQUE_INFO)(pInput->rgdwSetBuffer);
pSetRow = (PMIB_IPFORWARDROW)(pInfo->rgbyData);
switch(actionId)
{
case MIB_ACTION_VALIDATE:
{
TraceEnter("MibSetIpForwardEntry - VALIDATE");
dwResult = UpdateCache(FORWARD_MIB);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update IP Forward cache. Error %d", dwResult);
TraceLeave("GetIpForwardEntry");
return dwResult;
}
ASSERT(!(IsAsnTypeNull(&(pInput->ipForwardDest))));
pInfo->dwId = IP_FORWARDROW;
EnterWriter(FORWARD_MIB);
pInput->bLocked = TRUE;
pRpcIpForw = LocateIpForwardRow(actionId,
&(pInput->ipForwardDest),
&(pInput->ipForwardProto),
&(pInput->ipForwardPolicy),
&(pInput->ipForwardNextHop));
if(pRpcIpForw is NULL)
{
//
// So we are creating a row. We need the If index, the mask,
// next hop and metric 1
//
if(IsAsnTypeNull(&(pInput->ipForwardIfIndex)) or
IsAsnTypeNull(&(pInput->ipForwardMask)) or
IsAsnTypeNull(&(pInput->ipForwardNextHop)) or
IsAsnTypeNull(&(pInput->ipForwardMetric1)))
{
TRACE0("Not enough information to create a route");
ReleaseLock(FORWARD_MIB);
pInput->bLocked = FALSE;
TraceLeave("MibSetIpForwardEntry");
return MIB_S_INVALID_PARAMETER;
}
dwType = GetAsnInteger(&(pInput->ipForwardType),
MIB_IPROUTE_TYPE_OTHER);
if(dwType is MIB_IPROUTE_TYPE_INVALID)
{
//
// We couldnt be creating and deleting a row at the
// same time
//
ReleaseLock(FORWARD_MIB);
pInput->bLocked = FALSE;
TRACE0("Wrong type");
TraceLeave("MibSetIpForwardEntry");
return MIB_S_INVALID_PARAMETER;
}
pSetRow->dwForwardProto =
GetAsnInteger(&(pInput->ipForwardProto),
MIB_IPPROTO_NETMGMT);
if((pSetRow->dwForwardProto isnot MIB_IPPROTO_NETMGMT) and
(pSetRow->dwForwardProto isnot MIB_IPPROTO_LOCAL))
{
//
// wrong protocol
//
ReleaseLock(FORWARD_MIB);
pInput->bLocked = FALSE;
TRACE1("Wrong protocol %d",
pSetRow->dwForwardProto);
TraceLeave("MibSetIpForwardEntry");
return MIB_S_INVALID_PARAMETER;
}
pInput->raAction = CREATE_ROW;
pSetRow->dwForwardDest =
GetAsnIPAddress(&(pInput->ipForwardDest),
0xffffffff);
pSetRow->dwForwardMask =
GetAsnIPAddress(&(pInput->ipForwardMask),
0x00000000);
pSetRow->dwForwardPolicy = 0;
pSetRow->dwForwardNextHop =
GetAsnIPAddress(&(pInput->ipForwardNextHop),
0x00000000);
pSetRow->dwForwardIfIndex =
GetAsnInteger(&(pInput->ipForwardIfIndex),
0);
//
// We default to an age of 0 seconds, per RFC 2096.
//
pSetRow->dwForwardAge =
GetAsnInteger(&(pInput->ipForwardAge),0);
pSetRow->dwForwardNextHopAS = 0;
pSetRow->dwForwardMetric1 =
GetAsnInteger(&(pInput->ipForwardMetric1),0);
pSetRow->dwForwardMetric2 =
GetAsnInteger(&(pInput->ipForwardMetric2),-1);
pSetRow->dwForwardMetric3 =
GetAsnInteger(&(pInput->ipForwardMetric3),-1);
pSetRow->dwForwardMetric4 =
GetAsnInteger(&(pInput->ipForwardMetric4),-1);
pSetRow->dwForwardMetric5 =
GetAsnInteger(&(pInput->ipForwardMetric5),-1);
TraceLeave("MibSetIpForwardEntry");
return MIB_S_SUCCESS;
}
else
{
//
// Ok so we are only changing some stuff in the route
//
dwType = GetAsnInteger(&(pInput->ipForwardType),
pRpcIpForw->dwForwardType);
if(dwType is MIB_IPROUTE_TYPE_INVALID)
{
//
// Deleting a row
//
pInput->raAction = DELETE_ROW;
*pSetRow = *pRpcIpForw;
ReleaseLock(FORWARD_MIB);
pInput->bLocked = FALSE;
TraceLeave("MibSetIpForwardEntry");
return MIB_S_SUCCESS;
}
pSetRow->dwForwardProto =
GetAsnInteger(&(pInput->ipForwardProto),
pRpcIpForw->dwForwardProto);
if((pSetRow->dwForwardProto isnot MIB_IPPROTO_NETMGMT) and
(pSetRow->dwForwardProto isnot MIB_IPPROTO_LOCAL))
{
//
// wrong protocol
//
ReleaseLock(FORWARD_MIB);
pInput->bLocked = FALSE;
TRACE1("Wrong protocol %d",
pSetRow->dwForwardProto);
TraceLeave("MibSetIpForwardEntry");
return MIB_S_INVALID_PARAMETER;
}
pInput->raAction = SET_ROW;
pSetRow->dwForwardDest =
GetAsnIPAddress(&(pInput->ipForwardDest),
pRpcIpForw->dwForwardDest);
pSetRow->dwForwardMask =
GetAsnIPAddress(&(pInput->ipForwardMask),
pRpcIpForw->dwForwardMask);
pSetRow->dwForwardPolicy = 0;
pSetRow->dwForwardNextHop =
GetAsnIPAddress(&(pInput->ipForwardNextHop),
pRpcIpForw->dwForwardNextHop);
pSetRow->dwForwardIfIndex =
GetAsnInteger(&(pInput->ipForwardIfIndex),
pRpcIpForw->dwForwardIfIndex);
//
// The type gets set by the router manager. But incase
// we are writing to the stack we need some kind of valid type
//
pSetRow->dwForwardType =
GetAsnInteger(&(pInput->ipForwardType),
pRpcIpForw->dwForwardType);
pSetRow->dwForwardAge =
GetAsnInteger(&(pInput->ipForwardAge),
pRpcIpForw->dwForwardAge);
pSetRow->dwForwardNextHopAS = 0;
pSetRow->dwForwardMetric1 =
GetAsnInteger(&(pInput->ipForwardMetric1),
pRpcIpForw->dwForwardMetric1);
pSetRow->dwForwardMetric2 =
GetAsnInteger(&(pInput->ipForwardMetric2),
pRpcIpForw->dwForwardMetric2);
pSetRow->dwForwardMetric3 =
GetAsnInteger(&(pInput->ipForwardMetric3),
pRpcIpForw->dwForwardMetric3);
pSetRow->dwForwardMetric4 =
GetAsnInteger(&(pInput->ipForwardMetric4),
pRpcIpForw->dwForwardMetric4);
pSetRow->dwForwardMetric5 =
GetAsnInteger(&(pInput->ipForwardMetric5),
pRpcIpForw->dwForwardMetric5);
TraceLeave("MibSetIpForwardEntry");
return MIB_S_SUCCESS;
}
}
case MIB_ACTION_SET:
{
TraceEnter("MibSetIpForwardEntry - SET");
switch(pInput->raAction)
{
case CREATE_ROW:
{
dwResult = InternalCreateIpForwardEntry(pInfo);
#ifdef MIB_DEBUG
if(dwResult isnot NO_ERROR)
{
TRACE1("Create failed with error %d",dwResult);
}
#endif
InvalidateCache(FORWARD_MIB);
TraceLeave("MibSetIpForwardEntry");
return dwResult;
}
case SET_ROW:
{
dwResult = InternalSetIpForwardEntry(pInfo);
#ifdef MIB_DEBUG
if(dwResult isnot NO_ERROR)
{
TRACE1("Set failed with error %d",dwResult);
}
#endif
InvalidateCache(FORWARD_MIB);
TraceLeave("MibSetIpForwardEntry");
return dwResult;
}
case DELETE_ROW:
{
dwResult = InternalDeleteIpForwardEntry(pInfo);
#ifdef MIB_DEBUG
if(dwResult isnot NO_ERROR)
{
TRACE1("Delete failed with error %d",dwResult);
}
#endif
InvalidateCache(FORWARD_MIB);
TraceLeave("MibSetIpForwardEntry");
return dwResult;
}
default:
{
TRACE1("Wrong row action %d",pInput->raAction);
TraceLeave("MibSetIpForwardEntry");
return MIB_S_SUCCESS;
}
}
}
case MIB_ACTION_CLEANUP:
{
TraceEnter("MibSetIpForwardEntry - CLEANUP");
if(pInput->bLocked)
{
ReleaseLock(FORWARD_MIB);
}
TraceLeave("MibSetIpForwardEntry");
return MIB_S_SUCCESS;
}
default:
{
TraceEnter("MibSetIpForwardEntry - WRONG ACTION");
TraceLeave("MibSetIpForwardEntry");
return MIB_S_INVALID_PARAMETER;
}
}
}
UINT
MibGetSysInfo(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PSYS_INFO_GET pOutput;
TraceEnter("MibGetSysInfo");
dwResult = UpdateCache(MIB_II_SYS);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update SYS cache. Error %d", dwResult);
TraceLeave("MibGetSysInfo");
return dwResult;
}
pOutput = (PSYS_INFO_GET)objectArray;
EnterReader(MIB_II_SYS);
SetAsnOctetString(&(pOutput->sysDescr),
pOutput->rgbySysDescrInfo,
g_Cache.pRpcSysInfo->rgbySysDescr,
(strlen(g_Cache.pRpcSysInfo->rgbySysDescr)));
SetAsnInteger(&(pOutput->sysServices),g_Cache.pRpcSysInfo->dwSysServices);
SetAsnOctetString(&(pOutput->sysContact),
pOutput->rgbySysContactInfo,
g_Cache.pRpcSysInfo->rgbySysContact,
(strlen(g_Cache.pRpcSysInfo->rgbySysContact)));
SetAsnOctetString(&(pOutput->sysLocation),
pOutput->rgbySysLocationInfo,
g_Cache.pRpcSysInfo->rgbySysLocation,
(strlen(g_Cache.pRpcSysInfo->rgbySysLocation)));
SetAsnOctetString(&(pOutput->sysName),
pOutput->rgbySysNameInfo,
g_Cache.pRpcSysInfo->rgbySysName,
(strlen(g_Cache.pRpcSysInfo->rgbySysName)));
//
// must not cache system uptime so get update from dll
//
SetAsnTimeTicks(&(pOutput->sysUpTime),SnmpSvcGetUptime());
if (!IsAsnTypeNull(&pOutput->sysObjectID)) {
SnmpUtilOidCpy(&pOutput->sysObjectID.asnValue.object,
&g_Cache.pRpcSysInfo->aaSysObjectID.asnValue.object);
}
ReleaseLock(MIB_II_SYS);
TraceLeave("MibGetSysInfo");
return MIB_S_SUCCESS;
}
UINT
MibSetSysInfo(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult,dwValueLen,dwValueType,dwStringLen;
PSYS_INFO_SET pInput;
HKEY hkeyMib2;
pInput = (PSYS_INFO_SET)objectArray;
switch(actionId)
{
case MIB_ACTION_VALIDATE:
{
pInput->bLocked = FALSE;
EnterWriter(MIB_II_SYS);
pInput->bLocked = TRUE;
TraceEnter("MibSetSysInfo - VALIDATE");
dwResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
REG_KEY_MIB2,
0,
KEY_ALL_ACCESS,
&pInput->hkeyMib2);
if(dwResult isnot NO_ERROR)
{
ReleaseLock(MIB_II_SYS);
pInput->bLocked = FALSE;
TRACE1("Couldnt open mib2 registry key. Error %d", dwResult);
TraceLeave("MibSetSysInfo");
return dwResult;
}
TraceLeave("MibSetSysInfo");
return MIB_S_SUCCESS;
}
case MIB_ACTION_SET:
{
TraceEnter("MibSetSysInfo - SET");
hkeyMib2 = pInput->hkeyMib2;
dwValueType = REG_SZ;
if (!IsAsnTypeNull(&pInput->sysName)) {
dwStringLen = pInput->sysName.asnValue.string.length;
dwValueLen = dwStringLen + 1;
memcpy(&pInput->rgbySysNameInfo,
pInput->sysName.asnValue.string.stream,
dwStringLen);
pInput->rgbySysNameInfo[dwStringLen] = '\0';
dwResult = RegSetValueEx(
hkeyMib2,
TEXT("sysName"),
0,
dwValueType,
pInput->rgbySysNameInfo,
dwValueLen);
if (dwResult isnot NO_ERROR) {
TRACE1("Couldnt write sysName value. Error %d", dwResult);
TraceLeave("MibSetSysInfo");
return dwResult;
}
InvalidateCache(MIB_II_SYS);
}
if (!IsAsnTypeNull(&pInput->sysContact)) {
dwStringLen = pInput->sysContact.asnValue.string.length;
dwValueLen = dwStringLen + 1;
memcpy(&pInput->rgbySysContactInfo,
pInput->sysContact.asnValue.string.stream,
dwStringLen);
pInput->rgbySysContactInfo[dwStringLen] = '\0';
dwResult = RegSetValueEx(
hkeyMib2,
TEXT("sysContact"),
0,
dwValueType,
pInput->rgbySysContactInfo,
dwValueLen);
if (dwResult isnot NO_ERROR) {
TRACE1("Couldnt write sysContact value. Error %d", dwResult);
TraceLeave("MibSetSysInfo");
return dwResult;
}
InvalidateCache(MIB_II_SYS);
}
if (!IsAsnTypeNull(&pInput->sysLocation)) {
dwStringLen = pInput->sysLocation.asnValue.string.length;
dwValueLen = dwStringLen + 1;
memcpy(&pInput->rgbySysLocationInfo,
pInput->sysLocation.asnValue.string.stream,
dwStringLen);
pInput->rgbySysLocationInfo[dwStringLen] = '\0';
dwResult = RegSetValueEx(
hkeyMib2,
TEXT("sysLocation"),
0,
dwValueType,
pInput->rgbySysLocationInfo,
dwValueLen);
if (dwResult isnot NO_ERROR) {
TRACE1("Couldnt write sysLocation value. Error %d", dwResult);
TraceLeave("MibSetSysInfo");
return dwResult;
}
InvalidateCache(MIB_II_SYS);
}
TraceLeave("MibSetSysInfo");
return MIB_S_SUCCESS;
}
case MIB_ACTION_CLEANUP:
{
TraceEnter("MibSetSysInfo - CLEANUP");
if (pInput->hkeyMib2) {
RegCloseKey(pInput->hkeyMib2);
}
if(pInput->bLocked)
{
ReleaseLock(MIB_II_SYS);
}
TraceLeave("MibSetSysInfo");
return MIB_S_SUCCESS;
}
default:
{
TraceEnter("MibSetSysInfo - WRONG ACTION");
TraceLeave("MibSetSysInfo");
return MIB_S_INVALID_PARAMETER;
}
}
}
DWORD
GetIfIndexFromAddr(
DWORD dwAddr
)
{
DWORD dwResult, i;
PMIB_IPADDRROW pRpcIpAddr;
DWORD dwIfIndex = INVALID_IFINDEX;
TraceEnter("GetIfIndexFromIpAddr");
dwResult = UpdateCache(MIB_II_IPADDR);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update IP Addr cache. Error %d", dwResult);
TraceLeave("GetIfIndexFromIpAddr");
return dwIfIndex;
}
EnterReader(MIB_II_IPADDR);
pRpcIpAddr = &g_Cache.pRpcIpAddrTable->table[0];
for (i = 0; i < g_Cache.pRpcIpAddrTable->dwNumEntries; i++, pRpcIpAddr++)
{
if (dwAddr is pRpcIpAddr->dwAddr)
{
dwIfIndex = pRpcIpAddr->dwIndex;
TRACE1("Found exact match. ifIndex %d", dwIfIndex);
break;
}
if ((dwIfIndex is INVALID_IFINDEX) and (pRpcIpAddr->dwMask))
{
//
// See if addr is on the same subnet as this address.
//
if ((dwAddr & pRpcIpAddr->dwMask) is
(pRpcIpAddr->dwAddr & pRpcIpAddr->dwMask))
{
dwIfIndex = pRpcIpAddr->dwIndex;
TRACE1("Found possible match. ifIndex %d", dwIfIndex);
}
}
}
ReleaseLock(MIB_II_IPADDR);
TraceLeave("GetIfIndexFromIpAddr");
return dwIfIndex;
}
UINT
MibGetIpv6Group(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PIPV6_STATS_GET pOutput;
MIB_IPSTATS rpcIpStats;
TraceEnter("MibGetIpv6Group");
dwResult = GetIpStatisticsEx(&rpcIpStats, AF_INET6);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt get IP stats. Error %d",dwResult);
TraceLeave("MibGetIpGroup");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
pOutput = (PIPV6_STATS_GET)objectArray;
SetAsnInteger(&(pOutput->ipv6Forwarding), rpcIpStats.dwForwarding);
SetAsnInteger(&(pOutput->ipv6DefaultHopLimit), rpcIpStats.dwDefaultTTL);
SetAsnUnsigned32(&(pOutput->ipv6Interfaces), rpcIpStats.dwNumIf);
SetAsnTimeTicks(&(pOutput->ipv6IfTableLastChange), 0);
SetAsnGauge(&(pOutput->ipv6RouteNumber), rpcIpStats.dwNumRoutes);
SetAsnCounter(&(pOutput->ipv6DiscardedRoutes), 0);
TraceLeave("MibGetIpv6Group");
return MIB_S_SUCCESS;
}
UINT
MibGetIpv6IfEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PMIB_IPV6_IF pRpcIf;
PIPV6_IF_GET pOutput;
CHAR szDescription[MAX_IF_DESCR_LEN + 1];
TraceEnter("MibGetIf6Entry");
dwResult = UpdateCache(MIB_II_IPV6_IF);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldn't update IF cache. Error %d",dwResult);
TraceLeave("MibGetIfEntry");
return dwResult;
}
pOutput = (PIPV6_IF_GET)objectArray;
EnterReader(MIB_II_IPV6_IF);
pRpcIf = LocateIpv6IfRow(actionId,
&(pOutput->ipv6IfIndex));
if(pRpcIf is NULL)
{
ReleaseLock(MIB_II_IPV6_IF);
TRACE2("Unable to locate IF Row. Action is %d. Index is %d",
actionId,
GetAsnInteger(&(pOutput->ifIndex),-1));
TraceLeave("MibGetIfEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
ForceSetAsnInteger(&(pOutput->ipv6IfIndex),pRpcIf->dwIndex);
WideCharToMultiByte(CP_UTF8, 0, pRpcIf->wszDescription, -1,
szDescription, MAX_IF_DESCR_LEN,
NULL, NULL);
SetAsnOctetString(&(pOutput->ipv6IfDescr),
pOutput->rgbyIpv6IfDescrInfo,
szDescription,
min(strlen(szDescription),MAX_IF_DESCR_LEN));
//
// Don't implement ifLowerLayer, since it's non-trivial,
// and is obsoleted in the latest draft updating the RFC.
//
SetToZeroOid(&(pOutput->ipv6IfLowerLayer));
SetAsnUnsigned32(&(pOutput->ipv6IfEffectiveMtu), pRpcIf->dwEffectiveMtu);
SetAsnUnsigned32(&(pOutput->ipv6IfReasmMaxSize), pRpcIf->dwReasmMaxSize);
//
// TODO: The EUI-64 is not currently retrievable from user-mode.
//
SetAsnOctetString(&(pOutput->ipv6IfIdentifier),
pOutput->rgbyIpv6IfIdentifierInfo,
NULL,
0);
SetAsnInteger(&(pOutput->ipv6IfIdentifierLength), 0);
SetAsnOctetString(&(pOutput->ipv6IfPhysicalAddress),
pOutput->rgbyIpv6IfPhysicalAddressInfo,
pRpcIf->bPhysicalAddress,
min(pRpcIf->dwPhysicalAddressLength,MAX_PHYS_ADDR_LEN));
SetAsnInteger(&(pOutput->ipv6IfAdminStatus), pRpcIf->dwAdminStatus);
SetAsnInteger(&(pOutput->ipv6IfOperStatus), pRpcIf->dwOperStatus);
SetAsnTimeTicks(&(pOutput->ipv6IfLastChange), pRpcIf->dwLastChange);
ReleaseLock(MIB_II_IPV6_IF);
TraceLeave("MibGetIpv6IfEntry");
return MIB_S_SUCCESS;
}
UINT
MibGetIpv6IfStatsEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
LONG IfIndex;
PIPV6_IF_STATS_GET pOutput = (PIPV6_IF_STATS_GET)objectArray;
MIB_IPSTATS rpcIpStats;
TraceEnter("MibGetIpv6IfStatsEntry");
IfIndex = GetAsnInteger(&(pOutput->ipv6IfIndex),-1);
if ((actionId is MIB_ACTION_GETNEXT) && (IfIndex >= 0))
{
TraceLeave("MibGetIpv6IfStatsEntry");
return MIB_S_NO_MORE_ENTRIES;
}
if ((actionId is MIB_ACTION_GET) && (IfIndex != 0))
{
TraceLeave("MibGetIpv6IfStatsEntry");
return MIB_S_ENTRY_NOT_FOUND;
}
dwResult = GetIpStatisticsEx(&rpcIpStats, AF_INET6);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldn't get IPv6 stats. Error %d",dwResult);
TraceLeave("MibGetIpv6IfStatsEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
ForceSetAsnInteger(&(pOutput->ipv6IfIndex), 0);
SetAsnCounter(&(pOutput->ipv6IfStatsInReceives), rpcIpStats.dwInReceives);
SetAsnCounter(&(pOutput->ipv6IfStatsInHdrErrors), rpcIpStats.dwInHdrErrors);
SetAsnCounter(&(pOutput->ipv6IfStatsInTooBigErrors), 0);
SetAsnCounter(&(pOutput->ipv6IfStatsInNoRoutes), rpcIpStats.dwOutNoRoutes);
SetAsnCounter(&(pOutput->ipv6IfStatsInAddrErrors), rpcIpStats.dwInAddrErrors);
SetAsnCounter(&(pOutput->ipv6IfStatsInUnknownProtos), rpcIpStats.dwInUnknownProtos);
SetAsnCounter(&(pOutput->ipv6IfStatsInTruncatedPkts), 0);
SetAsnCounter(&(pOutput->ipv6IfStatsInDiscards), rpcIpStats.dwInDiscards);
SetAsnCounter(&(pOutput->ipv6IfStatsInDelivers), rpcIpStats.dwInDelivers);
SetAsnCounter(&(pOutput->ipv6IfStatsOutForwDatagrams), rpcIpStats.dwForwDatagrams);
SetAsnCounter(&(pOutput->ipv6IfStatsOutRequests), rpcIpStats.dwOutRequests);
SetAsnCounter(&(pOutput->ipv6IfStatsOutDiscards), rpcIpStats.dwOutDiscards);
SetAsnCounter(&(pOutput->ipv6IfStatsOutFragOKs), rpcIpStats.dwFragOks);
SetAsnCounter(&(pOutput->ipv6IfStatsOutFragFails), rpcIpStats.dwFragFails);
SetAsnCounter(&(pOutput->ipv6IfStatsOutFragCreates), rpcIpStats.dwFragCreates);
SetAsnCounter(&(pOutput->ipv6IfStatsReasmReqds), rpcIpStats.dwReasmReqds);
SetAsnCounter(&(pOutput->ipv6IfStatsReasmOKs), rpcIpStats.dwReasmOks);
SetAsnCounter(&(pOutput->ipv6IfStatsReasmFails), rpcIpStats.dwReasmFails);
SetAsnCounter(&(pOutput->ipv6IfStatsInMcastPkts), 0);
SetAsnCounter(&(pOutput->ipv6IfStatsOutMcastPkts), 0);
TraceLeave("MibGetIpv6IfStatsEntry");
return MIB_S_SUCCESS;
}
UINT
MibGetInetIcmpEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PINET_ICMP_GET pOutput = (PINET_ICMP_GET)objectArray;
PMIB_INET_ICMP pRow;
TraceEnter("MibGetInetIcmpEntry");
dwResult = UpdateCache(MIB_II_ICMP);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldn't update ICMP cache. Error %d",dwResult);
TraceLeave("MibGetInetIcmpEntry");
return dwResult;
}
EnterReader(MIB_II_ICMP);
pOutput = (PINET_ICMP_GET)objectArray;
pRow = LocateInetIcmpRow(actionId,
&(pOutput->inetIcmpAFType),
&(pOutput->inetIcmpIfIndex));
if(pRow is NULL)
{
ReleaseLock(MIB_II_ICMP);
TRACE0("Unable to locate icmp row");
TraceLeave("MibGetInetIcmpEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
ForceSetAsnInteger(&(pOutput->inetIcmpAFType), pRow->dwAFType);
ForceSetAsnInteger(&(pOutput->inetIcmpIfIndex), pRow->dwIfIndex);
SetAsnCounter(&(pOutput->inetIcmpInMsgs), pRow->dwInMsgs);
SetAsnCounter(&(pOutput->inetIcmpInErrors), pRow->dwInErrors);
SetAsnCounter(&(pOutput->inetIcmpOutMsgs), pRow->dwOutMsgs);
SetAsnCounter(&(pOutput->inetIcmpOutErrors), pRow->dwOutErrors);
ReleaseLock(MIB_II_ICMP);
TraceLeave("MibGetInetIcmpEntry");
return MIB_S_SUCCESS;
}
UINT
MibGetInetIcmpMsgEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PINET_ICMP_MSG_GET pOutput = (PINET_ICMP_MSG_GET)objectArray;
PMIB_INET_ICMP_MSG pRow;
TraceEnter("MibGetInetIcmpMsgEntry");
dwResult = UpdateCache(MIB_II_ICMP);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldnt update ICMP cache. Error %d",dwResult);
TraceLeave("MibGetInetIcmpMsgEntry");
return dwResult;
}
EnterReader(MIB_II_ICMP);
pOutput = (PINET_ICMP_MSG_GET)objectArray;
pRow = LocateInetIcmpMsgRow(actionId,
&(pOutput->inetIcmpMsgAFType),
&(pOutput->inetIcmpMsgIfIndex),
&(pOutput->inetIcmpMsgType),
&(pOutput->inetIcmpMsgCode));
if(pRow is NULL)
{
ReleaseLock(MIB_II_ICMP);
TRACE0("Unable to locate icmp row");
TraceLeave("MibGetInetIcmpMsgEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
ForceSetAsnInteger(&(pOutput->inetIcmpMsgAFType), pRow->dwAFType);
ForceSetAsnInteger(&(pOutput->inetIcmpMsgIfIndex), pRow->dwIfIndex);
ForceSetAsnInteger(&(pOutput->inetIcmpMsgType), pRow->dwType);
ForceSetAsnInteger(&(pOutput->inetIcmpMsgCode), pRow->dwCode);
SetAsnCounter(&(pOutput->inetIcmpMsgInPkts), pRow->dwInPkts);
SetAsnCounter(&(pOutput->inetIcmpMsgOutPkts), pRow->dwOutPkts);
ReleaseLock(MIB_II_ICMP);
TraceLeave("MibGetInetIcmpMsgEntry");
return MIB_S_SUCCESS;
}
UINT
MibGetIpv6AddrEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PIPV6_ADDR_GET pOutput;
PMIB_IPV6_ADDR pAddr;
TraceEnter("MibGetIpv6AddrEntry");
dwResult = UpdateCache(MIB_II_IPV6_IF);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldn't update IPv6 address cache. Error %d",dwResult);
TraceLeave("MibGetIpv6AddrEntry");
return dwResult;
}
EnterReader(MIB_II_IPV6_IF);
pOutput = (PIPV6_ADDR_GET)objectArray;
pAddr = LocateIpv6AddrRow(actionId,
&(pOutput->ipv6IfIndex),
&(pOutput->ipv6AddrAddress));
if(pAddr is NULL)
{
ReleaseLock(MIB_II_IPV6_IF);
TRACE0("Unable to locate IPv6 address row");
TraceLeave("MibGetIpv6AddrEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
ForceSetAsnInteger(&(pOutput->ipv6IfIndex), pAddr->dwIfIndex);
ForceSetAsnOctetString(&(pOutput->ipv6AddrAddress),
&pOutput->ipv6AddrAddressInfo,
&pAddr->ipAddress,
sizeof(IN6_ADDR));
SetAsnInteger(&(pOutput->ipv6AddrPfxLength), pAddr->dwPrefixLength);
SetAsnInteger(&(pOutput->ipv6AddrType), pAddr->dwType);
SetAsnInteger(&(pOutput->ipv6AddrAnycastFlag), pAddr->dwAnycastFlag);
SetAsnInteger(&(pOutput->ipv6AddrStatus), pAddr->dwStatus);
ReleaseLock(MIB_II_IPV6_IF);
TraceLeave("MibGetIpv6AddrEntry");
return MIB_S_SUCCESS;
}
UINT
MibGetIpv6AddrPrefixEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PIPV6_ADDR_PREFIX_GET pOutput;
PMIB_IPV6_ADDR_PREFIX pRow;
TraceEnter("MibGetIpv6AddrPrefixEntry");
dwResult = UpdateCache(MIB_II_IPV6_ROUTE);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldn't update IPv6 addr prefix table. Error %d",dwResult);
TraceLeave("MibGetIpv6AddrPrefixEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
EnterReader(MIB_II_IPV6_ROUTE);
pOutput = (PIPV6_ADDR_PREFIX_GET)objectArray;
pRow = LocateIpv6AddrPrefixRow(actionId,
&(pOutput->ipv6IfIndex),
&(pOutput->ipv6AddrPrefix),
&(pOutput->ipv6AddrPrefixLength));
if(pRow is NULL)
{
ReleaseLock(MIB_II_IPV6_ROUTE);
TRACE0("Unable to locate IPv6 route row");
TraceLeave("MibGetIpv6AddrPrefixEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
ForceSetAsnInteger(&(pOutput->ipv6IfIndex), pRow->dwIfIndex);
ForceSetAsnOctetString(&(pOutput->ipv6AddrPrefix),
&pOutput->ipv6AddrPrefixInfo,
&pRow->ipPrefix,
sizeof(IN6_ADDR));
ForceSetAsnInteger(&(pOutput->ipv6AddrPrefixLength), pRow->dwPrefixLength);
SetAsnInteger(&(pOutput->ipv6AddrPrefixOnLinkFlag), pRow->dwOnLinkFlag);
SetAsnInteger(&(pOutput->ipv6AddrPrefixAutonomousFlag),
pRow->dwAutonomousFlag);
SetAsnUnsigned32(&(pOutput->ipv6AddrPrefixAdvPreferredLifetime),
pRow->dwPreferredLifetime);
SetAsnUnsigned32(&(pOutput->ipv6AddrPrefixAdvValidLifetime),
pRow->dwValidLifetime);
ReleaseLock(MIB_II_IPV6_ROUTE);
TraceLeave("MibGetIpv6AddrPrefixEntry");
return MIB_S_SUCCESS;
}
UINT
MibGetIpv6RouteEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PIPV6_ROUTE_GET pOutput;
PMIB_IPV6_ROUTE pRow;
TraceEnter("MibGetIpv6RouteEntry");
dwResult = UpdateCache(MIB_II_IPV6_ROUTE);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldn't update IPv6 route table. Error %d",dwResult);
TraceLeave("MibGetIpv6RouteEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
EnterReader(MIB_II_IPV6_ROUTE);
pOutput = (PIPV6_ROUTE_GET)objectArray;
pRow = LocateIpv6RouteRow(actionId,
&(pOutput->ipv6RouteDest),
&(pOutput->ipv6RoutePfxLength),
&(pOutput->ipv6RouteIndex));
if(pRow is NULL)
{
ReleaseLock(MIB_II_IPV6_ROUTE);
TRACE0("Unable to locate IPv6 route row");
TraceLeave("MibGetIpv6RouteEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
ForceSetAsnOctetString(&(pOutput->ipv6RouteDest),
&pOutput->ipv6RouteDestInfo,
&pRow->ipPrefix,
sizeof(IN6_ADDR));
ForceSetAsnInteger(&(pOutput->ipv6RoutePfxLength), pRow->dwPrefixLength);
ForceSetAsnInteger(&(pOutput->ipv6RouteIndex), pRow->dwIndex);
SetAsnInteger(&(pOutput->ipv6RouteIfIndex), pRow->dwIfIndex);
SetAsnOctetString(&(pOutput->ipv6RouteNextHop),
&pOutput->ipv6RouteNextHopInfo,
&pRow->ipNextHop,
sizeof(IN6_ADDR));
SetAsnInteger(&(pOutput->ipv6RouteType), pRow->dwType);
SetAsnInteger(&(pOutput->ipv6RouteProtocol), pRow->dwProtocol);
SetAsnInteger(&(pOutput->ipv6RoutePolicy), pRow->dwPolicy);
SetAsnUnsigned32(&(pOutput->ipv6RouteAge), pRow->dwAge);
SetAsnUnsigned32(&(pOutput->ipv6RouteNextHopRDI), pRow->dwNextHopRDI);
SetAsnUnsigned32(&(pOutput->ipv6RouteMetric), pRow->dwMetric);
SetAsnUnsigned32(&(pOutput->ipv6RouteWeight), pRow->dwWeight);
SetToZeroOid(&(pOutput->ipv6RouteInfo));
SetAsnInteger(&(pOutput->ipv6RouteValid), pRow->dwValid);
ReleaseLock(MIB_II_IPV6_ROUTE);
TraceLeave("MibGetIpv6RouteEntry");
return MIB_S_SUCCESS;
}
UINT
MibGetIpv6NetToMediaEntry(
UINT actionId,
AsnAny *objectArray,
UINT *errorIndex
)
{
DWORD dwResult;
PIPV6_NET_TO_MEDIA_GET pOutput;
PMIB_IPV6_NET_TO_MEDIA pRow;
TraceEnter("MibGetIpv6NetToMediaEntry");
dwResult = UpdateCache(MIB_II_IPV6_NET_TO_MEDIA);
if(dwResult isnot NO_ERROR)
{
TRACE1("Couldn't update IPv6 neighbor cache. Error %d",dwResult);
TraceLeave("MibGetIpv6NetToMediaEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
EnterReader(MIB_II_IPV6_NET_TO_MEDIA);
pOutput = (PIPV6_NET_TO_MEDIA_GET)objectArray;
pRow = LocateIpv6NetToMediaRow(actionId,
&(pOutput->ipv6IfIndex),
&(pOutput->ipv6NetToMediaNetAddress));
if(pRow is NULL)
{
ReleaseLock(MIB_II_IPV6_NET_TO_MEDIA);
TRACE0("Unable to locate IPv6 neighbor row");
TraceLeave("MibGetIpv6NetToMediaEntry");
if(actionId is MIB_ACTION_GETNEXT)
{
return MIB_S_NO_MORE_ENTRIES;
}
return MIB_S_ENTRY_NOT_FOUND;
}
ForceSetAsnInteger(&(pOutput->ipv6IfIndex), pRow->dwIfIndex);
ForceSetAsnOctetString(&(pOutput->ipv6NetToMediaNetAddress),
&pOutput->ipv6NetToMediaNetAddressInfo,
&pRow->ipAddress,
sizeof(IN6_ADDR));
SetAsnOctetString(&(pOutput->ipv6NetToMediaPhysAddress),
pOutput->ipv6NetToMediaPhysAddressInfo,
pRow->bPhysAddress,
min(pRow->dwPhysAddressLen,MAX_PHYS_ADDR_LEN));
SetAsnInteger(&(pOutput->ipv6NetToMediaType), pRow->dwType);
SetAsnInteger(&(pOutput->ipv6NetToMediaState), pRow->dwState);
SetAsnTimeTicks(&(pOutput->ipv6NetToMediaLastUpdated), pRow->dwLastUpdated);
SetAsnInteger(&(pOutput->ipv6NetToMediaValid), pRow->dwValid);
ReleaseLock(MIB_II_IPV6_NET_TO_MEDIA);
TraceLeave("MibGetIpv6NetToMediaEntry");
return MIB_S_SUCCESS;
}