Attachment #182 for bug #236

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

(-)a/examples/tcp-large-transfer.cc (+3 lines)

Lines 71-76 int main (int argc, char *argv[])	Link Here

  // Make the random number generators generate reproducible results.

  // Make the random number generators generate reproducible results.

//

//

  RandomVariable::UseGlobalSeed (1, 1, 2, 3, 5, 8);

  RandomVariable::UseGlobalSeed (1, 1, 2, 3, 5, 8);

  Config::SetDefault("ns3::Ipv4L3Protocol::CalcChecksum", BooleanValue(true));

  Config::SetDefault("ns3::TcpL4Protocol::CalcChecksum", BooleanValue(true));

  // Allow the user to override any of the defaults and the above

  // Allow the user to override any of the defaults and the above

  // Bind()s at run-time, via command-line arguments

  // Bind()s at run-time, via command-line arguments

(-)a/examples/udp-echo.cc (+3 lines)

Lines 66-71 main (int argc, char *argv[])	Link Here

  LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_ALL);

  LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_ALL);

  LogComponentEnable("UdpEchoServerApplication", LOG_LEVEL_ALL);

  LogComponentEnable("UdpEchoServerApplication", LOG_LEVEL_ALL);

#endif

#endif

  Config::SetDefault("ns3::Ipv4L3Protocol::CalcChecksum", BooleanValue(true));

  Config::SetDefault("ns3::UdpL4Protocol::CalcChecksum", BooleanValue(true));

// Allow the user to override any of the defaults and the above Bind() at

// Allow the user to override any of the defaults and the above Bind() at

// run-time, via command-line arguments

// run-time, via command-line arguments





#endif /* BUFFER_USE_INLINE */

uint16_t
Buffer::Iterator::CalculateIpChecksum(uint16_t size)
{
  return CalculateIpChecksum(size, 0);
}

uint16_t
Buffer::Iterator::CalculateIpChecksum(uint16_t size, uint32_t initialChecksum)
{
  /* see RFC 1071 to understand this code. */
  uint32_t sum = initialChecksum;

  for (int j = 0; j < size/2; j++)
    sum += ReadU16 ();

  if (size & 1)
     sum += ReadU8 ();

  while (sum >> 16)
    sum = (sum & 0xffff) + (sum >> 16);
  return ~sum;
}

} // namespace ns3






       * bytes read.
       */
      void Read (uint8_t *buffer, uint32_t size);

      /**
       * \brief Calculate the checksum.
       * \param size size of the buffer.
       * \return checksum
       */
      uint16_t CalculateIpChecksum(uint16_t size);

      /**
       * \brief Calculate the checksum.
       * \param size size of the buffer.
       * \param initialChecksum initial value
       * \return checksum
       */
      uint16_t CalculateIpChecksum(uint16_t size, uint32_t initialChecksum);

  private:
      friend class Buffer;
      Iterator (Buffer const*buffer);

(-)a/src/internet-stack/tcp-header.cc (-22 / +73 lines)

Lines 28-35 namespace ns3 {	Link Here

NS_OBJECT_ENSURE_REGISTERED (TcpHeader);

NS_OBJECT_ENSURE_REGISTERED (TcpHeader);

bool TcpHeader::m_calcChecksum = false;

TcpHeader::TcpHeader ()

TcpHeader::TcpHeader ()

  : m_sourcePort (0),

  : m_sourcePort (0),

    m_destinationPort (0),

    m_destinationPort (0),

Lines 38-45 TcpHeader::TcpHeader ()	Link Here

    m_length (5),

    m_length (5),

    m_flags (0),

    m_flags (0),

    m_windowSize (0xffff),

    m_windowSize (0xffff),

    m_urgentPointer (0),

    m_initialChecksum(0),

    m_checksum (0),

    m_checksum (0),

    m_urgentPointer (0)

    m_calcChecksum(false),

    m_goodChecksum(true)

{}

{}

TcpHeader::~TcpHeader ()

TcpHeader::~TcpHeader ()

Lines 49-54 TcpHeader::EnableChecksums (void)	Link Here

TcpHeader::EnableChecksums (void)

TcpHeader::EnableChecksums (void)

  m_calcChecksum = true;

  m_calcChecksum = true;

void TcpHeader::SetPayloadSize(uint16_t payloadSize)

  m_payloadSize = payloadSize;

void TcpHeader::SetSourcePort (uint16_t port)

void TcpHeader::SetSourcePort (uint16_t port)

Lines 130-137 TcpHeader::InitializeChecksum (Ipv4Addre	Link Here

130

                                   Ipv4Address destination,

136

                                   Ipv4Address destination,

131

                                   uint8_t protocol)

137

                                   uint8_t protocol)

132

138

133

  m_checksum = 0;

139

  Buffer buf = Buffer(12);

134

//XXX requires peeking into IP to get length of the TCP segment

140

  uint8_t tmp[4];

141

  Buffer::Iterator it;

142

  uint16_t tcpLength = m_payloadSize + GetSerializedSize();

143

144

  buf.AddAtStart(12);

145

  it = buf.Begin();

146

147

  source.Serialize(tmp);

148

  it.Write(tmp, 4); /* source IP address */

149

  destination.Serialize(tmp);

150

  it.Write(tmp, 4); /* destination IP address */

151

  it.WriteU8(0); /* protocol */

152

  it.WriteU8(protocol); /* protocol */

153

  it.WriteU8(tcpLength >> 8); /* length */

154

  it.WriteU8(tcpLength & 0xff); /* length */

155

156

  it = buf.Begin();

157

  /* we don't CompleteChecksum ( ~ ) now */

158

  m_initialChecksum = ~(it.CalculateIpChecksum(12));

159

160

161

bool

162

TcpHeader::IsChecksumOk (void) const

163

164

  return m_goodChecksum;

135

165

136

166

137

TypeId

167

TypeId

Lines 188-215 uint32_t TcpHeader::GetSerializedSize (v	Link Here

188

218

189

void TcpHeader::Serialize (Buffer::Iterator start)  const

219

void TcpHeader::Serialize (Buffer::Iterator start)  const

190

220

191

  start.WriteHtonU16 (m_sourcePort);

221

  Buffer::Iterator i = start;

192

  start.WriteHtonU16 (m_destinationPort);

222

  uint16_t tcpLength = m_payloadSize + GetSerializedSize();

193

  start.WriteHtonU32 (m_sequenceNumber);

223

  i.WriteHtonU16 (m_sourcePort);

194

  start.WriteHtonU32 (m_ackNumber);

224

  i.WriteHtonU16 (m_destinationPort);

195

  start.WriteHtonU16 (m_length << 12 | m_flags); //reserved bits are all zero

225

  i.WriteHtonU32 (m_sequenceNumber);

196

  start.WriteHtonU16 (m_windowSize);

226

  i.WriteHtonU32 (m_ackNumber);

197

  //XXX calculate checksum here

227

  i.WriteHtonU16 (m_length << 12 | m_flags); //reserved bits are all zero

198

  start.WriteHtonU16 (m_checksum);

228

  i.WriteHtonU16 (m_windowSize);

199

  start.WriteHtonU16 (m_urgentPointer);

229

  i.WriteHtonU16 (0);

230

  i.WriteHtonU16 (m_urgentPointer);

231

232

  if(m_calcChecksum)

233

234

    i = start;

235

    uint16_t checksum = i.CalculateIpChecksum(tcpLength, m_initialChecksum);

236

237

    i = start;

238

    i.Next(16);

239

    i.WriteU16(checksum);

240

200

241

201

uint32_t TcpHeader::Deserialize (Buffer::Iterator start)

242

uint32_t TcpHeader::Deserialize (Buffer::Iterator start)

202

243

203

  m_sourcePort = start.ReadNtohU16 ();

244

  Buffer::Iterator i = start;

204

  m_destinationPort = start.ReadNtohU16 ();

245

  m_sourcePort = i.ReadNtohU16 ();

205

  m_sequenceNumber = start.ReadNtohU32 ();

246

  m_destinationPort = i.ReadNtohU16 ();

206

  m_ackNumber = start.ReadNtohU32 ();

247

  m_sequenceNumber = i.ReadNtohU32 ();

207

  uint16_t field = start.ReadNtohU16 ();

248

  m_ackNumber = i.ReadNtohU32 ();

249

  uint16_t field = i.ReadNtohU16 ();

208

  m_flags = field & 0x3F;

250

  m_flags = field & 0x3F;

209

  m_length = field>>12;

251

  m_length = field>>12;

210

  m_windowSize = start.ReadNtohU16 ();

252

  m_windowSize = i.ReadNtohU16 ();

211

  m_checksum = start.ReadNtohU16 ();

253

  m_checksum = i.ReadU16 ();

212

  m_urgentPointer = start.ReadNtohU16 ();

254

  m_urgentPointer = i.ReadNtohU16 ();

255

256

  if(m_calcChecksum)

257

258

      i = start;

259

      uint16_t checksum = i.CalculateIpChecksum(m_payloadSize + GetSerializedSize(), m_initialChecksum);

260

261

      m_goodChecksum = (checksum == 0);

262

263

213

  return GetSerializedSize ();

264

  return GetSerializedSize ();

214

265

215

266

(-)a/src/internet-stack/tcp-header.h (-3 / +18 lines)

Lines 47-53 public:	Link Here

/**

/**

   * \brief Enable checksum calculation for TCP (XXX currently has no effect)

   * \brief Enable checksum calculation for TCP (XXX currently has no effect)

*/

*/

  static void EnableChecksums (void);

  void EnableChecksums (void);

//Setters

//Setters

/**

/**

   * \param port The source port for this TcpHeader

   * \param port The source port for this TcpHeader

Lines 150-155 public:	Link Here

150

  virtual void Serialize (Buffer::Iterator start) const;

150

  virtual void Serialize (Buffer::Iterator start) const;

151

  virtual uint32_t Deserialize (Buffer::Iterator start);

151

  virtual uint32_t Deserialize (Buffer::Iterator start);

152

153

/**

154

   * \param size The payload size in bytes

155

*/

156

  void SetPayloadSize (uint16_t size);

157

158

/**

159

   * \brief Is the TCP checksum correct ?

160

   * \returns true if the checksum is correct, false otherwise.

161

*/

162

  bool IsChecksumOk (void) const;

163

153

private:

164

private:

154

  uint16_t m_sourcePort;

165

  uint16_t m_sourcePort;

155

  uint16_t m_destinationPort;

166

  uint16_t m_destinationPort;

Lines 158-167 private:	Link Here

158

  uint8_t m_length; // really a uint4_t

169

  uint8_t m_length; // really a uint4_t

159

  uint8_t m_flags;      // really a uint6_t

170

  uint8_t m_flags;      // really a uint6_t

160

  uint16_t m_windowSize;

171

  uint16_t m_windowSize;

172

  uint16_t m_urgentPointer;

173

  uint16_t m_payloadSize;

174

  uint16_t m_initialChecksum;

161

  uint16_t m_checksum;

175

  uint16_t m_checksum;

162

  uint16_t m_urgentPointer;

163

176

164

  static bool m_calcChecksum;

177

  bool m_calcChecksum;

178

  bool m_goodChecksum;

179

165

};

180

};

166

181

167

}; // namespace ns3

182

}; // namespace ns3

(-)a/src/internet-stack/tcp-l4-protocol.cc (-3 / +36 lines)

Lines 21-26	Link Here

#include "ns3/assert.h"

#include "ns3/assert.h"

#include "ns3/log.h"

#include "ns3/log.h"

#include "ns3/nstime.h"

#include "ns3/nstime.h"

#include "ns3/boolean.h"

#include "ns3/packet.h"

#include "ns3/packet.h"

#include "ns3/node.h"

#include "ns3/node.h"

Lines 328-333 TcpL4Protocol::GetTypeId (void)	Link Here

328

                   ObjectFactoryValue (GetDefaultRttEstimatorFactory ()),

329

                   ObjectFactoryValue (GetDefaultRttEstimatorFactory ()),

329

                   MakeObjectFactoryAccessor (&TcpL4Protocol::m_rttFactory),

330

                   MakeObjectFactoryAccessor (&TcpL4Protocol::m_rttFactory),

330

                   MakeObjectFactoryChecker ())

331

                   MakeObjectFactoryChecker ())

332

    .AddAttribute ("CalcChecksum", "If true, we calculate the checksum of outgoing packets"

333

                   " and verify the checksum of incoming packets.",

334

                   BooleanValue (false),

335

                   MakeBooleanAccessor (&TcpL4Protocol::m_calcChecksum),

336

                   MakeBooleanChecker ())

331

337

332

  return tid;

338

  return tid;

333

339

Lines 439-452 TcpL4Protocol::Receive (Ptr<Packet> pack	Link Here

439

  NS_LOG_FUNCTION (this << packet << source << destination << incomingInterface);

445

  NS_LOG_FUNCTION (this << packet << source << destination << incomingInterface);

440

446

441

  TcpHeader tcpHeader;

447

  TcpHeader tcpHeader;

448

  if(m_calcChecksum)

449

450

    tcpHeader.EnableChecksums();

451

452

  /* XXX very dirty but needs this to AddHeader again because of checksum */

453

  tcpHeader.SetLength(5); /* XXX TCP without options */

454

  tcpHeader.SetPayloadSize(packet->GetSize() - tcpHeader.GetSerializedSize());

455

  tcpHeader.InitializeChecksum(source, destination, PROT_NUMBER);

456

442

  //these two do a peek, so that the packet can be forwarded up

457

  //these two do a peek, so that the packet can be forwarded up

443

  packet->RemoveHeader (tcpHeader);

458

  packet->RemoveHeader (tcpHeader);

459

444

  NS_LOG_LOGIC("TcpL4Protocol " << this

460

  NS_LOG_LOGIC("TcpL4Protocol " << this

445

               << " receiving seq " << tcpHeader.GetSequenceNumber()

461

               << " receiving seq " << tcpHeader.GetSequenceNumber()

446

               << " ack " << tcpHeader.GetAckNumber()

462

               << " ack " << tcpHeader.GetAckNumber()

447

               << " flags "<< std::hex << (int)tcpHeader.GetFlags() << std::dec

463

               << " flags "<< std::hex << (int)tcpHeader.GetFlags() << std::dec

448

               << " data size " << packet->GetSize());

464

               << " data size " << packet->GetSize());

449

  packet->AddHeader (tcpHeader);

465

466

  if(!tcpHeader.IsChecksumOk ())

467

468

    NS_LOG_INFO("Bad checksum, dropping packet!");

469

    return;

470

471

472

  packet->AddHeader (tcpHeader);

450

  NS_LOG_LOGIC ("TcpL4Protocol "<<this<<" received a packet");

473

  NS_LOG_LOGIC ("TcpL4Protocol "<<this<<" received a packet");

451

  Ipv4EndPointDemux::EndPoints endPoints =

474

  Ipv4EndPointDemux::EndPoints endPoints =

452

    m_endPoints->Lookup (destination, tcpHeader.GetDestinationPort (),

475

    m_endPoints->Lookup (destination, tcpHeader.GetDestinationPort (),

Lines 478-483 TcpL4Protocol::Send (Ptr<Packet> packet,	Link Here

478

  TcpHeader tcpHeader;

501

  TcpHeader tcpHeader;

479

  tcpHeader.SetDestinationPort (dport);

502

  tcpHeader.SetDestinationPort (dport);

480

  tcpHeader.SetSourcePort (sport);

503

  tcpHeader.SetSourcePort (sport);

504

  tcpHeader.SetPayloadSize(packet->GetSize());

505

  if(m_calcChecksum)

506

507

    tcpHeader.EnableChecksums();

508

481

  tcpHeader.InitializeChecksum (saddr,

509

  tcpHeader.InitializeChecksum (saddr,

482

                               daddr,

510

                               daddr,

483

                               PROT_NUMBER);

511

                               PROT_NUMBER);

Lines 507-514 TcpL4Protocol::SendPacket (Ptr<Packet> p	Link Here

507

  // XXX outgoingHeader cannot be logged

535

  // XXX outgoingHeader cannot be logged

508

536

509

  outgoingHeader.SetLength (5); //header length in units of 32bit words

537

  outgoingHeader.SetLength (5); //header length in units of 32bit words

510

  outgoingHeader.SetChecksum (0);  //XXX

538

  outgoingHeader.SetPayloadSize(packet->GetSize());

511

  outgoingHeader.SetUrgentPointer (0); //XXX

539

  /* outgoingHeader.SetUrgentPointer (0); //XXX */

540

  if(m_calcChecksum)

541

542

    outgoingHeader.EnableChecksums();

543

544

  outgoingHeader.InitializeChecksum(saddr, daddr, PROT_NUMBER);

512

545

513

  packet->AddHeader (outgoingHeader);

546

  packet->AddHeader (outgoingHeader);

514

547

(-)a/src/internet-stack/tcp-l4-protocol.h (+3 lines)

Lines 117-122 private:	Link Here

117

  void SendPacket (Ptr<Packet>, TcpHeader,

117

  void SendPacket (Ptr<Packet>, TcpHeader,

118

                  Ipv4Address, Ipv4Address);

118

                  Ipv4Address, Ipv4Address);

119

  static ObjectFactory GetDefaultRttEstimatorFactory (void);

119

  static ObjectFactory GetDefaultRttEstimatorFactory (void);

120

121

  bool m_goodChecksum;

122

  bool m_calcChecksum;

120

};

123

};

121

124

122

}; // namespace ns3

125

}; // namespace ns3




 */

#include "udp-header.h"
#include "ipv4-checksum.h"

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (UdpHeader);

bool UdpHeader::m_calcChecksum = false;

/* The magic values below are used only for debugging.
 * They can be used to easily detect memory corruption

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

                              Ipv4Address destination,
                              uint8_t protocol)
{
  Buffer buf = Buffer(12);
  uint8_t tmp[4];
  Buffer::Iterator it;
  uint16_t udpLength = m_payloadSize + GetSerializedSize();
  buf[9] = protocol;
  uint16_t udpLength = m_payloadSize + GetSerializedSize ();
  buf[10] = udpLength >> 8;
  buf[11] = udpLength & 0xff;

  buf.AddAtStart(12);
  it = buf.Begin();

  source.Serialize(tmp);
  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 */
  m_initialChecksum = ~(it.CalculateIpChecksum(12));
}

bool
UdpHeader::IsChecksumOk (void) const
{
  return m_goodChecksum; 
}


TypeId 
UdpHeader::GetTypeId (void)

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 (udpLength);
  i.WriteU16 (0);

  if (m_calcChecksum)
    {
      i = start;
      uint16_t checksum = i.CalculateIpChecksum(udpLength, m_initialChecksum);

      i = start;
      i.Next(6);
      i.WriteU16(checksum);
      i = buffer->Begin ();
      i.Next (6);
      i.WriteU16 (checksum);
#endif
    }
}
uint32_t

  m_sourcePort = i.ReadNtohU16 ();
  m_destinationPort = i.ReadNtohU16 ();
  m_payloadSize = i.ReadNtohU16 () - GetSerializedSize ();
  m_checksum = i.ReadU16();

  if(m_calcChecksum)
  {
      i = start;
      uint16_t checksum = i.CalculateIpChecksum(m_payloadSize + GetSerializedSize(), m_initialChecksum);

      m_goodChecksum = (checksum == 0);
  }

  return GetSerializedSize ();
}





  /**
   * \brief Enable checksum calculation for UDP (XXX currently has no effect)
   */
  void EnableChecksums (void);
  /**
   * \param port the destination port for this UdpHeader
   */

  virtual void Serialize (Buffer::Iterator start) const;
  virtual uint32_t Deserialize (Buffer::Iterator start);

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

private:
  uint16_t m_sourcePort;
  uint16_t m_destinationPort;
  uint16_t m_payloadSize;
  uint16_t m_initialChecksum;
  uint16_t m_checksum;

  bool m_calcChecksum;
  bool m_goodChecksum;
};

} // namespace ns3

(-)a/src/internet-stack/udp-l4-protocol.cc (-1 / +25 lines)

Lines 22-27	Link Here

#include "ns3/assert.h"

#include "ns3/assert.h"

#include "ns3/packet.h"

#include "ns3/packet.h"

#include "ns3/node.h"

#include "ns3/node.h"

#include "ns3/boolean.h"

#include "udp-l4-protocol.h"

#include "udp-l4-protocol.h"

#include "udp-header.h"

#include "udp-header.h"

Lines 45-50 UdpL4Protocol::GetTypeId (void)	Link Here

  static TypeId tid = TypeId ("ns3::UdpL4Protocol")

  static TypeId tid = TypeId ("ns3::UdpL4Protocol")

    .SetParent<Ipv4L4Protocol> ()

    .SetParent<Ipv4L4Protocol> ()

    .AddConstructor<UdpL4Protocol> ()

    .AddConstructor<UdpL4Protocol> ()

    .AddAttribute ("CalcChecksum", "If true, we calculate the checksum of outgoing packets"

                   " and verify the checksum of incoming packets.",

                   BooleanValue (false),

                   MakeBooleanAccessor (&UdpL4Protocol::m_calcChecksum),

                   MakeBooleanChecker ())

  return tid;

  return tid;

Lines 151-159 UdpL4Protocol::Receive(Ptr<Packet> packe	Link Here

151

                       Ptr<Ipv4Interface> interface)

157

                       Ptr<Ipv4Interface> interface)

152

158

153

  NS_LOG_FUNCTION (this << packet << source << destination);

159

  NS_LOG_FUNCTION (this << packet << source << destination);

160

  UdpHeader udpHeader;

161

  if(m_calcChecksum)

162

163

    udpHeader.EnableChecksums();

164

154

165

155

  UdpHeader udpHeader;

166

  udpHeader.SetPayloadSize (packet->GetSize () - udpHeader.GetSerializedSize ());

167

  udpHeader.InitializeChecksum (source, destination, PROT_NUMBER);

168

156

  packet->RemoveHeader (udpHeader);

169

  packet->RemoveHeader (udpHeader);

170

171

  if(!udpHeader.IsChecksumOk ())

172

173

    NS_LOG_INFO("Bad checksum : dropping packet!");

174

    return;

175

176

157

  Ipv4EndPointDemux::EndPoints endPoints =

177

  Ipv4EndPointDemux::EndPoints endPoints =

158

    m_endPoints->Lookup (destination, udpHeader.GetDestinationPort (),

178

    m_endPoints->Lookup (destination, udpHeader.GetDestinationPort (),

159

                         source, udpHeader.GetSourcePort (), interface);

179

                         source, udpHeader.GetSourcePort (), interface);

Lines 172-177 UdpL4Protocol::Send (Ptr<Packet> packet,	Link Here

172

  NS_LOG_FUNCTION (this << packet << saddr << daddr << sport << dport);

192

  NS_LOG_FUNCTION (this << packet << saddr << daddr << sport << dport);

173

193

174

  UdpHeader udpHeader;

194

  UdpHeader udpHeader;

195

  if(m_calcChecksum)

196

197

    udpHeader.EnableChecksums();

198

175

  udpHeader.SetDestinationPort (dport);

199

  udpHeader.SetDestinationPort (dport);

176

  udpHeader.SetSourcePort (sport);

200

  udpHeader.SetSourcePort (sport);

177

  udpHeader.SetPayloadSize (packet->GetSize ());

201

  udpHeader.SetPayloadSize (packet->GetSize ());

(-)a/src/internet-stack/udp-l4-protocol.h (+1 lines)

Lines 93-98 private:	Link Here

private:

private:

  Ptr<Node> m_node;

  Ptr<Node> m_node;

  Ipv4EndPointDemux *m_endPoints;

  Ipv4EndPointDemux *m_endPoints;

  bool m_calcChecksum;

};

};

}; // namespace ns3

}; // namespace ns3




    m_protocol (0),
    m_flags (0),
    m_fragmentOffset (0),
    m_checksum(0),
    m_goodChecksum (true)
{}


  return m_goodChecksum;
}

uint16_t
Ipv4Header::ChecksumCalculate(Buffer::Iterator &i, uint16_t size)
{
  /* see RFC 1071 to understand this code. */
  uint32_t sum = 0;

  for (int j = 0; j < size/2; j++)
    sum += i.ReadU16 ();

  if (size & 1)
     sum += i.ReadU8 ();

  while (sum >> 16)
    sum = (sum & 0xffff) + (sum >> 16);
  return ~sum;
}

TypeId 
Ipv4Header::GetTypeId (void)
{

  if (m_calcChecksum) 
    {
      i = start;
      uint16_t checksum = i.CalculateIpChecksum(20);
      NS_LOG_LOGIC ("checksum=" <<checksum);
      i = start;
      i.Next (10);

  m_fragmentOffset <<= 3;
  m_ttl = i.ReadU8 ();
  m_protocol = i.ReadU8 ();
  m_checksum = i.ReadU16();
  /* i.Next (2); // checksum */
  m_source.Set (i.ReadNtohU32 ());
  m_destination.Set (i.ReadNtohU32 ());

  if (m_calcChecksum) 
    {
      i = start;
      uint16_t checksum = i.CalculateIpChecksum(headerSize);
      NS_LOG_LOGIC ("checksum=" <<checksum);

      m_goodChecksum = (checksum == 0);

(-)a/src/node/ipv4-header.h (-1 / +1 lines)

Lines 146-152 public:	Link Here

146

  virtual uint32_t Deserialize (Buffer::Iterator start);

146

  virtual uint32_t Deserialize (Buffer::Iterator start);

147

private:

147

private:

148

149

  static uint16_t ChecksumCalculate(Buffer::Iterator &i, uint16_t len);

150

  enum FlagsE {

149

  enum FlagsE {

151

    DONT_FRAGMENT = (1<<0),

150

    DONT_FRAGMENT = (1<<0),

152

    MORE_FRAGMENTS = (1<<1)

151

    MORE_FRAGMENTS = (1<<1)

Lines 163-168 private:	Link Here

163

  uint16_t m_fragmentOffset : 13;

162

  uint16_t m_fragmentOffset : 13;

164

  Ipv4Address m_source;

163

  Ipv4Address m_source;

165

  Ipv4Address m_destination;

164

  Ipv4Address m_destination;

165

  uint16_t m_checksum;

166

  bool m_goodChecksum;

166

  bool m_goodChecksum;

167

};

167

};

168

Return to bug 236