snmpgw.java
上传用户:aonuowh
上传日期:2021-05-23
资源大小:35390k
文件大小:16k
源码类别:

SNMP编程

开发平台:

C/C++

  1. /* $Id: snmpgw.src,v 1.4.2.5 2009/01/28 13:23:09 tmanoj Exp $ */
  2. /*
  3.  * @(#)snmpgw.java
  4.  * Copyright (c) 1996-2009 AdventNet, Inc. All Rights Reserved.
  5.  * Please read the COPYRIGHTS file for more details.
  6.  */
  7. /**
  8.  *  snmpgw acts as a gateway between a SNMPv3 management application and a
  9.  *  SNMP v1/v2c agent system.When you start the snmpgw application, you can
  10.  *  specify the remote v1 agent address and port number to which requests
  11.  *  from the SNMPv3 management applications need to be forwarded. You can
  12.  *  also specify the community string to be used while forwarding requests
  13.  *  and other session parameters that are appropriate.
  14.  *  The snmpgw applicaiton also requires the port number on which to listen
  15.  *  for SNMPv3 requests, the USM security parameters like the user name on
  16.  *  whose behalf the requests will be accepted, the authentication and privacy
  17.  *  parameters for the specified user etc. need to be specified. 
  18.  *  Usage:
  19.  *     snmpgw [-d] [-v agent_version(v1,v2)] [-c agent_community] [-wc agent_writeCommunity] [-h agent_host] [-p agent_port] [-t timeout] [-r retries] [-a auth_protocol] [-w auth_password] [-s priv_password] ] port engineID user;
  20.  *     Options:
  21.  *         -d To get detailed debug output. Currently not a very usefule option
  22.  *            Default : DEBUG is disabled
  23.  *         -v version. Used to specify the version of remote host (v1 or v2)
  24.  *            Default : remote agent version is SNMPv1
  25.  *         -c community. Specify the community string used in communication with the v1/v2c remote agent
  26.  *            Default : public
  27.  *         -wc writeCommunity. Specify the wite community string used in communication with the v1/v2c remote agent
  28.  *            Default : null
  29.  *         -h agent_host. The remote agent host on which the SNMPv1/SNMPv2c agent is running.
  30.  *            Default : localhost
  31.  *         -p agent_port. Specify the remote agent port on which the agent listens for SNMPv1/v2c requests
  32.  *            Default : 161
  33.  *         -t timeout. Specify the timeout that is applicable both to the v1/v2c session and the v3 session
  34.  *         -r retries. Specify the number of retries. Applicable both to the v1/v2c session and the v3 session
  35.  *         -a authProtocol. The authentication protocol used in communication between the SNMPv3 management
  36.  *              application and the snmpgw. Default: No Authentication
  37.  *         -w auth_password. The authentication password used between the SNMPv3 managemnet application and
  38.  *              the snmpgw application.
  39.  *         -s priv_password. The privacy password used between the SNMPv3 managemnet application and the
  40.  *              snmpgw application.
  41.  *         port. The local UDP port on which the gateway application listens for SNMPv3 requests
  42.  *         engineID. Specify the engineID of the snmpgw.
  43.  *         user. Specify the user for whom the security parameters are defined. Currently this is the only user
  44.  *              for whom the snmpgw will accept requests and forward it to the v1/v2c remote agent.
  45.  */
  46. import com.adventnet.snmp.snmp2.*;
  47. import com.adventnet.snmp.snmp2.usm.*;
  48. import java.util.*;
  49. public class snmpgw extends Thread implements SnmpClient
  50. {
  51.     SnmpAPI api;
  52.     SnmpSession v3_session;
  53.     SnmpSession v1_session;
  54.     Vector v;
  55.     int remoteVersion = 0;
  56.     String remoteHost = "localhost";
  57.     int remotePort = 161;
  58.     int local_port;
  59.     byte[] engineID; 
  60.     private static final int DEBUG_FLAG = 0;
  61.     private static final int VERSION_FLAG = 1;
  62.     private static final int COMMUNITY_FLAG = 2;
  63.     private static final int WRITE_COMMUNITY_FLAG = 3;
  64.     private static final int AGENTHOST_FLAG = 4;
  65.     private static final int AGENTPORT_FLAG = 5;
  66.     private static final int TIMEOUT_FLAG = 6;
  67.     private static final int RETRY_FLAG = 7;
  68.     private static final int AUTHPROTOCOL_FLAG = 8;
  69.     private static final int AUTHPASSWORD_FLAG = 9;
  70.     private static final int PRIVPASSWORD_FLAG = 10;
  71.     private static final int PRIVPROTOCOL_FLAG = 11;
  72.     snmpgw()
  73.     {
  74.         // Start SNMP API
  75.         api = new SnmpAPI();
  76.         try
  77.         {
  78.             Thread.sleep(500);
  79.         }
  80.         catch (Exception x)
  81.         {
  82.         }
  83.         // Open session and set remote host & port if needed,
  84.         v3_session = new SnmpSession(api);
  85.         v1_session = new SnmpSession(api);
  86.         v = new Vector();
  87.     }
  88.     public static void main(String args[])
  89.     {
  90.         snmpgw eserv = new snmpgw();
  91.         // Take care of getting options
  92.         String usage =
  93.         "snmpgw [-d] [-v agent_version(v1,v2)] [-c agent_community] n" +
  94.         "[-wc agent_writeCommunity] [-h agent_host] [-p agent_port] n" +
  95.         "[-t timeout] [-r retries] [-a auth_protocol] [-w auth_password] n" +
  96.         "[-s priv_password] ] [-pp privProtocol(DES/AES-128/AES-192/AES-256/3DES)] port engineID user";
  97.         String options[] = { "-d", "-v","-c", "-wc", "-h", "-p", "-t", "-r", "-a", "-w", "-s" ,"-pp" };
  98.         String values[] = { "None", null, null, null, null, null, null, null, null, null, null, null };
  99.         String userName = null;
  100.         int authProtocol = USMUserEntry.NO_AUTH;
  101.         String authPassword = null;
  102.         String privPassword = null;
  103.         int options_flag = 0;
  104. int privProtocol = USMUserEntry.NO_PRIV;
  105.         ParseOptions opt = new ParseOptions(args,options,values, usage);
  106.         if (opt.remArgs.length<3)
  107.         {
  108.             opt.usage_error();
  109.         }
  110.         eserv.local_port = Integer.parseInt(opt.remArgs[0]);
  111.         UDPProtocolOptions v3_opt = new UDPProtocolOptions();
  112.         v3_opt.setLocalPort(eserv.local_port);
  113.         eserv.v3_session.setProtocolOptions(v3_opt);
  114.         eserv.engineID = (opt.remArgs[1]).getBytes();
  115.         userName = opt.remArgs[2];
  116.         if (values[DEBUG_FLAG].equals("Set"))
  117.         {
  118.             System.out.println("Debug is TRUE");
  119.             eserv.api.setDebug( true );
  120.         }
  121.         if(values[VERSION_FLAG] != null)
  122.         {
  123.             if(values[VERSION_FLAG].equals("v2"))
  124.             {
  125.                 eserv.remoteVersion = (SnmpAPI.SNMP_VERSION_2C);
  126.             }
  127.             else if(values[VERSION_FLAG].equals("v1"))
  128.             {
  129.                 eserv.remoteVersion = (SnmpAPI.SNMP_VERSION_1);
  130.             }
  131.             else
  132.             {
  133.                 System.err.println("Invalid Version Number. Please use v1 or v2");
  134.                 System.exit(1);
  135.             }
  136.         }
  137.         if (values[COMMUNITY_FLAG] != null)
  138.         {
  139.             eserv.v1_session.setCommunity( values[COMMUNITY_FLAG] );
  140.         }
  141.         if (values[WRITE_COMMUNITY_FLAG] != null)
  142.         {
  143.             eserv.v1_session.setWriteCommunity( values[WRITE_COMMUNITY_FLAG] );
  144.         }
  145.         try
  146.         {
  147.             UDPProtocolOptions v1_opt = new UDPProtocolOptions();
  148.             if (values[AGENTHOST_FLAG] != null) 
  149.             {
  150.                 v1_opt.setRemoteHost(values[AGENTHOST_FLAG]);
  151.                 eserv.remoteHost = values[AGENTHOST_FLAG];
  152.             }
  153.             if (values[AGENTPORT_FLAG] != null) 
  154.             {
  155.                 eserv.remotePort = Integer.parseInt(values[AGENTPORT_FLAG]);
  156.                 v1_opt.setRemotePort(eserv.remotePort);
  157.             }
  158.             eserv.v1_session.setProtocolOptions(v1_opt);
  159.             if (values[TIMEOUT_FLAG] != null) 
  160.             {
  161.                 eserv.v1_session.setTimeout(Integer.parseInt(values[TIMEOUT_FLAG]));
  162.                 eserv.v3_session.setTimeout(Integer.parseInt(values[TIMEOUT_FLAG]));
  163.             }
  164.             if (values[RETRY_FLAG] != null) 
  165.             {
  166.                 eserv.v1_session.setRetries(Integer.parseInt(values[RETRY_FLAG]));
  167.                 eserv.v3_session.setRetries(Integer.parseInt(values[RETRY_FLAG]));
  168.             }
  169.             if (values[AUTHPROTOCOL_FLAG] != null) 
  170.             {
  171.                 if (values[AUTHPROTOCOL_FLAG].compareTo("MD5") == 0)
  172.                 {
  173.                     authProtocol = USMUserEntry.MD5_AUTH;
  174.                 }
  175.                 else if (values[AUTHPROTOCOL_FLAG].compareTo("SHA") == 0)
  176.                 {
  177.                     authProtocol = USMUserEntry.SHA_AUTH;
  178.                 }
  179.                 else
  180.                 {
  181.                     authProtocol = USMUserEntry.NO_AUTH;
  182.                 }
  183.             }
  184.             if (values[AUTHPASSWORD_FLAG] != null) 
  185.             {
  186.                 authPassword = values[AUTHPASSWORD_FLAG];
  187.             }
  188.              if (values[PRIVPASSWORD_FLAG] != null) 
  189.             {
  190.    
  191.                 privPassword = values[PRIVPASSWORD_FLAG];
  192.             }
  193.     if (values[PRIVPROTOCOL_FLAG] != null) 
  194.             {
  195.                 if (values[PRIVPROTOCOL_FLAG].compareTo("DES") == 0)
  196.                 {
  197.                     privProtocol = USMUserEntry.CBC_DES;
  198.                 }
  199.                 else if (values[PRIVPROTOCOL_FLAG].compareTo("AES-128") == 0)
  200.                 {
  201.                      privProtocol = USMUserEntry.CFB_AES_128;
  202.                 }
  203. else if (values[PRIVPROTOCOL_FLAG].compareTo("AES-192") == 0)
  204.                 {
  205.                      privProtocol = USMUserEntry.CFB_AES_192;
  206.                 }
  207. else if (values[PRIVPROTOCOL_FLAG].compareTo("AES-256") == 0)
  208.                 {
  209.                      privProtocol = USMUserEntry.CFB_AES_256;
  210.                 }
  211. else if (values[PRIVPROTOCOL_FLAG].compareTo("3DES") == 0)
  212.                 {
  213.                      privProtocol = USMUserEntry.CBC_3DES;
  214.                 }
  215.                 else
  216.                 {
  217.                     authProtocol = USMUserEntry.NO_AUTH;
  218.                 }
  219.             }
  220.         }
  221.         catch(Exception ex)
  222.         {
  223.             System.err.println(ex.getMessage());
  224.             System.exit(2);
  225.         }
  226.         try
  227.         {
  228.             eserv.v3_session.open();
  229.             eserv.v1_session.open();
  230.         }
  231.         catch (SnmpException e)
  232.         {
  233.         }
  234.         eserv.createUSMTable(userName.getBytes(), authProtocol, authPassword, privPassword, privProtocol);
  235.         eserv.v3_session.addSnmpClient(eserv);
  236.         eserv.start();
  237.     } // end main()
  238.     public boolean authenticate(SnmpPDU pdu, String community)
  239.     {
  240.         boolean rv = false;
  241.         if(pdu != null)
  242.         {
  243.             if(((Snmp3Message)pdu.getMsg()).isAuthenticationFailed())
  244.             {
  245.                 System.out.println("In snmpgw : authenticate "+
  246.                 "failed. Dropping PDU.");
  247.             }
  248.             else
  249.             {
  250.                 rv = true;
  251.             }
  252.         }
  253.         return rv;
  254.     }
  255.     public boolean callback(SnmpSession sess, SnmpPDU pdu, int reqID)
  256.     {
  257.         if (pdu == null)
  258.         {
  259.             System.err.println("Null PDU received");
  260.             return false;
  261.         }
  262.         enQ(pdu);
  263.         return true;
  264.     }
  265.     public void debugPrint(String debugOutput)
  266.     {
  267.     }
  268.     public void createUSMTable(byte[] name, int authProtocol, String authPassword, String privPassword, int privProtocol)
  269.     {
  270.         byte level = 0;
  271.         USMUserEntry entry = new USMUserEntry(name, engineID);
  272.         entry.setAuthProtocol(authProtocol);
  273.         if ((authProtocol != USMUserEntry.NO_AUTH) && (authPassword != null))
  274.         {
  275.             byte[] authKey = USMUtils.password_to_key(authProtocol, authPassword.getBytes(), authPassword.getBytes().length, engineID);
  276.             entry.setAuthKey(authKey);
  277.             level = 1;
  278.             if (privPassword != null)
  279.             {
  280. entry.setPrivProtocol(privProtocol); 
  281.                 byte[] tempKey = USMUtils.password_to_key(authProtocol, privPassword.getBytes(), privPassword.getBytes().length, engineID, privProtocol);
  282.                 byte privKey[]=null;
  283. if(privProtocol==USMUserEntry.CFB_AES_192)
  284. {
  285. privKey=new byte[24];
  286. System.arraycopy(tempKey,0,privKey,0,24);
  287. }
  288. else if(privProtocol==USMUserEntry.CFB_AES_256)
  289. {
  290. privKey =new byte[32];
  291. System.arraycopy(tempKey,0,privKey,0,32);
  292. }
  293. else if(privProtocol==USMUserEntry.CBC_3DES)
  294. {
  295. privKey =new byte[32];
  296. System.arraycopy(tempKey,0,privKey,0,32);
  297. }
  298. else
  299. {
  300. privKey=new byte[16];
  301. System.arraycopy(tempKey,0,privKey,0,16);
  302. }
  303.                 entry.setPrivKey(privKey);
  304.                 level |= 2;
  305.                
  306.             }
  307.         }
  308.         entry.setSecurityLevel(level);
  309.         USMUserTable USMTable = (USMUserTable)api.getSecurityProvider().getTable(3);
  310.         USMTable.addEntry(entry);
  311.         byte[] names = entry.getUserName();
  312.         byte[] id = entry.getEngineID();
  313.         SnmpEngineEntry e = new SnmpEngineEntry("localhost", local_port);
  314.         e.setEngineID(engineID);
  315.         entry.setEngineEntry(e);
  316.         api.setSnmpEngineID(engineID);
  317.     }
  318.     /** Print octet data in a more readable form */
  319.     String printOctets(byte[] data, int length)
  320.     {
  321.         StringBuffer s = new StringBuffer();
  322.         int j = 0, line = 20; // we'll allow 20 bytes per line
  323.         if (data.length < length)
  324.         {
  325.             length = data.length;
  326.         }
  327.         for (int i=0;i<length;i++)
  328.         {
  329.             if (j++ > 19)
  330.             {
  331.                 j=1;
  332.                 s.append("n");
  333.             }
  334.             String bs = Integer.toString(byteToInt(data[i]),16);
  335.             if (bs.length() < 2)
  336.             {
  337.                 bs = "0" + bs;
  338.             }
  339.             s.append(bs+ " ");
  340.         }
  341.         return s.toString();
  342.     }
  343.     public synchronized SnmpPDU deQ()
  344.     {
  345.         for (Enumeration e = v.elements() ; e.hasMoreElements() ;)
  346.         {
  347.             SnmpPDU pdu = (SnmpPDU) e.nextElement();
  348.             v.removeElement(pdu);
  349.             return pdu;
  350.         }
  351.         return null;
  352.     }
  353.     /** Place in specified queue */
  354.     public synchronized void enQ(SnmpPDU pdu)
  355.     {
  356.         v.addElement(pdu);
  357.         notifyAll();
  358.     }
  359.     public void run()
  360.     {
  361.         System.out.println("snmpgw: Ready to process requests from SNMPv3 Manager");
  362.         while (true)
  363.         {
  364.             SnmpPDU pdu = deQ();
  365.             if (pdu == null)
  366.             {
  367.                 wait_for_v3pdus();
  368.             }
  369.             if (pdu == null)
  370.             {
  371.                 continue;
  372.             }
  373.             SnmpPDU ref_pdu = pdu;
  374.             int version = ref_pdu.getVersion();
  375.             ProtocolOptions ref_opt = pdu.getProtocolOptions();
  376.             ref_pdu.setVersion(remoteVersion);
  377.             ref_pdu.setProtocolOptions(null);
  378.             SnmpPDU rpdu = null;
  379.             try
  380.             {
  381.                 // Send PDU
  382.                 SnmpVarBind varb = ref_pdu.getVariableBinding(0);
  383.                 if(varb!=null)
  384.                 {
  385.                     System.out.println("sent V" + (remoteVersion + 1) + " request: OID sent = " + varb.getObjectID());
  386.                 }
  387.                 rpdu = v1_session.syncSend(ref_pdu);
  388.             }
  389.             catch (SnmpException e)
  390.             {
  391.                 System.err.println("Sending V1 PDU" + e.getMessage());
  392.                 continue;
  393.             }
  394.             if (rpdu == null)  // timeout
  395.             {
  396.                 System.err.println("V1 Request timed out to: " + pdu.getProtocolOptions().getSessionId() );
  397.                 continue;
  398.             }
  399.             SnmpVarBind varb = null;
  400.             int size = pdu.getVariableBindings().size();
  401.             for (int i = 0; (i < size); i++)
  402.             {
  403.                 pdu.removeVariableBinding(0);
  404.             }
  405.             size = rpdu.getVariableBindings().size();
  406.             for (int i = 0; i < size; i++)
  407.             {
  408.                 pdu.addVariableBinding(rpdu.getVariableBinding(i));
  409.             }
  410.             SnmpVarBind varbr = pdu.getVariableBinding(0);
  411.             if(varbr!=null)
  412.             {
  413.                 System.out.println("Received V" + (remoteVersion + 1) + " response: OID received = " + varbr.getObjectID());
  414.             }
  415.             pdu.setVersion(version);
  416.             pdu.setCommand(rpdu.getCommand());
  417.             pdu.setErrstat(rpdu.getErrstat());
  418.             pdu.setErrindex(rpdu.getErrindex());
  419.             pdu.setProtocolOptions(ref_opt);
  420.             try
  421.             {
  422.                 v3_session.send(pdu);
  423.             }
  424.             catch (SnmpException e)
  425.             {
  426.                 System.err.println("Session Open "+e.getMessage());
  427.                 continue;
  428.             }
  429.         }
  430.     }
  431.     public synchronized void wait_for_v3pdus()
  432.     {
  433.         try
  434.         {
  435.             if (v.size() > 0)
  436.             {
  437.                 return;
  438.             }
  439.             else
  440.             {
  441.                 wait();
  442.             }
  443.         }
  444.         catch (InterruptedException i)
  445.         {
  446.         }
  447.     }
  448.     static int byteToInt(byte b) 
  449.     {
  450.         return (int)b & 0xFF;
  451.     }
  452. }