Changeset 1547 for trunk/src/common/sendpacket.c

Timestamp:

07/29/06 17:46:31 (2 years ago)

Author:

aturner

Message:

change injection priority to reflect that pcap_* methods don't support
sendpacket_get_hwaddr() refs #4

Files:

• trunk/src/common/sendpacket.c (modified) (17 diffs)

trunk/src/common/sendpacket.c

@@ -39 +39 @@
  
  /* sendpacket.[ch] is my attempt to write a universal packet injection
-  * API for libpcap, libnet, and Linux's PF_PACKET.  I got sick
+  * API for BPF, libpcap, libnet, and Linux's PF_PACKET.  I got sick
   * and tired dealing with libnet bugs and its lack of active maintenence,
   * but unfortunately, libpcap frame injection support is relatively new 
-  * and not everyone uses Linux, so I decided to support all three as
+  * and not everyone uses Linux, so I decided to support all four as
   * best as possible.  If your platform/OS/hardware supports an additional
   * injection method, then by all means add it here (and send me a patch).
@@ -49 +49 @@
   * 1. PF_PACKET
   * 2. BPF
-  * 3. pcap_inject()
-  * 4. pcap_sendpacket()
-  * 5. libnet
-  * Once I get some Linux testing, I should move PF_PACKET to the top of the list
-  * as it is the most direct method.
+  * 3. libnet
+  * 4. pcap_inject()
+  * 5. pcap_sendpacket()
+  *
+  * Right now, one big problem with the pcap_* methods is that libpcap doesn't provide a 
+  * reliable method of getting the MAC address of an interface (required for tcpbridge).
+  * You can use PF_PACKET or BPF to get that, but if your system suports those, might
+  * as well inject directly without going through another level of indirection.
   * 
   * Please note that some of this code was copied from Libnet 1.1.3
@@ -81 +84 @@
 
 #if defined HAVE_PF_PACKET
-
 /* older versions of glibc require different headers */
 #if __GLIBC__ >= 2 && __GLIBC_MINOR >= 1
@@ -93 +95 @@
 
 static sendpacket_t *sendpacket_open_pf(const char *, char *);
-static struct tcpr_ether_addr *get_hwaddr_pf(sendpacket_t *);
+static struct tcpr_ether_addr *sendpacket_get_hwaddr_pf(sendpacket_t *);
 
 #elif defined HAVE_BPF
@@ -102 +104 @@
 
 static sendpacket_t *sendpacket_open_bpf(const char *, char *);
-static struct tcpr_ether_addr *get_hwaddr_bpf(sendpacket_t *);
+static struct tcpr_ether_addr *sendpacket_get_hwaddr_bpf(sendpacket_t *);
+
+#elif defined HAVE_LIBNET
+static sendpacket_t *sendpacket_open_libnet(const char *, char *);
+static struct tcpr_ether_addr *sendpacket_get_hwaddr_libnet(sendpacket_t *);
 
 #elif defined HAVE_PCAP_INJECT || defined HAVE_PACKET_SENDPACKET
 #include <pcap.h>
 static sendpacket_t *sendpacket_open_pcap(const char *, char *);
-static struct tcpr_ether_addr *get_hwaddr_pcap(sendpacket_t *);
-
-#elif defined HAVE_LIBNET
-static sendpacket_t *sendpacket_open_libnet(const char *, char *);
-static struct tcpr_ether_addr *get_hwaddr_libnet(sendpacket_t *);
+static struct tcpr_ether_addr *sendpacket_get_hwaddr_pcap(sendpacket_t *);
 #endif
 
@@ -130 +132 @@
 {
     int retcode;
-#if defined HAVE_PF_PACKET
-    struct sockaddr sa;
-#endif
+
 
     assert(sp);
@@ -140 +140 @@
         return -1;
                 
+TRY_SEND_AGAIN:
     sp->attempt ++;
-    
-TRY_SEND_AGAIN:
 
 #if defined HAVE_PF_PACKET 
-    memset(&sa, 0, sizeof(sa));
-    strlcpy(sa.sa_data, sp->device, sizeof(sa.sa_data));
     retcode = (int)sendto(sp->handle.fd, (void *)data, (size_t)len, 0, 
-        &sa, sizeof(struct sockaddr));
+        &sp->sa, sizeof(struct sockaddr));
     if (retcode < 0 && errno == ENOBUFS && !didsig) {
         sp->retry ++;
@@ -165 +162 @@
     }
     
+#elif defined HAVE_LIBNET
+    retcode = libnet_adv_write_link(sp->handle.lnet, (u_int8_t*)data, (u_int32_t)len);
+    if (retcode < 0 && errno == ENOBUFS && !didsig) {
+        sp->retry ++;
+        goto TRY_SEND_AGAIN;
+    } else if (retcode < 0) {
+        sendpacket_seterr(sp, "Error with libnet_adv_write_link: %s", libnet_geterror(sp->handle.lnet));
+    }
+
     /* 
      * pcap methods don't seem to support ENOBUFS, so we just straight fail
@@ -172 +178 @@
     if ((retcode = pcap_inject(sp->handle.pcap, (void*)data, len)) < 0)
         sendpacket_seterr(sp, "Error with pcap_inject(): %s", pcap_geterr(sp->handle.pcap));
-    
+
 #elif defined HAVE_PCAP_SENDPACKET
     if ((retcode = pcap_sendpacket(sp->handle.pcap, data, (int)len)) < 0)
         sendpacket_seterr(sp, "Error with pcap_sendpacket(): %s", pcap_geterr(sp->handle.pcap));
-
-#elif defined HAVE_LIBNET
-    retcode = libnet_adv_write_link(sp->handle.lnet, (u_int8_t*)data, (u_int32_t)len);
-    if (retcode < 0 && errno == ENOBUFS && !didsig) {
-        sp->retry ++;
-        goto TRY_SEND_AGAIN;
-    } else if (retcode < 0) {
-        sendpacket_seterr(sp, "Error with libnet_adv_write_link: %s", libnet_geterror(sp->handle.lnet));
-    }
 #endif
 
@@ -213 +210 @@
 #elif defined HAVE_BPF
     sp = sendpacket_open_bpf(device, errbuf);
+#elif defined HAVE_LIBNET
+    sp = sendpacket_open_libnet(device, errbuf);
 #elif (defined HAVE_PCAP_INJECT || defined HAVE_PCAP_SENDPACKET)
     sp = sendpacket_open_pcap(device, errbuf);
-#elif defined HAVE_LIBNET
-    sp = sendpacket_open_libnet(device, errbuf);
 #endif
     if (sp != NULL)
@@ -264 +261 @@
         
 #if defined HAVE_PF_PACKET
-    addr = get_hwaddr_pf(sp);
+    addr = sendpacket_get_hwaddr_pf(sp);
 #elif defined HAVE_BPF
-    addr = get_hwaddr_bpf(sp);
+    addr = sendpacket_get_hwaddr_bpf(sp);
+#elif defined HAVE_LIBNET
+    addr = sendpacket_get_hwaddr_libnet(sp);
 #elif (defined HAVE_PCAP_INJECT || defined HAVE_PCAP_SENDPACKET)
-    addr = get_hwaddr_pcap(sp);
-#elif defined HAVE_LIBNET
-    addr = get_hwaddr_libnet(sp);
+    addr = sendpacket_get_hwaddr_pcap(sp);
 #endif
     return addr;
@@ -304 +301 @@
 
 
-
-
-
 #if defined HAVE_PCAP_INJECT || defined HAVE_PCAP_SENDPACKET
 static sendpacket_t *
@@ -328 +322 @@
 
 static struct tcpr_ether_addr *
-get_hwaddr_pcap(sendpacket_t *sp)
-{
-    assert(sp);
-    sendpacket_seterr(sp, "Error: get_hwaddr() not yet supported for pcap injection");
+sendpacket_get_hwaddr_pcap(sendpacket_t *sp)
+{
+    assert(sp);
+    sendpacket_seterr(sp, "Error: sendpacket_get_hwaddr() not yet supported for pcap injection");
     return NULL;
 }
@@ -356 +350 @@
 
 static struct tcpr_ether_addr *
-get_hwaddr_libnet(sendpacket_t *sp)
+sendpacket_get_hwaddr_libnet(sendpacket_t *sp)
 {
     struct tcpr_ether_addr *addr;
@@ -409 +403 @@
     strlcpy(sp->device, device, sizeof(sp->device));
     sp->handle.fd = mysocket;
+    
+    /* need this to do a write */
+    strlcpy(sp->sa.sa_data, sp->device, sizeof(sp->sa.sa_data));
+    
+    
     return sp;
 }
@@ -418 +417 @@
  */
 struct tcpr_ether_addr *
-get_hwaddr_pf(sendpacket_t *sp)
+sendpacket_get_hwaddr_pf(sendpacket_t *sp)
 {
     struct ifreq ifr;
@@ -570 +569 @@
 
 struct tcpr_ether_addr *
-get_hwaddr_bpf(sendpacket_t *sp)
+sendpacket_get_hwaddr_bpf(sendpacket_t *sp)
 {
     int mib[6];