Clean up network header stuff and make it more generic. Use

libdnet when we can instead of our own home grown stuff.

SConscript:
    separate the crc code into its own file
base/inet.cc:
    move the crc stuff to crc.cc
    add generic code for calculating ip/tcp/udp checksums
base/inet.hh:
    -  move crc stuff to crc.hh
    -  #include all of the libdnet stuff.  (this makes base/inet.hh the
    only file you need to include if you want to use this kind of stuff.)
    -  Wrap some of the libdnet structs to get easier access to structure
    members.  These wrappers will automatically deal with masking/shifting/
    byte-swapping.
base/refcnt.hh:
    If one derives from RefCountingPtr, they should have access to
    the internal data pointer.
build/SConstruct:
    make #include of dnet stuff work
dev/etherlink.cc:
dev/ethertap.cc:
dev/ethertap.hh:
    EtherPacket -> PacketData
dev/etherpkt.cc:
    EtherPacket -> PacketData
    add a function for populating extra info about a packet.
    Basically just gives pointers to ethernet/ip/tcp/udp headers
    if they exist.
dev/etherpkt.hh:
    EtherPacket -> PacketData
    remove most of the packet header stuff from teh PacketData
    class and just add a few generic functions for grabbing various
    headers that may exist in the packet.  The old functionality is
    contained in the headers.
dev/ns_gige.cc:
    -  IP -> Ip, UDP -> Udp, TCP ->Tcp when used in variable names
    -  get rid of our own byte swapping functions.
    -  whack checksum code and use libdnet version.
    -  Get pointers to the various packet headers and grab info from
    those headers.  (The byte swapping in the headers now.)
    -  Add stats for Udp Checksums
dev/ns_gige.hh:
    use libdnet for checksum code.
    IP -> Ip, TCP -> Tcp in variable names
    add stats for UDP checksums

--HG--
extra : convert_revision : 96c4160e1967b7c0090acd456df4a76e1f3aab53

1 files changed, 26 insertions, 46 deletions

diff --git a/dev/etherpkt.hh b/dev/etherpkt.hh
index abdf30166..53612b830 100644
--- a/dev/etherpkt.hh
+++ b/dev/etherpkt.hh
@@ -37,70 +37,50 @@
 #include <memory>
 #include <assert.h>
 
-#include "sim/host.hh"
 #include "base/refcnt.hh"
-#include "base/inet_hdrs.hh"
+#include "base/inet.hh"
+#include "sim/host.hh"
 
-class Checkpoint;
 /*
  * Reference counted class containing ethernet packet data
  */
-class EtherPacket : public RefCounted
+class Checkpoint;
+class PacketData : public RefCounted
 {
   public:
     uint8_t *data;
     int length;
 
-  public:
-    EtherPacket() : data(NULL), length(0) {}
-    EtherPacket(std::auto_ptr<uint8_t> d, int l)
-        : data(d.release()), length(l) {}
-    ~EtherPacket() { if (data) delete [] data; }
-
-  public:
-    bool IsUnicast() { return data[0] == 0x00; }
-    bool IsMulticast() { return data[0] == 0x01; }
-    bool IsBroadcast() { return data[0] == 0xff; }
-
-    bool isIpPkt() {
-        eth_header *eth = (eth_header *) data;
-        return (eth->type == 0x8);
-    }
-    bool isTcpPkt(ip_header *ip) {
-        return (ip->protocol == 0x6);
-    }
-    bool isTcpPkt() {
-        ip_header *ip = getIpHdr();
-        return (ip->protocol == 0x6);
-    }
-    bool isUdpPkt(ip_header *ip) {
-        return (ip->protocol == 17);
-    }
-    bool isUdpPkt() {
-        ip_header *ip = getIpHdr();
-        return (ip->protocol == 17);
-    }
+  protected:
+    uint8_t *_eth;
+    uint8_t *_ip;
+    uint8_t *_tcp;
+    uint8_t *_udp;
 
-    ip_header *getIpHdr() {
-        assert(isIpPkt());
-        return (ip_header *) (data + sizeof(eth_header));
+    void doext();
+    void ext()
+    {
+        if (_eth != data)
+            doext();
     }
 
-    tcp_header *getTcpHdr(ip_header *ip) {
-        assert(isTcpPkt(ip));
-        return (tcp_header *) ((uint8_t *) ip + (ip->vers_len & 0xf)*4);
-    }
+  public:
+    PacketData() : data(NULL), length(0) { doext(); }
+    PacketData(std::auto_ptr<uint8_t> d, int l)
+        : data(d.release()), length(l) { doext(); }
+    ~PacketData() { if (data) delete [] data; }
 
-    udp_header *getUdpHdr(ip_header *ip) {
-        assert(isUdpPkt(ip));
-        return (udp_header *) ((uint8_t *) ip + (ip->vers_len & 0xf)*4);
-    }
-    typedef RefCountingPtr<EtherPacket> PacketPtr;
+  public:
+    EthHdr *eth() { ext(); return (EthHdr *)_eth; }
+    IpHdr *ip() { ext(); return (IpHdr *)_ip; }
+    TcpHdr *tcp() { ext(); return (TcpHdr *)_tcp; }
+    UdpHdr *udp() { ext(); return (UdpHdr *)_udp; }
 
+  public:
     void serialize(std::ostream &os);
     void unserialize(Checkpoint *cp, const std::string &section);
 };
 
-typedef RefCountingPtr<EtherPacket> PacketPtr;
+typedef RefCountingPtr<PacketData> PacketPtr;
 
 #endif // __ETHERPKT_HH__