java实现基于snmp的网络拓扑发现

最新推荐文章于 2024-06-05 00:59:37 发布
最新推荐文章于 2024-06-05 00:59:37 发布
阅读量1.4w 收藏 34
点赞数 9
分类专栏： SNMP 文章标签： snmp

背景

目前手上只有二层交换机且支持snmp协议，故先实现子网内的网络拓扑发现，等有了三层交换机后再补充全网络的拓扑发现，至于发现的方式也是我看了一些资料以后用自己觉得可行且较方便的方式实现了出来，如果有什么不对的或者有更好的方法希望大家能够指正分享。

实现

需要了解的一些知识和工具：有snmp(Simple Network Manage Protocol)协议的概念，snmp4j框架，jpcap框架
下面是我实际测试的一个网络拓扑示意图

获取主机的IP和子网掩码
这里用的jpcap里的方法，我们可以获取一个带ipv4且不是回环地址（就是我们通常的127.0.0.1）的IP地址和这块网卡上的子网掩码，如果主机上有多块网卡也没关系（多块网卡在同一子网无需重复，在不同子网的话超出了本文范畴，以后会更新）
[java]  view plain  copy
  1. // 获取本机上的网络接口对象数组    
  2.             final NetworkInterface[] devices = JpcapCaptor.getDeviceList();    
  3. //获取本机第一个有ipv4网址且不是回环地址的网络接口  
  4.             for (NetworkInterface nc : devices) {     
  5.                 // 一块卡上可能有多个地址:    
  6.                 if(nc.addresses.length > 0 && !nc.loopback){  
  7.                     for (int t = 0; t < nc.addresses.length; t++) {    
  8.                         if(nc.addresses[t].address instanceof Inet4Address){  
  9.                             currentDevice = nc;  //这个就是需要获取的网络接口对象，在这里可以通过它获取ip和子网掩码如nc.addresses[t].address.getHostAddress()  nc.addresses[t].subnet.getAddress()  
  10.                             return nc.addresses[t];  
  11.                         }  
  12.                     }    
  13.                 }  
  14.             }    

根据主机IP和子网掩码算出子网的IP范围
这里就不贴源码了，需要对IP地址和子网掩码有所了解，可以通过刚刚获取的IP和子网掩码做按位与，获得IP地址里的网络号，剩下的位就代表的主机号，主机号的范围就是子网IP的范围。

通过arp请求获取所有子网在线设备
根据上一步获取的子网IP范围，挨个发送arp请求，如果有回应的话则存储起来，获得一个IP,MAC地址的map,下面贴下jpcap发送arp请求的官方例子，在jpcap下载下来的sample文件夹下面都有，我稍微修改加了点注释。
[java]  view plain  copy
  1. import java.net.Inet4Address;  
  2. import java.net.InetAddress;  
  3. import java.util.Arrays;  
  4.   
  5. import jpcap.JpcapCaptor;  
  6. import jpcap.JpcapSender;  
  7. import jpcap.NetworkInterface;  
  8. import jpcap.NetworkInterfaceAddress;  
  9. import jpcap.packet.ARPPacket;  
  10. import jpcap.packet.EthernetPacket;  
  11.   
  12. public class ARP {  
  13.     public static byte[] arp(InetAddress ip) throws java.io.IOException{  
  14.         //find network interface  
  15.         //获取网络接口列表  
  16.         NetworkInterface[] devices=JpcapCaptor.getDeviceList();  
  17.         NetworkInterface device=null;  
  18.   
  19. loop:   for(NetworkInterface d:devices){  
  20.             for(NetworkInterfaceAddress addr:d.addresses){  
  21.                 if(!(addr.address instanceof Inet4Address)) continue;  
  22.                 byte[] bip=ip.getAddress();  
  23.                 byte[] subnet=addr.subnet.getAddress();  
  24.                 byte[] bif=addr.address.getAddress();  
  25.                 for(int i=0;i<4;i++){  
  26.                     bip[i]=(byte)(bip[i]&subnet[i]);  
  27.                     bif[i]=(byte)(bif[i]&subnet[i]);  
  28.                 }  
  29.                 if(Arrays.equals(bip,bif)){  
  30.                     device=d;  
  31.                     break loop;  
  32.                 }  
  33.             }  
  34.         }  
  35.           
  36. //      device.addresses.  
  37. //      System.out.println("");  
  38.           
  39.         if(device==null)  
  40.             throw new IllegalArgumentException(ip+" is not a local address");  
  41.           
  42.         /** 
  43.          * 打开指定的网络接口，并返回实例 
  44.          * 2000:一次抓取的最大bytes 
  45.          * false: If true, the inferface becomes promiscuous mode 
  46.          * 3000:超时时间，并不是所有的平台都支持这个参数，如果不支持这个参数被忽略，如果支持的话只要不超时，Jpcap就会一直等待足够的数据到达 
  47.          */  
  48.         //JpcapCaptor:是用来抓包、读取包数据，通过libpcap的抓包文件  
  49.         JpcapCaptor captor=JpcapCaptor.openDevice(device,2000,false,100);  
  50.         //"arp":condition - a string representation of the filter   true:optimize - If true, the filter is optimized  
  51.         captor.setFilter("arp",true);  
  52.         //根据名字应该是发送包的对象  
  53.         JpcapSender sender=captor.getJpcapSenderInstance();  
  54.           
  55.         InetAddress srcip=null;  
  56.         //一个网络接口可能有多个地址，我们选取一个ipv4地址进行发送  
  57.         for(NetworkInterfaceAddress addr:device.addresses)  
  58.             if(addr.address instanceof Inet4Address){  
  59.                 srcip=addr.address;  
  60.                 break;  
  61.             }  
  62.         //广播地址  
  63.         byte[] broadcast=new byte[]{(byte)255,(byte)255,(byte)255,(byte)255,(byte)255,(byte)255};  
  64.         //是在jpcap.packet里面的一个类，里面还有其他的一些类，从这里也能了解到jpcap支持哪些协议的发送，这里的是用来处理arp和rarp的类  
  65.         ARPPacket arp=new ARPPacket();  
  66.         //硬件类型 从字面上看是以太网类型  
  67.         arp.hardtype=ARPPacket.HARDTYPE_ETHER;  
  68.         //协议类型：ip  
  69.         arp.prototype=ARPPacket.PROTOTYPE_IP;  
  70.         //arp请求  
  71.         arp.operation=ARPPacket.ARP_REQUEST;  
  72.         //mac地址长度  
  73.         arp.hlen=6;  
  74.         //ip长度  
  75.         arp.plen=4;  
  76.           
  77.         //源和目的的mac地址、ip地址  
  78.         arp.sender_hardaddr=device.mac_address;  
  79.         arp.sender_protoaddr=srcip.getAddress();  
  80.         arp.target_hardaddr=broadcast;  
  81.         arp.target_protoaddr=ip.getAddress();  
  82.           
  83.         //以太网数据包，可以看到这里只需要源和目的mac地址，是处在数据链路层的，后面也指定了arp的数据链路层  
  84.         EthernetPacket ether=new EthernetPacket();  
  85.         ether.frametype=EthernetPacket.ETHERTYPE_ARP;  
  86.         ether.src_mac=device.mac_address;  
  87.         ether.dst_mac=broadcast;  
  88.         arp.datalink=ether;  
  89.           
  90.         //下面就是发送arp和接收了  
  91.         sender.sendPacket(arp);  
  92. //      System.out.println(System.currentTimeMillis());  
  93.         while(true){  
  94.             ARPPacket p=(ARPPacket)captor.getPacket();  
  95. //          System.out.println(System.currentTimeMillis());  
  96.             if(p==null){  
  97.                 throw new IllegalArgumentException(ip+" is not a local address");  
  98.             }  
  99.             if(Arrays.equals(p.target_protoaddr,srcip.getAddress())){  
  100.                 return p.sender_hardaddr;  
  101.             }  
  102.         }  
  103.     }  
  104.           
  105.     public static String getMacAddress(byte[] mac){  
  106.         if (mac == null)  
  107.             return null;  
  108.   
  109.         StringBuilder sb = new StringBuilder(18);  
  110.         for (byte b : mac) {  
  111.             if (sb.length() > 0)  
  112.                 sb.append(':');  
  113.             sb.append(String.format("%02x", b));  
  114.         }  
  115.         return sb.toString();  
  116.     }  
  117.       
  118.     public static void main(String[] args) throws Exception{  
  119.           
  120.         byte[] mac=ARP.arp(InetAddress.getByName("192.168.10.196"));  
  121.         String strMac = getMacAddress(mac);  
  122.         System.out.println(strMac);  
  123.         System.exit(0);  
  124.           
  125.     }  
  126. }  

获取子网内交换机列表
这里需要说一下,因为我获取的是某个指定型号的交换机，只需要在上面获取的在线设备的mac地址中判断mac地址的前三位即可，更通用的方法可以用snmp4j测试刚刚获取的在线设备是否支持snmp（有些非交换机设备可能也支持snmp，如某些安装了snmp的计算机，这个可以进一步获取交换机特有的snmp中的mib信息加以区分）

获取主机默认网关的ip和mac地址，以默认网关作为子网的根节点
这里查过一些，java获取的一般方法无非就是在windows下通过执行ipconfig，linux下读配置文件，总感觉不太通用（windows不同的操作系统截取默认网关的地方好像还不同），总想找一个各个平台通用的方法，不过貌似java对这个的支持还不够，后来在看jpcap的sample的时候发现了一个可行方法，前提是需要能够访问外网
[java]  view plain  copy
  1. //通过访问外网（此处为百度）获取默认网关的mac地址  
  2.     public String getGatewayMac(){  
  3.         try {  
  4.             JpcapCaptor captor = JpcapCaptor.openDevice(currentDevice, 2000, false, 1000);  
  5.             // obtain MAC address of the default gateway  
  6.             InetAddress pingAddr = InetAddress.getByName("www.baidu.com");  
  7.             captor.setFilter("tcp and dst host " + pingAddr.getHostAddress(), true);  
  8.             for(int i = 0;i<5;i++){  
  9.                 new URL("http://www.baidu.com").openStream().close();  
  10.                 Packet ping = captor.getPacket();  
  11.                 if (ping == null) {  
  12.                     System.out.println("[CommonTool_getGatewayMac] getGatewayMac cannot obtain MAC address of default gateway.");  
  13.                     continue;  
  14.                 } else if (Arrays.equals(((EthernetPacket) ping.datalink).dst_mac,currentDevice.mac_address))  
  15.                     continue;  
  16.                 return ARPTool.getMacAddress(((EthernetPacket) ping.datalink).dst_mac);  
  17.             }  
  18.         } catch (IOException e) {  
  19.             System.out.println("[CommonTool_getGatewayMac] getGatewayMac openDevice failed");  
  20.         }  
  21.         return null;  
  22.     }  
这里是获取网关mac地址的方法，再通过mac地址在在线设备中找到对应的ip。这里应该是通过访问不在同一网段的网址，计算机会把数据直接丢到默认网关，通过解析默认网关的回应回去mac地址。
 
通过snmp获取每个交换机记忆的需要转发的mac地址表
因为是二层交换机，即工作在数据链路层的交换机，我们知道三层是IP层，二层不需要ip直接通过设备的mac地址进行通讯，所以二层交换机需要记下每个端口下设备对应的mac地址，这样才能将数据帧准确送到目的mac地址。有兴趣的话可以google一下交换机的工作原理。而我们通过snmp就可以获得交换机每个端口下记忆的mac地址。这里需要注意一下，交换机接入局域网的那个端口会记忆除了交换机其他端口记忆设备以外的所有子网设备mac地址，我们可以通过是否包含默认网关mac地址来确认哪个端口是接入子网的端口，因为我们发现拓扑只需要知道交换机下面挂的所有设备即可，故可以直接抛弃接入子网那个端口记忆的mac地址。下面贴一下通过snmp4j获取我们需要数据的方法
[java]  view plain  copy
  1. /** 
  2.      * 获取snmp的mib数据库的 dot1qTpFdbTable 的数据 通过 bulk方式 
  3.      *  "1.3.6.1.2.1.17.7.1.2.2" 这个是获取节点的起始路径  
  4.      * if arrive dot1qTpFdbStatus return detail see snmp mib 
  5.      * @param targetIp target snmp agent server ip 
  6.      * @param oid  
  7.      * @return last result's oid 
  8.      */  
  9.     public String snmpBulkFdbTable(String targetIp,String oid) {  
  10.           
  11.         String lastOid = null;  
  12.         Snmp snmp = null;  
  13.   
  14.         try {  
  15.             snmp = new Snmp(new DefaultUdpTransportMapping());  
  16.             snmp.listen();  
  17.   
  18.             CommunityTarget target = new CommunityTarget();  
  19.             target.setCommunity(new OctetString("public"));  
  20.             target.setVersion(SnmpConstants.version2c);  
  21.             target.setAddress(new UdpAddress(targetIp + "/161"));  
  22.             target.setTimeout(3000); // 3s  
  23.             target.setRetries(2);  
  24.   
  25.             PDU pdu = new PDU();  
  26.             pdu.setType(PDU.GETBULK);  
  27.             pdu.setMaxRepetitions(200);  
  28.             pdu.setNonRepeaters(0);  
  29.   
  30.             pdu.add(new VariableBinding(new OID(oid)));  
  31.             ResponseEvent responseEvent = snmp.send(pdu, target);  
  32.             PDU response = responseEvent.getResponse();  
  33.               
  34.             if (response == null) {  
  35.                 System.out.println("[SNMPTool_snmpBulkFdbTable] TimeOut... targetIp:"+targetIp);  
  36.             } else {  
  37.                 if (response.getErrorStatus() == PDU.noError) {  
  38.                     Vector<? extends VariableBinding> vbs = response.getVariableBindings();  
  39.                     for (VariableBinding vb : vbs) {  
  40.                         int dataType = vb.getOid().get(12);  
  41.                         //dot1qTpFdbAddress  
  42.                         if(dataType == 1){  
  43.                             switchLearnedMac.add(vb.getVariable().toString());  
  44.                         }  
  45.                         //dot1qTpFdbPort  
  46.                         else if(vb.getOid().get(12) == 2){  
  47.                             switchMacPort.add(vb.getVariable().toInt());  
  48.                         }  
  49.                         //arrive dot1qTpFdbStatus return  
  50.                         else{  
  51.                             return "finish";  
  52.                         }  
  53. //                      System.out.println("oid:"+vb.getOid()+"  varilable:"+vb.getVariable());  
  54.                     }  
  55.                     lastOid = vbs.get(vbs.size()-1).getOid().toString();  
  56.                 } else {  
  57.                     System.out.println("[SNMPTool_snmpBulkFdbTable] targetIp"+targetIp+" Error:" + response.getErrorStatusText());  
  58.                 }  
  59.             }  
  60.             snmp.close();  
  61.         } catch (IOException e) {  
  62.             System.out.println("[SNMPTool_snmpBulkFdbTable] snmpBulkFdbTable targetIp "+targetIp+" IOException "+e.getMessage());  
  63.         }  
  64.         return lastOid;  
  65.     }  
方法怎么调用可以看下说明（因为想要使用系统1024以下的端口必须要有root权限，所以我为方便测试直接sudo启动的eclipse，导致我的输入法不能用了，就用了蹩脚的英文注释了一下，至于怎么解决输入法问题留着我下一篇写吧）。我们可以通过判断是否返回字符串“finish”来判断是否获取完毕，如果不是“finish”的话我们可以用返回的lashOid继续调用这个方法，直到返回“finish”。还有要注意一下这个用的类型是pdu.setType(PDU.GETBULK)，这样一次能获取到尽量多的数据，具体可以看下snmp协议。

根据上面获取到的数据还原出整个子网的拓扑结构
上面的种种步骤无法是为了最后一步做准备，下面是我给出的算法，希望大家能讨论下是否还有更好的算法，或者能有什么地方可以改进
还是以开头的拓扑结构作为说明

由于交换机194,196,198的第5个端口都包含默认网关的mac地址故不需要这个端口的mac地址表，现获取的每个交换机的mac地址转发表如下（为了直观，mac地址用相应的ip地址代替）



可以看出上级交换机包含下级交换机及其下挂设备，所以上级交换机包含的设备一定大于下级交换机，可以得出目前下挂设备最多的交换机一定是跟默认网关直连的，然后我们可以继续对下挂设备最多的交换机进行处理，例子中就是192.168.10.196交换机，以196作为父节点，查看下挂设备是否包含交换机，如果包含的话找出下挂设备最多的交换机，继续上述计算，这里就用到了递归，一旦没有了下挂设备，则达到了递归的出口。每次找出最大交换机后，将其从子网在线交换机IP-MAC地址表中删除，这样下次找最大下挂设备交换机时就不用处理已经处理过的交换机了。还有一个需要注意的是由于上级交换机下挂设备包含下级交换机的下挂设备，所有每处理完一个下挂设备后需要记录，这样处理上级的时候判断是否已处理过，就会避免重复处理同一个下挂设备。表达能力有限，再贴个计算过程的动态图


最后为了大家方便测试讨论最后的算法，我贴个我做测试用的类（前面获取数据的步骤全部省略，直接自己凑的数据，注意一下凑的数据一定要符合上面的规则）

测试类

[java]  view plain  copy
  1. import java.util.HashMap;  
  2. import java.util.HashSet;  
  3. import java.util.LinkedHashMap;  
  4. import java.util.Map;  
  5. import java.util.Set;  
  6. import java.util.Map.Entry;  
  7.   
  8. import com.yanxw.object.NetworkDevice;  
  9. import com.yanxw.object.TreeNode;  
  10.   
  11. public class SimulationData {  
  12.     //子网内设备IP与设备信息的map  
  13.         private static Map<String,NetworkDevice> subnetIpDevices = new LinkedHashMap<>();  
  14.         //子网内设备mac与设备信息的map  
  15.         private static Map<String,NetworkDevice> subnetMacDevices = new LinkedHashMap<>();  
  16.         //子网内交换机ip与交换机信息的map  
  17.         private static Map<String,NetworkDevice> subnetIpSwitchs = new LinkedHashMap<>();  
  18.         //子网内交换机mac与交换机信息的map  
  19.         private static Map<String,NetworkDevice> subnetMacSwitchs = new LinkedHashMap<>();  
  20.         //需要用来展示拓扑结构树的节点信息  
  21.         private static TreeNode[] nodes;  
  22.         //全局变量TreeNode数组的索引  
  23.         private static int nodeIndex = 1;  
  24.           
  25.         //网关IP  
  26.         private static String gatewayIp = "192.168.10.1";  
  27.         private static float gatewayId;  
  28.           
  29.         //Map<IP（交换机的IP地址）,Set<Mac>（交换机除了接入网络的其他端口需要转发的mac地址）> 用于全局存储所有子网内交换机对应的mac地址  
  30.         private static Map<String,Set<String>> subnetSwitchsNextMacs;  
  31.         //已经生成节点信息的计算机（type = 3）节点的set 利用这个来防止重复生成计算机节点  
  32.         private static Set<String> hasNodeComputerMac = new HashSet<>();  
  33.           
  34.         public static void main(String[] args) {  
  35.             //--------------------------------------用于测试用的数据的构造 start------------------------------------//  
  36.             subnetIpDevices.put("192.168.10.1", new NetworkDevice("00:23:cd:87:b6:18", "192.168.10.1", 1));  
  37.               
  38.             subnetIpDevices.put("192.168.10.14", new NetworkDevice("ff:ff:ff:87:b6:14", "192.168.10.14", 3));  
  39.             subnetIpDevices.put("192.168.10.15", new NetworkDevice("ff:ff:ff:87:b6:15", "192.168.10.15", 3));  
  40.             subnetIpDevices.put("192.168.10.16", new NetworkDevice("ff:ff:ff:87:b6:16", "192.168.10.16", 3));  
  41.             subnetIpDevices.put("192.168.10.17", new NetworkDevice("ff:ff:ff:87:b6:17", "192.168.10.17", 3));  
  42.   
  43.             subnetIpDevices.put("192.168.10.89", new NetworkDevice("f0:8a:28:00:03:89", "192.168.10.89", 2));  
  44.             subnetIpDevices.put("192.168.10.196", new NetworkDevice("f0:8a:28:00:03:96", "192.168.10.196", 2));  
  45.             subnetIpDevices.put("192.168.10.198", new NetworkDevice("f0:8a:28:00:03:98", "192.168.10.198", 2));  
  46.               
  47.   
  48.               
  49.             //init subnetMacDevices  
  50.             for(Entry<String, NetworkDevice> entry : subnetIpDevices.entrySet()){  
  51.                 subnetMacDevices.put(entry.getValue().getMacAddress(), entry.getValue());  
  52.             }  
  53.             //init subnetIpSwitchs  
  54.             for(Entry<String, NetworkDevice> entry : subnetIpDevices.entrySet()){  
  55.                 if(entry.getValue().getDeviceType() == 2){  
  56.                     subnetIpSwitchs.put(entry.getKey(), entry.getValue());  
  57.                 }  
  58.             }  
  59.               
  60.             //init subnetMacSwitchs  
  61.             for(Entry<String, NetworkDevice> entry : subnetMacDevices.entrySet()){  
  62.                 if(entry.getValue().getDeviceType() == 2){  
  63.                     subnetMacSwitchs.put(entry.getKey(), entry.getValue());  
  64.                 }  
  65.             }  
  66.               
  67.             //  
  68.               
  69. //          check();  
  70.             //根据子网在线设备数初始化TreeNode数组  
  71.             nodes = new TreeNode[subnetIpDevices.size()];  
  72.               
  73.             subnetSwitchsNextMacs = new HashMap<>();  
  74.             //get subnet switchs port mac set  
  75.             for(Entry<String, NetworkDevice> entry : subnetIpSwitchs.entrySet()){  
  76.                   
  77.                 Set<String> set = getSwitchPortMac(entry.getKey());  
  78.                 subnetSwitchsNextMacs.put(entry.getKey(), set);  
  79.                   
  80.             }  
  81.               
  82.             nodes[0] = new TreeNode(gatewayId, 0, gatewayIp, true, "../../../css/zTreeStyle/img/diy/gateway1.png");  
  83.               
  84.             //--------------------------------------用于测试用的数据的构造 end------------------------------------//  
  85.               
  86. //          checkSwitchMac(switchsNextMacs);  
  87.               
  88.             //循环生成拓扑结构树，每生成一个分支，就把该分支删除掉，直到将网关下所有分支全部生成完毕  
  89.             while(subnetSwitchsNextMacs.size() > 0){  
  90.                 generateNodeTree(gatewayIp,subnetSwitchsNextMacs);  
  91.             }  
  92.               
  93.             //展示生成的节点，这里的数据就可以用来生成树需要的json数据了，用类似于gson的工具可以直接生成  
  94.             for(TreeNode node : nodes){  
  95.                 try{  
  96.                     System.out.println("id:"+node.getId()+"  pId:"+node.getpId()+"  isOpen:"+node.isOpen());  
  97.                 }catch (Exception e){  
  98.                     break;  
  99.                 }  
  100.             }  
  101.               
  102. //          for(Entry<String, Set<String>> entry : subnetSwitchsNextMacs.entrySet()){  
  103. //              System.out.println(entry.getKey());  
  104. //          }  
  105.               
  106.               
  107.         }  
  108.           
  109.         /** 
  110.          * 这个方法采用了递归 
  111.          * 我们是通过snmp获取的交换机下挂设备mac地址，获取的下挂设备的mac地址集合包括所有的直连设备（包括交换机和其他设备）和直连设备下挂设备的mac地址的集合 
  112.          * 给上面的话举个例子交换机1下挂交换机2、3，和设备a，2下挂设备b，则1下挂设备2、3、a、b，2下挂设备b，3则没有下挂设备，如果设备b也是交换机， 
  113.          * 下挂了c、d，则c和d既属于1，也属于2 
  114.          * 这里也可以看出父节点的下挂设备包含了子节点和子节点的下挂设备，所有父节点下挂设备一定比子节点下挂设备多 
  115.          * @param parentIp 父节点的ip（父节点可以是网关或交换机） 
  116.          * @param switchsNextMacs 父节点下的所有支持snmp的交换机及交换机下挂的设备的mac  地址Map<String（交换机IP）,Set<String>（交换机下挂设备的mac地址集合）> 
  117.          *  
  118.          * 基于上面的限定，我们首先要得出一个结论，即拥有最多下挂设备的交换机一定是parentIp的直接子节点， 
  119.          * 这个可以反证一个，如果不是直接子节点的话那么它和parentIp直接一定还有其他交换机，即它的父节点，但是根据上面的限定，子节点的下挂设备不可能大于父节点的下挂设备 
  120.          *  
  121.          * 首先以默认网关为父节点，找到下挂设备最多的交换机，这样这个交换机就可以确定是跟默认网关直连的了，然后再看这个交换机下的所有下挂设备是否包含交换机，如果包含则 
  122.          * 将这个交换机作为parentIp，将所有下挂的交换机作为switchsNextMacs，再次调用自身，直到没有下挂交换机为止 
  123.          */  
  124.         private static void generateNodeTree(String parentIp,Map<String,Set<String>> switchsNextMacs){  
  125.             //找出所有交换机中下挂设备最多的一个交换机  
  126.             String maxSwitchIp = getNextMaxSwitchIp(switchsNextMacs);  
  127.               
  128.             Set<String> parentSet = null;  
  129.             if(subnetSwitchsNextMacs.containsKey(parentIp)){  
  130.                 //获取当前处理的交换机的父设备的所有下挂设备  
  131.                 parentSet = subnetSwitchsNextMacs.get(parentIp);  
  132.                 //默认网关不支持snmp，无法获取所有下挂设备  
  133.                 if(null != parentSet){  
  134.                     //将当前处理的交换机从父设备的下挂设备中剔除，直到剔除干净，才算处理完了父设备  
  135.                     //@@标记A  
  136.                     parentSet.remove(subnetIpDevices.get(maxSwitchIp).getMacAddress());  
  137.                 }  
  138.             }  
  139.             //利用上面结论，这个下挂设备最多的交换机是parentIp直连的，生成节点数据  
  140.             nodes[nodeIndex] = new TreeNode(getDeviceIp(maxSwitchIp), getDeviceIp(parentIp), maxSwitchIp, true, "../../../css/zTreeStyle/img/diy/switch1.png");  
  141.             nodeIndex++;  
  142.               
  143.             //获取当前处理的有最多下挂设备的交换机的所有下挂设备  
  144.             Set<String> nextMacs = subnetSwitchsNextMacs.get(maxSwitchIp);  
  145.               
  146.             //<ip,Set<mac>> 用于存储当前处理的有最多下挂设备的交换机的下挂交换机  
  147.             Map<String,Set<String>> nextMap = new HashMap<>();  
  148.               
  149.             for(String mac : nextMacs){  
  150.                 if(subnetMacDevices.containsKey(mac) && subnetMacDevices.get(mac).getDeviceType() == 2){  
  151.                     String switchIp = subnetMacDevices.get(mac).getIpAddress();  
  152.                     nextMap.put(switchIp,switchsNextMacs.get(switchIp));  
  153.                     //把是当前处理的有最多下挂设备的交换机的所有下挂交换机从它的父交换机的下挂设备中清除，  
  154.                     //这样当回到处理父交换机时就不用再处理这些肯定不是跟她直连的交换机了  
  155.                     if(null != parentSet){  
  156.                         parentSet.remove(mac);  
  157.                     }  
  158.                 }  
  159.             }  
  160.   
  161.             while(nextMap.size() > 0){  
  162. //              System.out.println("maxSwitchIp:"+maxSwitchIp+"  nextMap size:"+nextMap.size());  
  163.                 //当下挂交换机的数量大于0时递归调用自己  
  164.                 generateNodeTree(maxSwitchIp,nextMap);  
  165.                   
  166.                 //调用完成后重新获取当前处理交换机的下挂交换机，如果还大于0继续  
  167.                 //交换机的剔除是在@@标记A处调用的  
  168.                 nextMap.clear();  
  169.   
  170.                 for(String mac : nextMacs){  
  171.                     if(subnetMacDevices.containsKey(mac) && subnetMacDevices.get(mac).getDeviceType() == 2){  
  172.                         String switchIp = subnetMacDevices.get(mac).getIpAddress();  
  173.                         nextMap.put(switchIp,switchsNextMacs.get(switchIp));  
  174.                     }  
  175.                 }  
  176.             }  
  177.   
  178.             //进入到这里代表当前处理的交换机已经没有下挂交换机了，可以把其他的下挂设备生成节点数据了，  
  179.             //要注意的是：因为父节点包含子节点和子节点的所有子节点，所有有些子节点的下挂设备已经生成过了，存储在hasNodeComputerMac里面的  
  180.             //把子节点的下挂设备剔除掉就是当前交换机自己的下挂设备啦  
  181.             for(String mac : nextMacs){  
  182.                 if(subnetMacDevices.containsKey(mac) && !hasNodeComputerMac.contains(mac)){  
  183.                     String computerIp = subnetMacDevices.get(mac).getIpAddress();;  
  184.                     nodes[nodeIndex] = new TreeNode(getDeviceIp(computerIp), getDeviceIp(maxSwitchIp), computerIp, "../../../css/zTreeStyle/img/diy/computer1.png");  
  185.                     hasNodeComputerMac.add(mac);  
  186.                     nodeIndex++;  
  187.                 }  
  188.             }  
  189.               
  190.             //最后把自己从需要处理的交换机集合中剔除掉就行了  
  191.             subnetSwitchsNextMacs.remove(maxSwitchIp);  
  192.         }  
  193.           
  194.           
  195.         //找出所有交换机中下挂设备最多的一个交换机  
  196.         private static String getNextMaxSwitchIp(Map<String,Set<String>> switchsNextMacs){  
  197.             int maxCount = -1;  
  198.             String maxSwitchIp = null;  
  199.             for(Entry<String, Set<String>> entry : switchsNextMacs.entrySet()){  
  200.                 if(entry.getValue().size() > maxCount){  
  201.                     maxCount = entry.getValue().size();  
  202.                     maxSwitchIp = entry.getKey();  
  203.                 }  
  204.             }  
  205.             return maxSwitchIp;  
  206.         }  
  207.           
  208.         private static Set<String> getSwitchPortMac(String targetIp){  
  209.               
  210.             Set<String> result = new HashSet<>();  
  211.             switch (targetIp) {  
  212.             case "192.168.10.89":  
  213.                 result.add("ff:ff:ff:87:b6:14");  
  214.                 result.add("ff:ff:ff:87:b6:15");  
  215.                 break;  
  216.             case "192.168.10.196":  
  217.                 result.add("ff:ff:ff:87:b6:16");  
  218.                 result.add("ff:ff:ff:87:b6:17");  
  219.                 result.add("f0:8a:28:00:03:98");  
  220.                 break;  
  221.             case "192.168.10.198":  
  222.                 result.add("ff:ff:ff:87:b6:16");  
  223.                 break;  
  224.             default:  
  225.                 break;  
  226.             }  
  227.               
  228.             return result;  
  229.               
  230.         }  
  231.           
  232.         public static float getDeviceIp(String deviceIp){  
  233.             String[] strs = deviceIp.split("\\.");  
  234.             float f = Float.parseFloat(strs[3]);  
  235.             return f;  
  236.         }  
  237. }  

NetworkDevice类

[java]  view plain  copy
  1. public class NetworkDevice {  
  2.   
  3.     private String macAddress;  
  4.     private String ipAddress;  
  5.     //1:default gateway  2:switch  3:computer  
  6.     private int deviceType;  
  7.       
  8.     public NetworkDevice(){  
  9.           
  10.     }  
  11.       
  12.     public NetworkDevice(String macAddress, String ipAddress) {  
  13.         super();  
  14.         this.macAddress = macAddress;  
  15.         this.ipAddress = ipAddress;  
  16.     }  
  17.       
  18.     public NetworkDevice(String macAddress, String ipAddress, int type){  
  19.         super();  
  20.         this.macAddress = macAddress;  
  21.         this.ipAddress = ipAddress;  
  22.         this.deviceType = type;  
  23.     }  
  24.       
  25.     public String getMacAddress() {  
  26.         return macAddress;  
  27.     }  
  28.     public void setMacAddress(String macAddress) {  
  29.         this.macAddress = macAddress;  
  30.     }  
  31.     public String getIpAddress() {  
  32.         return ipAddress;  
  33.     }  
  34.     public void setIpAddress(String ipAddress) {  
  35.         this.ipAddress = ipAddress;  
  36.     }  
  37.   
  38.     public int getDeviceType() {  
  39.         return deviceType;  
  40.     }  
  41.   
  42.     public void setDeviceType(int deviceType) {  
  43.         this.deviceType = deviceType;  
  44.     }  
  45.       
  46.       
  47. }  

TreeNode类（这个是为了展示用的，我为了方便用的zTree做的展示）

[java]  view plain  copy
  1. public class TreeNode {  
  2.       
  3.     private float id;  
  4.     private float pId;  
  5.     private String name;  
  6.     private boolean open;  
  7.     private String icon;  
  8.     public TreeNode(){  
  9.           
  10.     }  
  11.       
  12.       
  13.     public TreeNode(float id, float pId, String name, String icon) {  
  14.         super();  
  15.         this.id = id;  
  16.         this.pId = pId;  
  17.         this.name = name;  
  18.         this.icon = icon;  
  19.     }  
  20.   
  21.   
  22.     public TreeNode(float id, float pId, String name, boolean open, String icon) {  
  23.         super();  
  24.         this.id = id;  
  25.         this.pId = pId;  
  26.         this.name = name;  
  27.         this.open = open;  
  28.         this.icon = icon;  
  29.     }  
  30.   
  31.   
  32.     public float getId() {  
  33.         return id;  
  34.     }  
  35.     public void setId(float id) {  
  36.         this.id = id;  
  37.     }  
  38.     public float getpId() {  
  39.         return pId;  
  40.     }  
  41.     public void setpId(float pId) {  
  42.         this.pId = pId;  
  43.     }  
  44.     public String getName() {  
  45.         return name;  
  46.     }  
  47.     public void setName(String name) {  
  48.         this.name = name;  
  49.     }  
  50.     public boolean isOpen() {  
  51.         return open;  
  52.     }  
  53.     public void setOpen(boolean open) {  
  54.         this.open = open;  
  55.     }  
  56.     public String getIcon() {  
  57.         return icon;  
  58.     }  
  59.     public void setIcon(String icon) {  
  60.         this.icon = icon;  
  61.     }  
  62.       
  63.       
  64.       
  65. }  

最后大家可以根据测试类最后打印的结果得到一棵树，以此作为判断是否成功，最后贴一张在测试网络中发现的拓扑图，用的zTree做的展示



结语

到这里就算把子网内的拓扑发现讲完了，在实现的过程中也碰到过一些问题，更发现有更多的网络知识需要掌握，后面我会把遇到的问题整理出来，还有因为这个程序是要给一位用c#的同事调用的，所以后面也会讲把java通过ikvm打包成dll供c#调用（网上查的好多说不能包含第三方jar包或者调用native方法的，实践下来是可以的）。
以上这些过程都是我闭门造车出来的，难免有理解不当或错误的地方，全部写完也发现占用了很大的篇幅，其实内容就提纲的那么几步，希望大家能有耐心看完，最好能够讨论指正。
wh8_2011
关注
  • 9
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
基于SNMP和Java的网络拓扑发现
11-30
现代计算机网络迅猛发展，网络管理的任务也日趋复杂，而保证网络管理系统高效运行的基础正是网络拓扑发现。网络拓扑表现为计算机网络中各设备之间的连接关系。网络拓扑发现更能提高网络故障管理、计量管理、配置和名称管理、性能管理和安全管理的性能，其原理是利用协议收集网络中各设备的信息，通过某种算法生成完整的拓扑结构显示出来。本文介绍的就是基于SNMP协议的网络拓扑发现
java snmp全面开发解决方案（web service snmp网关、代理snmp网关、网络拓扑发现等）...
dfoungjava的专栏
12-09 1055
    ObjectSNMP是一个面向对象的SNMP开发组件，与关系数据库流行的O-R Mapping技术类似，实现了Object到SNMP MIB的操作映射（简称O-M Mapping），系统提供了Java/SNMP网关、RMI/SNMP网关 、Web Service/SNMP网关服务。开发者无需理解SNMP协议和MIB细节，只需要定义普通数据对象，然后将数据对象按添加、删除、修改、查询等模式提...
Java实现拓扑排序
最新发布
m0_74366279的博客
06-05 87
【代码】Java实现拓扑排序。
java和SNMP技术的网络拓扑发现和物理拓扑发现入门
dfoungjava的专栏
12-09 1740
    ObjectSNMP是一个面向对象的SNMP开发组件，与关系数据库流行的O-R Mapping技术类似，实现了Object到SNMP MIB的操作映射（简称O-M Mapping），系统提供了Java/SNMP网关、RMI/SNMP网关 、Web Service/SNMP网关服务、代理SNMP网关、 网络拓扑发现、物理拓扑发现、网络自动搜索发现 、设备连接关系发现、设备类型发现、网络漫游搜...
基于SNMP和JAVA的网路拓扑发现
08-25
一个介绍基于SNMP和JAVA的网路拓扑发现的论文，内容很短，适合用来了解思想
基于SNMP的网络拓扑发现.doc
03-11
基于SNMP的网络拓扑发现 一、 SNMP简介 SNMP（Simple Network Management Protocol，简单网络管理协议）是一种基于TCP/IP协议的互连网管理协议。 SNMP诞生于1988年，当时只想把它作为一个短期的网络管理框架，临时用于管理连接到Internet上的设备。但随着SNMP的发展和大量应用，其使用范围已大为扩展，超出了Internet的范围。SNMP逐渐作为一种标准的协议在网络管理领域得到了普遍的接受和支持，成为了事实上的国际标准。 SNMP采用“管理进程/代理进程”模型来监视和控制各种可管理网络设备。其核心思想是在每个网络节点上设置一个管理信息库MIB（Manage Information Base），由节点上的代理负责维护，管理进程通过应用层协议对这些信息库进行访问。 图3.1说明了SNMP网络管理框架的一般体系结构，它由四个主要部件构成，分别是：通信网络、网络协议、网络管理进程和被管网络实体。
基于SNMP协议的网络拓扑发现程序
04-14
基于SNMP协议的网络拓扑发现程序，有代码，C++语言。 操作界面十分简单，只有“开始探测”，“设置参数”和“群Ping”三个功能，分别对应“空格”，“S”和“P”三个快捷键，其中设置参数功能提供更改参数设置的...
niubi.rar_Niubi!_snmp java 拓扑_snmp 拓扑_snmp 拓扑发现_snmp拓扑
09-14
综上所述，"niubi.rar"包含的Java SNMP拓扑发现程序是网络管理的利器，结合SNMP协议的强大功能和Java的灵活性，为网络运维提供了一种高效、智能的解决方案。通过使用这款工具，网络管理员可以更轻松地管理和优化网络...
63535293SNMP.rar_snmp java 拓扑_snmp 发现_snmp 拓扑_snmp 拓扑发现_snmp拓扑
07-14
基于snmp协议的网络拓扑结构发现程序，以一个路由器作为起点开始搜索，输入路由器的IP 地址后，可以发现与之相连的其他网络设备，并得出其本的拓扑结构图。同时也可以得到路由器的系统信息，路由表及子网结构。
基于SNMP的网络拓扑发现 -------------
05-21
基于SNMP的网络拓扑发现 - 我的未来不是梦！ - JavaEye技术网站.files基于SNMP的网络拓扑发现 - 我的未来不是梦！ - JavaEye技术网站.files
基于SNMP的网络拓扑探测器
05-07
用C++实现基于SNMP的网络拓扑探测器 界
基于SNMP和Java的网络拓扑发现.kdh
07-23
基于SNMP和Java的网络拓扑发现.kdh
Snmp拓扑结构php,基于SNMP的网络拓扑结构生成
weixin_30000283的博客
03-27 1039
一、 论计题目:基于SNMP的网络拓扑结构生成二、 设计目标:利用SNMP协议分析MIB库中的路由表、接口表等有关变量,从而得到网络拓扑图的有关信息。最后，以VC为工具.构造网络拓扑图。三、 要解决的主要问题:在网络拓扑的构成过程中,会涉及这样几个问题:(1) 在实际网络系统中会涉及到不同的设备平台,彼此之间有不同的信息表示格式,如何...
java 拓扑发现_拓扑发现1
weixin_32256355的博客
02-12 963
网络拓扑自动发现-智能网管软件的基础网络拓扑作为一种表示网络设备逻辑连接与物理连接之间关系的方法，通过它网络管理员可以很直观地掌握当前网络设备的运行状况，准确定位网络中的故障点，并对准确分析网络中存在的问题提供基础数据，从而有针对性地优化网络，提高网络的性能。可以说,网络拓扑的自动发现是实现智能网络管理系统的技术关键，是构成智和网管软件的基础.拓扑发现原理目前有多种网络拓扑发现方法，包括：(1)...
使用 Python SNMP (LLDP) SQLite3 vis.js自动绘制网络拓扑图
allway2的博客
11-17 4753
import argparse import itertools import os import pprint import sqlite3 import sys import pysnmp.hlapi as hlapi import pysnmp.proto.rfc1902 as rfc1902 from pysnmp.hlapi import * NEIGHBOUR_PORT_OID = '1.0.8802.1.1.2.1.4.1.1.8.0' NEIGHBOUR_NAME_OID = '1.0.
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值