Udp接收和发送

目的：

    某现场设备厂家通过snmp协议发送告警到网管侧设备上，网管snmp采集程序接收不到告警，通过抓包命令能看到网卡上有告警，snmp协议版本为V2.

    1）从网卡上抓包日志中读取二进制内容发送到某机器端口；

    2）通过Udp接收程序从机器端口接收告警；

接收端代码

1. package com.udp;
3. import java.io.File;
4. import java.io.FileOutputStream;
5. import java.io.FileWriter;
6. import java.io.IOException;
7. import java.net.DatagramPacket;
8. import java.net.DatagramSocket;
9. import java.text.SimpleDateFormat;
10. import java.util.Date;
12. /**
13. * UDP接收
14. *
15. * 可用下面方式运行到Unxi/Linux环境
16. * a）程序目录情况
17. * udptest
18. * |--start.sh
19. * |--udpreceive.jar
20. * b）程序启停
21. * 启动 ./start.sh
22. * 停止 ps -ef | grep "program.name=UdpReceiver"|grep -v grep|awk '{print $2}'|xargs -i kill -9 {}
23. * c）脚本start.sh内容如下
24. #!/bin/sh
26. JARS="./udpreceive.jar"
27. export JARS
29. lintenPort=1622
30. nohup java -Dprogram.name=UdpReceiver -Dfile.encoding=GBK -cp $JARS com.boco.util.UdpReceiver $lintenPort &
31. *
32. * @author DAL.feng
33. *
34. */
35. public class UdpReceiver {
37. public static final int DEFAULT_LINSTEN_PORT = 1622;
39. private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
40. private static String home = "";
42. public static void main(String[] args) {
43. System.out.println("UdpReceiver is start ...");
44. receive(args);
45. System.out.println("UdpReceiver is end!");
46. }
48. private static void receive(String[] args) {
49. int linstenPort = init(args);
50. System.out.println("linstening port : " + linstenPort);
52. try {
53. DatagramSocket udp = new DatagramSocket(linstenPort);
54. udp.setSoTimeout(10);
56. boolean isRun = true;
57. long count = 1;
58. while(isRun) {
59. work(udp, count);
60. count ++;
61. }
63. } catch (Exception e) {
64. // TODO Auto-generated catch block
65. e.printStackTrace();
66. }
67. }
69. /**
70. * 启动参数第一个是udp接收的监听端口
71. * @param args
72. * @return
73. */
74. private static int init(String[] args) {
75. if(args == null || args.length < 1) {
76. return DEFAULT_LINSTEN_PORT;
77. }
78. return Integer.parseInt(args[0].trim());
79. }
81. /**
82. * 循环内的一次执行动作；
83. * @param udp
84. * @param count 动作执行次数
85. */
86. private static void work(DatagramSocket udp, long count) {
87. try {
88. DatagramPacket packet = receive0(udp);
89. if(packet == null) {
90. if(count % 6 == 1) {
91. System.out.println(sdf.format(new Date()) + " --- no data");
92. }
93. Thread.sleep(1000);
95. } else {
96. byte[] receiveData = packet.getData();
97. int dataLength = packet.getLength();
98. String result = new String(receiveData, 0, dataLength);
99. result = result.trim();
100. System.out.println("receive length:" + packet.getLength());
102. if(result.length() > 0) {
103. System.out.println("receive data:" + result);
104. }
106. saveFile(receiveData, dataLength);
108. packet = null;
109. }
111. } catch (Exception e) {
112. // TODO Auto-generated catch block
113. e.printStackTrace();
114. }
115. }
117. /**
118. * 从监听端口读取数据，有超时设置，默认10ms，如果无数据则返回null
119. * @param udp
120. * @return
121. */
122. private static DatagramPacket receive0(DatagramSocket udp) {
123. byte[] buf = new byte[10240];
124. DatagramPacket packet = new DatagramPacket(buf, buf.length);
125. try {
126. udp.receive(packet);
128. } catch (Exception e) {
129. // e.printStackTrace();
130. packet = null;
131. }
133. return packet;
134. }
136. private static void saveFile(byte[] result, int length) {
137. String filepath = getHome() + System.currentTimeMillis() + ".data";
138. try {
139. FileOutputStream f = new FileOutputStream(filepath);
140. f.write(result, 0, length);
141. f.flush();
142. System.out.println("save file: " + filepath);
144. f.close();
146. } catch (Exception e) {
147. // TODO Auto-generated catch block
148. e.printStackTrace();
149. }
151. }
153. private static String getHome() {
154. if(home == null || "".equals(home)) {
155. File f = new File("");
156. String home0 = f.getAbsolutePath();
157. System.out.println(home0);
158. home = home0.endsWith("/") ? home0 : home0+"/";
159. }
160. return home;
161. }
162. }

从文件读取二进制内容发送到Udp端口

1. package com.udp;
3. import java.io.FileInputStream;
4. import java.net.DatagramPacket;
5. import java.net.DatagramSocket;
6. import java.net.InetAddress;
8. import junit.framework.TestCase;
10. public class UdpLiteTest extends TestCase {
12. protected void setUp() throws Exception {
13. super.setUp();
14. }
16. public void testSendUdpLite() {
17. String targetHost = "10.10.1.162";
18. // String targetHost = "127.0.0.1";
19. int targetPort = 1625;
21. try {
22. // 初始化udp，采用随机端口
23. DatagramSocket udp = new DatagramSocket();
24. // 初始化数据包，里面包含了数据byte[]，目的地址，和目的端口，数据发送到哪，完全由数据包中目的地址和端口决定
25. DatagramPacket data = new DatagramPacket(new byte[0], 0, InetAddress.getByName(targetHost), targetPort);
26. // 读数据
27. data.setData(readSnmpData());
28. // 读心跳
29. // data.setData(readSnmpHeart());
30. // data.setData(readSnmpClient());
31. // 读其他模拟程序发的snmp内容，这个是一个完整的snmp样例
32. data.setData(readSnmpRealLong());
34. udp.send(data);
35. System.out.println("send finish");
37. } catch (Exception e) {
38. // TODO Auto-generated catch block
39. e.printStackTrace();
40. }
41. }
43. private byte[] readSnmpData() {
44. String snoopResultPath = "d:/03-Run/snmp/1009-1";
45. // int snmpLength = 2783;
46. int snmpLength = 1472;
47. int start = 0x850 + 10;
49. return readSnmp0(snoopResultPath, snmpLength, start);
50. }
52. private byte[] readSnmpHeart() {
53. String snoopResultPath = "d:/03-Run/snmp/1009-1";
54. int snmpLength = 187;
55. int start = 0x650 + 10;
57. return readSnmp0(snoopResultPath, snmpLength, start);
58. }
60. private byte[] readSnmpClient() {
61. String snoopResultPath = "d:/03-Run/snmp/soo7";
62. int snmpLength = 1176;
63. int start = 0x50 + 2;
65. return readSnmp0(snoopResultPath, snmpLength, start);
66. }
68. private byte[] readSnmpRealLong() {
69. String snoopResultPath = "d:/03-Run/snmp/1622-2.pcap";
70. int snmpLength = 3041;
71. int start = 0x50 + 2;
73. return readSnmp0(snoopResultPath, snmpLength, start);
74. }
76. private byte[] readSnmp0(String snoopFilepath, int readLength, int startIndex) {
77. String snoopResultPath = snoopFilepath;
78. int snmpLength = readLength;
79. int start = startIndex;
80. byte[] content = new byte[snmpLength];
81. try {
82. FileInputStream is = new FileInputStream(snoopResultPath);
83. // 先将起始位置之前的字节给去掉
84. is.skip(start);
85. is.read(content, 0, snmpLength);
86. System.out.println("------ content:" + new String(content));
88. // content = "ssss".getBytes();
89. is.close();
91. } catch (Exception e) {
92. // TODO Auto-generated catch block
93. e.printStackTrace();
94. }
95. return content;
96. }
98. }

来自为知笔记(Wiz)

附件列表

 

转载于:https://my.oschina.net/u/1997676/blog/402380