Attachment #2672 for bug #2221

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





NS_LOG_COMPONENT_DEFINE ("PacketTagList");

PacketTagList::TagData::TagData (size_t dataSize)
  : size (dataSize)
{
  NS_ASSERT_MSG (dataSize < std::numeric_limits<decltype(size)>::max (),
                 "Requested TagData size " << dataSize
                 << " exceeds maximum "
                 << std::numeric_limits<decltype(size)>::max () );
  data = (uint8_t *) std::malloc (size);
}

PacketTagList::TagData::~TagData (void)
{
  free (data);
}

bool
PacketTagList::COWTraverse (Tag & tag, PacketTagList::COWWriter Writer)
{

      NS_ASSERT (cur != 0);
      NS_ASSERT (cur->count > 1);
      cur->count--;                       // unmerge cur
      struct TagData * copy = new struct TagData (cur->size);
      copy->tid = cur->tid;
      copy->count = 1;
      memcpy (copy->data, cur->data, copy->size);
      copy->next = cur->next;             // merge into tail
      copy->next->count++;                // mark new merge
      *prevNext = copy;                   // point prior list at copy


  // found tid
  bool found = true;
  tag.Deserialize (TagBuffer (cur->data, cur->data + cur->size));
                              cur->data + TagData::MAX_SIZE));
  *prevNext = cur->next;            // link around cur

  if (preMerge)

  if (preMerge)
    {
      // found tid before first merge, so just rewrite
      tag.Serialize (TagBuffer (cur->data, cur->data + cur->size));
                                cur->data + tag.GetSerializedSize ()));
    }
  else
    {
      // cur is always a merge at this point
      // need to copy, replace, and link past cur
      cur->count--;                     // unmerge cur
      struct TagData * copy = new struct TagData (tag.GetSerializedSize ());
      copy->tid = tag.GetInstanceTypeId ();
      copy->count = 1;
      tag.Serialize (TagBuffer (copy->data, copy->data + copy->size));
                                copy->data + tag.GetSerializedSize ()));
      copy->next = cur->next;           // merge into tail
      if (copy->next != 0)
        {

    {
      NS_ASSERT_MSG (cur->tid != tag.GetInstanceTypeId (), "Error: cannot add the same kind of tag twice.");
    }
  struct TagData * head = new struct TagData (tag.GetSerializedSize ());
  head->count = 1;
  head->next = 0;
  head->tid = tag.GetInstanceTypeId ();
  head->next = m_next;
  tag.Serialize (TagBuffer (head->data, head->data + head->size));
  tag.Serialize (TagBuffer (head->data, head->data + tag.GetSerializedSize ()));

  const_cast<PacketTagList *> (this)->m_next = head;
}

      if (cur->tid == tid) 
        {
          /* found tag */
          tag.Deserialize (TagBuffer (cur->data, cur->data + cur->size));
          return true;
        }
    }




   *
   * See PacketTagList for a discussion of the data structure.
   *
   * \internal
   * Unfortunately this has to be public, because
   * PacketTagIterator::Item::GetTag() needs the data and size values.
   * The Item nested class can't be forward declared, so friending isn't
   * possible.
   */
  struct TagData
  {
    TagData (size_t dataSize);  /**< Construct with dataSize bytes */
    ~TagData (void);            /**< Destructor */
    
    struct TagData * next;      /**< Pointer to next in list */
    uint32_t count;             /**< Number of incoming links */
    TypeId tid;                 /**< Type of the tag serialized into #data */
    uint32_t size;              /**< Size of the \c data buffer */
    uint8_t * data;             /**< Serialization buffer */
     * no padding on 64-bit architectures.  (The architecture
     * affects the size because of the \c #next pointer.)
     * This would leave 18 bytes for \c #data.  However,
     * ns3:Ipv6PacketInfoTag needs 19 bytes!  The current
     * implementation allows 20 bytes, which gives TagData
     * a size of 30 bytes on 32-byte machines (which gets
     * padded with 2 bytes), and 34 bytes on 64-bit machines, which
     * gets padded to 40 bytes.
     */
    enum TagData_e
    {
      MAX_SIZE = 21           /**< Size of serialization buffer #data */
  };

    uint8_t data[MAX_SIZE];   /**< Serialization buffer */
    struct TagData * next;   /**< Pointer to next in list */
    TypeId tid;               /**< Type of the tag serialized into #data */
    uint32_t count;           /**< Number of incoming links */
  };  /* struct TagData */

  /**

   *          pointing to \pname{cur}.
   * \returns True, since tag will definitely be removed.
   */
  bool RemoveWriter  (Tag & tag, bool preMerge,
                      struct TagData * cur, struct TagData ** prevNext);
  /**
   * Copy-on-write implementing Replace

   *          pointing to \pname{cur}.
   * \returns True, since tag value will definitely be replaced.
   */
  bool ReplaceWriter (Tag & tag, bool preMerge,
                      struct TagData * cur, struct TagData ** prevNext);

  /**
   * Pointer to first \ref TagData on the list

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

Lines 113-120	Link Here

113

114

  NS_ASSERT (tag.GetInstanceTypeId () == m_data->tid);

114

  NS_ASSERT (tag.GetInstanceTypeId () == m_data->tid);

115

  tag.Deserialize (TagBuffer ((uint8_t*)m_data->data,

115

  tag.Deserialize (TagBuffer ((uint8_t*)m_data->data,

116

                              (uint8_t*)m_data->data

116

                              (uint8_t*)m_data->data + m_data->size));

117

                              + PacketTagList::TagData::MAX_SIZE));

118

117

119

118

120

119

(-)a/src/network/utils/packet-socket.cc (-3 lines)

Lines 643-649	Link Here

643

DeviceNameTag::GetSerializedSize (void) const

643

DeviceNameTag::GetSerializedSize (void) const

644

645

  uint32_t s = 1 + m_deviceName.size();  // +1 for name length field

645

  uint32_t s = 1 + m_deviceName.size();  // +1 for name length field

646

  s = std::min (s, (uint32_t)PacketTagList::TagData::MAX_SIZE);

647

  return s;

646

  return s;

648

647

649

void

648

void

Lines 652-659	Link Here

652

  const char *n = m_deviceName.c_str();

651

  const char *n = m_deviceName.c_str();

653

  uint8_t l = (uint8_t) m_deviceName.size ();

652

  uint8_t l = (uint8_t) m_deviceName.size ();

654

653

655

  l = std::min ((uint32_t)l, (uint32_t)PacketTagList::TagData::MAX_SIZE - 1);

656

657

  i.WriteU8 (l);

654

  i.WriteU8 (l);

658

  i.Write ( (uint8_t*) n , (uint32_t) l);

655

  i.Write ( (uint8_t*) n , (uint32_t) l);

659

656

Return to bug 2221