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, 89 insertions, 5 deletions

diff --git a/base/inet.hh b/base/inet.hh
index 67ac5a504..86a04aae4 100644
--- a/base/inet.hh
+++ b/base/inet.hh
@@ -26,12 +26,96 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef __INET_HH__
-#define __INET_HH__
+#ifndef __BASE_INET_HH__
+#define __BASE_INET_HH__
+
+#include <string>
+
+#include "dnet/os.h"
+
+#include "dnet/eth.h"
+#include "dnet/ip.h"
+#include "dnet/ip6.h"
+#include "dnet/addr.h"
+#include "dnet/arp.h"
+#include "dnet/icmp.h"
+#include "dnet/tcp.h"
+#include "dnet/udp.h"
+
+#include "dnet/intf.h"
+#include "dnet/route.h"
+#include "dnet/fw.h"
+
+#include "dnet/blob.h"
+#include "dnet/rand.h"
 
 #include "sim/host.hh"
 
-uint32_t crc32be(const uint8_t *buf, size_t len);
-uint32_t crc32le(const uint8_t *buf, size_t len);
 std::string eaddr_string(const uint8_t a[6]);
-#endif // __INET_HH__
+
+struct EthHdr : protected eth_hdr
+{
+    uint16_t type() const { return ntohs(eth_type); }
+    const uint8_t *payload() const { return (const uint8_t *)this + sizeof(*this); }
+    uint8_t *payload() { return (uint8_t *)this + sizeof(*this); }
+
+    bool unicast() { return eth_dst.data[0] == 0x00; }
+    bool multicast() { return eth_dst.data[0] == 0x01; }
+    bool broadcast() { return eth_dst.data[0] == 0xff; }
+};
+
+struct IpHdr : protected ip_hdr
+{
+    uint8_t  version() const { return ip_v; }
+    uint8_t  hlen() const { return ip_hl; }
+    uint8_t  tos() const { return ip_tos; }
+    uint16_t len() const { return ntohs(ip_len); }
+    uint16_t id() const { return ntohs(ip_id); }
+    uint16_t frag_flags() const { return ntohs(ip_off) >> 13; }
+    uint16_t frag_off() const { return ntohs(ip_off) & 0x1fff; }
+    uint8_t  ttl() const { return ip_ttl; }
+    uint8_t  proto() const { return ip_p; }
+    uint16_t sum() const { return ntohs(ip_sum); }
+    uint32_t src() const { return ntohl(ip_src); }
+    uint32_t dst() const { return ntohl(ip_dst); }
+
+    void sum(uint16_t sum) { ip_sum = htons(sum); }
+
+    uint16_t ip_cksum() const;
+    uint16_t tu_cksum() const;
+    const uint8_t  *payload() const { return (const uint8_t *)this + hlen(); }
+    uint8_t  *payload() { return (uint8_t *)this + hlen(); }
+};
+
+struct TcpHdr : protected tcp_hdr
+{
+    uint16_t sport() const { return ntohs(th_sport); }
+    uint16_t dport() const { return ntohs(th_dport); }
+    uint32_t seq() const { return ntohl(th_seq); }
+    uint32_t ack() const { return ntohl(th_ack); }
+    uint8_t  off() const { return th_off; }
+    uint8_t  flags() const { return th_flags & 0x3f; }
+    uint16_t win() const { return ntohs(th_win); }
+    uint16_t sum() const { return ntohs(th_sum); }
+    uint16_t urp() const { return ntohs(th_urp); }
+
+    void sum(uint16_t sum) { th_sum = htons(sum); }
+
+    const uint8_t *payload() const { return (const uint8_t *)this + off(); }
+    uint8_t *payload() { return (uint8_t *)this + off(); }
+};
+
+struct UdpHdr : protected udp_hdr
+{
+    uint16_t sport() const { return ntohs(uh_sport); }
+    uint16_t dport() const { return ntohs(uh_dport); }
+    uint16_t len() const { return ntohs(uh_ulen); }
+    uint16_t sum() const { return ntohs(uh_sum); }
+
+    void sum(uint16_t sum) { uh_sum = htons(sum); }
+
+    const uint8_t *payload() const { return (const uint8_t *)this + sizeof(*this); }
+    uint8_t *payload() { return (uint8_t *)this + sizeof(*this); }
+};
+
+#endif // __BASE_INET_HH__