1 /*

     2  * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 

    27 package com.sun.jmx.snmp.daemon;

    28 

    29 

    30 // java imports

    31 //

    32 import java.util.Vector;

    33 import java.util.Enumeration;

    34 import java.util.logging.Level;

    35 import java.net.DatagramSocket;

    36 import java.net.DatagramPacket;

    37 import java.net.InetAddress;

    38 import java.net.SocketException;

    39 import java.net.UnknownHostException;

    40 import java.io.ObjectInputStream;

    41 import java.io.IOException;

    42 import java.io.InterruptedIOException;

    43 

    44 

    45 // jmx imports

    46 //

    47 import javax.management.MBeanServer;

    48 import javax.management.MBeanRegistration;

    49 import javax.management.ObjectName;

    50 import static com.sun.jmx.defaults.JmxProperties.SNMP_ADAPTOR_LOGGER;

    51 import com.sun.jmx.snmp.SnmpIpAddress;

    52 import com.sun.jmx.snmp.SnmpMessage;

    53 import com.sun.jmx.snmp.SnmpOid;

    54 import com.sun.jmx.snmp.SnmpPduFactory;

    55 import com.sun.jmx.snmp.SnmpPduPacket;

    56 import com.sun.jmx.snmp.SnmpPduRequest;

    57 import com.sun.jmx.snmp.SnmpPduTrap;

    58 import com.sun.jmx.snmp.SnmpTimeticks;

    59 import com.sun.jmx.snmp.SnmpVarBind;

    60 import com.sun.jmx.snmp.SnmpVarBindList;

    61 import com.sun.jmx.snmp.SnmpDefinitions;

    62 import com.sun.jmx.snmp.SnmpStatusException;

    63 import com.sun.jmx.snmp.SnmpTooBigException;

    64 import com.sun.jmx.snmp.InetAddressAcl;

    65 import com.sun.jmx.snmp.SnmpPeer;

    66 import com.sun.jmx.snmp.SnmpParameters;

    67 // SNMP Runtime imports

    68 //

    69 import com.sun.jmx.snmp.SnmpPduFactoryBER;

    70 import com.sun.jmx.snmp.agent.SnmpMibAgent;

    71 import com.sun.jmx.snmp.agent.SnmpMibHandler;

    72 import com.sun.jmx.snmp.agent.SnmpUserDataFactory;

    73 import com.sun.jmx.snmp.agent.SnmpErrorHandlerAgent;

    74 

    75 import com.sun.jmx.snmp.IPAcl.SnmpAcl;

    76 

    77 import com.sun.jmx.snmp.tasks.ThreadService;

    78 

    79 /**

    80  * Implements an adaptor on top of the SNMP protocol.

    81  * <P>

    82  * When this SNMP protocol adaptor is started it creates a datagram socket

    83  * and is able to receive requests and send traps or inform requests.

    84  * When it is stopped, the socket is closed and neither requests

    85  * and nor traps/inform request are processed.

    86  * <P>

    87  * The default port number of the socket is 161. This default value can be

    88  * changed by specifying a port number:

    89  * <UL>

    90  * <LI>in the object constructor</LI>

    91  * <LI>using the {@link com.sun.jmx.snmp.daemon.CommunicatorServer#setPort

    92  *     setPort} method before starting the adaptor</LI>

    93  * </UL>

    94  * The default object name is defined by {@link

    95  * com.sun.jmx.snmp.ServiceName#DOMAIN com.sun.jmx.snmp.ServiceName.DOMAIN}

    96  * and {@link com.sun.jmx.snmp.ServiceName#SNMP_ADAPTOR_SERVER

    97  * com.sun.jmx.snmp.ServiceName.SNMP_ADAPTOR_SERVER}.

    98  * <P>

    99  * The SNMP protocol adaptor supports versions 1 and 2 of the SNMP protocol

   100  * in a stateless way: when it receives a v1 request, it replies with a v1

   101  * response, when it receives a v2 request it replies with a v2 response.

   102  * <BR>The method {@link #snmpV1Trap snmpV1Trap} sends traps using SNMP v1

   103  * format.

   104  * The method {@link #snmpV2Trap snmpV2Trap} sends traps using SNMP v2 format.

   105  * The method {@link #snmpInformRequest snmpInformRequest} sends inform

   106  * requests using SNMP v2 format.

   107  * <P>

   108  * To receive data packets, the SNMP protocol adaptor uses a buffer

   109  * which size can be configured using the property <CODE>bufferSize</CODE>

   110  * (default value is 1024).

   111  * Packets which do not fit into the buffer are rejected.

   112  * Increasing <CODE>bufferSize</CODE> allows the exchange of bigger packets.

   113  * However, the underlying networking system may impose a limit on the size

   114  * of UDP packets.

   115  * Packets which size exceed this limit will be rejected, no matter what

   116  * the value of <CODE>bufferSize</CODE> actually is.

   117  * <P>

   118  * An SNMP protocol adaptor may serve several managers concurrently. The

   119  * number of concurrent managers can be limited using the property

   120  * <CODE>maxActiveClientCount</CODE>.

   121  * <p>

   122  * The SNMP protocol adaptor specifies a default value (10) for the

   123  * <CODE>maxActiveClientCount</CODE> property. When the adaptor is stopped,

   124  * the active requests are interrupted and an error result is sent to

   125  * the managers.

   126  * <p><b>This API is a Sun Microsystems internal API  and is subject

   127  * to change without notice.</b></p>

   128  */

   129 

   130 public class SnmpAdaptorServer extends CommunicatorServer

   131     implements SnmpAdaptorServerMBean, MBeanRegistration, SnmpDefinitions,

   132                SnmpMibHandler {

   133 

   134     // PRIVATE VARIABLES

   135     //------------------

   136 

   137     /**

   138      * Port number for sending SNMP traps.

   139      * <BR>The default value is 162.

   140      */

   141     private int                 trapPort = 162;

   142 

   143     /**

   144      * Port number for sending SNMP inform requests.

   145      * <BR>The default value is 162.

   146      */

   147     private int                 informPort = 162;

   148 

   149     /**

   150      * The <CODE>InetAddress</CODE> used when creating the datagram socket.

   151      * <BR>It is specified when creating the SNMP protocol adaptor.

   152      * If not specified, the local host machine is used.

   153      */

   154     InetAddress address = null;

   155 

   156     /**

   157      * The IP address based ACL used by this SNMP protocol adaptor.

   158      */

   159     private InetAddressAcl ipacl = null;

   160 

   161     /**

   162      * The factory object.

   163      */

   164     private SnmpPduFactory pduFactory = null;

   165 

   166     /**

   167      * The user-data factory object.

   168      */

   169     private SnmpUserDataFactory userDataFactory = null;

   170 

   171     /**

   172      * Indicates if the SNMP protocol adaptor sends a response in case

   173      * of authentication failure

   174      */

   175     private boolean authRespEnabled = true;

   176 

   177     /**

   178      * Indicates if authentication traps are enabled.

   179      */

   180     private boolean authTrapEnabled = true;

   181 

   182     /**

   183      * The enterprise OID.

   184      * <BR>The default value is "1.3.6.1.4.1.42".

   185      */

   186     private SnmpOid enterpriseOid = new SnmpOid("1.3.6.1.4.1.42");

   187 

   188     /**

   189      * The buffer size of the SNMP protocol adaptor.

   190      * This buffer size is used for both incoming request and outgoing

   191      * inform requests.

   192      * <BR>The default value is 1024.

   193      */

   194     int bufferSize = 1024;

   195 

   196     private transient long            startUpTime     = 0;

   197     private transient DatagramSocket  socket          = null;

   198     transient DatagramSocket          trapSocket      = null;

   199     private transient SnmpSession     informSession   = null;

   200     private transient DatagramPacket  packet          = null;

   201     transient Vector<SnmpMibAgent>    mibs            = new Vector<>();

   202     private transient SnmpMibTree     root;

   203 

   204     /**

   205      * Whether ACL must be used.

   206      */

   207     private transient boolean         useAcl = true;

   208 

   209 

   210     // SENDING SNMP INFORMS STUFF

   211     //---------------------------

   212 

   213     /**

   214      * Number of times to try an inform request before giving up.

   215      * The default number is 3.

   216      */

   217     private int maxTries = 3 ;

   218 

   219     /**

   220      * The amount of time to wait for an inform response from the manager.

   221      * The default amount of time is 3000 millisec.

   222      */

   223     private int timeout = 3 * 1000 ;

   224 

   225     // VARIABLES REQUIRED FOR IMPLEMENTING SNMP GROUP (MIBII)

   226     //-------------------------------------------------------

   227 

   228     /**

   229      * The <CODE>snmpOutTraps</CODE> value defined in MIB-II.

   230      */

   231     int snmpOutTraps=0;

   232 

   233     /**

   234      * The <CODE>snmpOutGetResponses</CODE> value defined in MIB-II.

   235      */

   236     private int snmpOutGetResponses=0;

   237 

   238     /**

   239      * The <CODE>snmpOutGenErrs</CODE> value defined in MIB-II.

   240      */

   241     private int snmpOutGenErrs=0;

   242 

   243     /**

   244      * The <CODE>snmpOutBadValues</CODE> value defined in MIB-II.

   245      */

   246     private int snmpOutBadValues=0;

   247 

   248     /**

   249      * The <CODE>snmpOutNoSuchNames</CODE> value defined in MIB-II.

   250      */

   251     private int snmpOutNoSuchNames=0;

   252 

   253     /**

   254      * The <CODE>snmpOutTooBigs</CODE> value defined in MIB-II.

   255      */

   256     private int snmpOutTooBigs=0;

   257 

   258     /**

   259      * The <CODE>snmpOutPkts</CODE> value defined in MIB-II.

   260      */

   261     int snmpOutPkts=0;

   262 

   263     /**

   264      * The <CODE>snmpInASNParseErrs</CODE> value defined in MIB-II.

   265      */

   266     private int snmpInASNParseErrs=0;

   267 

   268     /**

   269      * The <CODE>snmpInBadCommunityUses</CODE> value defined in MIB-II.

   270      */

   271     private int snmpInBadCommunityUses=0;

   272 

   273     /**

   274      * The <CODE>snmpInBadCommunityNames</CODE> value defined in MIB-II.

   275      */

   276     private int snmpInBadCommunityNames=0;

   277 

   278     /**

   279      * The <CODE>snmpInBadVersions</CODE> value defined in MIB-II.

   280      */

   281     private int snmpInBadVersions=0;

   282 

   283     /**

   284      * The <CODE>snmpInGetRequests</CODE> value defined in MIB-II.

   285      */

   286     private int snmpInGetRequests=0;

   287 

   288     /**

   289      * The <CODE>snmpInGetNexts</CODE> value defined in MIB-II.

   290      */

   291     private int snmpInGetNexts=0;

   292 

   293     /**

   294      * The <CODE>snmpInSetRequests</CODE> value defined in MIB-II.

   295      */

   296     private int snmpInSetRequests=0;

   297 

   298     /**

   299      * The <CODE>snmpInPkts</CODE> value defined in MIB-II.

   300      */

   301     private int snmpInPkts=0;

   302 

   303     /**

   304      * The <CODE>snmpInTotalReqVars</CODE> value defined in MIB-II.

   305      */

   306     private int snmpInTotalReqVars=0;

   307 

   308     /**

   309      * The <CODE>snmpInTotalSetVars</CODE> value defined in MIB-II.

   310      */

   311     private int snmpInTotalSetVars=0;

   312 

   313     /**

   314      * The <CODE>snmpInTotalSetVars</CODE> value defined in rfc 1907 MIB-II.

   315      */

   316     private int snmpSilentDrops=0;

   317 

   318     private static final String InterruptSysCallMsg =

   319         "Interrupted system call";

   320     static final SnmpOid sysUpTimeOid = new SnmpOid("1.3.6.1.2.1.1.3.0") ;

   321     static final SnmpOid snmpTrapOidOid = new SnmpOid("1.3.6.1.6.3.1.1.4.1.0");

   322 

   323     private ThreadService threadService;

   324 

   325     private static int threadNumber = 6;

   326 

   327     static {

   328         String s = System.getProperty("com.sun.jmx.snmp.threadnumber");

   329 

   330         if (s != null) {

   331             try {

   332                 threadNumber = Integer.parseInt(System.getProperty(s));

   333             } catch (Exception e) {

   334                 SNMP_ADAPTOR_LOGGER.logp(Level.FINER,

   335                         SnmpAdaptorServer.class.getName(),

   336                         "<static init>",

   337                         "Got wrong value for com.sun.jmx.snmp.threadnumber: " +

   338                         s + ". Use the default value: " + threadNumber);

   339             }

   340         }

   341     }

   342 

   343     // PUBLIC CONSTRUCTORS

   344     //--------------------

   345 

   346     /**

   347      * Initializes this SNMP protocol adaptor using the default port (161).

   348      * Use the {@link com.sun.jmx.snmp.IPAcl.SnmpAcl} default

   349      * implementation of the <CODE>InetAddressAcl</CODE> interface.

   350      */

   351     public SnmpAdaptorServer() {

   352         this(true, null, com.sun.jmx.snmp.ServiceName.SNMP_ADAPTOR_PORT,

   353              null) ;

   354     }

   355 

   356     /**

   357      * Initializes this SNMP protocol adaptor using the specified port.

   358      * Use the {@link com.sun.jmx.snmp.IPAcl.SnmpAcl} default

   359      * implementation of the <CODE>InetAddressAcl</CODE> interface.

   360      *

   361      * @param port The port number for sending SNMP responses.

   362      */

   363     public SnmpAdaptorServer(int port) {

   364         this(true, null, port, null) ;

   365     }

   366 

   367     /**

   368      * Initializes this SNMP protocol adaptor using the default port (161)

   369      * and the specified IP address based ACL implementation.

   370      *

   371      * @param acl The <CODE>InetAddressAcl</CODE> implementation.

   372      *        <code>null</code> means no ACL - everybody is authorized.

   373      *

   374      * @since 1.5

   375      */

   376     public SnmpAdaptorServer(InetAddressAcl acl) {

   377         this(false, acl, com.sun.jmx.snmp.ServiceName.SNMP_ADAPTOR_PORT,

   378              null) ;

   379     }

   380 

   381     /**

   382      * Initializes this SNMP protocol adaptor using the default port (161)

   383      * and the

   384      * specified <CODE>InetAddress</CODE>.

   385      * Use the {@link com.sun.jmx.snmp.IPAcl.SnmpAcl} default

   386      * implementation of the <CODE>InetAddressAcl</CODE> interface.

   387      *

   388      * @param addr The IP address to bind.

   389      */

   390     public SnmpAdaptorServer(InetAddress addr) {

   391         this(true, null, com.sun.jmx.snmp.ServiceName.SNMP_ADAPTOR_PORT,

   392              addr) ;

   393     }

   394 

   395     /**

   396      * Initializes this SNMP protocol adaptor using the specified port and the

   397      * specified IP address based ACL implementation.

   398      *

   399      * @param acl The <CODE>InetAddressAcl</CODE> implementation.

   400      *        <code>null</code> means no ACL - everybody is authorized.

   401      * @param port The port number for sending SNMP responses.

   402      *

   403      * @since 1.5

   404      */

   405     public SnmpAdaptorServer(InetAddressAcl acl, int port) {

   406         this(false, acl, port, null) ;

   407     }

   408 

   409     /**

   410      * Initializes this SNMP protocol adaptor using the specified port and the

   411      * specified <CODE>InetAddress</CODE>.

   412      * Use the {@link com.sun.jmx.snmp.IPAcl.SnmpAcl} default

   413      * implementation of the <CODE>InetAddressAcl</CODE> interface.

   414      *

   415      * @param port The port number for sending SNMP responses.

   416      * @param addr The IP address to bind.

   417      */

   418     public SnmpAdaptorServer(int port, InetAddress addr) {

   419         this(true, null, port, addr) ;

   420     }

   421 

   422     /**

   423      * Initializes this SNMP protocol adaptor using the specified IP

   424      * address based ACL implementation and the specified

   425      * <CODE>InetAddress</CODE>.

   426      *

   427      * @param acl The <CODE>InetAddressAcl</CODE> implementation.

   428      * @param addr The IP address to bind.

   429      *

   430      * @since 1.5

   431      */

   432     public SnmpAdaptorServer(InetAddressAcl acl, InetAddress addr) {

   433         this(false, acl, com.sun.jmx.snmp.ServiceName.SNMP_ADAPTOR_PORT,

   434              addr) ;

   435     }

   436 

   437     /**

   438      * Initializes this SNMP protocol adaptor using the specified port, the

   439      * specified  address based ACL implementation and the specified

   440      * <CODE>InetAddress</CODE>.

   441      *

   442      * @param acl The <CODE>InetAddressAcl</CODE> implementation.

   443      * @param port The port number for sending SNMP responses.

   444      * @param addr The IP address to bind.

   445      *

   446      * @since 1.5

   447      */

   448     public SnmpAdaptorServer(InetAddressAcl acl, int port, InetAddress addr) {

   449         this(false, acl, port, addr);

   450     }

   451 

   452     /**

   453      * Initializes this SNMP protocol adaptor using the specified port and the

   454      * specified <CODE>InetAddress</CODE>.

   455      * This constructor allows to initialize an SNMP adaptor without using

   456      * the ACL mechanism (by setting the <CODE>useAcl</CODE> parameter to

   457      * false).

   458      * <br>This constructor must be used in particular with a platform that

   459      * does not support the <CODE>java.security.acl</CODE> package like pJava.

   460      *

   461      * @param useAcl Specifies if this new SNMP adaptor uses the ACL mechanism.

   462      * If the specified parameter is set to <CODE>true</CODE>, this

   463      * constructor is equivalent to

   464      * <CODE>SnmpAdaptorServer((int)port,(InetAddress)addr)</CODE>.

   465      * @param port The port number for sending SNMP responses.

   466      * @param addr The IP address to bind.

   467      */

   468     public SnmpAdaptorServer(boolean useAcl, int port, InetAddress addr) {

   469         this(useAcl,null,port,addr);

   470     }

   471 

   472     // If forceAcl is `true' and InetAddressAcl is null, then a default

   473     // SnmpAcl object is created.

   474     //

   475     private SnmpAdaptorServer(boolean forceAcl, InetAddressAcl acl,

   476                               int port, InetAddress addr) {

   477         super(CommunicatorServer.SNMP_TYPE) ;

   478 

   479 

   480         // Initialize the ACL implementation.

   481         //

   482         if (acl == null && forceAcl) {

   483             try {

   484                 acl = new SnmpAcl("SNMP protocol adaptor IP ACL");

   485             } catch (UnknownHostException e) {

   486                 if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {

   487                     SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,

   488                         "constructor", "UnknowHostException when creating ACL",e);

   489                 }

   490             }

   491         } else {

   492             this.useAcl = (acl!=null) || forceAcl;

   493         }

   494 

   495         init(acl, port, addr) ;

   496     }

   497 

   498     // GETTERS AND SETTERS

   499     //--------------------

   500 

   501     /**

   502      * Gets the number of managers that have been processed by this

   503      * SNMP protocol adaptor  since its creation.

   504      *

   505      * @return The number of managers handled by this SNMP protocol adaptor

   506      * since its creation. This counter is not reset by the <CODE>stop</CODE>

   507      * method.

   508      */

   509     @Override

   510     public int getServedClientCount() {

   511         return super.getServedClientCount();

   512     }

   513 

   514     /**

   515      * Gets the number of managers currently being processed by this

   516      * SNMP protocol adaptor.

   517      *

   518      * @return The number of managers currently being processed by this

   519      * SNMP protocol adaptor.

   520      */

   521     @Override

   522     public int getActiveClientCount() {

   523         return super.getActiveClientCount();

   524     }

   525 

   526     /**

   527      * Gets the maximum number of managers that this SNMP protocol adaptor can

   528      * process concurrently.

   529      *

   530      * @return The maximum number of managers that this SNMP protocol adaptor

   531      *         can process concurrently.

   532      */

   533     @Override

   534     public int getMaxActiveClientCount() {

   535         return super.getMaxActiveClientCount();

   536     }

   537 

   538     /**

   539      * Sets the maximum number of managers this SNMP protocol adaptor can

   540      * process concurrently.

   541      *

   542      * @param c The number of managers.

   543      *

   544      * @exception java.lang.IllegalStateException This method has been invoked

   545      * while the communicator was <CODE>ONLINE</CODE> or <CODE>STARTING</CODE>.

   546      */

   547     @Override

   548     public void setMaxActiveClientCount(int c)

   549         throws java.lang.IllegalStateException {

   550         super.setMaxActiveClientCount(c);

   551     }

   552 

   553     /**

   554      * Returns the Ip address based ACL used by this SNMP protocol adaptor.

   555      * @return The <CODE>InetAddressAcl</CODE> implementation.

   556      *

   557      * @since 1.5

   558      */

   559     @Override

   560     public InetAddressAcl getInetAddressAcl() {

   561         return ipacl;

   562     }

   563 

   564     /**

   565      * Returns the port used by this SNMP protocol adaptor for sending traps.

   566      * By default, port 162 is used.

   567      *

   568      * @return The port number for sending SNMP traps.

   569      */

   570     @Override

   571     public Integer getTrapPort() {

   572         return trapPort;

   573     }

   574 

   575     /**

   576      * Sets the port used by this SNMP protocol adaptor for sending traps.

   577      *

   578      * @param port The port number for sending SNMP traps.

   579      */

   580     @Override

   581     public void setTrapPort(Integer port) {

   582         setTrapPort(port.intValue());

   583     }

   584 

   585     /**

   586      * Sets the port used by this SNMP protocol adaptor for sending traps.

   587      *

   588      * @param port The port number for sending SNMP traps.

   589      */

   590     public void setTrapPort(int port) {

   591         int val= port ;

   592         if (val < 0) throw new

   593             IllegalArgumentException("Trap port cannot be a negative value");

   594         trapPort= val ;

   595     }

   596 

   597     /**

   598      * Returns the port used by this SNMP protocol adaptor for sending

   599      * inform requests. By default, port 162 is used.

   600      *

   601      * @return The port number for sending SNMP inform requests.

   602      */

   603     @Override

   604     public int getInformPort() {

   605         return informPort;

   606     }

   607 

   608     /**

   609      * Sets the port used by this SNMP protocol adaptor for sending

   610      * inform requests.

   611      *

   612      * @param port The port number for sending SNMP inform requests.

   613      */

   614     @Override

   615     public void setInformPort(int port) {

   616         if (port < 0)

   617             throw new IllegalArgumentException("Inform request port "+

   618                                                "cannot be a negative value");

   619         informPort= port ;

   620     }

   621 

   622     /**

   623      * Returns the protocol of this SNMP protocol adaptor.

   624      *

   625      * @return The string "snmp".

   626      */

   627     @Override

   628     public String getProtocol() {

   629         return "snmp";

   630     }

   631 

   632     /**

   633      * Returns the buffer size of this SNMP protocol adaptor.

   634      * This buffer size is used for both incoming request and outgoing

   635      * inform requests.

   636      * By default, buffer size 1024 is used.

   637      *

   638      * @return The buffer size.

   639      */

   640     @Override

   641     public Integer getBufferSize() {

   642         return bufferSize;

   643     }

   644 

   645     /**

   646      * Sets the buffer size of this SNMP protocol adaptor.

   647      * This buffer size is used for both incoming request and outgoing

   648      * inform requests.

   649      *

   650      * @param s The buffer size.

   651      *

   652      * @exception java.lang.IllegalStateException This method has been invoked

   653      * while the communicator was <CODE>ONLINE</CODE> or <CODE>STARTING</CODE>.

   654      */

   655     @Override

   656     public void setBufferSize(Integer s)

   657         throws java.lang.IllegalStateException {

   658         if ((state == ONLINE) || (state == STARTING)) {

   659             throw new IllegalStateException("Stop server before carrying out"+

   660                                             " this operation");

   661         }

   662         bufferSize = s.intValue() ;

   663     }

   664 

   665     /**

   666      * Gets the number of times to try sending an inform request before

   667      * giving up.

   668      * By default, a maximum of 3 tries is used.

   669      * @return The maximun number of tries.

   670      */

   671     @Override

   672     final public int getMaxTries() {

   673         return maxTries;

   674     }

   675 

   676     /**

   677      * Changes the maximun number of times to try sending an inform

   678      * request before giving up.

   679      * @param newMaxTries The maximun number of tries.

   680      */

   681     @Override

   682     final public synchronized void setMaxTries(int newMaxTries) {

   683         if (newMaxTries < 0)

   684             throw new IllegalArgumentException();

   685         maxTries = newMaxTries;

   686     }

   687 

   688     /**

   689      * Gets the timeout to wait for an inform response from the manager.

   690      * By default, a timeout of 3 seconds is used.

   691      * @return The value of the timeout property.

   692      */

   693     @Override

   694     final public int getTimeout() {

   695         return timeout;

   696     }

   697 

   698     /**

   699      * Changes the timeout to wait for an inform response from the manager.

   700      * @param newTimeout The timeout (in milliseconds).

   701      */

   702     @Override

   703     final public synchronized void setTimeout(int newTimeout) {

   704         if (newTimeout < 0)

   705             throw new IllegalArgumentException();

   706         timeout= newTimeout;

   707     }

   708 

   709     /**

   710      * Returns the message factory of this SNMP protocol adaptor.

   711      *

   712      * @return The factory object.

   713      */

   714     @Override

   715     public SnmpPduFactory getPduFactory() {

   716         return pduFactory ;

   717     }

   718 

   719     /**

   720      * Sets the message factory of this SNMP protocol adaptor.

   721      *

   722      * @param factory The factory object (null means the default factory).

   723      */

   724     @Override

   725     public void setPduFactory(SnmpPduFactory factory) {

   726         if (factory == null)

   727             pduFactory = new SnmpPduFactoryBER() ;

   728         else

   729             pduFactory = factory ;

   730     }

   731 

   732     /**

   733      * Set the user-data factory of this SNMP protocol adaptor.

   734      *

   735      * @param factory The factory object (null means no factory).

   736      * @see com.sun.jmx.snmp.agent.SnmpUserDataFactory

   737      */

   738     @Override

   739     public void setUserDataFactory(SnmpUserDataFactory factory) {

   740         userDataFactory = factory ;

   741     }

   742 

   743     /**

   744      * Get the user-data factory associated with this SNMP protocol adaptor.

   745      *

   746      * @return The factory object (null means no factory).

   747      * @see com.sun.jmx.snmp.agent.SnmpUserDataFactory

   748      */

   749     @Override

   750     public SnmpUserDataFactory getUserDataFactory() {

   751         return userDataFactory;

   752     }

   753 

   754     /**

   755      * Returns <CODE>true</CODE> if authentication traps are enabled.

   756      * <P>

   757      * When this feature is enabled, the SNMP protocol adaptor sends

   758      * an <CODE>authenticationFailure</CODE> trap each time an

   759      * authentication fails.

   760      * <P>

   761      * The default behaviour is to send authentication traps.

   762      *

   763      * @return <CODE>true</CODE> if authentication traps are enabled,

   764      *         <CODE>false</CODE> otherwise.

   765      */

   766     @Override

   767     public boolean getAuthTrapEnabled() {

   768         return authTrapEnabled ;

   769     }

   770 

   771     /**

   772      * Sets the flag indicating if traps need to be sent in case of

   773      * authentication failure.

   774      *

   775      * @param enabled Flag indicating if traps need to be sent.

   776      */

   777     @Override

   778     public void setAuthTrapEnabled(boolean enabled) {

   779         authTrapEnabled = enabled ;

   780     }

   781 

   782     /**

   783      * Returns <code>true</code> if this SNMP protocol adaptor sends a

   784      * response in case of authentication failure.

   785      * <P>

   786      * When this feature is enabled, the SNMP protocol adaptor sends a

   787      * response with <CODE>noSuchName</CODE> or <CODE>readOnly</CODE> when

   788      * the authentication failed. If the flag is disabled, the

   789      * SNMP protocol adaptor trashes the PDU silently.

   790      * <P>

   791      * The default behavior is to send responses.

   792      *

   793      * @return <CODE>true</CODE> if responses are sent.

   794      */

   795     @Override

   796     public boolean getAuthRespEnabled() {

   797         return authRespEnabled ;

   798     }

   799 

   800     /**

   801      * Sets the flag indicating if responses need to be sent in case of

   802      * authentication failure.

   803      *

   804      * @param enabled Flag indicating if responses need to be sent.

   805      */

   806     @Override

   807     public void setAuthRespEnabled(boolean enabled) {

   808         authRespEnabled = enabled ;

   809     }

   810 

   811     /**

   812      * Returns the enterprise OID. It is used by

   813      * {@link #snmpV1Trap snmpV1Trap} to fill the 'enterprise' field of the

   814      * trap request.

   815      *

   816      * @return The OID in string format "x.x.x.x".

   817      */

   818     @Override

   819     public String getEnterpriseOid() {

   820         return enterpriseOid.toString() ;

   821     }

   822 

   823     /**

   824      * Sets the enterprise OID.

   825      *

   826      * @param oid The OID in string format "x.x.x.x".

   827      *

   828      * @exception IllegalArgumentException The string format is incorrect

   829      */

   830     @Override

   831     public void setEnterpriseOid(String oid) throws IllegalArgumentException {

   832         enterpriseOid = new SnmpOid(oid) ;

   833     }

   834 

   835     /**

   836      * Returns the names of the MIBs available in this SNMP protocol adaptor.

   837      *

   838      * @return An array of MIB names.

   839      */

   840     @Override

   841     public String[] getMibs() {

   842         String[] result = new String[mibs.size()] ;

   843         int i = 0 ;

   844         for (Enumeration<SnmpMibAgent> e = mibs.elements() ; e.hasMoreElements() ;) {

   845             SnmpMibAgent mib = e.nextElement() ;

   846             result[i++] = mib.getMibName();

   847         }

   848         return result ;

   849     }

   850 

   851     // GETTERS FOR SNMP GROUP (MIBII)

   852     //-------------------------------

   853 

   854     /**

   855      * Returns the <CODE>snmpOutTraps</CODE> value defined in MIB-II.

   856      *

   857      * @return The <CODE>snmpOutTraps</CODE> value.

   858      */

   859     @Override

   860     public Long getSnmpOutTraps() {

   861         return (long)snmpOutTraps;

   862     }

   863 

   864     /**

   865      * Returns the <CODE>snmpOutGetResponses</CODE> value defined in MIB-II.

   866      *

   867      * @return The <CODE>snmpOutGetResponses</CODE> value.

   868      */

   869     @Override

   870     public Long getSnmpOutGetResponses() {

   871         return (long)snmpOutGetResponses;

   872     }

   873 

   874     /**

   875      * Returns the <CODE>snmpOutGenErrs</CODE> value defined in MIB-II.

   876      *

   877      * @return The <CODE>snmpOutGenErrs</CODE> value.

   878      */

   879     @Override

   880     public Long getSnmpOutGenErrs() {

   881         return (long)snmpOutGenErrs;

   882     }

   883 

   884     /**

   885      * Returns the <CODE>snmpOutBadValues</CODE> value defined in MIB-II.

   886      *

   887      * @return The <CODE>snmpOutBadValues</CODE> value.

   888      */

   889     @Override

   890     public Long getSnmpOutBadValues() {

   891         return (long)snmpOutBadValues;

   892     }

   893 

   894     /**

   895      * Returns the <CODE>snmpOutNoSuchNames</CODE> value defined in MIB-II.

   896      *

   897      * @return The <CODE>snmpOutNoSuchNames</CODE> value.

   898      */

   899     @Override

   900     public Long getSnmpOutNoSuchNames() {

   901         return (long)snmpOutNoSuchNames;

   902     }

   903 

   904     /**

   905      * Returns the <CODE>snmpOutTooBigs</CODE> value defined in MIB-II.

   906      *

   907      * @return The <CODE>snmpOutTooBigs</CODE> value.

   908      */

   909     @Override

   910     public Long getSnmpOutTooBigs() {

   911         return (long)snmpOutTooBigs;

   912     }

   913 

   914     /**

   915      * Returns the <CODE>snmpInASNParseErrs</CODE> value defined in MIB-II.

   916      *

   917      * @return The <CODE>snmpInASNParseErrs</CODE> value.

   918      */

   919     @Override

   920     public Long getSnmpInASNParseErrs() {

   921         return (long)snmpInASNParseErrs;

   922     }

   923 

   924     /**

   925      * Returns the <CODE>snmpInBadCommunityUses</CODE> value defined in MIB-II.

   926      *

   927      * @return The <CODE>snmpInBadCommunityUses</CODE> value.

   928      */

   929     @Override

   930     public Long getSnmpInBadCommunityUses() {

   931         return (long)snmpInBadCommunityUses;

   932     }

   933 

   934     /**

   935      * Returns the <CODE>snmpInBadCommunityNames</CODE> value defined in

   936      * MIB-II.

   937      *

   938      * @return The <CODE>snmpInBadCommunityNames</CODE> value.

   939      */

   940     @Override

   941     public Long getSnmpInBadCommunityNames() {

   942         return (long)snmpInBadCommunityNames;

   943     }

   944 

   945     /**

   946      * Returns the <CODE>snmpInBadVersions</CODE> value defined in MIB-II.

   947      *

   948      * @return The <CODE>snmpInBadVersions</CODE> value.

   949      */

   950     @Override

   951     public Long getSnmpInBadVersions() {

   952         return (long)snmpInBadVersions;

   953     }

   954 

   955     /**

   956      * Returns the <CODE>snmpOutPkts</CODE> value defined in MIB-II.

   957      *

   958      * @return The <CODE>snmpOutPkts</CODE> value.

   959      */

   960     @Override

   961     public Long getSnmpOutPkts() {

   962         return (long)snmpOutPkts;

   963     }

   964 

   965     /**

   966      * Returns the <CODE>snmpInPkts</CODE> value defined in MIB-II.

   967      *

   968      * @return The <CODE>snmpInPkts</CODE> value.

   969      */

   970     @Override

   971     public Long getSnmpInPkts() {

   972         return (long)snmpInPkts;

   973     }

   974 

   975     /**

   976      * Returns the <CODE>snmpInGetRequests</CODE> value defined in MIB-II.

   977      *

   978      * @return The <CODE>snmpInGetRequests</CODE> value.

   979      */

   980     @Override

   981     public Long getSnmpInGetRequests() {

   982         return (long)snmpInGetRequests;

   983     }

   984 

   985     /**

   986      * Returns the <CODE>snmpInGetNexts</CODE> value defined in MIB-II.

   987      *

   988      * @return The <CODE>snmpInGetNexts</CODE> value.

   989      */

   990     @Override

   991     public Long getSnmpInGetNexts() {

   992         return (long)snmpInGetNexts;

   993     }

   994 

   995     /**

   996      * Returns the <CODE>snmpInSetRequests</CODE> value defined in MIB-II.

   997      *

   998      * @return The <CODE>snmpInSetRequests</CODE> value.

   999      */

  1000     @Override

  1001     public Long getSnmpInSetRequests() {

  1002         return (long)snmpInSetRequests;

  1003     }

  1004 

  1005     /**

  1006      * Returns the <CODE>snmpInTotalSetVars</CODE> value defined in MIB-II.

  1007      *

  1008      * @return The <CODE>snmpInTotalSetVars</CODE> value.

  1009      */

  1010     @Override

  1011     public Long getSnmpInTotalSetVars() {

  1012         return (long)snmpInTotalSetVars;

  1013     }

  1014 

  1015     /**

  1016      * Returns the <CODE>snmpInTotalReqVars</CODE> value defined in MIB-II.

  1017      *

  1018      * @return The <CODE>snmpInTotalReqVars</CODE> value.

  1019      */

  1020     @Override

  1021     public Long getSnmpInTotalReqVars() {

  1022         return (long)snmpInTotalReqVars;

  1023     }

  1024 

  1025     /**

  1026      * Returns the <CODE>snmpSilentDrops</CODE> value defined in RFC

  1027      * 1907 NMPv2-MIB .

  1028      *

  1029      * @return The <CODE>snmpSilentDrops</CODE> value.

  1030      *

  1031      * @since 1.5

  1032      */

  1033     @Override

  1034     public Long getSnmpSilentDrops() {

  1035         return (long)snmpSilentDrops;

  1036     }

  1037 

  1038     /**

  1039      * Returns the <CODE>snmpProxyDrops</CODE> value defined in RFC

  1040      * 1907 NMPv2-MIB .

  1041      *

  1042      * @return The <CODE>snmpProxyDrops</CODE> value.

  1043      *

  1044      * @since 1.5

  1045      */

  1046     @Override

  1047     public Long getSnmpProxyDrops() {

  1048         return 0L;

  1049     }

  1050 

  1051 

  1052     // PUBLIC METHODS

  1053     //---------------

  1054 

  1055     /**

  1056      * Allows the MBean to perform any operations it needs before being

  1057      * registered in the MBean server.

  1058      * If the name of the SNMP protocol adaptor MBean is not specified,

  1059      * it is initialized with the default value:

  1060      * {@link com.sun.jmx.snmp.ServiceName#DOMAIN

  1061      *   com.sun.jmx.snmp.ServiceName.DOMAIN}:{@link

  1062      * com.sun.jmx.snmp.ServiceName#SNMP_ADAPTOR_SERVER

  1063      * com.sun.jmx.snmp.ServiceName.SNMP_ADAPTOR_SERVER}.

  1064      * If any exception is raised, the SNMP protocol adaptor MBean will

  1065      * not be registered in the MBean server.

  1066      *

  1067      * @param server The MBean server to register the service with.

  1068      * @param name The object name.

  1069      *

  1070      * @return The name of the SNMP protocol adaptor registered.

  1071      *

  1072      * @exception java.lang.Exception

  1073      */

  1074     @Override

  1075     public ObjectName preRegister(MBeanServer server, ObjectName name)

  1076         throws java.lang.Exception {

  1077 

  1078         if (name == null) {

  1079             name = new ObjectName(server.getDefaultDomain() + ":" +

  1080                              com.sun.jmx.snmp.ServiceName.SNMP_ADAPTOR_SERVER);

  1081         }

  1082         return (super.preRegister(server, name));

  1083     }

  1084 

  1085     /**

  1086      * Not used in this context.

  1087      */

  1088     @Override

  1089     public void postRegister (Boolean registrationDone) {

  1090         super.postRegister(registrationDone);

  1091     }

  1092 

  1093     /**

  1094      * Not used in this context.

  1095      */

  1096     @Override

  1097     public void preDeregister() throws java.lang.Exception {

  1098         super.preDeregister();

  1099     }

  1100 

  1101     /**

  1102      * Not used in this context.

  1103      */

  1104     @Override

  1105     public void postDeregister() {

  1106         super.postDeregister();

  1107     }

  1108 

  1109     /**

  1110      * Adds a new MIB in the SNMP MIB handler.

  1111      *

  1112      * @param mib The MIB to add.

  1113      *

  1114      * @return A reference to the SNMP MIB handler.

  1115      *

  1116      * @exception IllegalArgumentException If the parameter is null.

  1117      */

  1118     @Override

  1119     public SnmpMibHandler addMib(SnmpMibAgent mib)

  1120         throws IllegalArgumentException {

  1121         if (mib == null) {

  1122             throw new IllegalArgumentException() ;

  1123         }

  1124 

  1125         if(!mibs.contains(mib))

  1126             mibs.addElement(mib);

  1127 

  1128         root.register(mib);

  1129 

  1130         return this;

  1131     }

  1132 

  1133     /**

  1134      * Adds a new MIB in the SNMP MIB handler.