asnoctets.java

snmp zip 包开发snmp协议

        }
        return str;
    }


    int size() 
    { 
        return value.length; 
    }

    void write(OutputStream out, int pos) throws IOException 
    {
        int idx;

        // Output header
        AsnBuildHeader(out, type, value.length);
        if (debug > 10)
        {
            System.out.println("\tAsnOctets(): value = " + toString()
                + ", pos = " + pos);
        }
        
        // Output data
        for (idx=0; idx<value.length; idx++) 
        {
            out.write(value[idx]);
        }
    }

    /**
     * Returns this Octet as an IP Address string. The format is
     * aaa.bbb.ccc.ddd (IPv4) or a:b:c:d:e:f:g:h (IPv6).
     *
     * Note, the SNMP representation of IPv4 and IPv6 is different:
     * <ul>
     *    <li>IPv4: IPADDRESS (or ASN_OCTET_STR, see rfc 4001)</li>
     *    <li>IPv6: ASN_OCTET_STR</li>
     * </ul>
     * See also 
     * <a href="http://www.ietf.org/rfc/rfc2465.txt">IPV6-TC</a>,
     * <a href="http://www.ietf.org/rfc/rfc3416.txt">SNMPv2-PDU</a>,
     * <a href="http://www.ietf.org/rfc/rfc4001.txt">INET-ADDRESS-MIB</a>.
     *
     * @return The IP Address representation.
     * @see #toString
     * @see #getIpAddress
     * @see SnmpConstants#ASN_OCTET_STR
     * @see SnmpConstants#IPADDRESS
     */
    /*
     TODO: use Java's java.net.InetAddress, so it can be used for IPv4, and IPv6.
     */
    public String toIpAddress()
    {
        /* TODO: Does this work? Yes, but will not compile in jdk 1.2.X, and 
         * in order to load (a part of) the stack in Oracle, I need
         * 1.2.X
         */
        /*
        String str = "";
        try
        {
            InetAddress iad = InetAddress.getByAddress(value);
            str = iad.getHostAddress();
        }
        catch (java.net.UnknownHostException exc) { }
        */

        /*
        */
        StringBuffer sb = new StringBuffer(39);
        int length;
        long val;
        length = value.length;
        if (length > 0)
        {
            if (length > 4)
            {
                // IPv6
                // Nicked this code from Inet6Address.numericToTextFormat
                for (int i=0; i<length/2; i++) 
                {
                    sb.append(Integer.toHexString(((value[i<<1]<<8) & 0xff00)
                                                 | (value[(i<<1)+1] & 0xff)));
                    if (i < ((length/2)-1))
                    {
                        sb.append(":");
                    }
                }
            }
            else
            {
                // IPv4
                for (int i=0; i<length-1; i++)
                {
                    val = getPositiveValue(i);
                    sb.append(String.valueOf(val)).append(".");
                }
                val = getPositiveValue(length-1);
                sb.append(String.valueOf(val));
            }
        }
        return sb.toString();
    }

    /**
     * Returns this Octet as an IP Address. 
     *
     * Note, the SNMP representation of IPv4 and IPv6 is different:
     * <ul>
     *    <li>IPv4: IPADDRESS (or ASN_OCTET_STR, see rfc 4001)</li>
     *    <li>IPv6: ASN_OCTET_STR</li>
     * </ul>
     * See also 
     * <a href="http://www.ietf.org/rfc/rfc2465.txt">IPV6-TC</a>,
     * <a href="http://www.ietf.org/rfc/rfc3416.txt">SNMPv2-PDU</a>,
     * <a href="http://www.ietf.org/rfc/rfc4001.txt">INET-ADDRESS-MIB</a>.
     *
     * @return The IP Address representation.
     * @exception java.lang.RuntimeException Thrown when the Octets does
     * not represent an InetAddress or when the method internally throws
     * an java.net.UnknownHostException
     *
     * @see #toString
     * @see #toIpAddress
     * @see SnmpConstants#ASN_OCTET_STR
     * @see SnmpConstants#IPADDRESS
     * @since 4_14
     */
    public InetAddress getIpAddress()
    throws java.lang.RuntimeException
    {
        InetAddress iad = null;
        try
        {
            iad = InetAddress.getByAddress(value);
        }
        catch (java.net.UnknownHostException exc) 
        { 
            throw new java.lang.RuntimeException(exc);
        }
        return iad;
    }

    /**
     * Returns the positive long for an octet. Only if type is IPADDRESS
     * can the value be negative anyway.
     */
    private long getPositiveValue(int index)
    {
        long val = (long) value[index];
        if (val <0)
        {
            val += 256; 
        }
        return val;
    }
    
    /**
     * Returns this Octet as an hexadecimal String, without any prefix. 
     *
     * @return The hex representation.
     * @see #toString
     */
    public String toHex()
    {
        int length; 
        StringBuffer buffer = new StringBuffer("");

        length = value.length;
        if (length > 0)
        {
            for (int i=0; i<length-1; i++)
            {
                buffer.append(SnmpUtilities.toHex(value[i])).append(":");
            }
            buffer.append(SnmpUtilities.toHex(value[length-1]));
        }

        return buffer.toString();
    }


    /**
     * Returns this Octet as a display string (text convension). In contrast to the
     * method toString(), this method does not try to guess whether or
     * not this string is printable, it just converts it to a
     * String, using "US-ASCII" character set. 
     *
     * <p>
     * DisplayString
     * represents textual information taken from the NVT
     * ASCII character set, as defined in pages 4, 10-11
     * of <a href="http://www.ietf.org/rfc/rfc854.txt">RFC 854</a>. 
     * Any object defined using this syntax
     * may not exceed 255 characters in length.
     * Basicly it is US-ASCII with some changes.
     * </p>
     *
     * @return The string representation.
     * @see #toString
     */
    public String toDisplayString()
    {
        String str = "";
        int length; 

        length = value.length;
        if (length > 0)
        {
            try
            {
                str = new String(value, "US-ASCII");
            }
            catch (java.io.UnsupportedEncodingException exc)
            {
                str = new String(value);
            }
            str = str.trim();
        }

        return str;
    }

    /**
     * Returns this Octet as an international display string (text
     * convension). 
     * It calls AsnOctetsPrintableFace.toInternationalDisplayString().
     *
     * See
     * <a href="http://www.ietf.org/rfc/rfc2790.txt">HOST-RESOURCES-MIB</a>
     * 
     * @see AsnOctetsPrintableFace#toInternationalDisplayString
     * @since 4_14
     */
    public String toInternationalDisplayString()
    {
        return toInternationalDisplayString(printableObject);
    }


    /**
     * As toInternationalDisplayString(), but this methods will use this 
     * specific, one-off AsnOctetsPrintableFace object.
     * 
     * @see #toInternationalDisplayString
     * @since 4_14
     */
    public String toInternationalDisplayString(AsnOctetsPrintableFace face)
    {
        return face.toInternationalDisplayString(value);
    }


    /**
     * Returns the String representation according to the DateAndTime
     * convension.
     * This string it returns is not exactly the same as the
     * DISPLAY-HINT indicates.
     * See 
     * <a href="http://www.ietf.org/rfc/rfc2579.txt">SNMPv2-TC</a>
     *
     * @since 4_14
     * @exception java.lang.RuntimeException Thrown when the number of
     * Octets does not represent the DateAndTime length. 
     * @see #CALFORMAT
     */
    public String toCalendar()
    throws java.lang.RuntimeException
    {
        Calendar cal = this.getCalendar();
        Date date = cal.getTime();
        return CALFORMAT.format(date);
    }

    /**
     * Returns the Octets as Calendar according to the DateAndTime text
     * convension. You can only call this method if
     * the syntax of this Octet is the DateAndTime text convension.
     *
     * @exception java.lang.RuntimeException Thrown when the number of
     * Octets does not represent the DateAndTime length. 
     *
     * @since 4_14
     * @see #AsnOctets(java.util.Calendar)
     */
    public java.util.Calendar getCalendar()
    throws java.lang.RuntimeException
    {
        Calendar cal = Calendar.getInstance();
        if (value.length == 8 || value.length == 11)
        {
            int year = (int) ((getPositiveValue(0) * 256) + getPositiveValue(1));
            // Calendar: 0=January
            int month = value[2]-1; 
            int day = value[3];
            int hour = value[4];
            int min = value[5];
            int sec = value[6];
            int msec = value[7] * 100;
            cal.set(year, month, day, hour, min, sec); 
            cal.set(Calendar.MILLISECOND, msec);

            if (value.length == 11)
            {
                char dir = (char) value[8];
                int hourUTC = value[9];
                int minUTC = value[10];
                int secUTC = (hourUTC * 60) * 60;

                int msecGMT = secUTC * 1000;
                if (dir == '-')
                {
                    msecGMT = msecGMT * -1;
                }

                cal.set(Calendar.ZONE_OFFSET, msecGMT);
            }
        }
        else
        {
            throw new java.lang.RuntimeException("AsnOctets is not DateAndTime");
        }
        return cal;
    }


/**
 * Converts this Octet to its corresponding sub-identifiers.
 * Each octet will be encoded in a separate sub-identifier, by
 * converting the octet into a positive long.
 * 
 * <p>
 * Use this method when building an OID when this Octet specifies a
 * conceptual row. For example ipNetToMediaEntry, see 
 * <a href="http://www.ietf.org/rfc/rfc2011.txt">IP-MIB</a>
 * or SnmpCommunityEntry, see
 * <a href="http://www.ietf.org/rfc/rfc3584.txt">SNMP-COMMUNITY-MIB</a>
 * </p>
 *
 * <p>
 * The variable <code>length_implied</code> indicates that this MIB variable 
 * is preceded by the IMPLIED keyword:
 * </p>
 * <ul>
 * <li>
 * The IMPLIED keyword can only be present for an Octet having 
 * a variable-length syntax (e.g., variable-length strings or object 
 * identifier-valued objects). 
 * </li>
 * <li>
 * The IMPLIED keyword can only be associated with the last
 * object in the INDEX clause.  
 * </li>
 * <li>
 * The IMPLIED keyword may not be used on a variable-length
 * string Octet if that string might have a value of zero-length. 
 * </li>
 * </ul>
 *
 * <p>
 * If the length is implied, no extra sub-identifier will be created to
 * indicate its length. <br/>
 * If the length is not implied, the first
 * sub-identifier will be the length of the Octet.
 * </p>
 *
 * <p>
 * If this Octet is of type IPADDRESS, length_implied should be false.
 * </p>
 *
 * <p>
 * The mapping of the INDEX clause is
 * explained in <a href="http://www.ietf.org/rfc/rfc2578.txt">SNMPv2-SMI</a>,
 * section 7.7.
 * </p>
 *
 * @param length_implied Indicates if the length of this octet is
 * implied. 
 *
 * @see AsnObjectId#add(long[])
 */
public long [] toSubOid(boolean length_implied)
{
    long sub_oid[];
    int index = 0;
    int length = value.length;

    if (length_implied)
    {
        sub_oid = new long[length];
    }
    else
    {
        sub_oid = new long[length+1];
        sub_oid[0] = length;
        index++;
    }

    for (int i=0; i<length; i++)
    {
        sub_oid[index] = getPositiveValue(i);
        index++;
    }
    return sub_oid;
}


/**
 * Compares this Octet to the specified object.
 * The result is <code>true</code> if and only if the argument is not
 * <code>null</code> and is an <code>AsnOctets</code> object that represents
 * the same sequence of octets as this Octet.
 *
 * @param anObject the object to compare this <code>AsnOctets</code> 
 *                 against.
 * @return <code>true</code> if the <code>AsnOctets </code>are equal;
 *         <code>false</code> otherwise.
 */
public boolean equals(Object anObject) 
{
    if (this == anObject) 
    {
        return true;
    }
    if (anObject instanceof AsnOctets) 
    {
        AsnOctets anotherOctet = (AsnOctets)anObject;
        int n = value.length;
        if (n == anotherOctet.value.length) 
        {
            byte v1[] = value;
            byte v2[] = anotherOctet.value;
            int i = 0;
            int j = 0;
            while (n-- != 0) 
            {
                if (v1[i++] != v2[j++])
                {
                    return false;
                }
            }
            return true;
        }
    }
    return false;
}


/**
 * Returns a hash code for this Octet. The hash code for a
 * <code>AsnOctets</code> object is computed as
 * <blockquote><pre>
 * s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
 * </pre></blockquote>
 * using <code>int</code> arithmetic, where <code>s[i]</code> is the
 * <i>i</i>th character of the Octet, <code>n</code> is the length of
 * the Octet, and <code>^</code> indicates exponentiation.
 * (The hash value of the empty Octet is zero.)
 *
 * @return  a hash code value for this Octet.
 */
public int hashCode() 
{
    int h = hash;
    if (h == 0) 
    {
        int off = 0;
        byte val[] = value;
        int len = value.length;

        for (int i=0; i<len; i++) 
        {
            h = 31*h + val[off++];
        }
        hash = h;
    }
    return h;
}


}