print-snmp.c

来自「<B>Digital的Unix操作系统VAX 4.2源码</B>」· C语言 代码 · 共 965 行 · 第 1/2 页

	u_char *p = (u_char *)elem->data.raw;
	u_long asnlen = elem->asnlen;
	int i;

	switch (elem->type) {

	case BE_OCTET:
		for (i = asnlen; i-- > 0; p++);
			printf("_%.2x", *p);
		break;

	case BE_NULL:
		break;

	case BE_OID: {
		int o = 0, first = -1, i = asnlen;

		if (!nflag && asnlen > 2) {
			struct obj_abrev *a = &obj_abrev_list[0];
			for (; a->node; a++) {
				if (!memcmp(a->oid, p, strlen(a->oid))) {
					objp = a->node->child;
					i -= strlen(a->oid);
					p += strlen(a->oid);
					fputs(a->prefix, stdout);
					first = 1;
					break;
				}
			}
		}
		for (; i-- > 0; p++) {
			o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8);
			if (*p & ASN_LONGLEN)
				continue;

			/*
			 * first subitem encodes two items with 1st*OIDMUX+2nd
			 */
			if (first < 0) {
				if (!nflag)
					objp = mibroot;
				first = 0;
				OBJ_PRINT(o/OIDMUX, first);
				o %= OIDMUX;
			}
			OBJ_PRINT(o, first);
			if (--first < 0)
				first = 0;
			o = 0;
		}
		break;
	}

	case BE_INT:
		printf("%ld", elem->data.integer);
		break;

	case BE_UNS:
		printf("%ld", elem->data.uns);
		break;

	case BE_STR: {
		int printable = 1;
		u_char *p = elem->data.str;
		for (i = asnlen; printable && i-- > 0; p++)
			printable = isprint(*p);
		if (printable)
			putchar('"');
		for (p = elem->data.str, i = asnlen; i-- > 0; p++)
			if (printable)
				putchar(*p);
			else
				printf("_%.2x", *p);
		if (printable)
			putchar('"');
		break;
	}

	case BE_SEQ:
		printf("Seq(%d)", elem->asnlen);
		break;

	case BE_INETADDR: {
		char sep;
		if (asnlen != ASNLEN_INETADDR)
			fprintf(stdout, "[inetaddr len!=%d]", ASNLEN_INETADDR);
		sep='[';
		for (i = asnlen; i-- > 0; p++) {
			printf("%c%u", sep, *p);
			sep='.';
		}
		putchar(']');
		break;
	}

	case BE_PDU:
		printf("%s(%d)",
			Class[CONTEXT].Id[elem->id], elem->asnlen);
		break;

	default:
		printf("[be!?]");
		break;
	}
}

/*
 * Brute force ASN.1 printer: recurses to dump an entire structure
 */
void
asn1_decode(p, length)
	u_char *p;
	int length;
{
	struct be elem;
	int i = 0;

	while (i >= 0 && length > 0) {
		i = asn1_parse(p, length, &elem);
		if (i >= 0) {
			printf(" ");
			asn1_print(&elem);
			if (elem.type == BE_SEQ || elem.type == BE_PDU) {
				printf(" {");
				asn1_decode(elem.data.raw, elem.asnlen);
				printf(" }");
			}
			length -= i;
			p += i;
		}
	}
}

/*
 * General SNMP header
 *	SEQUENCE {
 *		version INTEGER {version-1(0)},
 *		community OCTET STRING,
 *		data ANY 	-- PDUs
 *	}
 * PDUs for all but Trap: (see rfc1157 from page 15 on)
 *	SEQUENCE {
 *		request-id INTEGER,
 *		error-status INTEGER,
 *		error-index INTEGER,
 *		varbindlist SEQUENCE OF
 *			SEQUENCE {
 *				name ObjectName,
 *				value ObjectValue
 *			}
 *	}
 * PDU for Trap:
 *	SEQUENCE {
 *		enterprise OBJECT IDENTIFIER,
 *		agent-addr NetworkAddress,
 *		generic-trap INTEGER,
 *		specific-trap INTEGER,
 *		time-stamp TimeTicks,
 *		varbindlist SEQUENCE OF
 *			SEQUENCE {
 *				name ObjectName,
 *				value ObjectValue
 *			}
 *	}
 */

/*
 * Decode SNMP varBind
 */
void
varbind_print (pduid, np, length, error)
	u_char pduid, *np;
	int length, error;
{
	struct be elem;
	int count = 0, index;

	/* Sequence of varBind */
	count = asn1_parse(np, length, &elem);
	if (elem.type != BE_SEQ) {
		printf("[!SEQ of varbind]");
		asn1_print(&elem);
		return;
	}
	if (count < length)
		printf("[%d extra after SEQ of varbind]", length - count);
	/* descend */
	np = (u_char *)elem.data.raw;
	length = snapend - np;

	for (index = 1; length > 0; index++) {
		u_char *vbend;
		int vblength;

		if (!error || index == error)
			fputs(" ", stdout);

		/* Sequence */
		count = asn1_parse(np, length, &elem);
		if (elem.type != BE_SEQ) {
			printf("[!varbind]");
			asn1_print(&elem);
			return;
		}
		vbend = np + count;
		vblength = length - count;
		/* descend */
		np = (u_char *)elem.data.raw;
		length = snapend - np;

		/* objName (OID) */
		count = asn1_parse(np, length, &elem);
		if (elem.type != BE_OID) {
			printf("[objName!=OID]");
			asn1_print(&elem);
			return;
		}
		if (!error || index == error)
			asn1_print(&elem);
		length -= count;
		np += count;

		if (pduid != GETREQ && pduid != GETNEXTREQ && !error)
				fputs("=", stdout);

		/* objVal (ANY) */
		count = asn1_parse(np, length, &elem);
		if (pduid == GETREQ || pduid == GETNEXTREQ) {
			if (elem.type != BE_NULL) {
				printf("[objVal!=NULL]");
				asn1_print(&elem);
			}
		} else
			if (error && index == error && elem.type != BE_NULL)
				printf("[err objVal!=NULL]");
			if (!error || index == error)
				asn1_print(&elem);

		length = vblength;
		np = vbend;
	}
}

/*
 * Decode SNMP PDUs: GetRequest, GetNextRequest, GetResponse, and SetRequest
 */
void
snmppdu_print (pduid, np, length)
	u_char pduid, *np;
	int length;
{
	struct be elem;
	int count = 0, error;

	/* reqId (Integer) */
	count = asn1_parse(np, length, &elem);
	if (elem.type != BE_INT) {
		printf("[reqId!=INT]");
		asn1_print(&elem);
		return;
	}
	/* ignore */
	length -= count;
	np += count;

	/* errorStatus (Integer) */
	count = asn1_parse(np, length, &elem);
	if (elem.type != BE_INT) {
		printf("[errorStatus!=INT]");
		asn1_print(&elem);
		return;
	}
	error = 0;
	if ((pduid == GETREQ || pduid == GETNEXTREQ)
	    && elem.data.integer != 0) {
		char errbuf[10];
		printf("[errorStatus(%s)!=0]", 
			DECODE_ErrorStatus(elem.data.integer));
	} else if (elem.data.integer != 0) {
		char errbuf[10];
		printf(" %s", DECODE_ErrorStatus(elem.data.integer));
		error = elem.data.integer;
	}
	length -= count;
	np += count;

	/* errorIndex (Integer) */
	count = asn1_parse(np, length, &elem);
	if (elem.type != BE_INT) {
		printf("[errorIndex!=INT]");
		asn1_print(&elem);
		return;
	}
	if ((pduid == GETREQ || pduid == GETNEXTREQ)
	    && elem.data.integer != 0)
		printf("[errorIndex(%d)!=0]", elem.data.integer);
	else if (elem.data.integer != 0) {
		if (!error)
			printf("[errorIndex(%d) w/o errorStatus]",
				elem.data.integer);
		else {
			printf("@%d", elem.data.integer);
			error = elem.data.integer;
		}
	} else if (error) {
		printf("[errorIndex==0]");
		error = 0;
	}
	length -= count;
	np += count;

	varbind_print(pduid, np, length, error);
	return;
}

/*
 * Decode SNMP Trap PDU
 */
void
trap_print (np, length)
	u_char *np;
	int length;
{
	struct be elem;
	int count = 0, generic;

	putchar(' ');

	/* enterprise (oid) */
	count = asn1_parse(np, length, &elem);
	if (elem.type != BE_OID) {
		printf("[enterprise!=OID]");
		asn1_print(&elem);
		return;
	}
	asn1_print(&elem);
	length -= count;
	np += count;

	putchar(' ');

	/* agent-addr (inetaddr) */
	count = asn1_parse(np, length, &elem);
	if (elem.type != BE_INETADDR) {
		printf("[agent-addr!=INETADDR]");
		asn1_print(&elem);
		return;
	}
	asn1_print(&elem);
	length -= count;
	np += count;

	/* generic-trap (Integer) */
	count = asn1_parse(np, length, &elem);
	if (elem.type != BE_INT) {
		printf("[generic-trap!=INT]");
		asn1_print(&elem);
		return;
	}
	generic = elem.data.integer;
	{
		char buf[10];
		printf(" %s", DECODE_GenericTrap(generic));
	}
	length -= count;
	np += count;

	/* specific-trap (Integer) */
	count = asn1_parse(np, length, &elem);
	if (elem.type != BE_INT) {
		printf("[specific-trap!=INT]");
		asn1_print(&elem);
		return;
	}
	if (generic != GT_ENTERPRISE) {
		if (elem.data.integer != 0)
			printf("[specific-trap(%d)!=0]", elem.data.integer);
	} else
		printf(" s=%d", elem.data.integer);
	length -= count;
	np += count;

	putchar(' ');

	/* time-stamp (TimeTicks) */
	count = asn1_parse(np, length, &elem);
	if (elem.type != BE_UNS) {			/* XXX */
		printf("[time-stamp!=TIMETICKS]");
		asn1_print(&elem);
		return;
	}
	asn1_print(&elem);
	length -= count;
	np += count;

	varbind_print (TRAP, np, length, 0);
	return;
}

/*
 * Decode SNMP header and pass on to PDU printing routines
 */
void
snmp_print (np, length)
	u_char *np;
	int length;
{
	struct be elem, pdu;
	int count = 0;

	putchar(' ');

	/* Sequence */
	length = snapend - np;
	count = asn1_parse(np, length, &elem);
	if (elem.type != BE_SEQ) {
		printf("[!init SEQ]");
		asn1_print(&elem);
		return;
	}
	if (count < length)
		printf("[%d extra after iSEQ]", length - count);
	/* descend */
	np = (u_char *)elem.data.raw;
	length = snapend - np;

	/* Version (Integer) */
	count = asn1_parse(np, length, &elem);
	if (elem.type != BE_INT) {
		printf("[version!=INT]");
		asn1_print(&elem);
		return;
	}
	/* only handle version==0 */
	if (elem.data.integer != DEF_VERSION) {
		printf("[version(%d)!=0]", elem.data.integer);
		return;
	}
	length -= count;
	np += count;

	/* Community (String) */
	count = asn1_parse(np, length, &elem);
	if (elem.type != BE_STR) {
		printf("[comm!=STR]");
		asn1_print(&elem);
		return;
	}
	/* default community */
	if (strncmp(elem.data.str, DEF_COMMUNITY, sizeof(DEF_COMMUNITY)-1))
		/* ! "public" */
		printf("C=%.*s ", elem.asnlen, elem.data.str);
	length -= count;
	np += count;

	/* PDU (Context) */
	count = asn1_parse(np, length, &pdu);
	if (pdu.type != BE_PDU) {
		printf("[no PDU]");
		return;
	}
	if (count < length)
		printf("[%d extra after PDU]", length - count);
	asn1_print(&pdu);
	/* descend into PDU */
	np = (u_char *)pdu.data.raw;
	length = snapend - np;

	switch (pdu.id) {
	case TRAP:
		trap_print(np, length);
		break;
	case GETREQ:
	case GETNEXTREQ:
	case GETRESP:
	case SETREQ:
		snmppdu_print(pdu.id, np, length);
		break;
	}
	return;
}