Attachment #2851 for bug #2505

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

(-)a/src/network/model/chunk.cc (+8 lines)

Lines 34-37	Link Here

  return tid;

  return tid;

// This default implementation is provided for backward compatibility

// reasons.  Subclasses should implement this method themselves.

uint32_t

Chunk::Deserialize (Buffer::Iterator start, Buffer::Iterator end)

  return Deserialize (start);

} // namespace ns3

} // namespace ns3





  /**
   * \brief Deserialize the object from a buffer iterator
   *
   * This version of Deserialize can be used when the Chunk has a fixed
   * size.  It should not be called for variable-sized Chunk derived types
   * (but must be implemented, for historical reasons).
   *
   * \param start the buffer iterator
   * \returns the number of deserialized bytes
   */
  virtual uint32_t Deserialize (Buffer::Iterator start) = 0;

  /**
   * \brief Deserialize the object from a buffer iterator
   *
   * This version of Deserialize must be used when the Chunk has a variable
   * size, because the bounds of the Chunk may not be known at the point
   * of deserialization (e.g. a sequence of TLV fields).
   *
   * The size of the chunk should be start.GetDistanceFrom (end);
   *
   * \param start the starting point
   * \param end the ending point
   * \returns the number of deserialized bytes
   */
  virtual uint32_t Deserialize (Buffer::Iterator start, Buffer::Iterator end);

  /**
   * \brief Print the object contents
   * \param os the output stream
   */

(-)a/src/network/model/header.h (+2 lines)

*/

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  virtual ~Header ();

  virtual ~Header ();

  using Chunk::Deserialize;

/**

/**

   * \returns the expected size of the header.

   * \returns the expected size of the header.

(-)a/src/network/model/packet.cc (-1 / +39 lines)

Lines 264-269	Link Here

264

  m_metadata.AddHeader (header, size);

264

  m_metadata.AddHeader (header, size);

265

266

uint32_t

266

uint32_t

267

Packet::RemoveHeader (Header &header, uint32_t size)

268

269

  Buffer::Iterator end;

270

  end = m_buffer.Begin ();

271

  end.Next (size);

272

  uint32_t deserialized = header.Deserialize (m_buffer.Begin (), end);

273

  NS_LOG_FUNCTION (this << header.GetInstanceTypeId ().GetName () << deserialized);

274

  m_buffer.RemoveAtStart (deserialized);

275

  m_byteTagList.Adjust (-deserialized);

276

  m_metadata.RemoveHeader (header, deserialized);

277

  return deserialized;

278

279

uint32_t

267

Packet::RemoveHeader (Header &header)

280

Packet::RemoveHeader (Header &header)

268

281

269

  uint32_t deserialized = header.Deserialize (m_buffer.Begin ());

282

  uint32_t deserialized = header.Deserialize (m_buffer.Begin ());

Lines 280-285	Link Here

280

  NS_LOG_FUNCTION (this << header.GetInstanceTypeId ().GetName () << deserialized);

293

  NS_LOG_FUNCTION (this << header.GetInstanceTypeId ().GetName () << deserialized);

281

  return deserialized;

294

  return deserialized;

282

295

296

uint32_t

297

Packet::PeekHeader (Header &header, uint32_t size) const

298

299

  Buffer::Iterator end;

300

  end = m_buffer.Begin ();

301

  end.Next (size);

302

  uint32_t deserialized = header.Deserialize (m_buffer.Begin (), end);

303

  NS_LOG_FUNCTION (this << header.GetInstanceTypeId ().GetName () << deserialized);

304

  return deserialized;

305

283

void

306

void

284

Packet::AddTrailer (const Trailer &trailer)

307

Packet::AddTrailer (const Trailer &trailer)

285

308

Lines 445-451	Link Here

445

                NS_ASSERT (instance != 0);

468

                NS_ASSERT (instance != 0);

446

                Chunk *chunk = dynamic_cast<Chunk *> (instance);

469

                Chunk *chunk = dynamic_cast<Chunk *> (instance);

447

                NS_ASSERT (chunk != 0);

470

                NS_ASSERT (chunk != 0);

448

                chunk->Deserialize (item.current);

471

                if (item.type == PacketMetadata::Item::HEADER)

472

473

                    Buffer::Iterator end = item.current;

474

                    end.Next (item.currentSize); // move from start

475

                    chunk->Deserialize (item.current, end);

476

477

                else if (item.type == PacketMetadata::Item::TRAILER)

478

479

                    Buffer::Iterator start = item.current;

480

                    start.Prev (item.currentSize); // move from end

481

                    chunk->Deserialize (start, item.current);

482

483

                else

484

485

                    chunk->Deserialize (item.current);

486

449

                chunk->Print (os);

487

                chunk->Print (os);

450

                delete chunk;

488

                delete chunk;

451

489




  /**
   * \brief Deserialize and remove the header from the internal buffer.
   *
   * This method invokes Header::Deserialize (begin) and should be used for
   * variable-length headers.
   *
   * \param header a reference to the header to remove from the internal buffer.
   * \returns the number of bytes removed from the packet.
   */
  uint32_t RemoveHeader (Header &header);
  /**
   * \brief Deserialize and remove the header from the internal buffer.
   *
   * This method invokes Header::Deserialize (begin, end) and should be 
   * used for variable-length headers (where the size is determined somehow
   * by the caller).
   *
   * \param header a reference to the header to remove from the internal buffer.
   * \param size number of bytes to deserialize
   * \returns the number of bytes removed from the packet.
   */
  uint32_t RemoveHeader (Header &header, uint32_t size);
  /**
   * \brief Deserialize but does _not_ remove the header from the internal buffer.
   * s
   * This method invokes Header::Deserialize.

   */
  uint32_t PeekHeader (Header &header) const;
  /**
   * \brief Deserialize but does _not_ remove the header from the internal buffer.
   * s
   * This method invokes Header::Deserialize (begin, end) and should be used
   * for variable-length headers (where the size is determined somehow
   * by the caller).
   *
   * \param header a reference to the header to read from the internal buffer.
   * \param size number of bytes to deserialize
   * \returns the number of bytes read from the packet.
   */
  uint32_t PeekHeader (Header &header, uint32_t size) const;
  /**
   * \brief Add trailer to this packet.
   *
   * This method invokes the

(-)a/src/network/model/trailer.cc (+8 lines)

Lines 42-47	Link Here

  return tid;

  return tid;

// This default implementation is provided for backward compatibility

// reasons.  Subclasses should implement this method themselves.

uint32_t

Trailer::Deserialize (Buffer::Iterator start, Buffer::Iterator end)

  return Deserialize (end);

std::ostream & operator << (std::ostream &os, const Trailer &trailer)

std::ostream & operator << (std::ostream &os, const Trailer &trailer)

  trailer.Print (os);

  trailer.Print (os);




   * representation of this trailer in real networks.
   * The input iterator points to the end of the area where the 
   * data shall be written. This method is thus expected to call
   * Buffer::Iterator::Prev prior to actually reading any data.
   */
  virtual uint32_t Deserialize (Buffer::Iterator end) = 0;
  /**
   * \param start an iterator which points to the start of the buffer
   *        where the trailer should be read from.
   * \param end an iterator which points to the end of the buffer
   *        where the trailer should be read from.
   * \returns the number of bytes read.
   *
   * This method is used by Packet::RemoveTrailer to
   * re-create a trailer from the byte buffer of a packet. 
   * The data read is expected to match bit-for-bit the 
   * representation of this trailer in real networks.
   * The input iterator end points to the end of the area where the 
   * data shall be written. 
   *
   * This variant should be provided by any variable-sized trailer subclass
   * (i.e. if GetSerializedSize () does not return a constant). 
   */
  virtual uint32_t Deserialize (Buffer::Iterator start, Buffer::Iterator end);
  /**
   * \param os output stream
   * This method is used by Packet::Print to print the 
   * content of a trailer as ascii data to a c++ output stream.

Return to bug 2505