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.
337 lines
9.3 KiB
337 lines
9.3 KiB
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
|
|
#include <iostream.h>
|
|
#include <fstream.h>
|
|
|
|
#include <afx.h>
|
|
#include <afxtempl.h>
|
|
#include <objbase.h>
|
|
#include <afxwin.h>
|
|
#include <afxole.h>
|
|
#include <afxmt.h>
|
|
#include <wchar.h>
|
|
#include <process.h>
|
|
#include <objbase.h>
|
|
#include <initguid.h>
|
|
|
|
#include <bool.hpp>
|
|
#include <nString.hpp>
|
|
#include <ui.hpp>
|
|
#include <symbol.hpp>
|
|
#include <type.hpp>
|
|
#include <value.hpp>
|
|
#include <valueRef.hpp>
|
|
#include <typeRef.hpp>
|
|
#include <oidValue.hpp>
|
|
#include <objType.hpp>
|
|
#include <objTypV1.hpp>
|
|
#include <objTypV2.hpp>
|
|
#include <objId.hpp>
|
|
#include <trapType.hpp>
|
|
#include <notType.hpp>
|
|
#include <group.hpp>
|
|
#include <notGroup.hpp>
|
|
#include <module.hpp>
|
|
#include <sValues.hpp>
|
|
#include <lex_yy.hpp>
|
|
#include <ytab.hpp>
|
|
#include <errorMsg.hpp>
|
|
#include <errorCon.hpp>
|
|
#include <scanner.hpp>
|
|
#include <parser.hpp>
|
|
#include <apTree.hpp>
|
|
#include <oidTree.hpp>
|
|
#include <pTree.hpp>
|
|
|
|
#include "debug.hpp"
|
|
#include "Oid.hpp"
|
|
#include "OTScan.hpp"
|
|
|
|
typedef struct _oidBuiltIn
|
|
{
|
|
const char * m_szSymbol;
|
|
UINT m_nSubID;
|
|
UINT m_nNextSibling;
|
|
} T_OID_BUILTIN;
|
|
|
|
#define BUILTIN_OID_COUNT 29
|
|
static T_OID_BUILTIN g_BuiltinOIDs[] = {
|
|
/*0 */ {"zero", 0, 29}, {"ccitt", 0, 2}, {"iso", 1, 28},
|
|
/*3 */ {"org", 3, 29}, {"dod", 6, 29}, {"internet", 1, 29},
|
|
/*6 */ {"directory", 1, 7}, {"mgmt", 2, 12}, {"mib-2", 1, 29},
|
|
/*9 */ {"interfaces", 2, 10}, {"ip", 4, 11}, {"transmission", 10, 29},
|
|
/*12*/ {"experimental", 3, 13}, {"private", 4, 15}, {"enterprises", 1, 29},
|
|
/*15*/ {"security", 5, 16}, {"snmpV2", 6, 29}, {"snmpDomains", 1, 24},
|
|
/*18*/ {"snmpUDPDomain", 1, 19}, {"snmpCLNSDomain", 2, 20}, {"snmpCONSDomain",3, 21},
|
|
/*21*/ {"snmpDDPDomain", 4, 22}, {"snmpIPXDomain", 5, 23}, {"rfc1157Domain", 6, 29},
|
|
/*24*/ {"snmpProxys", 2, 27}, {"rfc1157Proxy", 1, 29}, {"rfc1157Domain", 1, 29},
|
|
/*27*/ {"snmpModules", 3, 28}, {"joint-iso-ccitt", 2, 28}
|
|
};
|
|
|
|
|
|
// DESCRIPTION:
|
|
// Adds list of nodes from lstChildren to the tail of m_recursionTrace,
|
|
// constructing at the same time the OID lexicographically order.
|
|
// the list received as parameter should not be modified;
|
|
// PARAMETERS:
|
|
// (in) list of nodes to add
|
|
void OidTreeScanner::UpdateRecursionTrace(SIMCNodeList *pLstChildren, SIMCNodeList *pLstTrace)
|
|
{
|
|
int nChld;
|
|
POSITION posChld;
|
|
|
|
_ASSERT((pLstChildren != NULL) && (pLstTrace != NULL), "NULL parameter error!", NULL);
|
|
|
|
// for each node from the children list
|
|
for (posChld = pLstChildren->GetHeadPosition(), nChld=0;
|
|
posChld != NULL;
|
|
nChld++)
|
|
{
|
|
int nList;
|
|
POSITION posList;
|
|
SIMCOidTreeNode *nodeChld, *nodeList;
|
|
|
|
nodeChld = pLstChildren->GetNext(posChld);
|
|
nodeList = NULL;
|
|
|
|
// if it's the first child to add, it goes at the head of the list
|
|
if (nChld == 0)
|
|
{
|
|
_ASSERT(pLstTrace->AddHead(nodeChld)!=NULL,
|
|
"Memory Allocation error",
|
|
NULL);
|
|
}
|
|
// otherwise, the head of the list should be an ordered list of
|
|
// maximum nChld nodes. The new node is inserted in this list
|
|
// with respect to it's value.
|
|
else
|
|
{
|
|
// there are at least nChld nodes in m_recursionTrace
|
|
for (nList=0, posList = pLstTrace->GetHeadPosition();
|
|
nList < nChld;
|
|
nList++)
|
|
{
|
|
POSITION posBackup = posList;
|
|
|
|
nodeList = (SIMCOidTreeNode *)pLstTrace->GetNext(posBackup);
|
|
_ASSERT(nodeList != NULL, "Internal OidNode List error!", NULL);
|
|
|
|
// if the node to add has the value less then the current node, it
|
|
// should be inserted in the list right before it.
|
|
if (nodeChld->GetValue() < nodeList->GetValue())
|
|
break;
|
|
posList = posBackup;
|
|
}
|
|
if (posList != NULL)
|
|
{
|
|
_ASSERT(pLstTrace->InsertBefore(posList, nodeChld)!=NULL,
|
|
"Memory allocation error",
|
|
NULL);
|
|
}
|
|
else
|
|
{
|
|
_ASSERT(pLstTrace->AddTail(nodeChld)!=NULL,
|
|
"Memory allocation error",
|
|
NULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// DESCRIPTION:
|
|
// Gets the first symbol from the symbol list of the node pOidNode
|
|
// PARAMETERS:
|
|
// (in) pOidNode whose symbol is to be returned
|
|
// (out) cszSymbol - pointer to the symbol (do not alter or free)
|
|
// RETURN VALUE:
|
|
// 0 on success, -1 on failure
|
|
int OidTreeScanner::GetNodeSymbol(const SIMCOidTreeNode *pOidNode, const char * & cszSymbol)
|
|
{
|
|
const SIMCSymbolList *pSymbolList;
|
|
|
|
_VERIFY(pOidNode != NULL, -1);
|
|
pSymbolList = pOidNode->GetSymbolList();
|
|
_VERIFY(pSymbolList != NULL, -1);
|
|
|
|
if (pSymbolList->IsEmpty())
|
|
{
|
|
cszSymbol = (pOidNode->_pParam != NULL) ? (const char *)pOidNode->_pParam : NULL;
|
|
}
|
|
else
|
|
{
|
|
const SIMCSymbol **ppSymbol;
|
|
|
|
ppSymbol = pSymbolList->GetHead();
|
|
_VERIFY(ppSymbol != NULL && *ppSymbol != NULL, -1);
|
|
|
|
cszSymbol = (*ppSymbol)->GetSymbolName();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// DESCRIPTION:
|
|
// Gets the complete OID information for the given pOidNode.
|
|
// It supplies both the numeric value and symbolic name for each
|
|
// component of the OID.
|
|
// PARAMETERS:
|
|
// (in) pOidNode - the node whose OID is to be found
|
|
// (out) oid - the Oid object who stores the data
|
|
// RETURN VALUE:
|
|
// 0 on success
|
|
// -1 on failure
|
|
int OidTreeScanner::GetNodeOid(const SIMCOidTreeNode *pOidNode, Oid &oid)
|
|
{
|
|
_VERIFY(pOidNode != NULL, -1);
|
|
_VERIFY(m_pOidTree != NULL, -1);
|
|
do
|
|
{
|
|
const char * cszSymbol = NULL;
|
|
|
|
_VERIFY(GetNodeSymbol(pOidNode, cszSymbol)==0, -1);
|
|
|
|
_VERIFY(oid.AddComponent(pOidNode->GetValue(), cszSymbol)==0, -1);
|
|
|
|
pOidNode = m_pOidTree->GetParentOf(pOidNode);
|
|
} while (pOidNode != NULL);
|
|
oid.ReverseComponents();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
// initializes the OidTreeScanner
|
|
OidTreeScanner::OidTreeScanner()
|
|
{
|
|
m_pOidTree = NULL;
|
|
}
|
|
|
|
// DESCRIPTION:
|
|
// scans lexicographically the oid tree;
|
|
// RETURN VALUE:
|
|
// 0 on success
|
|
// -1 on failure;
|
|
int OidTreeScanner::Scan()
|
|
{
|
|
SIMCOidTreeNode *pOidNode;
|
|
SIMCNodeList recursionTrace;
|
|
|
|
// get the root node from the oid tree,
|
|
// return "error" if no tree or no root
|
|
_VERIFY(m_pOidTree != NULL, -1);
|
|
pOidNode = (SIMCOidTreeNode *)m_pOidTree->GetRoot();
|
|
_VERIFY(pOidNode != NULL, -1);
|
|
|
|
// initialize the recursion trace list with the root node
|
|
_VERIFY(recursionTrace.AddHead(pOidNode)!=NULL, -1);
|
|
|
|
// start to scan the tree
|
|
while (!recursionTrace.IsEmpty())
|
|
{
|
|
// list of current node's children
|
|
SIMCNodeList *lstChildren;
|
|
|
|
// allways pick up the node in the head of the list
|
|
pOidNode = recursionTrace.GetHead();
|
|
|
|
// then erase it from the list
|
|
recursionTrace.RemoveAt(recursionTrace.GetHeadPosition());
|
|
|
|
// check to see if the scanner should stop (with error code)
|
|
_VERIFY(OnScanNode(pOidNode)==0, -1);
|
|
|
|
// get the list of children
|
|
lstChildren = (SIMCNodeList *)pOidNode->GetListOfChildNodes();
|
|
|
|
// if there are children
|
|
if (lstChildren != NULL)
|
|
// add children to the head of the trace list
|
|
UpdateRecursionTrace(lstChildren, &recursionTrace);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// DESCRIPTION:
|
|
// Fills the symbols of the built-in objects from the static table
|
|
// RETURN VALUE:
|
|
// 0 - on success, -1 on failure
|
|
int OidTreeScanner::MergeBuiltIn()
|
|
{
|
|
SIMCNodeList lstOidStack;
|
|
SIMCOidTreeNode *pOid;
|
|
CList <unsigned int, unsigned int> wlstBuiltinStack;
|
|
unsigned int nBuiltin;
|
|
|
|
// initialize the two stacks with the root nodes from
|
|
// the oid tree and from the builtin symbols
|
|
pOid = (SIMCOidTreeNode *)m_pOidTree->GetRoot();
|
|
_VERIFY(pOid != NULL, -1);
|
|
_VERIFY(lstOidStack.AddHead(pOid)!=NULL, -1);
|
|
_VERIFY(wlstBuiltinStack.AddHead((unsigned int)0)!=NULL, -1);
|
|
|
|
// as long as there are items on the stack, process each item
|
|
// item is processed only if it doesn't have a symbol associated
|
|
while(!lstOidStack.IsEmpty())
|
|
{
|
|
const SIMCSymbolList *pSymbolList;
|
|
|
|
pOid = lstOidStack.RemoveHead();
|
|
nBuiltin = wlstBuiltinStack.RemoveHead();
|
|
pSymbolList = pOid->GetSymbolList();
|
|
_VERIFY(pSymbolList != NULL, -1);
|
|
|
|
// if node already has a symbol attached, no need to dive deeper
|
|
if (!pSymbolList->IsEmpty())
|
|
continue;
|
|
else
|
|
{
|
|
const SIMCNodeList *pChildList;
|
|
|
|
pOid->_pParam = (void *)g_BuiltinOIDs[nBuiltin].m_szSymbol;
|
|
|
|
// now push new nodes on the stacks
|
|
pChildList = pOid->GetListOfChildNodes();
|
|
_VERIFY(pChildList != NULL, -1);
|
|
for (POSITION p = pChildList->GetHeadPosition(); p != NULL;)
|
|
{
|
|
unsigned int i;
|
|
|
|
pOid = pChildList->GetNext(p);
|
|
_VERIFY(pOid != NULL, -1);
|
|
|
|
// the child nodes always begin at index nBuiltin+1 (if they exist)
|
|
// and end before the parent's first sibling node.
|
|
for (i = nBuiltin+1;
|
|
i < g_BuiltinOIDs[nBuiltin].m_nNextSibling;
|
|
i = g_BuiltinOIDs[i].m_nNextSibling)
|
|
{
|
|
// when the match is found, push both nodes on their stacks (in sync)
|
|
// and go to another child
|
|
if (g_BuiltinOIDs[i].m_nSubID == (UINT)pOid->GetValue())
|
|
{
|
|
_VERIFY(lstOidStack.AddHead(pOid)!=NULL, -1);
|
|
_VERIFY(wlstBuiltinStack.AddHead(i)!=NULL, -1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// DESCRIPTION:
|
|
// initializes the m_pOidTree.
|
|
// PARAMETERS:
|
|
// (in) pointer to the SIMCOidTree to scan.
|
|
void OidTreeScanner::SetOidTree(SIMCOidTree *pOidTree)
|
|
{
|
|
m_pOidTree = pOidTree;
|
|
}
|
|
|
|
OidTreeScanner::~OidTreeScanner()
|
|
{
|
|
}
|