xorheader_new.hh

COPE the first practical network coding scheme which is developped on click

#ifndef CLICK_XORHEADERN_HH
#define CLICK_XORHEADERN_HH

#include <clicknet/ip.h>
#include <clicknet/tcp.h>

CLICK_SIZE_PACKED_STRUCTURE(
struct click_xorn_header {,

  uint8_t _nentries;
  uint16_t _cksum;
 
  CLICK_SIZE_PACKED_STRUCTURE(
  struct routing_unit {,
    uint8_t _link_idx;
    uint32_t _fwd_metric;
    uint32_t _rev_metric;
    uint32_t _seq;
    uint32_t _age;
  });
 
  // One unit of the xor header
  CLICK_SIZE_PACKED_STRUCTURE(
  struct xor_unit {,
    uint16_t _ether_type;
    uint8_t _alias; // destination of the packet
    uint16_t _nseq; // neighbor sequence no from sr header
    uint8_t _next;  // index of next node who processes this packet in sr header
    uint8_t _nlinks;  // No of links in the source route
    uint32_t _src; // src IP (along with IP ID, uniquely identifies pkt)
    uint16_t _ipid; // IP ID
    uint8_t _ipttl; // IP TTL of the packet you coded
    uint16_t _len;  

    // bunch of fields for helping the snooper log stuff
    // DO NOT USE THESE FIELDS FOR THE ACTUAL PROTOCOL
    uint32_t _dst; // IP dst
    uint16_t _iplen; // ip_len field
    uint8_t _proto; // ip_proto field
    uint16_t _sport; // source port for TCP or UDP
    uint16_t _dport; // dst port for TCP or UDP
    tcp_seq_t _tcp_seq; // TCP sequence number
    tcp_seq_t _tcp_ack; // TCP ack number
    uint8_t _tcp_flags; // tcp th_flags fields
    // END ADDITIONAL FIELDS

    // changing fields in the routing protocol, routing metrics, seq and age

    struct routing_unit _rt_unit;
    
    void set_entry(uint16_t ether_type, uint8_t alias, uint16_t nseq, uint8_t next, uint8_t nlinks, uint32_t src, uint16_t ipid, uint8_t ipttl, uint16_t len) {
      _ether_type = htons(ether_type);
      _alias = alias;
      _nseq = htons(nseq);
      _next = next;
      _nlinks = nlinks;
      _src = src;
      _ipid = htons(ipid);
      _ipttl = ipttl;
      _len = htons(len);
    }

    // FOR ADDITIONAL FIELDS
    void set_entry_additional(uint32_t dst, uint16_t iplen, uint8_t proto, uint16_t sport, uint16_t dport, tcp_seq_t tcp_seq, tcp_seq_t tcp_ack, uint8_t tcp_flags) {
      _dst = dst;
      _iplen = htons(iplen);
      _proto = proto;
      _sport = htons(sport);
      _dport = htons(dport);
      _tcp_seq = htonl(tcp_seq);
      _tcp_ack = htonl(tcp_ack);
      _tcp_flags = tcp_flags;
    }
    // END ADDITIONAL FIELDS
 
    // Setting routing entry for a link on the source route for this packet
    void set_routing_entry(uint8_t entry_index, uint8_t link_idx, uint32_t fwd_metric, uint32_t rev_metric, uint32_t seq, uint32_t age) {
      struct routing_unit *unit = (struct routing_uint *)((uint8_t *)(this + 1) -  (nentry-1)*sizeof(struct routing_unit));
      unit->_link_idx = link_idx;
      unit->_fwd_metric = fwd_metric;
      unit->_rev_metric = rev_metric;
      unit->_seq = seq;
      unit->_age = age;
    }
   
    static size_t get_unit_len(uint8_t nlinks) {
      return (sizeof(struct xor_unit) + sizeof(struct routing_unit)*(nlinks-1));
    }

    size_t get_nlinks() {
      return _nlinks;
    }

  });

  struct xor_unit _unit;

  void set_entry(int entry_index, uint16_t ether_type, uint8_t alias, uint16_t nseq, uint8_t next, uint8_t nlinks, uint32_t src, uint16_t ipid, uint8_t ipttl, uint16_t len) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    unit->set_entry(ether_type, alias, nseq, next, nlinks, src, ipid, ipttl, len, nlinks);
  }

  void set_entry_additional(int entry_index, uint32_t dst, uint16_t iplen, uint8_t proto, uint16_t sport, uint16_t dport, tcp_seq_t tcp_seq, tcp_seq_t tcp_ack, uint8_t tcp_flags) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    unit->set_entry_additional(dst, iplen, proto, sport, dport, tcp_seq, tcp_ack, tcp_flags);
  }

  void set_entry_routing(int entry_index, int link_index, uint8_t idx, uint32_t fwd_metric, uint32_t rev_metric, uint32_t seq, uint32_t age) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    unit->set_routing_entry(link_index, idx, fwd_metric, rev_metric, seq, age); 
  }
    
    
  uint16_t get_entry_ethtype(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return ntohs(unit->_ether_type);
  }

  uint8_t get_entry_alias(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return unit->_alias;
  }

  uint16_t get_entry_nseq(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return ntohs(unit->_nseq);
  }

  uint8_t get_entry_next(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return unit->_next;
  }

  uint32_t get_entry_src(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return unit->_src;
  }

  uint16_t get_entry_ipid(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return ntohs(unit->_ipid);
  }

  uint8_t get_entry_ipttl(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return unit->_ipttl;
  }

  uint16_t get_entry_len(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return ntohs(unit->_len);
  }


  // ALL THIS IS FOR THE ADDITIONAL FIELDS
  uint32_t get_entry_dst(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return unit->_dst;
  }
  
  uint16_t get_entry_iplen(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return ntohs(unit->_iplen);
  }

  uint8_t get_entry_proto(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return unit->_proto;
  }

  uint16_t get_entry_sport(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return ntohs(unit->_sport);
  }

  uint16_t get_entry_dport(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return ntohs(unit->_dport);
  }

  tcp_seq_t get_entry_tcp_seq(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return ntohl(unit->_tcp_seq);
  }

  tcp_seq_t get_entry_tcp_ack(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return ntohl(unit->_tcp_ack);
  }

  uint8_t get_entry_tcp_flags(int entry_index) {
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx += (entry_index - 1) * sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    struct xor_unit *unit = (struct xor_unit*)ndx;
    return unit->_tcp_flags;
  }
  // END ADDITIONAL FIELDS

  void set_nentries(int n) {
    _nentries = n;
  }

  static size_t get_hlen(int nentries, int nlinks) {
    return sizeof(struct click_xorn_header) + (sizeof(struct xor_unit) * (nentries-1)) + (nlinks-nentries)*sizeof(struct routing_unit);
  }

  size_t nentries() {
    return _nentries;
  }

  size_t nlinks() {
    int nlinks = 0;
    uint8_t *ndx = (uint8_t *) (this+1);
    ndx -= sizeof(struct xor_unit);   
    for (int i = 0; i < entry_index; i++) {
      struct xor_unit *xor_unit_t = (struct xor_unit*)ndx;
      nlinks += xor_unit_t->get_nlinks();
      ndx += xor_unit_t->get_unit_len(xor_unit_t->_nlinks);
    }
    return nlinks;
  }
   

  void set_checksum() {
    unsigned int max_len = 0;
    for (unsigned int i = 0; i < nentries(); i++) {
      if (get_entry_len(i) > max_len) max_len = get_entry_len(i);
    }
    max_len += get_hlen(_nentries);
    _cksum = 0;
    _cksum = click_in_cksum((unsigned char *)this, max_len);
  }
});
    


#endif