smdump.c

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

#endif /* __STDC__ */
{
    if ((pO->pMod != pMosyMod) || (pO->ut.oid.usOType == MIBOToid) ||
            (pO->usNeed == MIBIEex))
        return;


    fprintf(fhOut, "%-20s ", pO->pszName);
    if (pO->ut.oid.pPar == &OidRoot)
        sprintf(szBuf, "%lu", pO->ut.oid.ulVal);
    else
        sprintf(szBuf, "%s.%lu",
                (pO->ut.oid.pPar)->pszName,
                pO->ut.oid.ulVal);

    fprintf(fhOut, "%-16s %-15s %-15s %s\n", szBuf,
                mosySYN(&(pO->ut.oid.syn)),
                accessType(pO->ut.oid.usAccess),
                symStatus(pO->usStatus));

} /* printMosyOtherItem */


/** printExtMosyItem - print any object in Extended MOSY format
*
* call with:
*   pO - item
*   aulOid - vector of OIDs
*   usLevel - number of parents
*/
    VOID
#ifdef __STDC__
printExtMosyItem(MIBSYM *pO, ULONG aulOid[], USHORT usLevel)
#else
printExtMosyItem(pO, aulOid, usLevel)
    MIBSYM *pO;
    ULONG aulOid[];
    USHORT usLevel;
#endif /* __STDC__ */
{
    MIBINDX *pI;


    if (pO->usNeed == MIBIEex)
        return;


    fprintf(fhOut, "%-20s ", pO->pszName);
    if (pO->ut.oid.pPar == &OidRoot)
        sprintf(szBuf, "%lu", pO->ut.oid.ulVal);
    else
        sprintf(szBuf, "%s.%lu",
                (pO->ut.oid.pPar)->pszName,
                pO->ut.oid.ulVal);

    switch(pO->ut.oid.usOType) {

    case MIBOToid:
        /* Object ID */
        if (usLevel == 0)
    		  {
           fprintf(fhOut, "%s Root\n", szBuf);
           }
        else
           {
           fprintf(fhOut, "%s Node\n", szBuf);
           }
        break;

    case MIBOTrow:
        /* a row in a table */
        fprintf(fhOut, "%-16s seq %s %u (", szBuf,
                (pO->ut.oid.syn.usi.pSeq)->pszName,
                pO->ut.oid.cIndx);
        for (pI = pO->ut.oid.pIndxL; pI != NULL; pI = pI->pNext) {
            switch (pI->usItype) {
            case MIBITbad:  /* bad index item */
                fprintf(fhOut, " **BAD**");
                break;

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

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

            case MIBITint:  /* index item is INTEGER */
                if ((pI->ulLow == 0L) &&
                        (pI->ulHigh == 0xFFFFFFFFL))
                    fprintf(fhOut, " INTEGER");
                else
                    fprintf(fhOut, " INTEGER (%lu..%lu)",
                            pI->ulLow, pI->ulHigh);
                break;

            case MIBIToct:  /* index item is OCTET STRING */
                if ((pI->ulLow == 0L) &&
                        (pI->ulHigh == 0L))
                    fprintf(fhOut, " OCTET STRING");
                else
                    fprintf(fhOut, " OCTET STRING (SIZE(%lu..%lu))",
                                pI->ulLow, pI->ulHigh);
                break;

            case MIBITnloct:/* index item is no length OCTET STRING */
                if ((pI->ulLow == 0L) &&
                        (pI->ulHigh == 0L))
                    fprintf(fhOut, " NOLENGTH OCTET STRING");
                else
                    fprintf(fhOut, " NOLENGTH OCTET STRING (SIZE(%lu..%lu))",
                                pI->ulLow, pI->ulHigh);
                break;

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

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

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

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

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

            default:
                fprintf(fhOut, " **unknown type %d**",
                        pI->usItype);
                break;
            }
        }
        fprintf(fhOut, " ) %s %s\n",
                accessType(pO->ut.oid.usAccess),
                symStatus(pO->usStatus));

// Modifications to output the description and reference field.
// This will be enabled when I can find the place where the description and
// reference are loaded.
#if 0
        if (pO->pszDesc != NULL)
        		{
            fprintf(fhOut, "%s\n", pO->pszDesc);
            }

        if (pO->pszRefer != NULL)
        		{
            fprintf(fhOut, "%s\n", pO->pszRefer);
            }
#endif
        break;

    case MIBOTtab:
    case MIBOTobj:
        /* table or object */
        fprintf(fhOut, "%-16s %-15s %-15s %s\n", szBuf,
                extMosySYN(&(pO->ut.oid.syn)),
                accessType(pO->ut.oid.usAccess),
                symStatus(pO->usStatus));
        break;

    case MIBOTunk:
    default:
        /* unknown or bad or data structure error */
        fprintf(fhOut, "%-16s ** unknown or bad type\n", szBuf);
        break;
    }

} /* printExtMosyItem */


/** dumpMosy - dump Objects in "mosy" format
*
*/
    VOID
#ifdef __STDC__
dumpMosy(VOID)
#else
dumpMosy()
#endif /* __STDC__ */
{
    MIBSYM *pM;


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

    fprintf(fhOut, "\n-- From module%s:\n", (cModUsed > 1) ? "s" : "");

    for (pM = pModGHL; pM != NULL; pM = pM->pNext) {
        fprintf(fhOut, "--   %s\n", pM->pszName);
        pMosyMod = pM;
        walkOIDtree(printMosyOidItem);
        walkOIDtree(printMosyOtherItem);
    }

    fprintf(fhOut, "-- **end of Mosy oid tree**\n");


} /* dumpMosy */


/** dumpExtMosy - dump Objects in extended "mosy" format
*
*/
    VOID
#ifdef __STDC__
dumpExtMosy(VOID)
#else
dumpExtMosy()
#endif /* __STDC__ */
{
    MIBSYM *pT;
    MIBSYM *pO;
    MIBSYM *pS;
    MIBENUM *pE;
    MIBSEQI *pSi;
    USHORT i;

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

    if (cEnumUsed > 0) {
        i = 0;
        /* check textual conventions */
        for (pT = pTcGHL; pT != NULL; pT = pT->pNext) {
            if (pT->usNeed == MIBIEex)
                continue;
            if (pT->ut.tc.syn.usSyntax == MIBSYNenum) {
                if (i++ == 0)
                    fprintf(fhOut, "\n-- Enumerations\n");
                fprintf(fhOut, "*%s %u (\n", pT->pszName, pT->ut.tc.syn.cEnum);
                for (pE = pT->ut.tc.syn.usi.pEnumL; pE != NULL;
                        pE = pE->pNext) {
                    fprintf(fhOut, "    %-20s %lu\n", pE->pszName, pE->ulVal);
                }
                fprintf(fhOut, ")\n");
            }
        }
        /* check objects */
        for (pO = pOidGHL; pO != NULL; pO = pO->pNext) {
            if (pO->usNeed == MIBIEex)
                continue;
            if (pO->ut.oid.syn.usSyntax == MIBSYNenum) {
                if (i++ == 0)
                    fprintf(fhOut, "\n-- Enumerations\n");
                fprintf(fhOut, "*%s %u (\n", pO->pszName, pO->ut.oid.syn.cEnum);
                for (pE = pO->ut.oid.syn.usi.pEnumL; pE != NULL;
                        pE = pE->pNext) {
                    fprintf(fhOut, "    %-20s %lu\n", pE->pszName, pE->ulVal);
                }
                fprintf(fhOut, ")\n");
            }
        }
        if (i != 0)
            fprintf(fhOut, "\n");
    }

    if (cTcUsed > 0) {
        for (pT = pTcGHL, i = 0; pT != NULL; pT = pT->pNext) {
            if (pT->usNeed == MIBIEex)
                continue;
            if (i++ == 0)
                fprintf(fhOut, "\n-- Textual Conventions\n");
            fprintf(fhOut, "+%-20s %s\n", pT->pszName,
                    extMosySYN(&(pT->ut.tc.syn)));
        }
        if (i != 0)
            fprintf(fhOut, "\n");
    }

    if (cSeqUsed > 0) {
        for (pS = pSeqGHL; pS != NULL; pS = pS->pNext) {
            if (pS->usNeed == MIBIEex)
                continue;
            if (i++ == 0)
                fprintf(fhOut, "-- Sequences\n");
            fprintf(fhOut, "$%s %u {\n", pS->pszName, pS->ut.seq.cSeqi);
            for (pSi = pS->ut.seq.pSeqIL; pSi != NULL; pSi = pSi->pNext) {
                fprintf(fhOut, "    %s\n", (pSi->pOid)->pszName);
            }
            fprintf(fhOut, "}\n");
        }
    }

    fprintf(fhOut, "\n-- Extended Mosy OID tree\n");
    walkOIDtree(printExtMosyItem);

    fprintf(fhOut, "\n-- **end of Extended Mosy OID tree**\n");

} /* dumpExtMosy */


/** printTNSDR - print type, name, status, description, and reference
*                in form for intermediate file
*
* call with:
*   pS - symbol
*/
    VOID
#ifdef __STDC__
printTNSDR(MIBSYM *pS)
#else
printTNSDR(pS)
    MIBSYM *pS;
#endif /* __STDC__ */
{
    CHAR chT;
    CHAR chS;

    switch(pS->usType) {
    case MIBSYMmod:
        /* module */
        chT = 'm';
        break;

    case MIBSYMoid:
        /* pure OID, Table, Row, or object */
        if (pS->ut.oid.usOType == MIBOToid)
            chT = 'o';
        else if (pS->ut.oid.usOType == MIBOTtab)
            chT = 't';
        else if (pS->ut.oid.usOType == MIBOTrow)
            chT = 'r';
        else if (pS->ut.oid.usOType == MIBOTobj)
            chT = 'b';
        else
            chT = '?';
        break;

    case MIBSYMseq:
        /* sequence */
        chT = 's';
        break;

    case MIBSYMtc:
        /* textual convention */
        chT = 'x';
        break;

    case MIBSYMtr:
        /* trap */
        chT = 'p';
        break;

    case MIBSYMimp:
        /* import */
        chT = 'i';
        break;

    case MIBSYMsmi:
        /* smi */
        chT = 'y';
        break;

    default:
        chT = '?';
    }

    switch(pS->usStatus) {
    case MIBSTAma:
        /* mandatory */
        chS = 'm';
        break;

    case MIBSTAop:
        /* optional */
        chS = 'o';
        break;

    case MIBSTAob:
        /* obsolete */
        chS = 'b';
        break;

    case MIBSTAde:
        /* deprecated */
        chS = 'd';
        break;
        
    case MIBSTAnu:
        /* not used */
        chS = 'n';
        break;

    default:
        chS = '?';
    }
        
    if ((pS->pszDesc == NULL) && (pS->pszRefer == NULL))
        fprintf(fhOut, "%c %s %c n",
                chT, pS->pszName, chS);
    else if ((pS->pszDesc == NULL) && (pS->pszRefer != NULL))
        fprintf(fhOut, "%c %s %c r \"%s\"",
                chT, pS->pszName, chS, pS->pszRefer);
    else if ((pS->pszDesc != NULL) && (pS->pszRefer == NULL))
        fprintf(fhOut, "%c %s %c d \"%s\"",
                chT, pS->pszName, chS, pS->pszDesc);
    else
        fprintf(fhOut, "%c %s %c b \"%s\" \"%s\"",
                chT, pS->pszName, chS, pS->pszDesc, pS->pszRefer);

} /* printTNSDR */


/** printSyntaxInfo - print syntax info in form for Intermediate file
*
* call with:
*   pSyn - syntax info
*/
    VOID
#ifdef __STDC__
printSyntaxInfo(MIBSYN *pSyn)
#else
printSyntaxInfo(pSyn)
    MIBSYN *pSyn;
#endif /* __STDC__ */
{
    MIBENUM *pE;
    USHORT i;


    switch(pSyn->usSyntax) {
    case MIBSYNnu:
    case MIBSYNbad:
        fprintf(fhOut, " ?");
        break;

    case MIBSYNint:
        if (pSyn->usSizeRange == MIBSRpp)
            fprintf(fhOut, " i p %lu %lu",
                    pSyn->usr.ulRange[0], pSyn->usr.ulRange[1]);
        else if (pSyn->usSizeRange == MIBSRnp)
            fprintf(fhOut, " i z %lu %lu",
                    pSyn->usr.ulRange[0], pSyn->usr.ulRange[1]);
        else if (pSyn->usSizeRange == MIBSRnn)
            fprintf(fhOut, " i g %lu %lu",
                    pSyn->usr.ulRange[0], pSyn->usr.ulRange[1]);
        else
            fprintf(fhOut, " i n");
        break;

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

    case MIBSYNoid:
        fprintf(fhOut, " d n");
        break;

    case MIBSYNnull:
        fprintf(fhOut, " u n");
        break;

    case MIBSYNnaddr:
        fprintf(fhOut, " n n");
        break;

    case MIBSYNipaddr:
        fprintf(fhOut, " p n");
        break;

    case MIBSYNcntr:
        fprintf(fhOut, " c n");
        break;

    case MIBSYNgauge:
        fprintf(fhOut, " g n");
        break;

    case MIBSYNticks:
        fprintf(fhOut, " t n");
        break;

    case MIBSYNopaque:
        if (pSyn->usSizeRange == MIBSRfs)