/*
*
* Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
// Copyright (c) 1995-96 by Cisco Systems, Inc.
package com.sun.jmx.snmp;
// java imports
//
import java.util.StringTokenizer;
import java.util.NoSuchElementException;
// sun imports
import sun.misc.JavaAWTAccess;
import sun.misc.SharedSecrets;
/**
* Represents an SNMP Object Identifier (OID).
*
* <p><b>This API is a Sun Microsystems internal API and is subject
* to change without notice.</b></p>
*/
public class SnmpOid extends SnmpValue {
// CONSTRUCTORS
//-------------
/**
* Constructs a new <CODE>SnmpOid</CODE> with no components.
*/
public SnmpOid() {
components = new long[15] ;
componentCount = 0 ;
}
/**
* Constructs a new <CODE>SnmpOid</CODE> from the specified component array.
* @param oidComponents The initialization component array.
*/
public SnmpOid(long[] oidComponents) {
components = oidComponents.clone() ;
componentCount = components.length ;
}
/**
* Constructs a new <CODE>SnmpOid</CODE> containing one component with the
* specified value.
* @param id The initialization component value.
*/
public SnmpOid(long id) {
components = new long[1] ;
components[0] = id ;
componentCount = components.length ;
}
/**
* Constructs a new <CODE>SnmpOid</CODE> containing four components
* with the specified values.
* @param id1 The first component value.
* @param id2 The second component values.
* @param id3 The third component values.
* @param id4 The fourth component values.
*/
public SnmpOid(long id1, long id2, long id3, long id4) {
components = new long[4] ;
components[0] = id1 ;
components[1] = id2 ;
components[2] = id3 ;
components[3] = id4 ;
componentCount = components.length ;
}
/**
* Constructs a new <CODE>SnmpOid</CODE> from a dot-formatted <CODE>String</CODE> or a MIB variable
* name. It generates an exception if the variable name cannot be resolved, or
* if the dot-formatted <CODE>String</CODE> has an invalid subidentifier.
* This constructor helps build an OID object with a <CODE>String</CODE> like .1.2.3.4 or 1.2.3.4
* or <CODE>ifInOctets</CODE> or <CODE>ifInOctets</CODE>.0.
* @param s <CODE>String</CODE> or MIB variable of the form .1.2.3 or 1.2.3 or <CODE>ifInOctets</CODE>.
* @exception IllegalArgumentException The subidentifier is neither a numeric <CODE>String</CODE>
* nor a <CODE>String</CODE> of the MIB database.
*/
public SnmpOid(String s) throws IllegalArgumentException {
String dotString = s ;
if (s.startsWith(".") == false) {
try {
dotString = resolveVarName(s);
} catch(SnmpStatusException e) {
throw new IllegalArgumentException(e.getMessage());
}
}
StringTokenizer st = new StringTokenizer(dotString, ".", false) ;
componentCount= st.countTokens();
// Now extract the ids
//
if (componentCount == 0) {
components = new long[15] ;
} else {
components = new long[componentCount] ;
try {
for (int i = 0 ; i < componentCount ; i++) {
try {
components[i] = Long.parseLong(st.nextToken()) ;
}
catch(NoSuchElementException e) {}
}
}
catch(NumberFormatException e) {
throw new IllegalArgumentException(s) ;
}
}
}
// PUBLIC METHODS
//---------------
/**
* Gets the number of components in this OID.
* @return The number of components.
*/
public int getLength() {
return componentCount ;
}
/**
* Returns a copy of the components array of this <CODE>SnmpOid</CODE>.
* @return The copy of the components array.
*/
public long[] longValue() {
long[] result = new long[componentCount] ;
System.arraycopy(components,0,result,0,componentCount);
return result ;
}
/**
* Returns the components array of this <CODE>SnmpOid</CODE>.
* If <code>duplicate</code> is true, a copy is returned.
* Otherwise, a reference to the internal array is returned,
* in which case the caller <b>shall not</b> modify this array.
* This method is provided to optimize processing in those cases
* where the caller needs only to read the components array.
*
* @param duplicate Indicates whether a copy or a reference must
* be returned:
* <li><code>true</code> if a copy must be returned,</li>
* <li><code>false</code> if a reference on the internal data
* can be returned.</li>
* @return A copy of (or a reference on) the components array.
*/
public final long[] longValue(boolean duplicate) {
if (duplicate) return longValue();
if (componentCount == components.length) return components ;
components = longValue();
componentCount = components.length;
return components ;
}
/**
* Returns the value of the OID arc found at the requested position
* in the <CODE>components</CODE> array. The first element is at
* position <code>0</code>.
*
* @param pos The position at which the OID arc should be peeked.
*
* @return The OID arc found at the requested position.
*
* @exception SnmpStatusException No OID arc was found at the requested
* position.
*/
public final long getOidArc(int pos) throws SnmpStatusException {
try {
return components[pos];
} catch(Exception e) {
throw new SnmpStatusException(SnmpStatusException.noAccess);
}
}
/**
* Converts the OID value to its <CODE>Long</CODE> form.
* @return The <CODE>Long</CODE> representation of the value.
*/
public Long toLong() {
if (componentCount != 1) {
throw new IllegalArgumentException() ;
}
return new Long(components[0]) ;
}
/**
* Converts the OID value to its <CODE>Integer</CODE> form.
* @return The <CODE>Integer</CODE> representation of the value.
*/
public Integer toInteger() {
if ((componentCount != 1) || (components[0] > Integer.MAX_VALUE)) {
throw new IllegalArgumentException() ;
}
return new Integer((int)components[0]) ;
}
/**
* Converts the OID value to its <CODE>String</CODE> form.
* @return The <CODE>String</CODE> representation of the value.
*/
public String toString() {
String result = "" ;
if (componentCount >= 1) {
for (int i = 0 ; i < componentCount - 1 ; i++) {
result = result + components[i] + "." ;
}
result = result + components[componentCount - 1] ;
}
return result ;
}
/**
* Converts the OID value to its <CODE>Boolean</CODE> form.
* @return The <CODE>Boolean</CODE> representation of the value.
*/
public Boolean toBoolean() {
if ((componentCount != 1) && (components[0] != 1) && (components[0] != 2)) {
throw new IllegalArgumentException() ;
}
return Boolean.valueOf(components[0] == 1) ;
}
/**
* Converts the OID value to its array of <CODE>Bytes</CODE> form.
* @return The array of <CODE>Bytes</CODE> representation of the value.
*/
public Byte[] toByte() {
Byte[] result = new Byte[componentCount] ;
for (int i =0 ; i < componentCount ; i++) {
if (components[0] > 255) {
throw new IllegalArgumentException() ;
}
result[i] = new Byte((byte)components[i]) ;
}
return result ;
}
/**
* Converts the OID value to its <CODE>SnmpOid</CODE> form.
* @return The OID representation of the value.
*/
public SnmpOid toOid() {
long[] ids = new long[componentCount] ;
for (int i = 0 ; i < componentCount ; i++) {
ids[i] = components[i] ;
}
return new SnmpOid(ids) ;
}
/**
* Extracts the OID from an index OID and returns its
* value converted as an <CODE>SnmpOid</CODE>.
* @param index The index array.
* @param start The position in the index array.
* @return The OID representing the OID value.
* @exception SnmpStatusException There is no OID value
* available at the start position.
*/
public static SnmpOid toOid(long[] index, int start) throws SnmpStatusException {
try {
if (index[start] > Integer.MAX_VALUE) {
throw new SnmpStatusException(SnmpStatusException.noSuchName) ;
}
int idCount = (int)index[start++] ;
long[] ids = new long[idCount] ;
for (int i = 0 ; i < idCount ; i++) {
ids[i] = index[start + i] ;
}
return new SnmpOid(ids) ;
}
catch(IndexOutOfBoundsException e) {
throw new SnmpStatusException(SnmpStatusException.noSuchName) ;
}
}
/**
* Scans an index OID, skips the OID value and returns the position
* of the next value.
* @param index The index array.
* @param start The position in the index array.
* @return The position of the next value.
* @exception SnmpStatusException There is no OID value
* available at the start position.
*/
public static int nextOid(long[] index, int start) throws SnmpStatusException {
try {
if (index[start] > Integer.MAX_VALUE) {
throw new SnmpStatusException(SnmpStatusException.noSuchName) ;
}
int idCount = (int)index[start++] ;
start += idCount ;
if (start <= index.length) {
return start ;
}
else {
throw new SnmpStatusException(SnmpStatusException.noSuchName) ;
}
}
catch(IndexOutOfBoundsException e) {
throw new SnmpStatusException(SnmpStatusException.noSuchName) ;
}
}
/**
* Appends an <CODE>SnmpOid</CODE> representing an <CODE>SnmpOid</CODE> to another OID.
* @param source An OID representing an <CODE>SnmpOid</CODE> value.
* @param dest Where source should be appended.
*/
public static void appendToOid(SnmpOid source, SnmpOid dest) {
dest.append(source.getLength()) ;
dest.append(source) ;
}
/**
* Performs a clone action. This provides a workaround for the
* <CODE>SnmpValue</CODE> interface.
* @return The SnmpValue clone.
*/
final synchronized public SnmpValue duplicate() {
return (SnmpValue)clone() ;
}
/**
* Clones the <CODE>SnmpOid</CODE> object, making a copy of its data.
* @return The object clone.
*/
public Object clone() {
try {
SnmpOid obj = (SnmpOid)super.clone() ;
obj.components = new long[this.componentCount] ;
System.arraycopy(this.components, 0, obj.components, 0,
this.componentCount) ;
return obj ;
} catch (CloneNotSupportedException e) {
throw new InternalError() ; // should never happen. VM bug.
}
}
/**
* Inserts a subid at the beginning of this <CODE>SnmpOid</CODE>.
* @param id The long subid to insert.
*/
public void insert(long id) {
enlargeIfNeeded(1) ;
for (int i = componentCount - 1 ; i >= 0 ; i--) {
components[i + 1] = components[i] ;
}
components[0] = id ;
componentCount++ ;
}
/**
* Inserts a subid at the beginning of this <CODE>SnmpOid</CODE>.
* @param id The integer subid to insert.
*/
public void insert(int id) {
insert((long)id) ;
}
/**
* Appends the specified <CODE>SnmpOid</CODE> to the end of this <CODE>SnmpOid</CODE>.
* @param oid The OID to append.
*/
public void append(SnmpOid oid) {
enlargeIfNeeded(oid.componentCount) ;
for (int i = 0 ; i < oid.componentCount ; i++) {
components[componentCount + i] = oid.components[i] ;
}
componentCount += oid.componentCount ;
}
/**
* Appends the specified long to the end of this <CODE>SnmpOid</CODE>.
* @param id The long to append.
*/
public void append(long id) {
enlargeIfNeeded(1) ;
components[componentCount] = id ;
componentCount++ ;
}
/**
* Adds the specified dot-formatted OID <CODE>String</CODE> to the end of this <CODE>SnmpOid</CODE>.
* The subidentifiers can be expressed as a dot-formatted <CODE>String</CODE> or a
* MIB variable name.
* @param s Variable name of the form .1.2.3 or 1.2.3 or
* <CODE>ifInOctets</CODE>.
* @exception SnmpStatusException An error occurred while accessing a MIB node.
*/
public void addToOid(String s) throws SnmpStatusException {
SnmpOid suffix= new SnmpOid(s);
this.append(suffix);
}
/**
* Adds the specified array of longs to the end of this <CODE>SnmpOid</CODE>.
* @param oid An array of longs.
* @exception SnmpStatusException An error occurred while accessing a MIB node.
*/
public void addToOid(long []oid) throws SnmpStatusException {
SnmpOid suffix= new SnmpOid(oid);
this.append(suffix);
}
/**
* Checks the validity of the OID.
* @return <CODE>true</CODE> if the OID is valid, <CODE>false</CODE> otherwise.
*/
public boolean isValid() {
return ((componentCount >= 2) &&
((0 <= components[0]) && (components[0] < 3)) &&
((0 <= components[1]) && (components[1] < 40))) ;
}
/**
* Checks whether the specified <CODE>Object</CODE> is equal to this <CODE>SnmpOid</CODE>.
* @param o The <CODE>Object</CODE> to be compared.
* @return <CODE>true</CODE> if <CODE>o</CODE> is an <CODE>SnmpOid</CODE> instance and equal to this, <CODE>false</CODE> otherwise.
*/
public boolean equals(Object o) {
boolean result = false ;
if (o instanceof SnmpOid) {
SnmpOid oid = (SnmpOid)o ;
if (oid.componentCount == componentCount) {
int i = 0 ;
long[] objoid = oid.components;
while ((i < componentCount) && (components[i] == objoid[i]))
i++ ;
result = (i == componentCount) ;
}
}
return result ;
}
/**
* The hashCode is computed from the OID components.
* @return a hashCode for this SnmpOid.
**/
public int hashCode() {
long acc=0;
for (int i=0;i<componentCount;i++) {
acc = acc*31+components[i];
}
return (int)acc;
}
/**
* Compares two OIDs lexicographically.
* @param other The OID to be compared.
* @return
* The value 0 if the parameter <CODE>other</CODE> is equal to this <CODE>SnmpOid</CODE>.
* A value smaller than 0 if this <CODE>SnmpOid</CODE> is lexicographically smaller than <CODE>other</CODE>.
* A value larger than 0 if this <CODE>SnmpOid</CODE> is lexicographically larger than <CODE>other</CODE>.
*/
public int compareTo(SnmpOid other) {
int result = 0 ;
int i = 0 ;
int cmplen = Math.min(componentCount, other.componentCount) ;
long[] otheroid = other.components;
for (i = 0; i < cmplen; i++) {
if (components[i] != otheroid[i]) {
break ;
}
}
if ((i == componentCount) && (i == other.componentCount)) {
result = 0 ;
}
else if (i == componentCount) {
result = -1 ;
}
else if (i == other.componentCount) {
result = 1 ;
}
else {
result = (components[i] < otheroid[i]) ? -1 : 1 ;
}
return result ;
}
/**
* Resolves a MIB variable <CODE>String</CODE> with the MIB database.
* @param s The variable name to resolve.
* @exception SnmpStatusException If the variable is not found in the MIB database.
*/
public String resolveVarName(String s) throws SnmpStatusException {
int index = s.indexOf('.') ;
// First handle the case where oid is expressed as 1.2.3.4
//
try {
return handleLong(s, index);
} catch(NumberFormatException e) {}
SnmpOidTable table = getSnmpOidTable();
// if we are here, it means we have something to resolve..
//
if (table == null)
throw new SnmpStatusException(SnmpStatusException.noSuchName);
// Ok assume there is a variable name to resolve ...
//
if (index <= 0) {
SnmpOidRecord rec = table.resolveVarName(s);
return rec.getOid();
} else {
SnmpOidRecord rec = table.resolveVarName(s.substring(0, index));
return (rec.getOid()+ s.substring(index));
}
}
/**
* Returns a textual description of the type object.
* @return ASN.1 textual description.
*/
public String getTypeName() {
return name ;
}
/**
* Returns the MIB table used for resolving MIB variable names.
* @return The MIB table.
*/
public static SnmpOidTable getSnmpOidTable() {
JavaAWTAccess awtAccess = SharedSecrets.getJavaAWTAccess();
if (awtAccess == null) {
return meta;
} else {
return (SnmpOidTable) awtAccess.get(SnmpOidTable.class);
}
}
/**
* Sets the MIB table to use for resolving MIB variable names.
* If no mib table is available, the class will not be able to resolve
* names contained in the Object Identifier.
* @param db The MIB table to use.
*/
public static void setSnmpOidTable(SnmpOidTable db) {
JavaAWTAccess awtAccess = SharedSecrets.getJavaAWTAccess();
if (awtAccess == null) {
meta = db;
} else {
if (db == null) {
awtAccess.remove(SnmpOidTable.class);
} else {
awtAccess.put(SnmpOidTable.class, db);
}
}
}
/**
* Converts an OID index converted string back to a DisplayString
*
**/
public String toOctetString() {
return new String(tobyte()) ;
}
// PRIVATE METHODS
//------------------
/**
* convert the components array into a byte array
**/
private byte[] tobyte() {
byte[] result = new byte[componentCount] ;
for (int i =0 ; i < componentCount ; i++) {
if (components[0] > 255) {
throw new IllegalArgumentException() ;
}
result[i] = (byte)components[i] ;
}
return result ;
}
/**
* Checks if there is enough space in the components
* array to insert n new subids. If not, it increases the size of
* the array.
* In fact it reallocates a new array and copy the old one into the new one.
* @param n The number of subids to insert.
*/
private void enlargeIfNeeded(int n) {
int neededSize = components.length ;
while (componentCount + n > neededSize) {
neededSize = neededSize * 2 ;
}
if (neededSize > components.length) {
long[] newComponents = new long[neededSize] ;
for (int i = 0 ; i < components.length ; i++) {
newComponents[i] = components[i] ;
}
components = newComponents ;
}
}
// PRIVATE METHODS
//----------------
private String handleLong(String oid, int index) throws NumberFormatException, SnmpStatusException {
String str;
if (index >0) {
str= oid.substring(0, index);
} else {
str= oid ;
}
// just parse the element.
//
Long.parseLong(str);
return oid;
}
// VARIABLES
//----------
/**
* The components' array.
* @serial
*/
protected long components[] = null ;
/**
* The length of the components' array.
* @serial
*/
protected int componentCount = 0 ;
/**
* The name of the type.
*/
final static String name = "Object Identifier";
/**
* Reference to a mib table. If no mib table is available,
* the class will not be able to resolve names contained in the Object Identifier.
*/
private static SnmpOidTable meta= null;
/**
* Ensure serialization compatibility with version 4.1 FCS
*
*/
static final long serialVersionUID = 8956237235607885096L;
}