smux.c

Snmp（简单网管协议）软件包。

	*oidlen = var_name_len;
	memcpy( objid,var_name, var_name_len * sizeof(oid));

    DEBUGMSGTL(("smux", "[smux_parse_var] returning oid : "));
    DEBUGMSGOID(("smux", objid, *oidlen));
    DEBUGMSG(("smux","\n"));
	/* XXX */
	len = SMUXMAXPKTSIZE;
        DEBUGMSGTL(("smux",
                    "[smux_parse_var] Asn coded len of var %d, type %d\n", 
                    var_val_len, (int)*vartype));

	switch((short)*vartype){
	case ASN_INTEGER:
		*varlength = sizeof(long);
		asn_parse_int(var_val, &len, vartype,
			      (long *)&smux_long, *varlength);
		return (u_char *)&smux_long;
		break;
	    case ASN_COUNTER:
	    case ASN_GAUGE:
	    case ASN_TIMETICKS:
	    case ASN_UINTEGER:
		*varlength = sizeof(u_long);
		asn_parse_unsigned_int(var_val, &len, vartype,
			      (u_long *)&smux_ulong, *varlength);
		return (u_char *)&smux_ulong;
		break;
	    case ASN_COUNTER64:
		*varlength = sizeof(smux_counter64);
		asn_parse_unsigned_int64(var_val, &len, vartype,
					 (struct counter64 *)&smux_counter64,
					 *varlength);
		return (u_char *)&smux_counter64;
		break;
	    case ASN_IPADDRESS:
		*varlength = 4;
		/* 
		 * consume the tag and length, but just copy here
		 * because we know it is an ip address
		 */
		if ((var_val = asn_parse_header(var_val, &len, &type)) == NULL)
			return NULL;
		memcpy((u_char *)&(smux_sa.sin_addr.s_addr), var_val,
		      *varlength);
		return (u_char *)&(smux_sa.sin_addr.s_addr);
		break;
	    case ASN_OCTET_STR:
		/* XXX */
		if (len == 0)
			return NULL;
		str_len = SMUXMAXSTRLEN;
		asn_parse_string(var_val, &len, vartype,
				 smux_str, &str_len);
		*varlength = str_len;
		return smux_str;
		break;
	    case ASN_OPAQUE:
	    case ASN_NSAP:
	    case ASN_OBJECT_ID:
		objid_len = MAX_OID_LEN;
		asn_parse_objid(var_val, &len, vartype, 
				smux_objid, &objid_len);
		*varlength = objid_len*sizeof(oid);
		return (u_char *)smux_objid;
		break;
            case SNMP_NOSUCHOBJECT:
            case SNMP_NOSUCHINSTANCE:
            case SNMP_ENDOFMIBVIEW:
	    case ASN_NULL:
	    	return NULL;
		break;
	    case ASN_BIT_STR:
		/* XXX */
		if (len == 0)
			return NULL;
		str_len = SMUXMAXSTRLEN;
		asn_parse_bitstring(var_val, &len, vartype,
				 smux_str, &str_len);
		*varlength = str_len;
		return (u_char *)smux_str;
		break;
	    default:
	 snmp_log(LOG_ERR, "bad type returned (%x)\n", *vartype);
		return NULL;
		break;
	}
}

/* XXX This is a bad hack - do not want to muck with ucd code */
static int
smux_build(u_char type,
	u_long reqid,
	oid *objid,
	size_t *oidlen,
	u_char val_type,
	u_char *val,
	size_t val_len,
	u_char *packet,
	size_t *length)
{
	u_char *ptr, *save1, *save2;
	size_t len;
	long errstat = 0;
	long errindex = 0;

	/* leave space for Seq and length */
	save1 = packet;
	ptr = packet + 4;
	len = *length - 4;
	
	/* build reqid */
	ptr = asn_build_unsigned_int(ptr, &len, 
	      (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
	      &reqid, sizeof(reqid));

	/* build err stat */
	ptr = asn_build_int(ptr, &len, 
	      (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
	      &errstat, sizeof(errstat));

	/* build err index */
	ptr = asn_build_int(ptr, &len, 
	      (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
	      &errindex, sizeof(errindex));

	save2 = ptr;
	ptr += 4;
	len -= 4;

	if (type != SMUX_SET) {
		val_type = ASN_NULL;
		val_len = 0;
	}

	/* build var list : snmp_build_var_op not liked by gated XXX */
	ptr = snmp_build_var_op(ptr, objid, oidlen, val_type, val_len,
	    val, &len);

	len = ptr - save1;
	asn_build_sequence(save1, &len, type,
	    (ptr - save1 - 4));

	len = ptr - save2;
	asn_build_sequence(save2, &len,
	    (ASN_SEQUENCE | ASN_CONSTRUCTOR), (ptr - save2 - 4));

	*length = ptr - packet;

	return 0;
}

static void
smux_peer_cleanup(int sd)
{
	smux_reg *nrptr, *rptr, *rptr2;
	int nfound, i;

	nfound = 0;

	/* close the descriptor */
	close(sd);

	/* delete all of the passive registrations that this peer owns */
	for (rptr = PassiveRegs; rptr; rptr = nrptr) {
		nrptr = rptr->sr_next;
		if (rptr->sr_fd == sd) {
			smux_list_detach(&PassiveRegs, &rptr);
			free(rptr);
		}
		rptr = nrptr;
	}
	/* find replacements for all of the active registrations found */
	for (rptr = ActiveRegs; rptr; rptr = rptr2) {
		rptr2 = rptr->sr_next;
		if (rptr->sr_fd == sd) {
			smux_list_detach(&ActiveRegs, &rptr);
			unregister_mib(rptr->sr_name, rptr->sr_name_len);
			if ((nrptr = smux_find_replacement(rptr->sr_name,
			     rptr->sr_name_len)) != NULL) {
				smux_list_detach(&PassiveRegs, &nrptr);
				smux_list_add(&ActiveRegs, nrptr);
				register_mib("smux", (struct variable *)
				    smux_variables, sizeof(struct variable2), 
				    1, nrptr->sr_name, nrptr->sr_name_len);
			}
			free(rptr);
		}
	}

	/* decrement the peer count */
	npeers--;

	/* make his auth available again */
	for (i = 0; i < nauths; i++) {
		if (Auths[i]->sa_active_fd == sd) {
		  	char oid_name[128];
			Auths[i]->sa_active_fd = -1;
			sprint_objid(oid_name, Auths[i]->sa_oid, Auths[i]->sa_oid_len);
			snmp_log(LOG_INFO, "peer disconnected: %s\n", oid_name);
		}
	}
}

int 
smux_send_rrsp(int sd, int pri)
{
	u_char outdata[2 + sizeof(int)];
	u_char *ptr = outdata;
	int intsize = sizeof(int);
	u_int mask = ((u_int) 0xFF) << (8 * (sizeof(int) - 1));
		/* e.g. mask is 0xFF000000 on a 32-bit machine */
	int sent;

	/*
	 * This is kind of like calling asn_build_int(), but the
	 * encoding will always be the size of an integer on this
	 * machine, never shorter.
	 */
	*ptr++ = (u_char) SMUX_RRSP;
	*ptr++ = (u_char) intsize;

	/* Copy each byte, most significant first. */
	while (intsize--) {
		*ptr++ = (u_char) ((pri & mask) >> (8 * (sizeof(int) - 1)));
		pri <<= 8;
	}

	sent = send(sd, (char *)outdata, sizeof outdata, 0);
	if (sent < 0) {
		DEBUGMSGTL (("smux","[smux_send_rrsp] send failed\n"));
	}
	return (sent);
}

static u_char *
smux_trap_process(u_char *rsp, size_t *len)
{
	oid sa_enterpriseoid[MAX_OID_LEN], var_name[MAX_OID_LEN];
	size_t datalen, var_name_len, var_val_len, maxlen;
	int sa_enterpriseoid_len;
	u_char vartype, *ptr, *var_val;

	long trap, specific;
	u_long timestamp;

	struct variable_list *snmptrap_head, *snmptrap_ptr, *snmptrap_tmp;
	snmptrap_head = NULL;
	snmptrap_ptr = NULL;

	ptr = rsp;

	/* parse the sub-agent enterprise oid */
	datalen = MAX_OID_LEN;
	if ((ptr = asn_parse_objid(ptr, len, 
			&vartype, (oid *)&sa_enterpriseoid, 
			&sa_enterpriseoid_len)) == NULL ) {
			DEBUGMSGTL (("smux","[smux_trap_process] asn_parse_objid failed\n"));
			return NULL;
	}

	/* parse the agent-addr ipAddress */
	datalen = SMUXMAXSTRLEN;
	if (((ptr = asn_parse_string(ptr, len,
		    &vartype, smux_str, 
		    &datalen)) == NULL) ||
		    (vartype != (u_char)ASN_IPADDRESS)) {
			DEBUGMSGTL (("smux", "[smux_trap_process] asn_parse_string failed\n"));
			return NULL;
	}

	/* parse the generic trap int */
	datalen = sizeof(long);
	if ((ptr = asn_parse_int(ptr, len,
			&vartype, &trap,
			datalen)) == NULL ) {
			DEBUGMSGTL (("smux","[smux_trap_process] asn_parse_int generic failed\n"));
			return NULL;
	}

	/* parse the specific trap int */
	datalen = sizeof(long);
	if ((ptr = asn_parse_int(ptr, len,
			 &vartype, &specific,
			 datalen)) == NULL ) {
			 DEBUGMSGTL (("smux","[smux_trap_process] asn_parse_int specific failed\n"));
			 return NULL;
	}

	/* parse the timeticks timestamp */
	datalen = sizeof(u_long);
	if (((ptr = asn_parse_unsigned_int(ptr, len,
				&vartype, (u_long *)&timestamp,
			    datalen)) == NULL) ||
				(vartype != (u_char)ASN_TIMETICKS)) {
				DEBUGMSGTL (("smux","[smux_trap_process] asn_parse_unsigned_int (timestamp) failed\n"));
				return NULL;
	}

	/* parse out the overall sequence */
	ptr = asn_parse_header(ptr, len, &vartype);
	if (ptr == NULL || vartype != (ASN_SEQUENCE | ASN_CONSTRUCTOR)) {
		return NULL;
	}

	/* parse the variable bindings */
	while (ptr && *len) {

		/* get the objid and the asn1 coded value */
		var_name_len = MAX_OID_LEN;
		ptr = snmp_parse_var_op(ptr, var_name, &var_name_len, &vartype,
					&var_val_len, (u_char **)&var_val, len);

		if (ptr==NULL) {
			return NULL;
		}

		maxlen = SMUXMAXPKTSIZE;
		switch((short)vartype){
		    case ASN_INTEGER:
				var_val_len = sizeof(long);
				asn_parse_int(var_val, &maxlen, &vartype,
					      (long *)&smux_long, var_val_len);
				var_val = (u_char *)&smux_long;
				break;
		    case ASN_COUNTER:
		    case ASN_GAUGE:
		    case ASN_TIMETICKS:
		    case ASN_UINTEGER:
				var_val_len = sizeof(u_long);
				asn_parse_unsigned_int(var_val, &maxlen, &vartype,
					      (u_long *)&smux_ulong, var_val_len);
				var_val = (u_char *)&smux_ulong;
				break;
		    case ASN_COUNTER64:
				var_val_len = sizeof(smux_counter64);
				asn_parse_unsigned_int64(var_val, &maxlen, &vartype,
							 (struct counter64 *)&smux_counter64,
							 var_val_len);
				var_val = (u_char *)&smux_counter64;
				break;
		    case ASN_IPADDRESS:
				var_val_len = 4;
				/* 
				 * consume the tag and length, but just copy here
				 * because we know it is an ip address
				 */
				if ((var_val = asn_parse_header(var_val, &maxlen, &vartype)) == NULL)
					return NULL;
				memcpy((u_char *)&(smux_sa.sin_addr.s_addr), var_val,
				      var_val_len);
				var_val = (u_char *)&(smux_sa.sin_addr.s_addr);
				break;
		    case ASN_OPAQUE:
		    case ASN_OCTET_STR:
				/* XXX */
				if (len == 0)
					return NULL;
				var_val_len = SMUXMAXSTRLEN;
				asn_parse_string(var_val, &maxlen, &vartype,
						 smux_str, &var_val_len);
				var_val = smux_str;
				break;
		    case ASN_OBJECT_ID:
				var_val_len = MAX_OID_LEN;
				asn_parse_objid(var_val, &maxlen, &vartype, 
						smux_objid, &var_val_len);
                                var_val_len *= sizeof(oid);
				var_val = (u_char *)smux_objid;
				break;
		    case SNMP_NOSUCHOBJECT:
		    case SNMP_NOSUCHINSTANCE:
		    case SNMP_ENDOFMIBVIEW:
		    case ASN_NULL:
	    			var_val = NULL;
				break;
		    case ASN_BIT_STR:
			/* XXX */
				if (len == 0)
					return NULL;
				var_val_len = SMUXMAXSTRLEN;
				asn_parse_bitstring(var_val, &maxlen, &vartype,
						 smux_str, &var_val_len);
				var_val = (u_char *)smux_str;
				break;
		    case ASN_NSAP:
		    default:
				 snmp_log(LOG_ERR, "bad type returned (%x)\n", vartype);
				var_val = NULL;
				break;
		}

		snmptrap_tmp = (struct variable_list *)malloc(sizeof(struct variable_list));
		if (snmptrap_tmp == NULL)
		  return NULL;
		memset(snmptrap_tmp, 0, sizeof(struct variable_list));
		if (snmptrap_head == NULL) {
			snmptrap_head = snmptrap_tmp;
			snmptrap_ptr = snmptrap_head;
		}
		else {
			snmptrap_ptr->next_variable = snmptrap_tmp;
			snmptrap_ptr = snmptrap_ptr->next_variable;
		}

		snmp_set_var_objid(snmptrap_ptr, var_name, var_name_len);
		snmp_set_var_value(snmptrap_ptr, (char *)var_val, var_val_len);
		snmptrap_ptr->type = vartype;
		snmptrap_ptr->next_variable = NULL;

	}

	/* send the traps */
	send_enterprise_trap_vars(trap, specific, (oid *)&sa_enterpriseoid, sa_enterpriseoid_len, snmptrap_head);

	/* free trap variables */
	snmp_free_varbind(snmptrap_head);

	return ptr;

}