smdump.c

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

            break;

        case MIBOTtab:
            fprintf(fhOut, "  syntax:");
            dumpSYN(&(pT->ut.oid.syn));
            break;

        case MIBOTrow:
            fprintf(fhOut, "  syntax:");
            dumpSYN(&(pT->ut.oid.syn));
            prIndx(pT->ut.oid.cIndx, pT->ut.oid.pIndxL);
            if (pT->ut.oid.pIndxL != NULL)
                prInst(pT->ut.oid.pIndxL);
            break;

        case MIBOTobj:
            fprintf(fhOut, "  syntax:");
            dumpSYN(&(pT->ut.oid.syn));
            if (pT->ut.oid.syn.usSyntax != pT->ut.oid.rsyn.usSyntax) {
                fprintf(fhOut, "  resynt:");
                dumpSYN(&(pT->ut.oid.rsyn));
            }
            fprintf(fhOut, "  access: %s\n", accessType(pT->ut.oid.usAccess));
            if ((pT->ut.oid.pDefSeq == NULL) &&
                    (pT->ut.oid.cIndx == 0)) {
                /* no instance */
                fprintf(fhOut, "  instance: 0\n");
            } else if (pT->ut.oid.cIndx != 0) {
                /* instance determined by index clause */
                prIndx(pT->ut.oid.cIndx, pT->ut.oid.pIndxL);

                fprintf(fhOut, "  instance: from index clause\n");
                prInst(pT->ut.oid.pIndxL);
            } else {
                /* item in table */
                if ((pT->ut.oid.pDefSeq)->ut.seq.pRow != NULL)
                    fprintf(fhOut, "  instance: from row \"%s\"\n",
                            ((pT->ut.oid.pDefSeq)->ut.seq.pRow)->pszName);
                else
                    fprintf(fhOut, "  instance: from sequence \"%s\" (no row defined)\n",
                        (pT->ut.oid.pDefSeq)->pszName);
            }
            switch(pT->ut.oid.usDefVal) {
            case MIBDFVno:
                /* no default value */
                break;
            case MIBDFVbad:
                /* bad default value */
                fprintf(fhOut, "  df: **bad\n");
                break;
            case MIBDFVstr:
                /* string */
                fprintf(fhOut, "  df: \"%s\"\n", pT->ut.oid.udv.pszDefVal);
                break;
            case MIBDFVbstr:
                /* binary string */
                fprintf(fhOut, "  df: \'%s\'b\n", pT->ut.oid.udv.pszDefVal);
                break;
            case MIBDFVhstr:
                /* hex string */
                fprintf(fhOut, "  df: \'%s\'h\n", pT->ut.oid.udv.pszDefVal);
                break;
            case MIBDFVint:
                /* integer */
                fprintf(fhOut, "  df: %lu\n", pT->ut.oid.udv.ulDefVal);
                break;
            case MIBDFVneg:
                /* negative number */
                fprintf(fhOut, "  df: -%lu\n", pT->ut.oid.udv.ulDefVal);
                break;
            case MIBDFVna:
                /* name (enumerated value) */
                fprintf(fhOut, "  df: %s\n", pT->ut.oid.udv.pszDefVal);
                break;
            case MIBDFVip:
                /* ip address */
                fprintf(fhOut, "  df: %u.%u.%u.%u\n",
                        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:
                /* object identifier */
                fprintf(fhOut, "  df: %s\n",
                        (pT->ut.oid.udv.pOid)->pszName);
                break;
            default:
                /* bad value */
                fprintf(fhOut, "  df: **unknown type(%d)**\n", pT->ut.oid.usDefVal);
                break;
            }
            break;

        case MIBOTunk:      /* unknown or bad */
        default:
            break;
        }
    }
    fprintf(fhOut, "**end of oid objects**\n");

} /* dumpOID */


/** printOIDitem - print item for dump of OID tree
*
* call with:
*   pO - item
*   aulOid - vector of ancester OIDs
*   usLevel - number of parents
*/
    VOID
#ifdef __STDC__
printOIDitem(MIBSYM *pO, ULONG aulOid[], USHORT usLevel)
#else
printOIDitem(pO, aulOid, usLevel)
    MIBSYM *pO;
    ULONG aulOid[];
    USHORT usLevel;
#endif /* __STDC__ */
{
    USHORT j;

    /* check if excluded */
    if (pO->usNeed == MIBIEex)
        return;

    /* print OID of ancestors */
    for (j = 0; j < usLevel; j++) {
        fprintf(fhOut, "%lu.", aulOid[j]);
    }

    /* print object oid and type */
    if (pO->ut.oid.usOType == MIBOToid)
			{
         if (usLevel == 0)
         	{
        		fprintf(fhOut, "%lu %s %s Root\n", pO->ut.oid.ulVal, pO->pszName,
               (pO->ut.oid.pPar)->pszName);
            }
         else
         	{
        		fprintf(fhOut, "%lu %s %s Node\n", pO->ut.oid.ulVal, pO->pszName,
               (pO->ut.oid.pPar)->pszName);
        		}
         }
    else if (pO->ut.oid.usOType == MIBOTunk)
        fprintf(fhOut, "%lu %s %s **unknown or bad**\n",
                pO->ut.oid.ulVal, pO->pszName, (pO->ut.oid.pPar)->pszName);
    else {
        fprintf(fhOut, "%lu %s %s ", pO->ut.oid.ulVal, pO->pszName, (pO->ut.oid.pPar)->pszName);
        fprintf(fhOut, "%s %s %s\n", extMosySYN(&(pO->ut.oid.syn)),
                accessType(pO->ut.oid.usAccess), symStatus(pO->usStatus));
#if 0
        dumpSYNshort(&(pO->ut.oid.syn));
#endif
    }

} /* printOIDitem */


/** dumpOIDtree - dump OID info in tree form
*
*/
    VOID
#ifdef __STDC__
dumpOIDtree(VOID)
#else
dumpOIDtree()
#endif /* __STDC__ */
{
    USHORT i;
    USHORT j;
    SHORT k;
    MIBSYM *pT;
    MIBENT *pE;
    MIBSYM *pPar;
    ULONG aulOid[MXOIDL];


    /* print OIDs */
    fprintf(fhOut, "\nOID tree\n");
    walkOIDtree(printOIDitem);
    fprintf(fhOut, "**end of oid tree**\n");

    /* print traps */
    fprintf(fhOut, "\nTraps\n");
    for (pE = pEntGHL, i = 0; pE != NULL; pE = pE->pNext) {
        /* print traps having the same enterprise value */
        for (pT = pE->pTr, j = 0; pT != NULL; pT = pT->ut.tr.pEntTr) {
            if (pT->usNeed == MIBIEex)
                continue;
            if (j++ == 0) {
                aulOid[0] = (pE->pOid)->ut.oid.ulVal;
                for (pPar = (pE->pOid)->ut.oid.pPar, k = 1; (pPar != NULL) &&
                        (pPar != &OidRoot); pPar = pPar->ut.oid.pPar, k++) {
                    if (k == MXOIDL) {
                        fprintf(fhOut, "***OIDs nested too deep***\n");
                        return;
                    }
                    aulOid[k] = pPar->ut.oid.ulVal;
                }
                fprintf(fhOut, "  enterprise: %s  %lu",
                          (pE->pOid)->pszName, aulOid[--k]);
                for (k--; k != -1; k--) {
                    fprintf(fhOut, ".%lu", aulOid[k]);
                }
                fprintf(fhOut,"\n");
            }
            fprintf(fhOut, "    trap: %s, value %lu\n",
                    pT->pszName, pT->ut.tr.ulVal);
        }
        i += j;
    }
    if (i == 0)
        fprintf(fhOut, "  --None Defined\n");
    fprintf(fhOut, "**end of TRAPs**\n");

} /* dumpOIDtree */


/** mosySYN - return syntax info in mosy form
*
* call with:
*   pSyn - syntax info
*/
    PSZ
#ifdef __STDC__
mosySYN(MIBSYN *pSyn)
#else
mosySYN(pSyn)
    MIBSYN *pSyn;
#endif /* __STDC__ */
{
    switch(pSyn->usSyntax) {
    case MIBSYNnu:
        return("**syntax not used**");
        break;

    case MIBSYNbad:
        return("**bad syntax");
        break;

    case MIBSYNint:
        return("INTEGER");
        break;

    case MIBSYNoctstr:
        return("OctetString");
        break;

    case MIBSYNoid:
        return("ObjectID");
        break;

    case MIBSYNnull:
        return("NULL");
        break;

    case MIBSYNnaddr:
        return("NetworkAddress");
        break;

    case MIBSYNipaddr:
        return("IpAddress");
        break;

    case MIBSYNcntr:
        return("Counter");
        break;

    case MIBSYNgauge:
        return("Gauge");
        break;

    case MIBSYNticks:
        return("TimeTicks");
        break;

    case MIBSYNopaque:
        return("Opaque");
        break;

    case MIBSYNenum:
        return("INTEGER");
        break;

    case MIBSYNseqOf:
        return("Aggregate");
        break;

    case MIBSYNseq:
        return("Aggregate");
        break;

    case MIBSYNtc:
        return((pSyn->usi.pTC)->pszName);
        break;

    default:
        return("**unknown syntax**");
        break;
    }
} /* mosySYN */


CHAR szMosy[80];
/** extMosySYN - return syntax info in extended mosy form
*
* call with:
*   pSyn - syntax info
*/
    PSZ
#ifdef __STDC__
extMosySYN(MIBSYN *pSyn)
#else
extMosySYN(pSyn)
    MIBSYN *pSyn;
#endif /* __STDC__ */
{
    switch(pSyn->usSyntax) {
    case MIBSYNnu:
        return("**syntax not used**");
        break;

    case MIBSYNbad:
        return("**syntax bad");
        break;

    case MIBSYNint:
        if (pSyn->usSizeRange == MIBSRpp)
            sprintf(szMosy, "INTEGER (%lu..%lu)",
                    pSyn->usr.ulRange[0], pSyn->usr.ulRange[1]);
        else if (pSyn->usSizeRange == MIBSRnp)
            sprintf(szMosy, "INTEGER (-%lu..%lu)",
                    pSyn->usr.ulRange[0], pSyn->usr.ulRange[1]);
        else if (pSyn->usSizeRange == MIBSRnn)
            sprintf(szMosy, "INTEGER (-%lu..-%lu)",
                    pSyn->usr.ulRange[0], pSyn->usr.ulRange[1]);
        else
            strcpy(szMosy, "INTEGER");
        return(szMosy);
        break;

    case MIBSYNoctstr:
        if (pSyn->usSizeRange == MIBSRfs)
            sprintf(szMosy, "OctetString (SIZE (%u))",
                    pSyn->usr.usSize[0]);
        else if (pSyn->usSizeRange == MIBSRvs)
            sprintf(szMosy, "OctetString (SIZE (%u..%u))",
                    pSyn->usr.usSize[0], pSyn->usr.usSize[1]);
        else
            strcpy(szMosy, "OctetString");
        return(szMosy);
        break;

    case MIBSYNoid:
        return("ObjectID");
        break;

    case MIBSYNnull:
        return("NULL");
        break;

    case MIBSYNnaddr:
        return("NetworkAddress");
        break;

    case MIBSYNipaddr:
        return("IpAddress");
        break;

    case MIBSYNcntr:
        return("Counter");
        break;

    case MIBSYNgauge:
        return("Gauge");
        break;

    case MIBSYNticks:
        return("TimeTicks");
        break;

    case MIBSYNopaque:
        return("Opaque");
        break;

    case MIBSYNenum:
        return("Enum");
        break;

    case MIBSYNseqOf:
        sprintf(szMosy, "Table SEQUENCE_OF %s", (pSyn->usi.pSeq)->pszName);
        return(szMosy);
        break;

    case MIBSYNseq:
        sprintf(szMosy, "Row SEQUENCE %s", (pSyn->usi.pSeq)->pszName);
        return(szMosy);
        break;

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

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

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

        case MIBSRfs:
            sprintf(szMosy, "%s (SIZE (%u))", (pSyn->usi.pTC)->pszName,
                    pSyn->usr.usSize[0]);
            break;

        case MIBSRvs:
            sprintf(szMosy, "%s (SIZE (%u..%u))", (pSyn->usi.pTC)->pszName,
                    pSyn->usr.usSize[0], pSyn->usr.usSize[1]);
            break;

        case MIBSRno:
            sprintf(szMosy, "%s", (pSyn->usi.pTC)->pszName);
        }
        return(szMosy);
        break;

    default:
        return("**unknown syntax**");
        break;
    }
} /* extMosySYN */


MIBSYM *pMosyMod;
/** printMosyOidItem - print an OID object in MOSY format
*
* call with:
*   pO - item
*   aulOid - vector of OIDs
*   usLevel - number of parents
*/
    VOID
#ifdef __STDC__
printMosyOidItem(MIBSYM *pO, ULONG aulOid[], USHORT usLevel)
#else
printMosyOidItem(pO, aulOid, usLevel)
    MIBSYM *pO;
    ULONG aulOid[];
    USHORT usLevel;
#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, "%s\n", szBuf);
    
} /* printMosyOidItem */


/** printMosyOtherItem - print an "Other" object in MOSY format
*
* call with:
*   pO - item
*   aulOid - vector of OIDs
*   usLevel - number of parents
*/
    VOID
#ifdef __STDC__
printMosyOtherItem(MIBSYM *pO, ULONG aulOid[], USHORT usLevel)
#else
printMosyOtherItem(pO, aulOid, usLevel)
    MIBSYM *pO;
    ULONG aulOid[];
    USHORT usLevel;