linkerlau/my-jdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(jdk8): move files to new folder to avoid resources compiled.

Browse Source
This commit is contained in:
linkerlau
2025-09-07 15:25:52 +08:00
parent 3f0047bf6f
commit 8c35cfb1c0
17415 changed files with 217 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

566
jdkSrc/jdk8/com/sun/jmx/snmp/agent/SnmpMibOid.java Normal file
View File

@@ -0,0 +1,566 @@
/*
* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.jmx.snmp.agent;
// java imports
//
import java.io.Serializable;
import java.util.Vector;
import java.util.Enumeration;
// jmx imports
//
import com.sun.jmx.snmp.SnmpOid;
import com.sun.jmx.snmp.SnmpVarBind;
import com.sun.jmx.snmp.SnmpStatusException;
/**
* Represents a node in an SNMP MIB which is neither a group nor a variable.
* This class defines a list of sub-nodes and the methods that allow to
* manipulate the sub-nodes.
* <P>
* This class is used internally and by the class generated by
* <CODE>mibgen</CODE>.
* You should not need to use this class directly.
*
* <p><b>This API is a Sun Microsystems internal API and is subject
* to change without notice.</b></p>
*/
public class SnmpMibOid extends SnmpMibNode implements Serializable {
private static final long serialVersionUID = 5012254771107446812L;
/**
* Default constructor.
*/
public SnmpMibOid() {
}
// PUBLIC METHODS
//---------------
/**
* Generic handling of the <CODE>get</CODE> operation.
*
* <p> This method should be overridden in subclasses.
* <p>
*
* @param req The sub-request that must be handled by this node.
*
* @param depth The depth reached in the OID tree.
*
* @exception SnmpStatusException The default implementation (if not
* overridden) is to generate a SnmpStatusException.
*/
@Override
public void get(SnmpMibSubRequest req, int depth)
throws SnmpStatusException {
for (Enumeration<SnmpVarBind> e= req.getElements(); e.hasMoreElements();) {
SnmpVarBind var= e.nextElement();
SnmpStatusException x =
new SnmpStatusException(SnmpStatusException.noSuchObject);
req.registerGetException(var,x);
}
}
/**
* Generic handling of the <CODE>set</CODE> operation.
*
* <p> This method should be overridden in subclasses.
* <p>
*
* @param req The sub-request that must be handled by this node.
*
* @param depth The depth reached in the OID tree.
*
* @exception SnmpStatusException The default implementation (if not
* overridden) is to generate a SnmpStatusException.
*/
@Override
public void set(SnmpMibSubRequest req, int depth)
throws SnmpStatusException {
for (Enumeration<SnmpVarBind> e= req.getElements(); e.hasMoreElements();) {
SnmpVarBind var= e.nextElement();
SnmpStatusException x =
new SnmpStatusException(SnmpStatusException.noAccess);
req.registerSetException(var,x);
}
}
/**
* Generic handling of the <CODE>check</CODE> operation.
*
* <p> This method should be overridden in subclasses.
* <p>
*
* @param req The sub-request that must be handled by this node.
*
* @param depth The depth reached in the OID tree.
*
* @exception SnmpStatusException The default implementation (if not
* overridden) is to generate a SnmpStatusException.
*/
@Override
public void check(SnmpMibSubRequest req, int depth)
throws SnmpStatusException {
for (Enumeration<SnmpVarBind> e= req.getElements(); e.hasMoreElements();) {
SnmpVarBind var= e.nextElement();
SnmpStatusException x =
new SnmpStatusException(SnmpStatusException.noAccess);
req.registerCheckException(var,x);
}
}
// ---------------------------------------------------------------------
//
// Implements the method defined in SnmpMibNode.
//
// ---------------------------------------------------------------------
//
@Override
void findHandlingNode(SnmpVarBind varbind,
long[] oid, int depth,
SnmpRequestTree handlers)
throws SnmpStatusException {
final int length = oid.length;
SnmpMibNode node = null;
if (handlers == null)
throw new SnmpStatusException(SnmpStatusException.snmpRspGenErr);
if (depth > length) {
// Nothing is left... the oid is not valid
throw new SnmpStatusException(SnmpStatusException.noSuchObject);
} else if (depth == length) {
// The oid is not complete...
throw new SnmpStatusException(SnmpStatusException.noSuchInstance);
} else {
// Some children variable or subobject is being querried
// getChild() will raise an exception if no child is found.
//
final SnmpMibNode child= getChild(oid[depth]);
// XXXX zzzz : what about null children?
// (variables for nested groups)
// if child==null, then we're dealing with a variable or
// a table: we register this node.
// This behaviour should be overriden in subclasses,
// in particular in group meta classes: the group
// meta classes that hold tables should take care
// of forwarding this call to all the tables involved.
//
if (child == null)
handlers.add(this,depth,varbind);
else
child.findHandlingNode(varbind,oid,depth+1,handlers);
}
}
// ---------------------------------------------------------------------
//
// Implements the method defined in SnmpMibNode.
//
// ---------------------------------------------------------------------
//
@Override
long[] findNextHandlingNode(SnmpVarBind varbind,
long[] oid, int pos, int depth,
SnmpRequestTree handlers,
AcmChecker checker)
throws SnmpStatusException {
final int length = oid.length;
SnmpMibNode node = null;
long[] result = null;
if (handlers == null) {
// This should be considered as a genErr, but we do not want to
// abort the whole request, so we're going to throw
// a noSuchObject...
//
throw new SnmpStatusException(SnmpStatusException.noSuchObject);
}
final Object data = handlers.getUserData();
final int pduVersion = handlers.getRequestPduVersion();
if (pos >= length) {
long[] newOid= new long[1];
newOid[0]= getNextVarId(-1,data,pduVersion);
result = findNextHandlingNode(varbind,newOid,0,depth,handlers,
checker);
return result;
}
// search the element specified in the oid
//
long[] newOid= new long[1];
long index= oid[pos];
while (true) {
try {
final SnmpMibNode child = getChild(index);
// SnmpOid result = null;
if (child == null) {
// shouldn't happen
throw new SnmpStatusException(SnmpStatusException.noSuchObject);
// validateVarId(index);
// handlers.add(this,varbind,depth);
// result = new SnmpOid(0);
} else {
checker.add(depth, index);
try {
result = child.findNextHandlingNode(varbind,oid,pos+1,
depth+1,handlers,
checker);
} finally {
checker.remove(depth);
}
}
// Build up the leaf OID
result[depth] = index;
return result;
} catch(SnmpStatusException e) {
// If there is no such element go one level up ...
//
index= getNextVarId(index,data,pduVersion);
// There is no need to carry the original oid ...
newOid[0]=index;
pos= 1;
oid=newOid;
}
}
}
/**
* Computes the root OID of the MIB.
*/
@Override
public void getRootOid(Vector<Integer> result) {
// If a node has several children, let assume that we are one step to
// far in order to get the MIB root.
//
if (nbChildren != 1)
return;
result.addElement(varList[0]);
// Now query our child.
//
children.firstElement().getRootOid(result);
}
/**
* Registers a specific node in the tree.
*/
public void registerNode(String oidString ,SnmpMibNode node)
throws IllegalAccessException {
SnmpOid oid= new SnmpOid(oidString);
registerNode(oid.longValue(), 0, node);
}
// PROTECTED METHODS
//------------------
/**
* Registers a specific node in the tree.
*/
void registerNode(long[] oid, int cursor ,SnmpMibNode node)
throws IllegalAccessException {
if (cursor >= oid.length)
throw new IllegalAccessException();
// Check if the node is already defined
//
long var= oid[cursor];
//System.out.println("entering registration for val="
// + String.valueOf(var) + " position= " + cursor);
int pos = retrieveIndex(var);
if (pos == nbChildren) {
nbChildren++;
varList= new int[nbChildren];
varList[0]= (int) var;
pos =0;
if ( (cursor + 1) == oid.length) {
// That 's the end of the trip.
// Do not forward the registration
//System.out.println("End of trip for val="
// + String.valueOf(var) + " position= " + cursor);
children.insertElementAt(node,pos);
return;
}
//System.out.println("Create node for val="
// + String.valueOf(var) + " position= " + cursor);
SnmpMibOid child= new SnmpMibOid();
children.insertElementAt(child, pos);
child.registerNode(oid, cursor + 1, node);
return;
}
if (pos == -1) {
// The node is not yet registered
//
int[] tmp= new int[nbChildren + 1];
tmp[nbChildren]= (int) var;
System.arraycopy(varList, 0, tmp, 0, nbChildren);
varList= tmp;
nbChildren++;
SnmpMibNode.sort(varList);
int newPos = retrieveIndex(var);
varList[newPos]= (int) var;
if ( (cursor + 1) == oid.length) {
// That 's the end of the trip.
// Do not forward the registration
//System.out.println("End of trip for val="
// + String.valueOf(var) + " position= " + cursor);
children.insertElementAt(node, newPos);
return;
}
SnmpMibOid child= new SnmpMibOid();
// System.out.println("Create node for val=" +
// String.valueOf(var) + " position= " + cursor);
children.insertElementAt(child, newPos);
child.registerNode(oid, cursor + 1, node);
}
else {
// The node is already registered
//
SnmpMibNode child= children.elementAt(pos);
if ( (cursor + 1) == oid.length ) {
//System.out.println("Node already registered val=" +
// String.valueOf(var) + " position= " + cursor);
if (child == node) return;
if (child != null && node != null) {
// Now we're going to patch the tree the following way:
// if a subgroup has been registered before its father,
// we're going to replace the father OID node with
// the actual group-node and export the children from
// the temporary OID node to the actual group node.
//
if (node instanceof SnmpMibGroup) {
// `node' is a group => replace `child' with `node'
// export the child's subtree to `node'.
//
((SnmpMibOid)child).exportChildren((SnmpMibOid)node);
children.setElementAt(node,pos);
return;
} else if ((node instanceof SnmpMibOid) &&
(child instanceof SnmpMibGroup)) {
// `node' is a temporary node, and `child' is a
// group => keep child and export the node's
// subtree to `child'.
//
((SnmpMibOid)node).exportChildren((SnmpMibOid)child);
return;
} else if (node instanceof SnmpMibOid) {
// `node' and `child' are both temporary OID nodes
// => replace `child' with `node' and export child's
// subtree to `node'.
//
((SnmpMibOid)child).exportChildren((SnmpMibOid)node);
children.setElementAt(node,pos);
return;
}
}
children.setElementAt(node,pos);
} else {
if (child == null)
throw new IllegalAccessException();
((SnmpMibOid)child).registerNode(oid, cursor + 1, node);
}
}
}
/**
* Export this node's children to a brother node that will replace
* this node in the OID tree.
* This method is a patch that fixes the problem of registering
* a subnode before its father node.
*
**/
void exportChildren(SnmpMibOid brother)
throws IllegalAccessException {
if (brother == null) return;
final long[] oid = new long[1];
for (int i=0; i<nbChildren; i++) {
final SnmpMibNode child = children.elementAt(i);
if (child == null) continue;
oid[0] = varList[i];
brother.registerNode(oid,0,child);
}
}
// PRIVATE METHODS
//----------------
SnmpMibNode getChild(long id) throws SnmpStatusException {
// first we need to retrieve the identifier in the list of children
//
final int pos= getInsertAt(id);
if (pos >= nbChildren) {
throw new SnmpStatusException(SnmpStatusException.noSuchObject);
}
if (varList[pos] != (int) id) {
throw new SnmpStatusException(SnmpStatusException.noSuchObject);
}
// Access the node
//
SnmpMibNode child = null;
try {
child = children.elementAtNonSync(pos);
} catch(ArrayIndexOutOfBoundsException e) {
throw new SnmpStatusException(SnmpStatusException.noSuchObject);
}
if (child == null) {
throw new SnmpStatusException(SnmpStatusException.noSuchInstance);
}
return child;
}
private int retrieveIndex(long val) {
int low= 0;
int cursor= (int) val;
if (varList == null || varList.length < 1)
return nbChildren;
int max= varList.length -1 ;
int curr= low + (max-low)/2;
int elmt;
while (low <= max) {
elmt= varList[curr];
if (cursor == elmt) {
// We need to get the next index ...
//
return curr;
}
if (elmt < cursor) {
low= curr +1;
} else {
max= curr -1;
}
curr= low + (max-low)/2;
}
return -1;
}
private int getInsertAt(long val) {
int low= 0;
final int index= (int) val;
if (varList == null)
return -1;
int max= varList.length -1 ;
int elmt;
//final int[] v = varList;
//if (index > a[max])
//return max +1;
int curr= low + (max-low)/2;
while (low <= max) {
elmt= varList[curr];
// never know ...we might find something ...
//
if (index == elmt)
return curr;
if (elmt < index) {
low= curr +1;
} else {
max= curr -1;
}
curr= low + (max-low)/2;
}
return curr;
}
// PRIVATE VARIABLES
//------------------
/**
* Contains the list of sub nodes.
*/
private NonSyncVector<SnmpMibNode> children = new NonSyncVector<>(1);
/**
* The number of sub nodes.
*/
private int nbChildren= 0;
// All the methods of the Vector class are synchronized.
// Synchronization is a very expensive operation. In our case it is
// not always required...
//
@SuppressWarnings("serial") // We will never serialize this
class NonSyncVector<E> extends Vector<E> {
public NonSyncVector(int size) {
super(size);
}
final void addNonSyncElement(E obj) {
ensureCapacity(elementCount + 1);
elementData[elementCount++] = obj;
}
@SuppressWarnings("unchecked") // cast to E
final E elementAtNonSync(int index) {
return (E) elementData[index];
}
}
}