Attachment #197 for bug #247

View | Details | Raw Unified | Return to bug 247
Collapse All | Expand All

(-)a/src/common/buffer.cc (+6 lines)

Lines 1128-1133 Buffer::Iterator::CalculateIpChecksum(ui	Link Here

1128

  return ~sum;

1128

  return ~sum;

1129

1130

1131

uint32_t

1132

Buffer::Iterator::GetSize (void) const

1133

1134

  return m_dataEnd - m_dataStart;

1135

1136

1131

} // namespace ns3

1137

} // namespace ns3

1132

1138

1133

1139

(-)a/src/common/buffer.h (+5 lines)

Lines 358-363 public:	Link Here

358

*/

358

*/

359

      uint16_t CalculateIpChecksum(uint16_t size, uint32_t initialChecksum);

359

      uint16_t CalculateIpChecksum(uint16_t size, uint32_t initialChecksum);

360

361

/**

362

       * \returns the size of the underlying buffer we are iterating

363

*/

364

      uint32_t GetSize (void) const;

365

361

  private:

366

  private:

362

      friend class Buffer;

367

      friend class Buffer;

363

      Iterator (Buffer const*buffer);

368

      Iterator (Buffer const*buffer);




#include "tcp-socket-impl.h"
#include "tcp-header.h"
#include "ns3/buffer.h"
#include "ns3/address-utils.h"

namespace ns3 {


    m_flags (0),
    m_windowSize (0xffff),
    m_urgentPointer (0),
    m_initialChecksum(0),
    m_checksum (0),
    m_calcChecksum(false),
    m_goodChecksum(true)
{}

TcpHeader::EnableChecksums (void)
{
  m_calcChecksum = true;
}

void TcpHeader::SetPayloadSize(uint16_t payloadSize)
{
  m_payloadSize = payloadSize;
}

void TcpHeader::SetSourcePort (uint16_t port)

void TcpHeader::SetWindowSize (uint16_t windowSize)
{
  m_windowSize = windowSize;
}
void TcpHeader::SetChecksum (uint16_t checksum)
{
  m_checksum = checksum;
}
void TcpHeader::SetUrgentPointer (uint16_t urgentPointer)
{

{
  return m_windowSize;
}
uint16_t TcpHeader::GetChecksum () const
{
  return m_checksum;
}
uint16_t TcpHeader::GetUrgentPointer () const
{
  return m_urgentPointer;


void 
TcpHeader::InitializeChecksum (Ipv4Address source, 
                               Ipv4Address destination,
                               uint8_t protocol)
{
  m_source = source;
  m_destination = destination;
  m_protocol = protocol;
}

uint16_t
TcpHeader::CalculateHeaderChecksum (uint16_t size) const
{
  Buffer buf = Buffer (12);
  buf.AddAtStart (12);
  Buffer::Iterator it = buf.Begin ();

  WriteTo (it, m_source);
  WriteTo (it, m_destination);
  it.WriteU8 (0); /* protocol */
  it.WriteU8 (m_protocol); /* protocol */
  it.WriteU8 (size >> 8); /* length */
  it.WriteU8 (size & 0xff); /* length */
  it.WriteU8(tcpLength >> 8); /* length */
  it.WriteU8(tcpLength & 0xff); /* length */

  it = buf.Begin ();
  /* we don't CompleteChecksum ( ~ ) now */
  return ~(it.CalculateIpChecksum (12));
}

bool

void TcpHeader::Serialize (Buffer::Iterator start)  const
{
  Buffer::Iterator i = start;
  uint16_t tcpLength = m_payloadSize + GetSerializedSize();
  i.WriteHtonU16 (m_sourcePort);
  i.WriteHtonU16 (m_destinationPort);
  i.WriteHtonU32 (m_sequenceNumber);


  if(m_calcChecksum)
  {
    uint16_t headerChecksum = CalculateHeaderChecksum (start.GetSize ());
    i = start;
    uint16_t checksum = i.CalculateIpChecksum(start.GetSize (), headerChecksum);
    
    i = start;
    i.Next(16);

  m_flags = field & 0x3F;
  m_length = field>>12;
  m_windowSize = i.ReadNtohU16 ();
  i.Next (2);
  m_urgentPointer = i.ReadNtohU16 ();

  if(m_calcChecksum)
    {
      uint16_t headerChecksum = CalculateHeaderChecksum (start.GetSize ());
      i = start;
      uint16_t checksum = i.CalculateIpChecksum(start.GetSize (), headerChecksum);

      m_goodChecksum = (checksum == 0);
    }

  return GetSerializedSize ();
}




   */
  void SetWindowSize (uint16_t windowSize);
  /**
   * \param checksum the checksum for this TcpHeader
   */
  void SetChecksum (uint16_t checksum);
  /**
   * \param urgentPointer the urgent pointer for this TcpHeader
   */
  void SetUrgentPointer (uint16_t urgentPointer);

   */
  uint16_t GetWindowSize () const;
  /**
   * \return the checksum for this TcpHeader
   */
  uint16_t GetChecksum () const;
  /**
   * \return the urgent pointer for this TcpHeader
   */
  uint16_t GetUrgentPointer () const;

  virtual uint32_t Deserialize (Buffer::Iterator start);

  /**
   * \param size The payload size in bytes
   */
  void SetPayloadSize (uint16_t size);

  /**
   * \brief Is the TCP checksum correct ?
   * \returns true if the checksum is correct, false otherwise.
   */
  bool IsChecksumOk (void) const;

private:
  uint16_t CalculateHeaderChecksum (uint16_t size) const;
  uint16_t m_sourcePort;
  uint16_t m_destinationPort;
  uint32_t m_sequenceNumber;

  uint8_t m_flags;      // really a uint6_t
  uint16_t m_windowSize;
  uint16_t m_urgentPointer;

  Ipv4Address m_source;
  Ipv4Address m_destination;
  uint8_t m_protocol;

  uint16_t m_initialChecksum;
  uint16_t m_checksum;

  bool m_calcChecksum;
  bool m_goodChecksum;

};

}; // namespace ns3




  if(m_calcChecksum)
  {
    tcpHeader.EnableChecksums();
    tcpHeader.InitializeChecksum (source, destination, PROT_NUMBER);
  }

  packet->PeekHeader (tcpHeader);

  TcpHeader tcpHeader;
  tcpHeader.SetDestinationPort (dport);
  tcpHeader.SetSourcePort (sport);
  tcpHeader.SetPayloadSize(packet->GetSize());
  if(m_calcChecksum)
  {
    tcpHeader.EnableChecksums();

  // XXX outgoingHeader cannot be logged

  outgoingHeader.SetLength (5); //header length in units of 32bit words
  outgoingHeader.SetPayloadSize(packet->GetSize());
  /* outgoingHeader.SetUrgentPointer (0); //XXX */
  if(m_calcChecksum)
  {




 */

#include "udp-header.h"
#include "ns3/address-utils.h"

namespace ns3 {


  : m_sourcePort (0xfffd),
    m_destinationPort (0xfffd),
    m_payloadSize (0xfffd),
    m_initialChecksum (0),
    m_checksum(0),
    m_calcChecksum(false),
    m_goodChecksum(true)
{}

                              Ipv4Address destination,
                              uint8_t protocol)
{
  m_source = source;
  m_destination = destination;
  m_protocol = protocol;
}
uint16_t
UdpHeader::CalculateHeaderChecksum (uint16_t size) const
{
  Buffer buf = Buffer (12);
  buf.AddAtStart (12);
  Buffer::Iterator it = buf.Begin ();

  WriteTo (it, m_source);
  WriteTo (it, m_destination);
  it.WriteU8 (0); /* protocol */
  it.WriteU8 (m_protocol); /* protocol */
  it.WriteU8 (size >> 8); /* length */
  it.WriteU8 (size & 0xff); /* length */

  it = buf.Begin ();
  it.Write(tmp, 4); /* source IP address */
  destination.Serialize(tmp);
  it.Write(tmp, 4); /* destination IP address */
  it.WriteU8(0); /* protocol */
  it.WriteU8(protocol); /* protocol */
  it.WriteU8(udpLength >> 8); /* length */
  it.WriteU8(udpLength & 0xff); /* length */

  it = buf.Begin();
  /* we don't CompleteChecksum ( ~ ) now */
  return ~(it.CalculateIpChecksum (12));
}

bool

UdpHeader::Serialize (Buffer::Iterator start) const
{
  Buffer::Iterator i = start;
  uint16_t udpLength = m_payloadSize + GetSerializedSize();

  i.WriteHtonU16 (m_sourcePort);
  i.WriteHtonU16 (m_destinationPort);
  i.WriteHtonU16 (start.GetSize ());
  i.WriteU16 (0);

  if (m_calcChecksum)
    {
      uint16_t headerChecksum = CalculateHeaderChecksum (start.GetSize ());
      i = start;
      uint16_t checksum = i.CalculateIpChecksum (start.GetSize (), headerChecksum);

      i = start;
      i.Next(6);

  m_sourcePort = i.ReadNtohU16 ();
  m_destinationPort = i.ReadNtohU16 ();
  m_payloadSize = i.ReadNtohU16 () - GetSerializedSize ();
  i.Next (2);

  if(m_calcChecksum)
  {
      uint16_t headerChecksum = CalculateHeaderChecksum (start.GetSize ());
      i = start;
      uint16_t checksum = i.CalculateIpChecksum (start.GetSize (), headerChecksum);

      m_goodChecksum = (checksum == 0);
  }




  bool IsChecksumOk (void) const;

private:
  uint16_t CalculateHeaderChecksum (uint16_t size) const;
  uint16_t m_sourcePort;
  uint16_t m_destinationPort;
  uint16_t m_payloadSize;
  uint16_t m_initialChecksum;
  uint16_t m_checksum;

  Ipv4Address m_source;
  Ipv4Address m_destination;
  uint8_t m_protocol;
  bool m_calcChecksum;
  bool m_goodChecksum;
};

Return to bug 247