smdump.c

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

            fprintf(fhOut, " q f %u",
                    pSyn->usr.usSize[0]);
        else if (pSyn->usSizeRange == MIBSRvs)
            fprintf(fhOut, " q v %u %u",
                    pSyn->usr.usSize[0], pSyn->usr.usSize[1]);
        else
            fprintf(fhOut, " q n");
        break;

    case MIBSYNenum:
        fprintf(fhOut, " e %u", pSyn->cEnum);
        for (i = 2, pE = pSyn->usi.pEnumL; pE != NULL; i++, pE = pE->pNext) {
            if (i%4 == 0)
                fprintf(fhOut, "\n   ");
            fprintf(fhOut, " %s %lu", pE->pszName, pE->ulVal);
        }
        break;

    case MIBSYNseqOf:
        fprintf(fhOut, " ?");
        break;

    case MIBSYNseq:
        fprintf(fhOut, " ?");
        break;

    case MIBSYNtc:
        switch (pSyn->usSizeRange) {
        case MIBSRpp:
            fprintf(fhOut, " x %s p %lu %lu",
                    (pSyn->usi.pTC)->pszName,
                    pSyn->usr.ulRange[0],
                    pSyn->usr.ulRange[1]);
            break;

        case MIBSRnp:
            fprintf(fhOut, " x %s z %lu %lu",
                    (pSyn->usi.pTC)->pszName,
                    pSyn->usr.ulRange[0],
                    pSyn->usr.ulRange[1]);
            break;

        case MIBSRnn:
            fprintf(fhOut, " x %s g %lu %lu",
                    (pSyn->usi.pTC)->pszName,
                    pSyn->usr.ulRange[0],
                    pSyn->usr.ulRange[1]);
            break;

        case MIBSRfs:
            fprintf(fhOut, " x %s f %u",
                    (pSyn->usi.pTC)->pszName,
                    pSyn->usr.usSize[0]);
            break;

        case MIBSRvs:
            fprintf(fhOut, " x %s v %u %u",
                    (pSyn->usi.pTC)->pszName,
                    pSyn->usr.usSize[0],
                    pSyn->usr.usSize[1]);
            break;

        case MIBSRno:
            fprintf(fhOut, " x %s n",
                    (pSyn->usi.pTC)->pszName);
        }
        break;

    default:
        fprintf(fhOut, " ?");
        break;
    }
} /* printSyntaxInfo */


/** printIntermInst - print instance for intermediate file
*
* call with:
*   pI - ptr to list of index items
*
*/
    VOID
#ifdef __STDC__
printIntermInst(MIBINDX *pI)
#else
printIntermInst(pI)
    MIBINDX *pI;
#endif /* __STDC__ */
{
    USHORT i;

    /* print names of items in index */
    for (i = 2; pI != NULL; i++, pI = pI->pNext) {
        if (i%4 == 0)
            fprintf(fhOut, "\n   ");
        switch (pI->usItype) {
        case MIBITbad:  /* bad index item */
            fprintf(fhOut, " 1");
            break;

        case MIBITobj:  /* index item is an object */
            fprintf(fhOut, " 2 %s", (pI->pOid)->pszName);
            break;

        case MIBITnlobj:/* index item is no length object */
            fprintf(fhOut, " 3 %s", (pI->pOid)->pszName);
            break;

        case MIBITint:  /* index item is INTEGER */
            fprintf(fhOut, " 4 %lu %lu",
                    pI->ulLow, pI->ulHigh);
            break;

        case MIBIToct:  /* index item is OCTET STRING */
            fprintf(fhOut, " 5 %lu %lu",
                    pI->ulLow, pI->ulHigh);
            break;

        case MIBITnloct:/* index item is no length OCTET STRING */
            fprintf(fhOut, " 6 %lu %lu",
                    pI->ulLow, pI->ulHigh);
            break;

        case MIBITfloct:/* index item is fixed size OCTET STRING */
            fprintf(fhOut, " 7 %lu", pI->ulLow);
            break;

        case MIBIToid:  /* index item is OBJECT IDENTIFIER */
            fprintf(fhOut, " 8");
            break;

        case MIBITnloid:/* index item is no length OID */
            fprintf(fhOut, " 9");
            break;

        case MIBITnaddr:/* index item is NetworkAddress */
            fprintf(fhOut, " A");
            break;

        case MIBITipaddr:/* index item is IpAddress */
            fprintf(fhOut, " B");
            break;

        default:
            fprintf(fhOut, " ?");
            break;
        }
    }

} /* printIntermInst */



MIBSYM *pModCur;

/** printIntermOID1 - print intermediate OID item in first form
*
* call with:
*   pT - item to print
*/
    VOID
#ifdef __STDC__
printIntermOID1(MIBSYM *pT, ULONG aulOid[], USHORT usLevel)
#else
printIntermOID1(pT, aulOid, usLevel)
    MIBSYM *pT;
    ULONG aulOid[];
    USHORT usLevel;
#endif /* __STDC__ */
{
#ifdef NEW
    MIBSYM *pS;
    MIBSEQI *pSi;
#endif

    if (pT->pMod != pModCur)
        return;

    printTNSDR(pT);

    if (pT->ut.oid.usOType == MIBOTtab) {
        /* table */
        /* print sequence name */
        fprintf(fhOut, " f %s", (pT->ut.oid.syn.usi.pSeq)->pszName);

    } else if (pT->ut.oid.usOType == MIBOTrow) {
        /* row */
        /* print sequence name and number of items in index */
        fprintf(fhOut, " s %s %u",
                (pT->ut.oid.syn.usi.pSeq)->pszName,
                pT->ut.oid.cIndx);
        /* print names of items in index */
        printIntermInst(pT->ut.oid.pIndxL);

#ifdef NEW
/**** start test ****/
/*?? NOTE: The backend parser needs to be changed for
           this to work! */
        /* print info for sequence */
        if ((pS = pT->ut.oid.syn.usi.pSeq) != NULL) {

            fprintf(fhOut, "\n");
            printTNSDR(pS);
            fprintf(fhOut, " %u", pS->ut.seq.cSeqi);
            for (i = 1, pSi = pS->ut.seq.pSeqIL; pSi != NULL;
                    i++, pSi = pSi->pNext) {
                if (i%2 == 0)
                    fprintf(fhOut, "\n   ");
                fprintf(fhOut, " %s", (pSi->pOid)->pszName);
                printSyntaxInfo(&(pSi->syn));
            }
        }
/**** end test ****/
#endif
    } else if (pT->ut.oid.usOType == MIBOTobj) {
        /* object */
        /* print access */
        switch(pT->ut.oid.usAccess) {
        case MIBACCnu:
            /* not used */
            fprintf(fhOut, " ?");
            break;

        case MIBACCro:
            /* read-only */
            fprintf(fhOut, " r");
            break;

        case MIBACCrw:
            /* read-write */
            fprintf(fhOut, " b");
            break;

        case MIBACCwo:
            /* write-only */
            fprintf(fhOut, " w");
            break;

        case MIBACCna:
            /* not-accessible */
            fprintf(fhOut, " n");
            break;

        default:
            fprintf(fhOut, " ?");
        }

        /* print syntax */
        printSyntaxInfo(&(pT->ut.oid.syn));
        /* printf defval */
        switch(pT->ut.oid.usDefVal) {
        case MIBDFVno:
            /* no default value */
            fprintf(fhOut, " u");
            break;

        case MIBDFVstr:
            /* string */
            fprintf(fhOut, " s \"%s\"",
                    pT->ut.oid.udv.pszDefVal);
            break;

        case MIBDFVbstr:
            /* binary string */
            fprintf(fhOut, " b \'%s\'B",
                    pT->ut.oid.udv.pszDefVal);
            break;

        case MIBDFVhstr:
            /* hex string */
            fprintf(fhOut, " h \'%s\'H",
                    pT->ut.oid.udv.pszDefVal);
            break;

        case MIBDFVint:
            /* integer */
            fprintf(fhOut, " i %lu",
                    pT->ut.oid.udv.ulDefVal);
            break;

        case MIBDFVneg:
            /* negative number */
            fprintf(fhOut, " g %lu",
                    pT->ut.oid.udv.ulDefVal);
            break;

        case MIBDFVna:
            /* name (enumerated value) */
            fprintf(fhOut, " n %s",
                    pT->ut.oid.udv.pszDefVal);
            break;

        case MIBDFVip:
            /* ip address */
            fprintf(fhOut, " p %u.%u.%u.%u",
                    pT->ut.oid.udv.ipDefVal[0],
                    pT->ut.oid.udv.ipDefVal[1],
                    pT->ut.oid.udv.ipDefVal[2],
                    pT->ut.oid.udv.ipDefVal[3]);
            break;

        case MIBDFVoid:
            /* oid */
            fprintf(fhOut, " o %s %s",
                    ((pT->ut.oid.udv.pOid)->pMod)->pszName,
                    (pT->ut.oid.udv.pOid)->pszName);
            break;

        default:
            /* bad value */
            fprintf(fhOut, " ?");
        break;
        }

        /* print INDEX clause */
        fprintf(fhOut, "  %u",
                pT->ut.oid.cIndx);
        if (pT->ut.oid.cIndx != 0)
            printIntermInst(pT->ut.oid.pIndxL);

    } else {
        /* oid (or unknown or bad) - nothing to do */
    }
    fprintf(fhOut, "\n");

}  /* printIntermOID1 */


USHORT usOldLevel;

/** printIntermOID2 - print intermediate OID item in second form
*
* call with:
*   pO - item
*   aulOid - vector of ancester OIDs
*   usLevel - number of parents
*/
    VOID
#ifdef __STDC__
printIntermOID2(MIBSYM *pO, ULONG aulOid[], USHORT usLevel)
#else
printIntermOID2(pO, aulOid, usLevel)
    MIBSYM *pO;
    ULONG aulOid[];
    USHORT usLevel;
#endif /* __STDC__ */
{
#ifdef OLD
    CHAR chL;


    if (usLevel > usOldLevel)
        chL = '>';
    else if (usLevel == usOldLevel)
        chL = '=';
    else {
        while (--usOldLevel > usLevel) {
            fprintf(fhOut, "<");
        }
        chL = '<';
    }
    usOldLevel = usLevel;

    fprintf(fhOut, "%c %lu %s:%s\n", chL,
            pO->ut.oid.ulVal, pO->pszName, (pO->pMod)->pszName);
#else
    fprintf(fhOut, "%s %s %lu",
            pO->pszName,
            (pO->pMod)->pszName,
            pO->ut.oid.ulVal);

    if (pO->ut.oid.pPar == &OidRoot)
        fprintf(fhOut, " _ _\n");
    else
        fprintf(fhOut, " %s %s\n",
                (pO->ut.oid.pPar)->pszName,
                ((pO->ut.oid.pPar)->pMod)->pszName);
#endif

} /* printIntermOID2 */


/** dumpInterm - dump Objects in Intermediate format
*
*/
    VOID
#ifdef __STDC__
dumpInterm(VOID)
#else
dumpInterm()
#endif /* __STDC__ */
{
    MIBSYM *pT;
    MIBSYM *pM;
    MIBMODREF *pR;
    MIBIMPI *pI;
    USHORT i;
    MIBSEQI *pSi;
    MIBVAR *pV;

    
    fprintf(fhOut, "\n-- Intermediate format from\n");
    fprintf(fhOut, "--   %s\n\n", getVer());

    for (pM = pModGHL; pM != NULL; pM = pM->pNext) {
        printTNSDR(pM);
        fprintf(fhOut,"\n");

        /* Imports */
        for (pR = pM->ut.mod.pImodHL; pR != NULL; pR = pR->pNext) {
            fprintf(fhOut, "i %s %u", (pR->pMod)->pszName, pR->cImpi);
            for (i = 2, pI = pR->pImpIL; pI != NULL; i++, pI = pI->pNext) {
                if (i%4 == 0)
                    fprintf(fhOut, "\n   ");
                fprintf(fhOut, " %s", (pI->pNa)->pszVal);
            }
            fprintf(fhOut, "\n");
        }

        /* Smi items */
        for (pT = pSmiGHL; pT != NULL; pT = pT->pNext) {
            if (pT->pMod != pM)
                continue;

            printTNSDR(pT);
            fprintf(fhOut, "\n");
        }

        /* Textual Conventions */
        for (pT = pTcGHL; pT != NULL; pT = pT->pNext) {
            if (pT->pMod != pM)
                continue;

            printTNSDR(pT);

            printSyntaxInfo(&(pT->ut.tc.syn));
            fprintf(fhOut, "\n");
        }

        /* Sequences */
        for (pT = pSeqGHL; pT != NULL; pT = pT->pNext) {
            if (pT->pMod != pM)
                continue;

            printTNSDR(pT);

            fprintf(fhOut, " %u", pT->ut.seq.cSeqi);
            for (i = 1, pSi = pT->ut.seq.pSeqIL; pSi != NULL;
                    i++, pSi = pSi->pNext) {
                if (i%2 == 0)
                    fprintf(fhOut, "\n   ");
                fprintf(fhOut, " %s", (pSi->pOid)->pszName);
                printSyntaxInfo(&(pSi->syn));
            }
            fprintf(fhOut, "\n");
        }

        /* items identified with OIDs */
        pModCur = pM;
        walkOIDtree(printIntermOID1);

        /* traps */
        for (pT = pTrGHL; pT != NULL; pT = pT->pNext) {
            if (pT->pMod != pM)
                continue;

            printTNSDR(pT);

            fprintf(fhOut, " %s %lu %u",
                    (pT->ut.tr.pOid)->pszName,
                    pT->ut.tr.ulVal, pT->ut.tr.cVar);
            for (i = 2, pV = pT->ut.tr.pVarL; pV != NULL;
                    i++, pV = pV->pNext) {
                if (i%4 == 0)
                    fprintf(fhOut, "\n   ");
                fprintf(fhOut, " %s", (pV->pOid)->pszName);
            }
            fprintf(fhOut, "\n");
        }

/*?? this may need to be changed so that when processing
     each symbol type, the aliases for the symbol are
     printed immediately after the symbol */

        /* print aliases */
        for (pT = pAlGHL; pT != NULL; pT = pT->pNext) {
            if (pT->pMod == NULL) {
                if (pT->ut.al.pAlSym != pM)
                    continue;
                fprintf(fhOut, "1 %s %s\n",
                        pT->pszName, (pT->ut.al.pAlSym)->pszName);
            } else {
                if (pT->pMod != pM)