JDK8/Java8源码在线阅读
/*
* Copyright (c) 1998, 2013, 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.daemon;
// java import
//
import java.util.Vector;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.logging.Level;
import java.io.InterruptedIOException;
import java.net.DatagramSocket;
import java.net.DatagramPacket;
import java.net.SocketException;
// jmx imports
//
import javax.management.MBeanServer;
import javax.management.ObjectName;
import com.sun.jmx.snmp.SnmpMessage;
import com.sun.jmx.snmp.SnmpPduFactory;
import com.sun.jmx.snmp.SnmpPduBulk;
import com.sun.jmx.snmp.SnmpPduPacket;
import com.sun.jmx.snmp.SnmpPduRequest;
import com.sun.jmx.snmp.SnmpPduTrap;
import com.sun.jmx.snmp.SnmpValue;
import com.sun.jmx.snmp.SnmpVarBind;
import com.sun.jmx.snmp.SnmpVarBindList;
import com.sun.jmx.snmp.SnmpDefinitions;
import com.sun.jmx.snmp.SnmpStatusException;
import com.sun.jmx.snmp.SnmpTooBigException;
import com.sun.jmx.snmp.SnmpDataTypeEnums;
// RI imports
//
import static com.sun.jmx.defaults.JmxProperties.SNMP_ADAPTOR_LOGGER;
// SNMP runtime import
//
import com.sun.jmx.snmp.agent.SnmpMibAgent;
import com.sun.jmx.snmp.agent.SnmpUserDataFactory;
//import com.sun.jmx.snmp.IPAcl.IPAcl;
import com.sun.jmx.snmp.InetAddressAcl;
class SnmpRequestHandler extends ClientHandler implements SnmpDefinitions {
private transient DatagramSocket socket = null ;
private transient DatagramPacket packet = null ;
private transient Vector<SnmpMibAgent> mibs = null ;
/**
* Contains the list of sub-requests associated to the current request.
*/
private transient Hashtable<SnmpMibAgent, SnmpSubRequestHandler> subs = null;
/**
* Reference on the MIBS
*/
private transient SnmpMibTree root;
private transient InetAddressAcl ipacl = null ;
private transient SnmpPduFactory pduFactory = null ;
private transient SnmpUserDataFactory userDataFactory = null ;
private transient SnmpAdaptorServer adaptor = null;
/**
* Full constructor
*/
public SnmpRequestHandler(SnmpAdaptorServer server, int id,
DatagramSocket s, DatagramPacket p,
SnmpMibTree tree, Vector<SnmpMibAgent> m,
InetAddressAcl a,
SnmpPduFactory factory,
SnmpUserDataFactory dataFactory,
MBeanServer f, ObjectName n)
{
super(server, id, f, n);
// Need a reference on SnmpAdaptorServer for getNext & getBulk,
// in case of oid equality (mib overlapping).
//
adaptor = server;
socket = s;
packet = p;
root= tree;
mibs = new Vector<>(m);
subs= new Hashtable<>(mibs.size());
ipacl = a;
pduFactory = factory ;
userDataFactory = dataFactory ;
//thread.start();
}
/**
* Treat the request available in 'packet' and send the result
* back to the client.
* Note: we overwrite 'packet' with the response bytes.
*/
@Override
public void doRun() {
// Trace the input packet
//
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"doRun","Packet received:\n" +
SnmpMessage.dumpHexBuffer(packet.getData(), 0, packet.getLength()));
}
// Let's build the response packet
//
DatagramPacket respPacket = makeResponsePacket(packet) ;
// Trace the output packet
//
if ((SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) && (respPacket != null)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"doRun","Packet to be sent:\n" +
SnmpMessage.dumpHexBuffer(respPacket.getData(), 0, respPacket.getLength()));
}
// Send the response packet if any
//
if (respPacket != null) {
try {
socket.send(respPacket) ;
} catch (SocketException e) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
if (e.getMessage().equals(InterruptSysCallMsg)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"doRun", "interrupted");
} else {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"doRun", "I/O exception", e);
}
}
} catch(InterruptedIOException e) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"doRun", "interrupted");
}
} catch(Exception e) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"doRun", "failure when sending response", e);
}
}
}
}
/**
* Here we make a response packet from a request packet.
* We return null if there no response packet to sent.
*/
private DatagramPacket makeResponsePacket(DatagramPacket reqPacket) {
DatagramPacket respPacket = null ;
// Transform the request packet into a request SnmpMessage
//
SnmpMessage reqMsg = new SnmpMessage() ;
try {
reqMsg.decodeMessage(reqPacket.getData(), reqPacket.getLength()) ;
reqMsg.address = reqPacket.getAddress() ;
reqMsg.port = reqPacket.getPort() ;
}
catch(SnmpStatusException x) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"makeResponsePacket", "packet decoding failed", x);
}
reqMsg = null ;
((SnmpAdaptorServer)adaptorServer).incSnmpInASNParseErrs(1) ;
}
// Make the response SnmpMessage if any
//
SnmpMessage respMsg = null ;
if (reqMsg != null) {
respMsg = makeResponseMessage(reqMsg) ;
}
// Try to transform the response SnmpMessage into response packet.
// NOTE: we overwrite the request packet.
//
if (respMsg != null) {
try {
reqPacket.setLength(respMsg.encodeMessage(reqPacket.getData())) ;
respPacket = reqPacket ;
}
catch(SnmpTooBigException x) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"makeResponsePacket", "response message is too big");
}
try {
respMsg = newTooBigMessage(reqMsg) ;
reqPacket.setLength(respMsg.encodeMessage(reqPacket.getData())) ;
respPacket = reqPacket ;
}
catch(SnmpTooBigException xx) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"makeResponsePacket", "'too big' is 'too big' !!!");
}
adaptor.incSnmpSilentDrops(1);
}
}
}
return respPacket ;
}
/**
* Here we make a response message from a request message.
* We return null if there is no message to reply.
*/
private SnmpMessage makeResponseMessage(SnmpMessage reqMsg) {
SnmpMessage respMsg = null ;
// Transform the request message into a request pdu
//
SnmpPduPacket reqPdu;
Object userData = null;
try {
reqPdu = (SnmpPduPacket)pduFactory.decodeSnmpPdu(reqMsg) ;
if (reqPdu != null && userDataFactory != null)
userData = userDataFactory.allocateUserData(reqPdu);
}
catch(SnmpStatusException x) {
reqPdu = null ;
SnmpAdaptorServer snmpServer = (SnmpAdaptorServer)adaptorServer ;
snmpServer.incSnmpInASNParseErrs(1) ;
if (x.getStatus()== SnmpDefinitions.snmpWrongSnmpVersion)
snmpServer.incSnmpInBadVersions(1) ;
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"makeResponseMessage", "message decoding failed", x);
}
}
// Make the response pdu if any
//
SnmpPduPacket respPdu = null ;
if (reqPdu != null) {
respPdu = makeResponsePdu(reqPdu,userData) ;
try {
if (userDataFactory != null)
userDataFactory.releaseUserData(userData,respPdu);
} catch (SnmpStatusException x) {
respPdu = null;
}
}
// Try to transform the response pdu into a response message if any
//
if (respPdu != null) {
try {
respMsg = (SnmpMessage)pduFactory.
encodeSnmpPdu(respPdu, packet.getData().length) ;
}
catch(SnmpStatusException x) {
respMsg = null ;
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"makeResponseMessage", "failure when encoding the response message", x);
}
}
catch(SnmpTooBigException x) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"makeResponseMessage", "response message is too big");
}
try {
// if the PDU is too small, why should we try to do
// recovery ?
//
if (packet.getData().length <=32)
throw x;
int pos= x.getVarBindCount();
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"makeResponseMessage", "fail on element" + pos);
}
int old;
while (true) {
try {
respPdu = reduceResponsePdu(reqPdu, respPdu, pos) ;
respMsg = (SnmpMessage)pduFactory.
encodeSnmpPdu(respPdu,
packet.getData().length -32) ;
break;
} catch (SnmpTooBigException xx) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"makeResponseMessage", "response message is still too big");
}
old= pos;
pos= xx.getVarBindCount();
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"makeResponseMessage","fail on element" + pos);
}
if (pos == old) {
// we can not go any further in trying to
// reduce the message !
//
throw xx;
}
}
}// end of loop
} catch(SnmpStatusException xx) {
respMsg = null ;
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"makeResponseMessage", "failure when encoding the response message", xx);
}
}
catch(SnmpTooBigException xx) {
try {
respPdu = newTooBigPdu(reqPdu) ;
respMsg = (SnmpMessage)pduFactory.
encodeSnmpPdu(respPdu, packet.getData().length) ;
}
catch(SnmpTooBigException xxx) {
respMsg = null ;
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"makeResponseMessage", "'too big' is 'too big' !!!");
}
adaptor.incSnmpSilentDrops(1);
}
catch(Exception xxx) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"makeResponseMessage", "Got unexpected exception", xxx);
}
respMsg = null ;
}
}
catch(Exception xx) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"makeResponseMessage", "Got unexpected exception", xx);
}
respMsg = null ;
}
}
}
return respMsg ;
}
/**
* Here we make a response pdu from a request pdu.
* We return null if there is no pdu to reply.
*/
private SnmpPduPacket makeResponsePdu(SnmpPduPacket reqPdu,
Object userData) {
SnmpAdaptorServer snmpServer = (SnmpAdaptorServer)adaptorServer ;
SnmpPduPacket respPdu = null ;
snmpServer.updateRequestCounters(reqPdu.type) ;
if (reqPdu.varBindList != null)
snmpServer.updateVarCounters(reqPdu.type,
reqPdu.varBindList.length) ;
if (checkPduType(reqPdu)) {
respPdu = checkAcl(reqPdu) ;
if (respPdu == null) { // reqPdu is accepted by ACLs
if (mibs.size() < 1) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"makeResponsePdu", "Request " + reqPdu.requestId +
" received but no MIB registered.");
}
return makeNoMibErrorPdu((SnmpPduRequest)reqPdu, userData);
}
switch(reqPdu.type) {
case SnmpPduPacket.pduGetRequestPdu:
case SnmpPduPacket.pduGetNextRequestPdu:
case SnmpPduPacket.pduSetRequestPdu:
respPdu = makeGetSetResponsePdu((SnmpPduRequest)reqPdu,
userData) ;
break ;
case SnmpPduPacket.pduGetBulkRequestPdu:
respPdu = makeGetBulkResponsePdu((SnmpPduBulk)reqPdu,
userData) ;
break ;
}
}
else { // reqPdu is rejected by ACLs
// respPdu contains the error response to be sent.
// We send this response only if authResEnabled is true.
if (!snmpServer.getAuthRespEnabled()) { // No response should be sent
respPdu = null ;
}
if (snmpServer.getAuthTrapEnabled()) { // A trap must be sent
try {
snmpServer.snmpV1Trap(SnmpPduTrap.
trapAuthenticationFailure, 0,
new SnmpVarBindList()) ;
}
catch(Exception x) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"makeResponsePdu", "Failure when sending authentication trap", x);
}
}
}
}
}
return respPdu ;
}
//
// Generates a response packet, filling the values in the
// varbindlist with one of endOfMibView, noSuchObject, noSuchInstance
// according to the value of <code>status</code>
//
// @param statusTag should be one of:
// <li>SnmpDataTypeEnums.errEndOfMibViewTag</li>
// <li>SnmpDataTypeEnums.errNoSuchObjectTag</li>
// <li>SnmpDataTypeEnums.errNoSuchInstanceTag</li>
//
SnmpPduPacket makeErrorVarbindPdu(SnmpPduPacket req, int statusTag) {
final SnmpVarBind[] vblist = req.varBindList;
final int length = vblist.length;
switch (statusTag) {
case SnmpDataTypeEnums.errEndOfMibViewTag:
for (int i=0 ; i<length ; i++)
vblist[i].value = SnmpVarBind.endOfMibView;
break;
case SnmpDataTypeEnums.errNoSuchObjectTag:
for (int i=0 ; i<length ; i++)
vblist[i].value = SnmpVarBind.noSuchObject;
break;
case SnmpDataTypeEnums.errNoSuchInstanceTag:
for (int i=0 ; i<length ; i++)
vblist[i].value = SnmpVarBind.noSuchInstance;
break;
default:
return newErrorResponsePdu(req,snmpRspGenErr,1);
}
return newValidResponsePdu(req,vblist);
}
// Generates an appropriate response when no mib is registered in
// the adaptor.
//
// <li>If the version is V1:</li>
// <ul><li>Generates a NoSuchName error V1 response PDU</li></ul>
// <li>If the version is V2:</li>
// <ul><li>If the request is a GET, fills the varbind list with
// NoSuchObject's</li>
// <li>If the request is a GET-NEXT/GET-BULK, fills the varbind
// list with EndOfMibView's</li>
// <li>If the request is a SET, generates a NoAccess error V2
// response PDU</li>
// </ul>
//
//
SnmpPduPacket makeNoMibErrorPdu(SnmpPduRequest req, Object userData) {
// There is no agent registered
//
if (req.version == SnmpDefinitions.snmpVersionOne) {
// Version 1: => NoSuchName
return
newErrorResponsePdu(req,snmpRspNoSuchName,1);
} else if (req.version == SnmpDefinitions.snmpVersionTwo) {
// Version 2: => depends on PDU type
switch (req.type) {
case pduSetRequestPdu :
case pduWalkRequest :
// SET request => NoAccess
return
newErrorResponsePdu(req,snmpRspNoAccess,1);
case pduGetRequestPdu :
// GET request => NoSuchObject
return
makeErrorVarbindPdu(req,SnmpDataTypeEnums.
errNoSuchObjectTag);
case pduGetNextRequestPdu :
case pduGetBulkRequestPdu :
// GET-NEXT or GET-BULK => EndOfMibView
return
makeErrorVarbindPdu(req,SnmpDataTypeEnums.
errEndOfMibViewTag);
default:
}
}
// Something wrong here: => snmpRspGenErr
return newErrorResponsePdu(req,snmpRspGenErr,1);
}
/**
* Here we make the response pdu from a get/set request pdu.
* At this level, the result is never null.
*/
private SnmpPduPacket makeGetSetResponsePdu(SnmpPduRequest req,
Object userData) {
// Create the trhead group specific for handling sub-requests
// associated to the current request. Use the invoke id
//
// Nice idea to use a thread group on a request basis.
// However the impact on performance is terrible !
// theGroup= new ThreadGroup(thread.getThreadGroup(),
// "request " + String.valueOf(req.requestId));
// Let's build the varBindList for the response pdu
//
if (req.varBindList == null) {
// Good ! Let's make a full response pdu.
//
return newValidResponsePdu(req, null) ;
}
// First we need to split the request into subrequests
//
splitRequest(req);
int nbSubRequest= subs.size();
if (nbSubRequest == 1)
return turboProcessingGetSet(req,userData);
// Execute all the subrequests resulting from the split of the
// varbind list.
//
SnmpPduPacket result= executeSubRequest(req,userData);
if (result != null)
// It means that an error occurred. The error is already
// formatted by the executeSubRequest
// method.
return result;
// So far so good. So we need to concatenate all the answers.
//
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"makeGetSetResponsePdu",
"Build the unified response for request " + req.requestId);
}
return mergeResponses(req);
}
/**
* The method runs all the sub-requests associated to the current
* instance of SnmpRequestHandler.
*/
private SnmpPduPacket executeSubRequest(SnmpPduPacket req,
Object userData) {
int errorStatus = SnmpDefinitions.snmpRspNoError ;
int i;
// If it's a set request, we must first check any varBind
//
if (req.type == pduSetRequestPdu) {
i=0;
for(Enumeration<SnmpSubRequestHandler> e= subs.elements(); e.hasMoreElements() ; i++) {
// Indicate to the sub request that a check must be invoked ...
// OK we should have defined out own tag for that !
//
SnmpSubRequestHandler sub= e.nextElement();
sub.setUserData(userData);
sub.type= pduWalkRequest;
sub.run();
sub.type= pduSetRequestPdu;
if (sub.getErrorStatus() != SnmpDefinitions.snmpRspNoError) {
// No point to go any further.
//
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"executeSubRequest", "an error occurs");
}
return newErrorResponsePdu(req, errorStatus,
sub.getErrorIndex() + 1) ;
}
}
}// end processing check operation for a set PDU.
// Let's start the sub-requests.
//
i=0;
for(Enumeration<SnmpSubRequestHandler> e= subs.elements(); e.hasMoreElements() ;i++) {
SnmpSubRequestHandler sub= e.nextElement();
/* NPCTE fix for bugId 4492741, esc 0, 16-August 2001 */
sub.setUserData(userData);
/* end of NPCTE fix for bugId 4492741 */
sub.run();
if (sub.getErrorStatus() != SnmpDefinitions.snmpRspNoError) {
// No point to go any further.
//
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"executeSubRequest", "an error occurs");
}
return newErrorResponsePdu(req, errorStatus,
sub.getErrorIndex() + 1) ;
}
}
// everything is ok
//
return null;
}
/**
* Optimize when there is only one sub request
*/
private SnmpPduPacket turboProcessingGetSet(SnmpPduRequest req,
Object userData) {
int errorStatus;
SnmpSubRequestHandler sub = subs.elements().nextElement();
sub.setUserData(userData);
// Indicate to the sub request that a check must be invoked ...
// OK we should have defined out own tag for that !
//
if (req.type == SnmpDefinitions.pduSetRequestPdu) {
sub.type= pduWalkRequest;
sub.run();
sub.type= pduSetRequestPdu;
// Check the error status.
//
errorStatus= sub.getErrorStatus();
if (errorStatus != SnmpDefinitions.snmpRspNoError) {
// No point to go any further.
//
return newErrorResponsePdu(req, errorStatus,
sub.getErrorIndex() + 1) ;
}
}
// process the operation
//
sub.run();
errorStatus= sub.getErrorStatus();
if (errorStatus != SnmpDefinitions.snmpRspNoError) {
// No point to go any further.
//
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"turboProcessingGetSet", "an error occurs");
}
int realIndex= sub.getErrorIndex() + 1;
return newErrorResponsePdu(req, errorStatus, realIndex) ;
}
// So far so good. So we need to concatenate all the answers.
//
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"turboProcessingGetSet", "build the unified response for request "
+ req.requestId);
}
return mergeResponses(req);
}
/**
* Here we make the response pdu for a bulk request.
* At this level, the result is never null.
*/
private SnmpPduPacket makeGetBulkResponsePdu(SnmpPduBulk req,
Object userData) {
SnmpVarBind[] respVarBindList;
// RFC 1905, Section 4.2.3, p14
int L = req.varBindList.length ;
int N = Math.max(Math.min(req.nonRepeaters, L), 0) ;
int M = Math.max(req.maxRepetitions, 0) ;
int R = L - N ;
if (req.varBindList == null) {
// Good ! Let's make a full response pdu.
//
return newValidResponsePdu(req, null) ;
}
// Split the request into subrequests.
//
splitBulkRequest(req, N, M, R);
SnmpPduPacket result= executeSubRequest(req,userData);
if (result != null)
return result;
respVarBindList= mergeBulkResponses(N + (M * R));
// Now we remove useless trailing endOfMibView.
//
int m2 ; // respVarBindList[m2] item and next are going to be removed
int t = respVarBindList.length ;
while ((t > N) && (respVarBindList[t-1].
value.equals(SnmpVarBind.endOfMibView))) {
t-- ;
}
if (t == N)
m2 = N + R ;
else
m2 = N + ((t -1 -N) / R + 2) * R ; // Trivial, of course...
if (m2 < respVarBindList.length) {
SnmpVarBind[] truncatedList = new SnmpVarBind[m2] ;
for (int i = 0 ; i < m2 ; i++) {
truncatedList[i] = respVarBindList[i] ;
}
respVarBindList = truncatedList ;
}
// Good ! Let's make a full response pdu.
//
return newValidResponsePdu(req, respVarBindList) ;
}
/**
* Check the type of the pdu: only the get/set/bulk request
* are accepted.
*/
private boolean checkPduType(SnmpPduPacket pdu) {
boolean result;
switch(pdu.type) {
case SnmpDefinitions.pduGetRequestPdu:
case SnmpDefinitions.pduGetNextRequestPdu:
case SnmpDefinitions.pduSetRequestPdu:
case SnmpDefinitions.pduGetBulkRequestPdu:
result = true ;
break;
default:
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"checkPduType", "cannot respond to this kind of PDU");
}
result = false ;
break;
}
return result ;
}
/**
* Check if the specified pdu is conform to the ACL.
* This method returns null if the pdu is ok. If not, it returns
* the response pdu to be replied.
*/
private SnmpPduPacket checkAcl(SnmpPduPacket pdu) {
SnmpPduPacket response = null ;
String community = new String(pdu.community) ;
// We check the pdu type and create an error response if
// the check failed.
//
if (ipacl != null) {
if (pdu.type == SnmpDefinitions.pduSetRequestPdu) {
if (!ipacl.checkWritePermission(pdu.address, community)) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"checkAcl", "sender is " + pdu.address +
" with " + community +". Sender has no write permission");
}
int err = SnmpSubRequestHandler.
mapErrorStatus(SnmpDefinitions.
snmpRspAuthorizationError,
pdu.version, pdu.type);
response = newErrorResponsePdu(pdu, err, 0) ;
}
else {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"checkAcl", "sender is " + pdu.address +
" with " + community +". Sender has write permission");
}
}
}
else {
if (!ipacl.checkReadPermission(pdu.address, community)) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"checkAcl", "sender is " + pdu.address +
" with " + community +". Sender has no read permission");
}
int err = SnmpSubRequestHandler.
mapErrorStatus(SnmpDefinitions.
snmpRspAuthorizationError,
pdu.version, pdu.type);
response = newErrorResponsePdu(pdu,
err,
0);
SnmpAdaptorServer snmpServer =
(SnmpAdaptorServer)adaptorServer;
snmpServer.updateErrorCounters(SnmpDefinitions.
snmpRspNoSuchName);
}
else {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"checkAcl", "sender is " + pdu.address +
" with " + community +". Sender has read permission");
}
}
}
}
// If the response is not null, this means the pdu is rejected.
// So let's update the statistics.
//
if (response != null) {
SnmpAdaptorServer snmpServer = (SnmpAdaptorServer)adaptorServer ;
snmpServer.incSnmpInBadCommunityUses(1) ;
if (ipacl.checkCommunity(community) == false)
snmpServer.incSnmpInBadCommunityNames(1) ;
}
return response ;
}
/**
* Make a response pdu with the specified error status and index.
* NOTE: the response pdu share its varBindList with the request pdu.
*/
private SnmpPduRequest newValidResponsePdu(SnmpPduPacket reqPdu,
SnmpVarBind[] varBindList) {
SnmpPduRequest result = new SnmpPduRequest() ;
result.address = reqPdu.address ;
result.port = reqPdu.port ;
result.version = reqPdu.version ;
result.community = reqPdu.community ;
result.type = SnmpPduRequest.pduGetResponsePdu ;
result.requestId = reqPdu.requestId ;
result.errorStatus = SnmpDefinitions.snmpRspNoError ;
result.errorIndex = 0 ;
result.varBindList = varBindList ;
((SnmpAdaptorServer)adaptorServer).
updateErrorCounters(result.errorStatus) ;
return result ;
}
/**
* Make a response pdu with the specified error status and index.
* NOTE: the response pdu share its varBindList with the request pdu.
*/
private SnmpPduRequest newErrorResponsePdu(SnmpPduPacket req,int s,int i) {
SnmpPduRequest result = newValidResponsePdu(req, null) ;
result.errorStatus = s ;
result.errorIndex = i ;
result.varBindList = req.varBindList ;
((SnmpAdaptorServer)adaptorServer).
updateErrorCounters(result.errorStatus) ;
return result ;
}
private SnmpMessage newTooBigMessage(SnmpMessage reqMsg)
throws SnmpTooBigException {
SnmpMessage result = null ;
SnmpPduPacket reqPdu;
try {
reqPdu = (SnmpPduPacket)pduFactory.decodeSnmpPdu(reqMsg) ;
if (reqPdu != null) {
SnmpPduPacket respPdu = newTooBigPdu(reqPdu) ;
result = (SnmpMessage)pduFactory.
encodeSnmpPdu(respPdu, packet.getData().length) ;
}
}
catch(SnmpStatusException x) {
// This should not occur because decodeIncomingRequest has normally
// been successfully called before.
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"newTooBigMessage", "Internal error", x);
}
throw new InternalError(x) ;
}
return result ;
}
private SnmpPduPacket newTooBigPdu(SnmpPduPacket req) {
SnmpPduRequest result =
newErrorResponsePdu(req, SnmpDefinitions.snmpRspTooBig, 0) ;
result.varBindList = null ;
return result ;
}
private SnmpPduPacket reduceResponsePdu(SnmpPduPacket req,
SnmpPduPacket resp,
int acceptedVbCount)
throws SnmpTooBigException {
// Reduction can be attempted only on bulk response
//
if (req.type != SnmpPduPacket.pduGetBulkRequestPdu) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"reduceResponsePdu", "cannot remove anything");
}
throw new SnmpTooBigException(acceptedVbCount) ;
}
// We're going to reduce the varbind list.
// First determine which items should be removed.
// Next duplicate and replace the existing list by the reduced one.
//
// acceptedVbCount is the number of varbind which have been
// successfully encoded before reaching bufferSize:
// * when it is >= 2, we split the varbindlist at this
// position (-1 to be safe),
// * when it is 1, we only put one (big?) item in the varbindlist
// * when it is 0 (in fact, acceptedVbCount is not available),
// we split the varbindlist by 2.
//
int vbCount;
if (acceptedVbCount >= 3)
vbCount = Math.min(acceptedVbCount - 1, resp.varBindList.length) ;
else if (acceptedVbCount == 1)
vbCount = 1 ;
else // acceptedCount == 0 ie it is unknown
vbCount = resp.varBindList.length / 2 ;
if (vbCount < 1) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"reduceResponsePdu", "cannot remove anything");
}
throw new SnmpTooBigException(acceptedVbCount) ;
}
else {
SnmpVarBind[] newVbList = new SnmpVarBind[vbCount] ;
for (int i = 0 ; i < vbCount ; i++) {
newVbList[i] = resp.varBindList[i] ;
}
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"reduceResponsePdu", (resp.varBindList.length - newVbList.length) +
" items have been removed");
}
resp.varBindList = newVbList ;
}
return resp ;
}
/**
* The method takes the incoming requests and split it into subrequests.
*/
private void splitRequest(SnmpPduRequest req) {
int nbAgents= mibs.size();
SnmpMibAgent agent = mibs.firstElement();
if (nbAgents == 1) {
// Take all the oids contained in the request and
//
subs.put(agent, new SnmpSubRequestHandler(agent, req, true));
return;
}
// For the get next operation we are going to send the varbind list
// to all agents
//
if (req.type == pduGetNextRequestPdu) {
for(Enumeration<SnmpMibAgent> e= mibs.elements(); e.hasMoreElements(); ) {
final SnmpMibAgent ag= e.nextElement();
subs.put(ag, new SnmpSubNextRequestHandler(adaptor, ag, req));
}
return;
}
int nbReqs= req.varBindList.length;
SnmpVarBind[] vars= req.varBindList;
SnmpSubRequestHandler sub;
/**代码未完, 请加载全部代码(NowJava.com).**/
关注时代Java
关注时代Java