tools/upslug2/patches/100-libpcap_fix.patch

   1 --- a/pcap_wire.cc
   2 +++ b/pcap_wire.cc
   3 @@ -18,6 +18,7 @@
   4
   5  #include <sys/time.h>
   6  #include <sys/select.h>
   7 +#include <sys/poll.h>
   8
   9  /* Ways of finding the hardware MAC on this machine... */
  10  /* This is the Linux only fallback. */
  11 @@ -130,20 +131,18 @@ namespace NSLU2Upgrade {
  12                  * non-static (real) Handler.
  13                  */
  14                 void Handler(const struct pcap_pkthdr *packet_header, const u_char *packet) {
  15 -                       /* This should only be called once... */
  16 -                       if (captured)
  17 -                               throw std::logic_error("Handler called twice");
  18 -
  19                         /* Verify the protocol and originating address of the packet, then
  20                          * return this packet.
  21                          */
  22 +                       if (captured)
  23 +                               return;
  24                         if (packet_header->caplen > 14 && (broadcast ||
  25                                 std::memcmp(packet+6, header, 6) == 0)) {
  26 -                               /* Record the address and copy the data */
  27 -                               std::memcpy(source, packet+6, 6);
  28                                 const size_t len(packet_header->caplen - 14);
  29                                 if (len > captureSize)
  30 -                                       throw std::logic_error("packet too long");
  31 +                                       return;
  32 +                               /* Record the address and copy the data */
  33 +                               std::memcpy(source, packet+6, 6);
  34                                 std::memcpy(captureBuffer, packet+14, len);
  35                                 captureSize = len;
  36                                 captured = true;
  37 @@ -156,7 +155,7 @@ namespace NSLU2Upgrade {
  38                          * packet and the buffer should be big enough.
  39                          */
  40                         if (packet_header->caplen < packet_header->len)
  41 -                               throw std::logic_error("truncated packet");
  42 +                               return;
  43
  44                         /*IGNORE EVIL: known evil cast */
  45                         reinterpret_cast<PCapWire*>(user)->Handler(packet_header, packet);
  46 @@ -173,56 +172,24 @@ namespace NSLU2Upgrade {
  47                 virtual void Receive(void *buffer, size_t &size, unsigned long timeout) {
  48                         /* Now try to read packets until the timeout has been consumed.
  49                          */
  50 -                       struct timeval tvStart;
  51 -                       if (timeout > 0 && gettimeofday(&tvStart, 0) != 0)
  52 -                               throw OSError(errno, "gettimeofday(base)");
  53 +                       int time_count;
  54
  55                         captureBuffer = buffer;
  56                         captureSize = size;
  57                         captured = false;
  58 +                       time_count = timeout / 2000; /* 2 ms intervals */
  59 +                       time_count++;
  60                         do {
  61                                 /*IGNORE EVIL: known evil cast */
  62 -                               int count(pcap_dispatch(pcap, 1, PCapHandler,
  63 -                                                       reinterpret_cast<u_char*>(this)));
  64 +                               int count = pcap_dispatch(pcap, 1, PCapHandler,
  65 +                                                       reinterpret_cast<u_char*>(this));
  66
  67 -                               if (count > 0) {
  68 -                                       /* Were any packets handled? */
  69 -                                       if (captured) {
  70 -                                               size = captureSize;
  71 -                                               return;
  72 -                                       }
  73 -                                       /* else try again. */
  74 -                               } else if (count == 0) {
  75 -                                       /* Nothing to handle - do the timeout, do this
  76 -                                        * by waiting a bit then trying again, the trick
  77 -                                        * to this is to work out how long to wait each
  78 -                                        * time, for the moment a 10ms delay is used.
  79 -                                        */
  80 -                                       if (timeout == 0)
  81 -                                               break;
  82 -
  83 -                                       struct timeval tvNow;
  84 -                                       if (gettimeofday(&tvNow, 0) != 0)
  85 -                                               throw OSError(errno, "gettimeofday(now)");
  86 -
  87 -                                       unsigned long t(tvNow.tv_sec - tvStart.tv_sec);
  88 -                                       t *= 1000000;
  89 -                                       t += tvNow.tv_usec;
  90 -                                       t -= tvStart.tv_usec;
  91 -                                       if (t > timeout)
  92 -                                               break;
  93 -
  94 -                                       tvNow.tv_sec = 0;
  95 -                                       tvNow.tv_usec = timeout-t;
  96 -                                       if (tvNow.tv_usec > 10000)
  97 -                                               tvNow.tv_usec = 10000;
  98 -
  99 -                                       /* Delay, may be interrupted - this should
 100 -                                        * be portable to the BSDs (since the
 101 -                                        * technique originates in BSD.)
 102 -                                        */
 103 -                                       (void)select(0, 0, 0, 0, &tvNow);
 104 -                               } else {
 105 +                               /* Were any packets handled? */
 106 +                               if (captured) {
 107 +                                       size = captureSize;
 108 +                                       return;
 109 +                               }
 110 +                               if (count < 0) {
 111                                         /* Error condition. */
 112                                         if (count == -1) {
 113                                                 if (errno != EINTR)
 114 @@ -232,7 +199,8 @@ namespace NSLU2Upgrade {
 115                                         } else
 116                                                 throw std::logic_error("pcap unexpected result");
 117                                 }
 118 -                       } while (timeout != 0);
 119 +                               time_count--;
 120 +                       } while (time_count > 0);
 121
 122                         /* Here on timeout. */
 123                         size = 0;
 124 @@ -288,6 +256,7 @@ NSLU2Upgrade::Wire *NSLU2Upgrade::Wire::
 125                 const unsigned char *mac, const unsigned char *address, int uid) {
 126         /* This is used to store the error passed to throw. */
 127         static char PCapErrbuf[PCAP_ERRBUF_SIZE];
 128 +       struct bpf_program fp;
 129
 130         /* Check the device name.  If not given use 'DEFAULT_ETHERNET_IF'. */
 131         if (device == NULL)
 132 @@ -301,20 +270,12 @@ NSLU2Upgrade::Wire *NSLU2Upgrade::Wire::
 133                  * for other ethernet MACs.  (Because the code above does not
 134                  * check that the destination matches the device in use).
 135                  */
 136 -               pcap = pcap_open_live(device, 1540, false/*promiscuous*/, 1/*ms*/, PCapErrbuf);
 137 +               pcap = pcap_open_live(device, 1540, false/*promiscuous*/, 2/*ms*/, PCapErrbuf);
 138
 139                 if (pcap == NULL)
 140                         throw WireError(errno, PCapErrbuf);
 141         }
 142
 143 -       /* Always do a non-blocking read, because the 'timeout' above
 144 -        * doesn't work on Linux (return is immediate) and on OSX (and
 145 -        * maybe other BSDs) the interface tends to hang waiting for
 146 -        * the timeout to expire even after receiving a single packet.
 147 -        */
 148 -       if (pcap_setnonblock(pcap, true, PCapErrbuf))
 149 -               throw WireError(errno, PCapErrbuf);
 150 -
 151         try {
 152                 /* The MAC of the transmitting device is needed - without
 153                  * this the return packet won't go to the right place!