📄 smparcom.c
字号:
MIBENUM *pOT;
MIBENUM *pEnum;
USHORT rt;
int err;
/* check if any available */
pEnum = (MIBENUM *)malloc(sizeof(MIBENUM));
if (pEnum != NULL)
{
err = AllocMemAdd(pEnum);
if (err)
{
free(pEnum);
return(FALSE);
}
else
{
cEnumUsed++;
/* init fields */
pEnum->pszName = pNa->pszVal;
pEnum->ulVal = ulVal;
pEnum->pNext = NULL;
pSyn->cEnum++;
/* check for duplicate name or value */
for (pOT = NULL, pT = pSyn->usi.pEnumL; pT != NULL;
pOT = pT, pT = pT->pNext)
{
if ((rt = strcmp(pEnum->pszName, pT->pszName)) == 0)
{
/* duplicate name */
fprintf(fhMsg, "duplicate name \"%s\" in ENUMERATION",
pEnum->pszName);
}
if (ulVal == pT->ulVal)
{
/* duplicate value */
fprintf(fhMsg, "duplicate value of %lu for \"%s\" and \"%s\" in ENUMERATION",
ulVal, pEnum->pszName, pT->pszName);
}
}
if (pOT == NULL)
{
/* insert at beginning of list */
pSyn->usi.pEnumL = pEnum;
}
else
{
/* insert in list */
pOT->pNext = pEnum;
}
/* check if name in lowercase */
if (!islower(*(pEnum->pszName)))
{
fprintf(fhMsg, "Name of enumerated value \"%s\" must start with a lowercase letter",
pEnum->pszName);
}
}
}
return(TRUE);
} /* addENUMitem */
#if 0
BOOL
#ifdef __STDC__
addENUMitem(STRTAB *pNa, ULONG ulVal, MIBSYN *pSyn)
#else
addENUMitem(pNa, ulVal, pSyn)
STRTAB *pNa;
ULONG ulVal;
MIBSYN *pSyn;
#endif /* __STDC__ */
{
MIBENUM *pT;
MIBENUM *pOT;
MIBENUM *pEnum;
USHORT i;
USHORT rt;
/* check if any available */
if (pEnumAvail == NULL) {
/* none avail - so allocate some */
pEnumAvail = (MIBENUM *)malloc(sizeof(MIBENUM)*MIBENUMACT);
if (pEnumAvail == NULL) {
yyerror("addENUMitem: out of heap memory");
yystats();
yyterm();
return(FALSE);
}
cEnumAlloc += MIBENUMACT;
/* put items in list */
for (pT = pEnumAvail, i = 1; i < MIBENUMACT; i++, pT++) {
pT->pNext = pT+1;
}
pT->pNext = NULL;
}
/* get enumerated item from list */
pEnum = pEnumAvail;
pEnumAvail = pEnumAvail->pNext;
cEnumUsed++;
/* init fields */
pEnum->pszName = pNa->pszVal;
pEnum->ulVal = ulVal;
pEnum->pNext = NULL;
pSyn->cEnum++;
/* check for duplicate name or value */
for (pOT = NULL, pT = pSyn->usi.pEnumL; pT != NULL;
pOT = pT, pT = pT->pNext) {
if ((rt = strcmp(pEnum->pszName, pT->pszName)) == 0) {
/* duplicate name */
yyerror("duplicate name \"%s\" in ENUMERATION",
pEnum->pszName);
#ifdef OLD
yyterm();
return(FALSE);
#endif
}
if (ulVal == pT->ulVal) {
/* duplicate value */
yyerror("duplicate value of %lu for \"%s\" and \"%s\" in ENUMERATION",
ulVal, pEnum->pszName, pT->pszName);
#ifdef OLD
yyterm();
return(FALSE);
#endif
}
}
if (pOT == NULL) {
/* insert at beginning of list */
pSyn->usi.pEnumL = pEnum;
} else {
/* insert in list */
pOT->pNext = pEnum;
}
/* check if name in lowercase */
if (!islower(*(pEnum->pszName))) {
yywarning("Name of enumerated value \"%s\" must start with a lowercase letter",
pEnum->pszName);
}
return(TRUE);
} /* addENUMitem */
#endif
/** newINDX - allocate an Index item
*
* call with:
* pOid - row object
* usItype - index type
* pOidIndx - index item (or NULL)
* ulLow - low for range (or size for fixed length string)
* ulHigh - high for range
*
* returns:
* ptr to new item or NULL if error
*/
MIBINDX *newINDX(MIBSYM *pOid, USHORT usItype, MIBSYM *pOidIndx,
ULONG ulLow, ULONG ulHigh)
{
MIBINDX *pT;
MIBINDX *pOT;
MIBINDX *pIndx;
SHORT rt;
BOOL fCkNa;
int err;
pIndx = (MIBINDX *)malloc(sizeof(MIBINDX));
if (pIndx != NULL)
{
err = AllocMemAdd(pIndx);
if (err)
{
free(pIndx);
}
else
{
cIndxUsed++;
/* initialize */
++(pOid->ut.oid.cIndx);
/* init fields */
pIndx->usItype = usItype;
pIndx->pOid = pOidIndx;
pIndx->ulLow = ulLow;
pIndx->ulHigh = ulHigh;
/* insert at end of list after checking for dups */
fCkNa = (usItype == MIBITobj) || (usItype == MIBITnlobj);
for (pOT = NULL, pT = pOid->ut.oid.pIndxL; pT != NULL;
pOT = pT, pT = pT->pNext)
{
if (fCkNa && (pT->pOid != NULL) && ((rt = strcmp(pOidIndx->pszName,
(pT->pOid)->pszName)) == 0))
{
/* duplicate name */
yyerror("duplicate name \"%s\" in INDEX list", pOidIndx->pszName);
}
}
if (pOT == NULL)
{
/* insert at beginning of list */
pOid->ut.oid.pIndxL = pIndx;
}
else
{
/* insert in list */
pOT->pNext = pIndx;
}
pIndx->pNext = pT;
}
}
return(pIndx);
}
#if 0
MIBINDX *
#ifdef __STDC__
newINDX(MIBSYM *pOid, USHORT usItype, MIBSYM *pOidIndx,
ULONG ulLow, ULONG ulHigh)
#else
newINDX(pOid, usItype, pOidIndx, ulLow, ulHigh)
MIBSYM *pOid;
USHORT usItype;
MIBSYM *pOidIndx;
ULONG ulLow;
ULONG ulHigh;
#endif /* __STDC__ */
{
MIBINDX *pT;
MIBINDX *pOT;
MIBINDX *pIndx;
USHORT i;
SHORT rt;
BOOL fCkNa;
/* check if any available */
if (pIndxAvail == NULL) {
/* none avail - so allocate some */
pIndxAvail = (MIBINDX *)malloc(sizeof(MIBINDX)*MIBINDXACT);
if (pIndxAvail == NULL) {
yyerror("newINDX: out of heap memory");
yystats();
yyterm();
return(NULL);
}
cIndxAlloc += MIBINDXACT;
/* put items in list */
for (pT = pIndxAvail, i = 1; i < MIBINDXACT; i++, pT++) {
pT->pNext = pT+1;
}
pT->pNext = NULL;
}
/* get index item from list */
pIndx = pIndxAvail;
pIndxAvail = pIndxAvail->pNext;
cIndxUsed++;
++(pOid->ut.oid.cIndx);
/* init fields */
pIndx->usItype = usItype;
pIndx->pOid = pOidIndx;
pIndx->ulLow = ulLow;
pIndx->ulHigh = ulHigh;
/* insert at end of list after checking for dups */
fCkNa = (usItype == MIBITobj) || (usItype == MIBITnlobj);
for (pOT = NULL, pT = pOid->ut.oid.pIndxL; pT != NULL;
pOT = pT, pT = pT->pNext) {
if (fCkNa && (pT->pOid != NULL) && ((rt = strcmp(pOidIndx->pszName,
(pT->pOid)->pszName)) == 0)) {
/* duplicate name */
yyerror("duplicate name \"%s\" in INDEX list",
pOidIndx->pszName);
#ifdef OLD
yyterm();
return(NULL);
#endif
}
}
if (pOT == NULL) {
/* insert at beginning of list */
pOid->ut.oid.pIndxL = pIndx;
} else {
/* insert in list */
pOT->pNext = pIndx;
}
pIndx->pNext = pT;
return(pIndx);
} /* newINDX */
#endif
/** addINDXitem - add index item to row (or leaf) object
*
* NOTE: can not determine if item is the proper type
* at this point in time.
* MUST check later!!
*
* call with:
* pOid - row object
* usItype - index type
* pNa - index item
* ulLow - low for range/size
* ulHigh - high for range/size
* pMod - module
*
* returns:
* TRUE - no error
* FALSE - an error
*/
BOOL
#ifdef __STDC__
addINDXitem(MIBSYM *pOid, USHORT usItype, STRTAB *pNa,
ULONG ulLow, ULONG ulHigh, MIBSYM *pMod)
#else
addINDXitem(pOid, usItype, pNa, ulLow, ulHigh, pMod)
MIBSYM *pOid;
USHORT usItype;
STRTAB *pNa;
ULONG ulLow;
ULONG ulHigh;
MIBSYM *pMod;
#endif /* __STDC__ */
{
MIBSYM *pSym;
MIBSYM *pOidIndx;
USHORT usType;
USHORT usItypeSav;
pOidIndx = NULL;
/* handle special cases */
switch(usItype) {
case MIBITobj:
case MIBITnlobj:
/* object name (or TC name) given */
/* check if item defined */
pSym = pNa->pSym;
if ((pSym != NULL) && (pSym->pMod == pMod)) {
/* item defined */
/* check if import */
if (pSym->usType == MIBSYMimp) {
pSym->ut.imp.cUse++;
pSym = pSym->ut.imp.pImpSym;
}
/* check if Textual convention */
if ((usType = (pSym->usType & MIBSYMmask)) == MIBSYMtc) {
/* textual convention */
pSym->ut.tc.cUse++;
/* get resolved syntax */
usItypeSav = usItype;
switch (pSym->ut.tc.rsyn.usSyntax) {
case MIBSYNnu: /* not used */
case MIBSYNbad: /* invalid syntax specified */
case MIBSYNnull: /* NULL */
case MIBSYNopaque: /* opaque */
case MIBSYNseqOf: /* sequence of (table) (pSeq pts to type) */
case MIBSYNseq: /* sequence (row) (pSeq pts to type) */
case MIBSYNtc: /* textual convention (pTC points to item) */
default:
yyerror("addINDXitem: bad syntax type of %d for \"%s\"",
pSym->ut.tc.rsyn.usSyntax, pSym->pszName);
usItype = MIBITbad; /* bad index item */
break;
case MIBSYNint: /* integer */
case MIBSYNcntr: /* counter */
case MIBSYNgauge: /* gauge */
case MIBSYNticks: /* timer tics */
case MIBSYNenum: /* enumerated */
usItype = MIBITint; /* INTEGER */
if (pSym->ut.tc.rsyn.usSizeRange == MIBSRno) {
/* no range - make max */
ulHigh = 0xffffffffL;
} else if (pSym->ut.tc.rsyn.usSizeRange == MIBSRpp) {
/* non-negative to positive */
ulLow = pSym->ut.tc.rsyn.usr.ulRange[0];
ulHigh = pSym->ut.tc.rsyn.usr.ulRange[1];
} else {
/* a problem - make make max */
/*?? put more tests in */
ulHigh = 0xffffffffL;
}
break;
case MIBSYNoctstr: /* octet string */
if (pSym->ut.tc.rsyn.usSizeRange == MIBSRfs) {
usItype = MIBITfloct; /* fixed length OCTET STRING */
ulLow = pSym->ut.tc.rsyn.usr.usSize[0];
} else if (pSym->ut.tc.rsyn.usSizeRange != MIBSRbad) {
usItype = (usItypeSav == MIBITnlobj) ?
MIBITnloct : MIBIToct;
ulLow = pSym->ut.tc.rsyn.usr.usSize[0];
ulHigh = pSym->ut.tc.rsyn.usr.usSize[1];
} else
usItype = MIBSRbad;
break;
case MIBSYNoid: /* object identifier */
usItype = (usItypeSav == MIBITnlobj) ?
MIBITnloid : MIBIToid;
break;
case MIBSYNnaddr: /* network address */
usItype = MIBITnaddr;
break;
case MIBSYNipaddr: /* IP address */
usItype = MIBITipaddr;
break;
}
/* check for illegal NOLENGTH clause */
if ((usItypeSav == MIBITnlobj) &&
(usItype != MIBITnloid) &&
(usItype != MIBITnloct))
yyerror("Invalid NOLENGTH qualifier for \"%s\" ignored",
pSym->pszName);
break;
}
/* check if OID type (ignore real checks) */
if (usType != MIBSYMoid) {
/* not OID type */
yyerror("\"%s\" is not valid type for index item",
pSym->pszName);
#ifdef OLD
yyterm();
return(FALSE);
#endif
}
pOidIndx = pSym;
} else {
/* item not defined */
/* allocate new symbol */
pOidIndx = newOID(pNa, pMod);
}
break;
case MIBITint:
/* integer */
/* check that range is valid */
if (ulLow > ulHigh) {
yyerror("Invalid range given, low %lu greater than high %lu",
ulLow, ulHigh);
}
break;
case MIBIToct:
case MIBITnloct:
/* octet string or nolength octet string */
/* check that size is valid */
if (ulLow > ulHigh) {
yyerror("Invalid size given, low %lu greater than high %lu",
ulLow, ulHigh);
}
break;
case MIBITfloct:
case MIBIToid:
case MIBITnloid:
case MIBITnaddr:
case MIBITipaddr:
/* nothing special to do */
break;
default:
yyerror("addINDXitem: bad index type of %d", usItype);
break;
}
/* allocate new index item */
newINDX(pOid, usItype, pOidIndx, ulLow, ulHigh);
return(TRUE);
} /* addINDXitem */
/** addDV - add default value
*
* NOTE: can not determine if value valid for this object
* at this point in time.
* MUST check later!!
*
* call with:
* pOid - object
* usDevVal - type of value
* pVal - string value
* ulVal - integer value
* pComp - oid value
*
* returns:
* TRUE - no error
* FALSE - an error
*/
BOOL
#ifdef __STDC__
addDV(MIBSYM *pOid, USHORT usDefVal, STRTAB *pVal, ULONG ulVal, MIBSYM *pComp)
#else
addDV(pOid, usDefVal, pVal, ulVal, pComp)
MIBSYM *pOid;
USHORT usDefVal;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -