smparcom.c

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

        }
        pT->pNext = NULL;
    }

    /* get module from list */
    pModRef = pModRefAvail;
    pModRefAvail = pModRefAvail->pNext;
    cModRefUsed++;

    /* init fields */
    pModRef->pMod = NULL;
    pModRef->pImpIL = NULL;
    pModRef->cImpi = 0;
    pModRef->pNext = NULL;

    /* add to tail of list for module */
    if (pMod->ut.mod.pImodHL == NULL) {
        /* list empty */
        pMod->ut.mod.pImodHL = pModRef;
    } else {
        /* add to end */
        (pMod->ut.mod.pImodTL)->pNext = pModRef;
    }
    pMod->ut.mod.pImodTL = pModRef;

    return(pModRef);

} /* newMODREF */
#endif

/** newIMPI - allocate an IMPORT item
*
* call with:
*   pModRef - import module
*   pNa - name of item
*
* returns:
*   ptr to new item or NULL if error
*/
MIBIMPI *newIMPI(MIBMODREF *pModRef, STRTAB *pNa)
	{
   MIBIMPI *pT;
   MIBIMPI *pOT;
   MIBIMPI *pImpi;
   SHORT rt;
   int err;

   pImpi = (MIBIMPI *)malloc(sizeof(MIBIMPI));
   if (pImpi != NULL)
   	{
      err = AllocMemAdd(pImpi);
      if (err)
      	{
         free(pImpi);
         pImpi = NULL;
         }
      else
      	{
         /* insert at end of list after checking for dups */
         for (pOT = NULL, pT = pModRef->pImpIL; pT != NULL;
         	pOT = pT, pT = pT->pNext)
            {
         	if ((rt = strcmp(pNa->pszVal, (pT->pNa)->pszVal)) == 0)
            	{
               /* duplicate name */
               fprintf(fhMsg, "duplicate name \"%s\" in IMPORTS",
                       pNa->pszVal);
               /*?? just ignore for now */
               free(pImpi);
               return(NULL);
           		}
         	}
         cImpiUsed++;
         ++(pModRef->cImpi);

         /* init fields */
         pImpi->pNa = pNa;

         if (pOT == NULL) {
           /* insert at beginning of list */
           pModRef->pImpIL = pImpi;
         } else {
           /* insert in list */
           pOT->pNext = pImpi;
         }
         pImpi->pNext = pT;
         }
      }
   return(pImpi);
   }
#if 0
    MIBIMPI *
#ifdef __STDC__
newIMPI(MIBMODREF *pModRef, STRTAB *pNa)
#else
newIMPI(pModRef, pNa)
    MIBMODREF *pModRef;
    STRTAB *pNa;
#endif /* __STDC__ */
{
    MIBIMPI *pT;
    MIBIMPI *pOT;
    MIBIMPI *pImpi;
    USHORT i;
    SHORT rt;


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

    /* insert at end of list after checking for dups */
    for (pOT = NULL, pT = pModRef->pImpIL; pT != NULL;
            pOT = pT, pT = pT->pNext) {
        if ((rt = strcmp(pNa->pszVal, (pT->pNa)->pszVal)) == 0) {
            /* duplicate name */
            yyerror("duplicate name \"%s\" in IMPORTS",
                    pNa->pszVal);
#ifdef OLD
            yyterm();
#endif
            /*?? just ignore for now */
            return(NULL);
        }
    }

    /* get import item from list */
    pImpi = pImpiAvail;
    pImpiAvail = pImpiAvail->pNext;
    cImpiUsed++;
    ++(pModRef->cImpi);

    /* init fields */
    pImpi->pNa = pNa;

    if (pOT == NULL) {
        /* insert at beginning of list */
        pModRef->pImpIL = pImpi;
    } else {
        /* insert in list */
        pOT->pNext = pImpi;
    }
    pImpi->pNext = pT;

    return(pImpi);

} /* newIMPI */
#endif

/** newIMP - allocate new imported object
*
* ??NOTE: change to allocate only space needed
*
* call with:
*   pMod - module into which symbol is imported
*   pSym - originally defined symbol
*   pNa - place to insert in string table
*
* returns:
*   ptr to imported object or NULL if an error
*/
MIBSYM *newIMP(MIBSYM *pMod, MIBSYM *pSym, STRTAB *pNa)
	{
   MIBSYM *pImp;
   int err;

   pImp = (MIBSYM *)malloc(sizeof(MIBSYM));
   if (pImp != NULL)
   	{
      /*
		 * keep the memory allocated on the StrTabAlloc linked list
       * so that later we can free it.
       */
		err = AllocMemAdd(pImp);
      if (err)
      	{
         free(pImp);
         return (NULL);
         }
      else
      	{
		   cImpUsed++;

         /* initialize */
         pImp->usType = MIBSYMimp;
         pImp->pSym = pNa->pSym;
         pNa->pSym = pImp;
         pImp->pMod = pMod;
         pImp->pAlist = NULL;
         pImp->pszName = pNa->pszVal;
         pImp->usStatus = MIBSTAnu;
         pImp->usNeed = MIBIEns;
         pImp->pBKEdata = NULL;
         pImp->pszDesc = NULL;
         pImp->pszRefer = NULL;
         pImp->pNext = NULL;

         pImp->ut.imp.pImpSym = pSym;
         pImp->ut.imp.cUse = 0;

         /* link to end of global list of imports */
         if (pImpGHL == NULL)
         	{
         	/* list empty */
         	pImpGHL = pImp;
         	}
         else
         	{
           	/* add to end */
           	pImpGTL->pNext = pImp;
         	}
         pImpGTL = pImp;
			}
      }
   return(pImp);
	} /* newIMP */
#if 0
    MIBSYM *
#ifdef __STDC__
newIMP(MIBSYM *pMod, MIBSYM *pSym, STRTAB *pNa)
#else
newIMP(pMod, pSym, pNa)
    MIBSYM *pMod;
    MIBSYM *pSym;
    STRTAB *pNa;
#endif /* __STDC__ */
{
    MIBSYM *pT;
    MIBSYM *pImp;
    USHORT i;


    /* check if any available */
    if (pImpAvail == NULL) {
        /* none avail - so allocate some */
        /* This variable is never freed */
        pImpAvail = (MIBSYM *)malloc(sizeof(MIBSYM)*MIBIMPACT);
        if (pImpAvail == NULL) {
            yyerror("newIMP: out of heap memory");
            yystats();
            yyterm();
            return(NULL);
        }
        cImpAlloc += MIBIMPACT;
        /* put items in list */
        for (pT = pImpAvail, i = 1; i < MIBIMPACT; i++, pT++) {
            pT->pNext = pT+1;
        }
        pT->pNext = NULL;
    }

    /* get import item from list */
    pImp = pImpAvail;
    pImpAvail = pImpAvail->pNext;
    cImpUsed++;

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

    pImp->ut.imp.pImpSym = pSym;
    pImp->ut.imp.cUse = 0;

    /* link to end of global list of imports */
    if (pImpGHL == NULL) {
        /* list empty */
        pImpGHL = pImp;
    } else {
        /* add to end */
        pImpGTL->pNext = pImp;
    }
    pImpGTL = pImp;

    return(pImp);

} /* newIMP */
#endif

/** newAL - allocate new alias
*
* ??NOTE: change to allocate only space needed
*
* call with:
*   pSym - symbol being aliased
*   pAlNa - name of alias
*
* returns:
*   ptr to alias or NULL if an error
*/
    MIBSYM *
#ifdef __STDC__
newAL(MIBSYM *pSym, STRTAB *pAlNa)
#else
newAL(pSym, pAlNa)
    MIBSYM *pSym;
    STRTAB *pAlNa;
#endif /* __STDC__ */
{
    MIBSYM *pT;
    MIBSYM *pAl;
    USHORT i;


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

    /* get alias item from list */
    pAl = pAlAvail;
    pAlAvail = pAlAvail->pNext;
    cAlUsed++;

    /* init fields */
    pAl->usType = MIBSYMalias;
    pAl->pSym = pAlNa->pSym;
    pAlNa->pSym = pAl;
    pAl->pMod = pSym->pMod;
    pAl->pAlist = NULL;
    pAl->pszName = pAlNa->pszVal;
    pAl->usStatus = MIBSTAnu;
    pAl->usNeed = MIBIEns;
    pAl->pBKEdata = NULL;
    pAl->pszDesc = NULL;
    pAl->pszRefer = NULL;
    pAl->pNext = NULL;

    pAl->ut.al.pAlSym = pSym;
    pAl->ut.al.cUse = 0;
    pAl->ut.al.pNext = pSym->pAlist;
    pSym->pAlist = pAl;

    /* link to end of global list of imports */
    if (pAlGHL == NULL) {
        /* list empty */
        pAlGHL = pAl;
    } else {
        /* add to end */
        pAlGTL->pNext = pAl;
    }
    pAlGTL = pAl;

    return(pAl);

} /* newAL */


/** addMODalias - add alias for module
*
* call with:
*   pNa - module name
*   pAlNa - alias for module
*
* returns:
*   TRUE - alias added
*   FALSE - an error adding alias
*/
    BOOL
#ifdef __STDC__
addMODalias(STRTAB *pNa, STRTAB *pAlNa)
#else
addMODalias(pNa, pAlNa)
    STRTAB *pNa;
    STRTAB *pAlNa;
#endif /* __STDC__ */
{
    MIBSYM *pMod;
    MIBSYM *pSym;
    MIBSYM *pAl;
    USHORT usType;


    /* check if module defined */
    for (pMod = pNa->pSym; pMod != NULL; pMod = pMod->pSym) {
        if ((usType = (pMod->usType & MIBSYMmask)) == MIBSYMmod)
            break;
        if ((usType == MIBSYMalias) &&
                (((pMod->ut.al.pAlSym)->usType & MIBSYMmask) == MIBSYMmod)) {
            /* alias to module */
            pMod->ut.al.cUse++;
            pMod = pMod->ut.al.pAlSym;
            break;
        }
    }
    if (pMod == NULL) {
        yyerror("module \"%s\" not defined - ignoring module alias",
                pNa->pszVal);
        return(FALSE);
    }

    /* check if alias already used */
    for (pSym = pAlNa->pSym; pSym != NULL; pSym = pSym->pSym) {
        if (((usType = (pSym->usType & MIBSYMmask)) == MIBSYMmod) ||
                ((usType == MIBSYMalias) &&
                (((pSym->ut.al.pAlSym)->usType & MIBSYMmask) == MIBSYMmod))) {
            yyerror("alias \"%s\" for module \"%s\" is already used - ignoring module alias",
                    pAlNa->pszVal, pNa->pszVal);
            return(FALSE);
        }
    }

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

    return(TRUE);

} /* addMODalias */


/** addSYMalias - add alias for a symbol
*
* call with:
*   pModNa - module containing the symbol
*   pNa - name of symbol
*   pAlNa - alias for the symbol
*
* returns:
*   TRUE - alias added
*   FALSE - an error adding alias
*/
    BOOL
#ifdef __STDC__
addSYMalias(STRTAB *pModNa, STRTAB *pNa, STRTAB *pAlNa)
#else
addSYMalias(pModNa, pNa, pAlNa)
    STRTAB *pModNa;
    STRTAB *pNa;
    STRTAB *pAlNa;
#endif /* __STDC__ */
{
    MIBSYM *pMod;
    MIBSYM *pSym;
    MIBSYM *pAl;
    USHORT usType;


    /* check if module defined */
    for (pMod = pModNa->pSym; pMod != NULL; pMod = pMod->pSym) {
        if ((usType = (pMod->usType & MIBSYMmask)) == MIBSYMmod)
            break;
        if ((usType == MIBSYMalias) &&
                (((pMod->ut.al.pAlSym)->usType & MIBSYMmask) == MIBSYMmod)) {
            /* alias to module */
            pMod->ut.al.cUse++;
            pMod = pMod->ut.al.pAlSym;
            break;
        }
    }
    if (pMod == NULL) {
        yyerror("module \"%s\" not defined - ignoring symbol alias",
                pModNa->pszVal);
        return(FALSE);
    }


    /* check if alias already used */
    for (pSym = pAlNa->pSym; pSym != NULL; pSym = pSym->pSym) {
        if (((usType = (pSym->usType & MIBSYMmask)) == MIBSYMmod) ||
                ((usType == MIBSYMalias) &&
                (((pSym->ut.al.pAlSym)->usType & MIBSYMmask) == MIBSYMmod))) {
            yyerror("alias \"%s\" for module \"%s\" is already used - ignoring module alias",
                    pAlNa->pszVal, pNa->pszVal);
            return(FALSE);
        }
    }

    /* check if item defined in module and can be aliased */
    /* invalid symbols are imports and sequences */
    for (pSym = pNa->pSym; pSym != NULL; pSym = pSym->pSym) {
        if (pSym->pMod == pMod)
                break;
    }
    if (pSym == NULL) {
        yyerror("Item \"%s\" not defined in module \"%s\" - ignoring symbol alias",
                pNa->pszVal, pModNa->pszVal);
        return(FALSE);
    }

    /* check if item is an alias */
    if ((usType = (pSym->usType & MIBSYMmask)) == MIBSYMalias) {