Merge branch 'betschwa-v1' into v1

kaitoy · Mar 7, 2017 · 7cfda7c · 7cfda7c
2 parents c301599 + 0ced990
commit 7cfda7c
Show file tree

Hide file tree

Showing 4 changed files with 154 additions and 3 deletions.
diff --git a/CHANGES.md b/CHANGES.md
@@ -3,6 +3,7 @@ Future
 ### New Features ###
 * Support DNS (RFC1035 and RFC3596)
 * [PR#84](https://github.com/kaitoy/pcap4j/pull/84): Support bpf applying. (Add BpfProgram#applyFilter().)
+* [PR#89](https://github.com/kaitoy/pcap4j/pull/89): Add PcapHandle#sendPacket(byte[] bytes, int len).
 
 ### Bug Fixes ###
 * [Issues#76](https://github.com/kaitoy/pcap4j/issues/76): NullPointerException when dissecting an ICMP error packet.

diff --git a/pcap4j-core/src/main/java/org/pcap4j/core/PcapHandle.java b/pcap4j-core/src/main/java/org/pcap4j/core/PcapHandle.java
@@ -1,6 +1,6 @@
 /*_##########################################################################
   _##
-  _##  Copyright (C) 2011-2015  Pcap4J.org
+  _##  Copyright (C) 2011-2017  Pcap4J.org
   _##
   _##########################################################################
 */
@@ -1208,6 +1208,18 @@ public void sendPacket(Packet packet) throws PcapNativeException, NotOpenExcepti
    * @throws NullPointerException if any of arguments are null.
    */
   public void sendPacket(byte[] bytes) throws NotOpenException, PcapNativeException {
+    sendPacket(bytes, bytes.length);
+  }
+
+  /**
+   *
+   * @param bytes raw bytes
+   * @param len length
+   * @throws PcapNativeException if an error occurs in the pcap native library.
+   * @throws NotOpenException if this PcapHandle is not open.
+   * @throws NullPointerException if any of arguments are null.
+   */
+  public void sendPacket(byte[] bytes, int len) throws NotOpenException, PcapNativeException {
     if (bytes == null) {
       throw new NullPointerException("bytes may not be null");
     }
@@ -1224,7 +1236,7 @@ public void sendPacket(byte[] bytes) throws NotOpenException, PcapNativeExceptio
         throw new NotOpenException();
       }
 
-      int rc = NativeMappings.pcap_sendpacket(handle, bytes, bytes.length);
+      int rc = NativeMappings.pcap_sendpacket(handle, bytes, len);
       if (rc < 0) {
         throw new PcapNativeException(
                 "Error occured in pcap_sendpacket(): " + getError(),

diff --git a/pcap4j-core/src/test/java/org/pcap4j/core/PcapHandleTest.java b/pcap4j-core/src/test/java/org/pcap4j/core/PcapHandleTest.java
@@ -5,6 +5,10 @@
 import java.io.EOFException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.TimeUnit;
 
 import org.junit.After;
 import org.junit.AfterClass;
@@ -19,7 +23,9 @@
 import org.pcap4j.packet.IcmpV4EchoReplyPacket;
 import org.pcap4j.packet.Packet;
 import org.pcap4j.packet.UdpPacket;
+import org.pcap4j.packet.UnknownPacket;
 import org.pcap4j.packet.namednumber.DataLinkType;
+import org.pcap4j.util.ByteArrays;
 
 @SuppressWarnings("javadoc")
 public class PcapHandleTest {
@@ -317,4 +323,133 @@ public void testSetFilterUdp() throws Exception {
     }
   }
 
+  @Test
+  public void testSendPacket() throws Exception {
+    if (System.getenv("TRAVIS") != null) {
+      // run only on Travis CI
+      PcapNetworkInterface nif = Pcaps.getDevByName("lo");
+      final PcapHandle handle = nif.openLive(65536, PromiscuousMode.PROMISCUOUS, 10);
+      byte[] sendingRawPacket = new byte[50];
+      sendingRawPacket[0] = 1;
+      sendingRawPacket[1] = 2;
+      sendingRawPacket[2] = 3;
+      sendingRawPacket[3] = 4;
+      sendingRawPacket[4] = 5;
+      Packet sendingPacket = UnknownPacket.newPacket(sendingRawPacket, 0, sendingRawPacket.length);
+
+      ExecutorService pool = Executors.newSingleThreadExecutor();
+      final byte[] result = new byte[sendingRawPacket.length];
+      final FutureTask<byte[]> future
+        = new FutureTask<byte[]>(
+            new Runnable() {
+
+              @Override
+              public void run() {}
+
+            },
+            result
+          );
+      pool.execute(
+        new Runnable() {
+
+          @Override
+          public void run() {
+            try {
+              handle.loop(
+                -1,
+                new RawPacketListener() {
+
+                  @Override
+                  public void gotPacket(byte[] p) {
+                    if (p[0] == 1 && p[1] == 2 && p[2] == 3 && p[3] == 4 && p[4] == 5) {
+                      assertEquals(result.length, p.length);
+                      System.arraycopy(p, 0, result, 0, result.length);
+                      future.run();
+                    }
+                  }
+
+                }
+              );
+            } catch (PcapNativeException e) {
+            } catch (InterruptedException e) {
+            } catch (NotOpenException e) {
+            }
+          }
+
+        }
+      );
+
+      Thread.sleep(1000);
+      handle.sendPacket(sendingPacket);
+      future.get(5, TimeUnit.SECONDS);
+      handle.breakLoop();
+      handle.close();
+      assertArrayEquals(sendingRawPacket, result);
+    }
+  }
+
+  @Test
+  public void testSendPacketWithLen() throws Exception {
+    if (System.getenv("TRAVIS") != null) {
+      // run only on Travis CI
+      PcapNetworkInterface nif = Pcaps.getDevByName("lo");
+      final PcapHandle handle = nif.openLive(65536, PromiscuousMode.PROMISCUOUS, 10);
+      byte[] sendingRawPacket = new byte[100];
+      sendingRawPacket[0] = 1;
+      sendingRawPacket[1] = 2;
+      sendingRawPacket[2] = 3;
+      sendingRawPacket[3] = 4;
+      sendingRawPacket[4] = 5;
+
+      ExecutorService pool = Executors.newSingleThreadExecutor();
+      final byte[] result = new byte[50];
+      final FutureTask<byte[]> future
+        = new FutureTask<byte[]>(
+            new Runnable() {
+
+              @Override
+              public void run() {}
+
+            },
+            result
+          );
+      pool.execute(
+        new Runnable() {
+
+          @Override
+          public void run() {
+            try {
+              handle.loop(
+                -1,
+                new RawPacketListener() {
+
+                  @Override
+                  public void gotPacket(byte[] p) {
+                    if (p[0] == 1 && p[1] == 2 && p[2] == 3 && p[3] == 4 && p[4] == 5) {
+                      assertEquals(result.length, p.length);
+                      System.arraycopy(p, 0, result, 0, result.length);
+                      future.run();
+                    }
+                  }
+
+                }
+              );
+            } catch (PcapNativeException e) {
+            } catch (InterruptedException e) {
+            } catch (NotOpenException e) {
+            }
+          }
+
+        }
+      );
+
+      Thread.sleep(1000);
+      handle.sendPacket(sendingRawPacket, result.length);
+      future.get(5, TimeUnit.SECONDS);
+      handle.breakLoop();
+      handle.close();
+      assertArrayEquals(ByteArrays.getSubArray(sendingRawPacket, 0, result.length), result);
+    }
+  }
+
 }
diff --git a/www/api_mappings.md b/www/api_mappings.md
@@ -159,12 +159,15 @@ Mapping between pcap API and Pcap4j API
     <td>void org.pcap4j.core.BpfProgram.free()</td>
   </tr>
   <tr>
-    <td rowspan="2">int pcap_sendpacket(pcap_t *, const u_char *, int)</td>
+    <td rowspan="3">int pcap_sendpacket(pcap_t *, const u_char *, int)</td>
     <td>void org.pcap4j.core.PcapHandle.sendPacket(Packet)</td>
   </tr>
   <tr>
     <td>void org.pcap4j.core.PcapHandle.sendPacket(byte[])</td>
   </tr>
+  <tr>
+    <td>void org.pcap4j.core.PcapHandle.sendPacket(byte[], int)</td>
+  </tr>
   <tr>
     <td>void pcap_close(pcap_t *)</td>
     <td>void org.pcap4j.core.PcapHandle.close()</td>