smparcom.c

基于单片机的 snmp协议解析的一些原代码 给有用的 同行

        /* get real symbol and type */
        pSym->ut.al.cUse++;
        pSym = pSym->ut.al.pAlSym;
        usType = pSym->usType & MIBSYMmask;
    }

    /* check if item imported in original module */
    if (usType == MIBSYMimp) {
        yyerror("Item \"%s\" from module \"%s\" is imported - ignoring symbol alias",
                pNa->pszVal, pModNa->pszVal);
        return(FALSE);
    }

    /* check for sequence item */
    if (usType == MIBSYMseq) {
        yyerror("Item \"%s\" from module \"%s\" is a sequence - ignoring symbol alias",
                pNa->pszVal, pModNa->pszVal);
        return(FALSE);
    }

    /* check if SMI item */
    if (usType == MIBSYMsmi) {
        yyerror("Item \"%s\" from module \"%s\" is an SMI item - ignoring symbol alias",
                pNa->pszVal, pModNa->pszVal);
        return(FALSE);
    }

    /* add new alias */
    pAl = newAL(pSym, pAlNa);

    return(TRUE);


} /* addSYMalias */


/** newSMI - allocate a SMI name
*
* ??NOTE: change to allocate only space needed
*
* call with:
*   pNa - name to add
*   pMod - module containing name
*
* returns:
*   ptr to symbol or NULL for error
*/
MIBSYM *newSMI(STRTAB *pNa, MIBSYM *pMod)
	{
   MIBSYM *pSmi;
   int err;

   /* none avail - so allocate some */
   pSmi = (MIBSYM *)malloc(sizeof(MIBSYM));
   if (pSmi != NULL)
   	{
      err = AllocMemAdd(pSmi);
      if (err)
      	{
         free(pSmi);
         pSmi = NULL;
         }
      else
      	{
         cSmiUsed++;

         /* init fields */
         pSmi->usType = MIBSYMsmi;
         pSmi->pSym = pNa->pSym;
         pNa->pSym = pSmi;
         pSmi->pMod = pMod;
         pSmi->pAlist = NULL;
         pSmi->pszName = pNa->pszVal;
         pSmi->usStatus = MIBSTAnu;
         pSmi->usNeed = MIBIEns;
         pSmi->pBKEdata = NULL;
         pSmi->pszDesc = NULL;
         pSmi->pszRefer = NULL;
         pSmi->pNext = NULL;

         pSmi->ut.smi.iKW = 0;

         /* link to end of global list of smi objects */
         if (pSmiGHL == NULL)
         	{
           	/* list empty */
           	pSmiGHL = pSmi;
         	}
         else
         	{
           	/* add to end */
           	pSmiGTL->pNext = pSmi;
         	}
         pSmiGTL = pSmi;
         }
		}
   return(pSmi);
	} /* newSMI */
#if 0
    MIBSYM *
#ifdef __STDC__
newSMI(STRTAB *pNa, MIBSYM *pMod)
#else
newSMI(pNa, pMod)
    STRTAB *pNa;
    MIBSYM *pMod;
#endif /* __STDC__ */
{
    MIBSYM *pT;
    USHORT i;
    MIBSYM *pSmi;


    /* check if any available */
    if (pSmiAvail == NULL) {
        /* none avail - so allocate some */
        pSmiAvail = (MIBSYM *)malloc(sizeof(MIBSYM)*MIBSMIACT);
        if (pSmiAvail == NULL) {
            yyerror("newSMI: out of heap memory");
            yystats();
            yyterm();
            return(NULL);
        }
        cSmiAlloc += MIBSMIACT;
        /* put items in list */
        for (pT = pSmiAvail, i = 1; i < MIBSMIACT; i++, pT++) {
            pT->pNext = pT+1;
        }
        pT->pNext = NULL;
    }

    /* get SMI item from list */
    pSmi = pSmiAvail;
    pSmiAvail = pSmiAvail->pNext;
    cSmiUsed++;

    /* init fields */
    pSmi->usType = MIBSYMsmi;
    pSmi->pSym = pNa->pSym;
    pNa->pSym = pSmi;
    pSmi->pMod = pMod;
    pSmi->pAlist = NULL;
    pSmi->pszName = pNa->pszVal;
    pSmi->usStatus = MIBSTAnu;
    pSmi->usNeed = MIBIEns;
    pSmi->pBKEdata = NULL;
    pSmi->pszDesc = NULL;
    pSmi->pszRefer = NULL;
    pSmi->pNext = NULL;

    pSmi->ut.smi.iKW = 0;

    /* link to end of global list of smi objects */
    if (pSmiGHL == NULL) {
        /* list empty */
        pSmiGHL = pSmi;
    } else {
        /* add to end */
        pSmiGTL->pNext = pSmi;
    }
    pSmiGTL = pSmi;

    return(pSmi);

} /* newSMI */
#endif

/** newTR - allocate a trap
*
* ??NOTE: change to allocate only space needed
*
* call with:
*   pNa - name of trap
*   pMod - module containing trap
*
* returns:
*   ptr to trap or NULL if error
*/
    MIBSYM *
#ifdef __STDC__
newTR(STRTAB *pNa, MIBSYM *pMod)
#else
newTR(pNa, pMod)
    STRTAB *pNa;
    MIBSYM *pMod;
#endif /* __STDC__ */
	{
   MIBSYM *pTr;
	int err;
   
   pTr = (MIBSYM *)malloc(sizeof(MIBSYM));
   if (pTr != NULL)
   	{
      err = AllocMemAdd(pTr);
      if (err)
      	{
         free(pTr);
         pTr = NULL;
         }
      else
      	{
         cTrUsed++;

         /* init fields */
         pTr->usType = MIBSYMtr | MIBSYMFR; /* make forward reference */
         pTr->pSym = pNa->pSym;
         pNa->pSym = pTr;
         pTr->pMod = pMod;
         pTr->pAlist = NULL;
         pTr->pszName = pNa->pszVal;
         pTr->usStatus = MIBSTAnu;
         pTr->usNeed = MIBIEns;
         pTr->pBKEdata = NULL;
         pTr->pszDesc = NULL;
         pTr->pszRefer = NULL;
         pTr->pNext = NULL;

         pTr->ut.tr.pOid = NULL;
         pTr->ut.tr.pEntTr = NULL;
         pTr->ut.tr.pVarL = NULL;
         pTr->ut.tr.cVar = 0;
         pTr->ut.tr.ulVal = 0L;

         /* link to end of global list of traps */
         if (pTrGHL == NULL)
         	{
           	/* list empty */
           	pTrGHL = pTr;
         	}
         else
         	{
           	/* add to end */
           	pTrGTL->pNext = pTr;
         	}
         pTrGTL = pTr;
         }
      }
   return(pTr);
	} /* newTR */
#if 0
    MIBSYM *
#ifdef __STDC__
newTR(STRTAB *pNa, MIBSYM *pMod)
#else
newTR(pNa, pMod)
    STRTAB *pNa;
    MIBSYM *pMod;
#endif /* __STDC__ */
{
    MIBSYM *pT;
    MIBSYM *pTr;
    USHORT i;


    /* check if any available */
    if (pTrAvail == NULL) {
        /* none avail - so allocate some */
        pTrAvail = (MIBSYM *)malloc(sizeof(MIBSYM)*MIBTRACT);
        if (pTrAvail == NULL) {
            yyerror("newTR: out of heap memory");
            yystats();
            yyterm();
            return(NULL);
        }
        cTrAlloc += MIBTRACT;
        /* put traps in list */
        for (pT = pTrAvail, i = 1; i < MIBTRACT; i++, pT++) {
            pT->pNext = pT+1;
        }
        pT->pNext = NULL;
    }

    /* get trap from list */
    pTr = pTrAvail;
    pTrAvail = pTrAvail->pNext;
    cTrUsed++;

    /* init fields */
    pTr->usType = MIBSYMtr | MIBSYMFR; /* make forward reference */
    pTr->pSym = pNa->pSym;
    pNa->pSym = pTr;
    pTr->pMod = pMod;
    pTr->pAlist = NULL;
    pTr->pszName = pNa->pszVal;
    pTr->usStatus = MIBSTAnu;
    pTr->usNeed = MIBIEns;
    pTr->pBKEdata = NULL;
    pTr->pszDesc = NULL;
    pTr->pszRefer = NULL;
    pTr->pNext = NULL;

    pTr->ut.tr.pOid = NULL;
    pTr->ut.tr.pEntTr = NULL;
    pTr->ut.tr.pVarL = NULL;
    pTr->ut.tr.cVar = 0;
    pTr->ut.tr.ulVal = 0L;

    /* link to end of global list of traps */
    if (pTrGHL == NULL) {
        /* list empty */
        pTrGHL = pTr;
    } else {
        /* add to end */
        pTrGTL->pNext = pTr;
    }
    pTrGTL = pTr;

    return(pTr);

} /* newTR */
#endif

/** newENT - allocate an enterprise list item
*
* call with:
*   pTr - first trap to add
*
* returns:
*   ptr to Enterprise list item or NULL if error
*/
    MIBENT *
#ifdef __STDC__
newENT(MIBSYM *pFrTr)
#else
newENT(pFrTr)
    MIBSYM *pFrTr;
#endif /* __STDC__ */
{
    MIBENT *pT;
    MIBENT *pEnt;
    USHORT i;


    /* check if any available */
    if (pEntAvail == NULL) {
        /* none avail - so allocate some */
        pEntAvail = (MIBENT *)malloc(sizeof(MIBENT)*MIBENTACT);
        if (pEntAvail == NULL) {
            yyerror("newENT: out of heap memory");
            yystats();
            yyterm();
            return(NULL);
        }
        cEntAlloc += MIBENTACT;
        /* put enterprise list items in list */
        for (pT = pEntAvail, i = 1; i < MIBENTACT; i++, pT++) {
            pT->pNext = pT+1;
        }
        pT->pNext = NULL;
    }

    /* get enterprise item from list */
    pEnt = pEntAvail;
    pEntAvail = pEntAvail->pNext;
    cEntUsed++;

    /* init fields */
    pEnt->pOid = pFrTr->ut.tr.pOid;
    pEnt->pTr = pFrTr;
    pEnt->pNext = NULL;


    /* link to end of global list of enterprise items */
    if (pEntGHL == NULL) {
        /* list empty */
        pEntGHL = pEnt;
    } else {
        /* add to end */
        pEntGTL->pNext = pEnt;
    }
    pEntGTL = pEnt;

    return(pEnt);

} /* newENT */


/** newVAR - allocate a trap var
*
* call with:
*   pTr - trap
*   pOid - variable
*
* returns:
*   ptr to new item or NULL if error
*/
    MIBVAR *
#ifdef __STDC__
newVAR(MIBSYM *pTr, MIBSYM *pOid)
#else
newVAR(pTr, pOid)
    MIBSYM *pTr;
    MIBSYM *pOid;
#endif /* __STDC__ */
{
    MIBVAR *pT;
    MIBVAR *pOT;
    MIBVAR *pVar;
    USHORT i;
    SHORT rt;


    /* check if any available */
    if (pVarAvail == NULL) {
        /* none avail - so allocate some */
        pVarAvail = (MIBVAR *)malloc(sizeof(MIBVAR)*MIBVARACT);
        if (pVarAvail == NULL) {
            yyerror("newVAR: out of heap memory");
            yystats();
            yyterm();
            return(NULL);
        }
        cVarAlloc += MIBVARACT;
        /* put items in list */
        for (pT = pVarAvail, i = 1; i < MIBVARACT; i++, pT++) {
            pT->pNext = pT+1;
        }
        pT->pNext = NULL;
    }

    /* get trap var from list */
    pVar = pVarAvail;
    pVarAvail = pVarAvail->pNext;
    cVarUsed++;
    ++(pTr->ut.tr.cVar);

    /* init fields */
    pVar->pOid = pOid;
    /* insert at end of list after checking for dups */
    for (pOT = NULL, pT = pTr->ut.tr.pVarL; pT != NULL;
            pOT = pT, pT = pT->pNext) {
        if ((rt = strcmp(pOid->pszName, (pT->pOid)->pszName)) == 0) {
            /* duplicate name */
            yyerror("duplicate name \"%s\" in VARIABLES list",
                    pOid->pszName);
            yyterm();
            return(NULL);
        }
    }
    if (pOT == NULL) {
        /* insert at beginning of list */
        pTr->ut.tr.pVarL = pVar;
    } else {
        /* insert in list */
        pOT->pNext = pVar;
    }
    pVar->pNext = pT;

    return(pVar);

} /* newVAR */


/** addVAR - add variable to trap
*
* NOTE: the checking of the variable's type must be done
*       later after all objects are defined
*
* call with:
*   pTr - trap
*   pNa - variable
*   pMod - current module
*
* returns:
*   TRUE - no errors
*   FALSE - an error
*/
    BOOL
#ifdef __STDC__
addVAR(MIBSYM *pTr, STRTAB *pNa, MIBSYM *pMod)
#else
addVAR(pTr, pNa, pMod)
    MIBSYM *pTr;
    STRTAB *pNa;
    MIBSYM *pMod;
#endif /* __STDC__ */
{
    MIBSYM *pSym;
    MIBSYM *pOid;


    /* check if trap variable 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 OID type (ignore real checks) */
        if ((pSym->usType & MIBSYMmask) != MIBSYMoid) {
            yyerror("\"%s\" is not valid type for trap variable",
                    pSym->pszName);
#ifdef OLD
            yyterm();
#endif
            return(FALSE);
        }
        pOid = pSym;
    } else {
        /* item not defined */
        /* allocate new symbol */
        pOid = newOID(pNa, pMod);
    }

    /* allocate new trap variable */
    newVAR(pTr, pOid);

    return(TRUE);

} /* addVAR */


/** newTC - allocate a new textual convention object
*
* ??NOTE: change to allocate only space needed