smdump.c

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

                    continue;
                fprintf(fhOut, "2 %s %s %s\n",
                        pT->pszName, (pT->pMod)->pszName,
                        (pT->ut.al.pAlSym)->pszName);
            }
        }
    }



    /* print separator */
    fprintf(fhOut, "z %u\n", cOidUsed);

    /* print OID tree */
    walkOIDtree(printIntermOID2);

} /* dumpInterm */


/** symFR - return forward reference flag
*
* call with:
*   usType - symbol type
*
* returns:
*   ptr to name of type
*/
    PSZ
#ifdef __STDC__
symFR(USHORT usType)
#else
symFR(usType)
    USHORT usType;
#endif /* __STDC__ */
{
    if (usType & MIBSYMFR)
        return("FR:");
    else
        return("");

} /* symFR */


/** symType - return value of type
*
* call with:
*   usType - symbol type
*
* returns:
*   ptr to name of type
*/
    PSZ
#ifdef __STDC__
symType(USHORT usType)
#else
symType(usType)
    USHORT usType;
#endif /* __STDC__ */
{
    switch(usType & MIBSYMmask) {
    case MIBSYMmod:
        return("module");
    case MIBSYMoid:
        return("OID object");
    case MIBSYMseq:
        return("sequence");
    case MIBSYMtc:
        return("textual convention");
    case MIBSYMtr:
        return("trap");
    case MIBSYMimp:
        return("import");
    case MIBSYMsmi:
        return("SMI");
    case MIBSYMalias:
        return("alias");
    default:
        return("**unknown**");
    }
} /* symType */


/** symStatus - return value of status
*
* call with:
*   usStatus
*
* returns:
*   ptr to name of type
*/
    PSZ
#ifdef __STDC__
symStatus(USHORT usStatus)
#else
symStatus(usStatus)
    USHORT usStatus;
#endif /* __STDC__ */
{
    switch(usStatus) {
    case MIBSTAnu:
        return("not used");
    case MIBSTAbad:
        return("**bad**");
    case MIBSTAma:
        return("mandatory");
    case MIBSTAop:
        return("optional");
    case MIBSTAob:
        return("obsolete");
    case MIBSTAde:
        return("deprecated");
    default:
        return("**unknown**");
    }
} /* symStatus */


/** printText - print formatted text. If text ptr is NULL then
*               don't print anything.
*
* ??NOTE: for now it just dumps the text. Fix so that the
*         text is wrapped
*
* call with:
*   pszLeader - leading text
*   pszText - bulk text
*
*/
    VOID
#ifdef __STDC__
printText(PSZ pszLeader, PSZ pszText)
#else
printText(pszLeader, pszText)
    PSZ pszLeader;
    PSZ pszText;
#endif /* __STDC__ */
{
    if (pszText == NULL)
        return;

    fprintf(fhOut, "%s%s\n", pszLeader, pszText);

} /* printText */


/** printNameOID - print name and OID of an item
*
* call with:
*   pSym - mib symbol
*/
    VOID
#ifdef __STDC__
printNameOID(MIBSYM *pSym)
#else
printNameOID(pSym)
    MIBSYM *pSym;
#endif /* __STDC__ */
{
    ULONG aulOid[MXOIDL];
    SHORT i;
    MIBSYM *pPar;

    while (pSym != NULL) {
        if ((pSym->usType == MIBSYMoid) && (pSym->usNeed != MIBIEex)) {
            aulOid[0] = pSym->ut.oid.ulVal;
            for (pPar = pSym->ut.oid.pPar, i = 1; (pPar != NULL) &&
                    (pPar != &OidRoot); pPar = pPar->ut.oid.pPar, i++) {
                if (i == MXOIDL) {
                    fprintf(fhOut, "***OIDs nested too deep***\n");
                    return;
                }
                aulOid[i] = pPar->ut.oid.ulVal;
            }
            i--;
            if (aulOid[i] == 0xFFFFFFFFL)
                fprintf(fhOut, "%-24s **not defined**",
                        pSym->pszName);
            else
                fprintf(fhOut, "%-24s %lu",
                        pSym->pszName, aulOid[i]);
            for (i--; i != -1; i--) {
                fprintf(fhOut, ".%lu", aulOid[i]);
            }
            if (pSym->ut.oid.fDup)
                fprintf(fhOut, "  **dup**");
            fprintf(fhOut, "\n");
        }
        pSym = pSym->pSym;
    }
} /* printNameOID */


/** OIDnameInOrder - print out names (and OID values) of OID items
*
* call with:
*   pStrTab - subtree of string table
*/
    VOID
#ifdef __STDC__
OIDnameInOrder(STRTAB *pCur)
#else
OIDnameInOrder(pCur)
    STRTAB *pCur;
#endif /* __STDC__ */
{
    /* check if anything to do */
    if (pCur == NULL)
        return;

    /* do left subtree */
    OIDnameInOrder(pCur->pLeft);

    /* do item */
    printNameOID(pCur->pSym);

    /* do right subtree */
    OIDnameInOrder(pCur->pRight);

} /* OIDnameInOrder */


/** symIE - return value for INCLUDE/EXCLUDE field
*
* call with:
*   usNeed - value
*
* returns:
*   ptr to value expressed as a string
*/
    PSZ
#ifdef __STDC__
symIE(USHORT usNeed)
#else
symIE(usNeed)
    USHORT usNeed;
#endif /* __STDC__ */
{
    switch(usNeed) {
    case MIBIEns:
        return("not specified");
    case MIBIEbad:
        return("**bad**");
    case MIBIEin:
        return("included");
    case MIBIEex:
        return("excluded");
    default:
        return("**unknown**");
    }
} /* symIE */



/** dumpOIDname - print out names (and OID values) of OID items
*
*/
    VOID
#ifdef __STDC__
dumpOIDname(VOID)
#else
dumpOIDname()
#endif /* __STDC__ */
{

    OIDnameInOrder(pStrTabRoot);

} /* dumpOIDname */


/** dumpSYM - dump symbol info
*
* call with:
*   pSym - symbol
*/
    VOID
#ifdef __STDC__
dumpSYM(MIBSYM *pSym)
#else
dumpSYM(pSym)
    MIBSYM *pSym;
#endif /* __STDC__ */
{
    MIBSYM *pAl;


    fprintf(fhOut, "%s: \"%s\"", symType(pSym->usType), pSym->pszName);
    if (pSym->pMod != NULL)
        fprintf(fhOut, " from \"%s\"\n", (pSym->pMod)->pszName);
    else
        fprintf(fhOut, "\n");
    if (pSym->pAlist != NULL) {
        for (pAl = pSym->pAlist; pAl != NULL; pAl = pAl->ut.al.pNext) {
            fprintf(fhOut, "  alias: %s\n", pAl->pszName);
        }
    }
    if (pSym->usNeed != MIBIEns)
        fprintf(fhOut, "  I/E: %s\n",
                    symIE(pSym->usNeed));
    if (pSym->usStatus != MIBSTAnu)
        fprintf(fhOut, "  status: %s%s\n",
                    symStatus(pSym->usStatus), symFR(pSym->usStatus));
    if ((pSym->pszDesc != NULL) && (*(pSym->pszDesc) != 0))
        printText("  descr: ", pSym->pszDesc);
    if ((pSym->pszRefer != NULL) && (*(pSym->pszRefer) != 0))
        printText("  refer: ", pSym->pszRefer);

} /* dumpSYM */


/** dumpMOD - dump module info
*
*/
    VOID
#ifdef __STDC__
dumpMOD(VOID)
#else
dumpMOD()
#endif /* __STDC__ */
{
    USHORT i, j, k;
    MIBSYM *pT;
    MIBMODREF *pR;
    MIBIMPI *pI;


    fprintf(fhOut, "\nDumping Module info\n");

    for (pR = pModRefAvail, i = 0; pR != NULL; pR = pR->pNext) {
        i++;
    }
    fprintf(fhOut, "%d of %d module refs in avail list\n", i, MIBMODREFACT);

    for (pI = pImpiAvail, i = 0; pI != NULL; pI = pI->pNext) {
        i++;
    }
    fprintf(fhOut, "%d of %d import items in avail list\n", i, MIBIMPIACT);

    for (pT = pModAvail, i = 0; pT != NULL; pT = pT->pNext) {
        i++;
    }
    fprintf(fhOut, "%d of %d modules in avail list\n", i, MIBMODACT);

    for (pT = pModGHL, i = 0, j = 0; pT != NULL; pT = pT->pNext) {
        i++;
        if (pT->usNeed == MIBIEex)
            j++;
    }
    fprintf(fhOut, "%d modules specified\n", i);
    if (j != 0)
        fprintf(fhOut, "%d modules excluded\n", j);


    for (pT = pModGHL, i = 0; pT != NULL; pT = pT->pNext) {
        i++;
        dumpSYM((MIBSYM *)pT);
        for (pR = pT->ut.mod.pImodHL, j = 0; pR != NULL; pR = pR->pNext) {
            j++;
            fprintf(fhOut, "    mod: \"%s\": %d items\n",
                    (pR->pMod)->pszName, pR->cImpi);
            for (pI = pR->pImpIL, k = 0; pI != 0; pI = pI->pNext) {
                k++;
                fprintf(fhOut, "        \"%s\"\n", (pI->pNa)->pszVal);
            }
        }
    }
    fprintf(fhOut, "**end of modules**\n");

} /* dumpMOD */


/** dumpAL - dump alias info
*
*/
    VOID
#ifdef __STDC__
dumpAL(VOID)
#else
dumpAL()
#endif /* __STDC__ */
{
    USHORT i;
    USHORT j;
    MIBSYM *pT;


    fprintf(fhOut, "\nDumping Alias info\n");

    for (pT = pAlAvail, i = 0; pT != NULL; pT = pT->pNext) {
        i++;
    }
    fprintf(fhOut, "%d of %d aliases in avail list\n", i, MIBALACT);

    for (pT = pAlGHL, i = 0, j = 0; pT != NULL; pT = pT->pNext) {
        i++;
        if (pT->usNeed == MIBIEex)
            j++;
    }
    fprintf(fhOut, "%d aliases specified\n", i);
    if (j != 0)
        fprintf(fhOut, "%d aliases excluded\n", j);

    for (pT = pAlGHL, i = 0; pT != NULL; pT = pT->pNext) {
        i++;
        dumpSYM((MIBSYM *)pT);
        fprintf(fhOut, "    for: %s\n", (pT->ut.al.pAlSym)->pszName);
        fprintf(fhOut, "    use: %d\n", pT->ut.al.cUse);
    }
    fprintf(fhOut, "**end of aliases**\n");

} /* dumpAL */


/** dumpSMI - dump SMI info
*
*/
    VOID
#ifdef __STDC__
dumpSMI(VOID)
#else
dumpSMI()
#endif /* __STDC__ */
{
    USHORT i;
    USHORT j;
    MIBSYM *pT;


    fprintf(fhOut, "\nDumping SMI item info\n");

    for (pT = pSmiAvail, i = 0; pT != NULL; pT = pT->pNext) {
        i++;
    }
    fprintf(fhOut, "%d of %d SMI items in avail list\n", i, MIBSMIACT);

    for (pT = pSmiGHL, i = 0, j = 0; pT != NULL; pT = pT->pNext) {
        i++;
        if (pT->usNeed == MIBIEex)
            j++;
    }
    fprintf(fhOut, "%d SMI items specified\n", i);
    if (j != 0)
        fprintf(fhOut, "%d SMI items excluded\n", j);


    for (pT = pSmiGHL, i = 0; pT != NULL; pT = pT->pNext) {
        i++;
        dumpSYM((MIBSYM *)pT);
    }
    fprintf(fhOut, "**end of smi items**\n");

} /* dumpSMI */


/** dumpIMP - dump import info
*
*/
    VOID
#ifdef __STDC__
dumpIMP(VOID)
#else
dumpIMP()
#endif /* __STDC__ */
{
    USHORT i;
    USHORT j;
    MIBSYM *pT;


    fprintf(fhOut, "\nDumping IMPORT info\n");

    for (pT = pImpAvail, i = 0; pT != NULL; pT = pT->pNext) {
        i++;
    }
    fprintf(fhOut, "%d of %d IMPORT items in avail list\n", i, MIBIMPACT);

    for (pT = pImpGHL, i = 0, j = 0; pT != NULL; pT = pT->pNext) {
        i++;
        if (pT->usNeed != MIBIEex)
            j++;
    }
    fprintf(fhOut, "%d IMPORT items specified\n", i);
    if (j != 0)
        fprintf(fhOut, "%d IMPORT items excluded\n", j);


    for (pT = pImpGHL, i = 0; pT != NULL; pT = pT->pNext) {
        i++;
        dumpSYM((MIBSYM *)pT);
        fprintf(fhOut, "  defined in module \"%s\"\n",
            ((pT->ut.imp.pImpSym)->pMod)->pszName);