This API is a Sun Microsystems internal API and is subject * to change without notice.
* @since 1.5 */ public abstract class SnmpMsg implements SnmpDefinitions { /** * The protocol version. *decodeMessage and encodeMessage do not
* perform any check on this value.
* decodeSnmpPdu and encodeSnmpPdu only
* accept the values 0 (for SNMPv1), 1 (for SNMPv2) and 3 (for SNMPv3).
*/
public int version = 0;
/**
* Encoding of the PDU.
*
This is usually the BER encoding of the PDU's syntax
* defined in RFC1157 and RFC1902. However, this can be authenticated
* or encrypted data (but you need to implemented your own
* SnmpPduFactory class).
*/
public byte[] data = null;
/**
* Number of useful bytes in the data field.
*/
public int dataLength = 0;
/**
* Source or destination address.
*
For an incoming message it's the source.
* For an outgoing message it's the destination.
*/
public InetAddress address = null;
/**
* Source or destination port.
*
For an incoming message it's the source.
* For an outgoing message it's the destination.
*/
public int port = 0;
/**
* Security parameters. Contain informations according to Security Model (Usm, community string based, ...).
*/
public SnmpSecurityParameters securityParameters = null;
/**
* Returns the encoded SNMP version present in the passed byte array.
* @param data The unmarshalled SNMP message.
* @return The SNMP version (0, 1 or 3).
*/
public static int getProtocolVersion(byte[] data)
throws SnmpStatusException {
int version = 0;
BerDecoder bdec = null;
try {
bdec = new BerDecoder(data);
bdec.openSequence();
version = bdec.fetchInteger();
}
catch(BerException x) {
throw new SnmpStatusException("Invalid encoding") ;
}
try {
bdec.closeSequence();
}
catch(BerException x) {
}
return version;
}
/**
* Returns the associated request ID.
* @param data The flat message.
* @return The request ID.
*/
public abstract int getRequestId(byte[] data) throws SnmpStatusException;
/**
* Encodes this message and puts the result in the specified byte array.
* For internal use only.
*
* @param outputBytes An array to receive the resulting encoding.
*
* @exception ArrayIndexOutOfBoundsException If the result does not fit
* into the specified array.
*/
public abstract int encodeMessage(byte[] outputBytes)
throws SnmpTooBigException;
/**
* Decodes the specified bytes and initializes this message.
* For internal use only.
*
* @param inputBytes The bytes to be decoded.
*
* @exception SnmpStatusException If the specified bytes are not a valid encoding.
*/
public abstract void decodeMessage(byte[] inputBytes, int byteCount)
throws SnmpStatusException;
/**
* Initializes this message with the specified pdu.
*
* This method initializes the data field with an array of
* maxDataLength bytes. It encodes the pdu.
* The resulting encoding is stored in the data field
* and the length of the encoding is stored in dataLength.
*
* If the encoding length exceeds maxDataLength,
* the method throws an exception.
*
* @param pdu The PDU to be encoded.
* @param maxDataLength The maximum length permitted for the data field.
*
* @exception SnmpStatusException If the specified pdu is not valid.
* @exception SnmpTooBigException If the resulting encoding does not fit
* into maxDataLength bytes.
* @exception ArrayIndexOutOfBoundsException If the encoding exceeds maxDataLength.
*/
public abstract void encodeSnmpPdu(SnmpPdu pdu, int maxDataLength)
throws SnmpStatusException, SnmpTooBigException;
/**
* Gets the PDU encoded in this message.
*
* This method decodes the data field and returns the resulting PDU.
*
* @return The resulting PDU.
* @exception SnmpStatusException If the encoding is not valid.
*/
public abstract SnmpPdu decodeSnmpPdu()
throws SnmpStatusException;
/**
* Dumps the content of a byte buffer using hexadecimal form.
*
* @param b The buffer to dump.
* @param offset The position of the first byte to be dumped.
* @param len The number of bytes to be dumped starting from offset.
*
* @return The string containing the dump.
*/
public static String dumpHexBuffer(byte [] b, int offset, int len) {
StringBuffer buf = new StringBuffer(len << 1) ;
int k = 1 ;
int flen = offset + len ;
for (int i = offset; i < flen ; i++) {
int j = b[i] & 0xFF ;
buf.append(Character.forDigit((j >>> 4) , 16)) ;
buf.append(Character.forDigit((j & 0x0F), 16)) ;
k++ ;
if (k%16 == 0) {
buf.append('\n') ;
k = 1 ;
} else
buf.append(' ') ;
}
return buf.toString() ;
}
/**
* Dumps this message in a string.
*
* @return The string containing the dump.
*/
public String printMessage() {
StringBuffer sb = new StringBuffer() ;
sb.append("Version: ") ;
sb.append(version) ;
sb.append("\n") ;
if (data == null) {
sb.append("Data: null") ;
}
else {
sb.append("Data: {\n") ;
sb.append(dumpHexBuffer(data, 0, dataLength)) ;
sb.append("\n}\n") ;
}
return sb.toString() ;
}
/**
* For SNMP Runtime private use only.
*/
public void encodeVarBindList(BerEncoder benc,
SnmpVarBind[] varBindList)
throws SnmpStatusException, SnmpTooBigException {
//
// Remember: the encoder does backward encoding
//
int encodedVarBindCount = 0 ;
try {
benc.openSequence() ;
if (varBindList != null) {
for (int i = varBindList.length - 1 ; i >= 0 ; i--) {
SnmpVarBind bind = varBindList[i] ;
if (bind != null) {
benc.openSequence() ;
encodeVarBindValue(benc, bind.value) ;
benc.putOid(bind.oid.longValue()) ;
benc.closeSequence() ;
encodedVarBindCount++ ;
}
}
}
benc.closeSequence() ;
}
catch(ArrayIndexOutOfBoundsException x) {
throw new SnmpTooBigException(encodedVarBindCount) ;
}
}
/**
* For SNMP Runtime private use only.
*/
void encodeVarBindValue(BerEncoder benc,
SnmpValue v)throws SnmpStatusException {
if (v == null) {
benc.putNull() ;
}
else if (v instanceof SnmpIpAddress) {
benc.putOctetString(((SnmpIpAddress)v).byteValue(), SnmpValue.IpAddressTag) ;
}
else if (v instanceof SnmpCounter) {
benc.putInteger(((SnmpCounter)v).longValue(), SnmpValue.CounterTag) ;
}
else if (v instanceof SnmpGauge) {
benc.putInteger(((SnmpGauge)v).longValue(), SnmpValue.GaugeTag) ;
}
else if (v instanceof SnmpTimeticks) {
benc.putInteger(((SnmpTimeticks)v).longValue(), SnmpValue.TimeticksTag) ;
}
else if (v instanceof SnmpOpaque) {
benc.putOctetString(((SnmpOpaque)v).byteValue(), SnmpValue.OpaqueTag) ;
}
else if (v instanceof SnmpInt) {
benc.putInteger(((SnmpInt)v).intValue()) ;
}
else if (v instanceof SnmpString) {
benc.putOctetString(((SnmpString)v).byteValue()) ;
}
else if (v instanceof SnmpOid) {
benc.putOid(((SnmpOid)v).longValue()) ;
}
else if (v instanceof SnmpCounter64) {
if (version == snmpVersionOne) {
throw new SnmpStatusException("Invalid value for SNMP v1 : " + v) ;
}
benc.putInteger(((SnmpCounter64)v).longValue(), SnmpValue.Counter64Tag) ;
}
else if (v instanceof SnmpNull) {
int tag = ((SnmpNull)v).getTag() ;
if ((version == snmpVersionOne) && (tag != SnmpValue.NullTag)) {
throw new SnmpStatusException("Invalid value for SNMP v1 : " + v) ;
}
if ((version == snmpVersionTwo) &&
(tag != SnmpValue.NullTag) &&
(tag != SnmpVarBind.errNoSuchObjectTag) &&
(tag != SnmpVarBind.errNoSuchInstanceTag) &&
(tag != SnmpVarBind.errEndOfMibViewTag)) {
throw new SnmpStatusException("Invalid value " + v) ;
}
benc.putNull(tag) ;
}
else {
throw new SnmpStatusException("Invalid value " + v) ;
}
}
/**
* For SNMP Runtime private use only.
*/
public SnmpVarBind[] decodeVarBindList(BerDecoder bdec)
throws BerException {
bdec.openSequence() ;
Vector