Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code | Sign in
(513)

Unified Diff: src/internet-stack/ipv6-extension-header.cc

Issue 144048: Added IPv6 extensions
Patch Set: Created 14 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Please Sign in to add in-line comments.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: src/internet-stack/ipv6-extension-header.cc
===================================================================
new file mode 100644
--- /dev/null
+++ b/src/internet-stack/ipv6-extension-header.cc
@@ -0,0 +1,597 @@
+/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2007-2009 Strasbourg University
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation;
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Author: David Gross <gdavid.devel@gmail.com>
+ */
+
+#include "ns3/assert.h"
+#include "ns3/log.h"
+#include "ns3/header.h"
+#include "ipv6-extension-header.h"
+
+namespace ns3
+{
+
+NS_LOG_COMPONENT_DEFINE ("Ipv6ExtensionHeader");
+
+NS_OBJECT_ENSURE_REGISTERED (Ipv6ExtensionHeader);
+
+TypeId Ipv6ExtensionHeader::GetTypeId ()
+{
+ static TypeId tid = TypeId ("ns3::Ipv6ExtensionHeader")
+ .AddConstructor<Ipv6ExtensionHeader> ()
+ .SetParent<Header> ()
+ ;
+ return tid;
+}
+
+TypeId Ipv6ExtensionHeader::GetInstanceTypeId () const
+{
+ return GetTypeId ();
+}
+
+Ipv6ExtensionHeader::Ipv6ExtensionHeader ()
+ : m_nextHeader (0),
+ m_length (0),
+ m_data (0)
+{
+}
+
+Ipv6ExtensionHeader::~Ipv6ExtensionHeader ()
+{
+}
+
+void Ipv6ExtensionHeader::SetNextHeader (uint8_t nextHeader)
+{
+ m_nextHeader = nextHeader;
+}
+
+uint8_t Ipv6ExtensionHeader::GetNextHeader () const
+{
+ return m_nextHeader;
+}
+
+void Ipv6ExtensionHeader::SetLength (uint16_t length)
+{
+ m_length = (length >> 3) - 1;
+}
+
+uint16_t Ipv6ExtensionHeader::GetLength () const
+{
+ return (m_length + 1) << 3;
+}
+
+void Ipv6ExtensionHeader::Print (std::ostream &os) const
+{
+ os << "( nextHeader = " << (uint32_t)GetNextHeader () << " length = " << (uint32_t)GetLength () << " )";
+}
+
+uint32_t Ipv6ExtensionHeader::GetSerializedSize () const
+{
+ return 2;
+}
+
+void Ipv6ExtensionHeader::Serialize (Buffer::Iterator start) const
+{
+ Buffer::Iterator i = start;
+
+ i.WriteU8 (m_nextHeader);
+ i.WriteU8 (m_length);
+ i.Write (m_data.PeekData (), m_data.GetSize ());
+}
+
+uint32_t Ipv6ExtensionHeader::Deserialize (Buffer::Iterator start)
+{
+ Buffer::Iterator i = start;
+
+ m_nextHeader = i.ReadU8 ();
+ m_length = i.ReadU8 ();
+
+ uint32_t dataLength = GetLength () - 2;
+ uint8_t data[dataLength];
+ i.Read (data, dataLength);
+
+ if (dataLength > m_data.GetSize ())
+ {
+ m_data.AddAtEnd (dataLength - m_data.GetSize ());
+ }
+ else
+ {
+ m_data.RemoveAtEnd (m_data.GetSize () - dataLength);
+ }
+
+ i = m_data.Begin ();
+ i.Write (data, dataLength);
+
+ return GetSerializedSize ();
+}
+
+NS_OBJECT_ENSURE_REGISTERED (Ipv6ExtensionHopByHopHeader);
+
+TypeId Ipv6ExtensionHopByHopHeader::GetTypeId ()
+{
+ static TypeId tid = TypeId ("ns3::Ipv6ExtensionHopByHopHeader")
+ .AddConstructor<Ipv6ExtensionHopByHopHeader> ()
+ .SetParent<Ipv6ExtensionHeader> ()
+ ;
+ return tid;
+}
+
+TypeId Ipv6ExtensionHopByHopHeader::GetInstanceTypeId () const
+{
+ return GetTypeId ();
+}
+
+Ipv6ExtensionHopByHopHeader::Ipv6ExtensionHopByHopHeader ()
+{
+}
+
+Ipv6ExtensionHopByHopHeader::~Ipv6ExtensionHopByHopHeader ()
+{
+}
+
+void Ipv6ExtensionHopByHopHeader::Print (std::ostream &os) const
+{
+ os << "( nextHeader = " << (uint32_t)GetNextHeader () << " length = " << (uint32_t)GetLength () << " )";
+}
+
+uint32_t Ipv6ExtensionHopByHopHeader::GetSerializedSize () const
+{
+ return 2;
+}
+
+void Ipv6ExtensionHopByHopHeader::Serialize (Buffer::Iterator start) const
+{
+ Buffer::Iterator i = start;
+
+ i.WriteU8 (GetNextHeader ());
+ i.WriteU8 ((GetLength () >> 3) - 1);
+}
+
+uint32_t Ipv6ExtensionHopByHopHeader::Deserialize (Buffer::Iterator start)
+{
+ Buffer::Iterator i = start;
+
+ SetNextHeader (i.ReadU8 ());
+ SetLength ((i.ReadU8 () + 1) << 3);
+
+ return GetSerializedSize ();
+}
+
+NS_OBJECT_ENSURE_REGISTERED (Ipv6ExtensionDestinationHeader);
+
+TypeId Ipv6ExtensionDestinationHeader::GetTypeId ()
+{
+ static TypeId tid = TypeId ("ns3::Ipv6ExtensionDestinationHeader")
+ .AddConstructor<Ipv6ExtensionDestinationHeader> ()
+ .SetParent<Ipv6ExtensionHeader> ()
+ ;
+ return tid;
+}
+
+TypeId Ipv6ExtensionDestinationHeader::GetInstanceTypeId () const
+{
+ return GetTypeId ();
+}
+
+Ipv6ExtensionDestinationHeader::Ipv6ExtensionDestinationHeader ()
+{
+}
+
+Ipv6ExtensionDestinationHeader::~Ipv6ExtensionDestinationHeader ()
+{
+}
+
+void Ipv6ExtensionDestinationHeader::Print (std::ostream &os) const
+{
+ os << "( nextHeader = " << (uint32_t)GetNextHeader () << " length = " << (uint32_t)GetLength () << " )";
+}
+
+uint32_t Ipv6ExtensionDestinationHeader::GetSerializedSize () const
+{
+ return 2;
+}
+
+void Ipv6ExtensionDestinationHeader::Serialize (Buffer::Iterator start) const
+{
+ Buffer::Iterator i = start;
+
+ i.WriteU8 (GetNextHeader ());
+ i.WriteU8 ((GetLength () >> 3) - 1);
+}
+
+uint32_t Ipv6ExtensionDestinationHeader::Deserialize (Buffer::Iterator start)
+{
+ Buffer::Iterator i = start;
+
+ SetNextHeader (i.ReadU8 ());
+ SetLength ((i.ReadU8 () + 1) << 3);
+
+ return GetSerializedSize ();
+}
+
+NS_OBJECT_ENSURE_REGISTERED (Ipv6ExtensionFragmentHeader);
+
+TypeId Ipv6ExtensionFragmentHeader::GetTypeId ()
+{
+ static TypeId tid = TypeId ("ns3::Ipv6ExtensionFragmentHeader")
+ .AddConstructor<Ipv6ExtensionFragmentHeader> ()
+ .SetParent<Ipv6ExtensionHeader> ()
+ ;
+ return tid;
+}
+
+TypeId Ipv6ExtensionFragmentHeader::GetInstanceTypeId () const
+{
+ return GetTypeId ();
+}
+
+Ipv6ExtensionFragmentHeader::Ipv6ExtensionFragmentHeader ()
+ : m_offset (0),
+ m_identification (0)
+{
+}
+
+Ipv6ExtensionFragmentHeader::~Ipv6ExtensionFragmentHeader ()
+{
+}
+
+void Ipv6ExtensionFragmentHeader::SetOffset (uint16_t offset)
+{
+ // Clear the offset, and save the MF bit
+ m_offset &= 1;
+ m_offset |= offset & (~7);
+}
+
+uint16_t Ipv6ExtensionFragmentHeader::GetOffset () const
+{
+ return m_offset & (~1);
+}
+
+void Ipv6ExtensionFragmentHeader::SetMoreFragment (bool moreFragment)
+{
+ m_offset = moreFragment ? m_offset | 1 : m_offset & (~1);
+}
+
+bool Ipv6ExtensionFragmentHeader::GetMoreFragment () const
+{
+ return m_offset & 1;
+}
+
+void Ipv6ExtensionFragmentHeader::SetIdentification (uint32_t identification)
+{
+ m_identification = identification;
+}
+
+uint32_t Ipv6ExtensionFragmentHeader::GetIdentification () const
+{
+ return m_identification;
+}
+
+void Ipv6ExtensionFragmentHeader::Print (std::ostream &os) const
+{
+ os << "( nextHeader = " << (uint32_t)GetNextHeader () << " length = " << (uint32_t)GetLength ()
+ << " offset = " << (uint32_t)GetOffset () << " MF = " << (uint32_t)GetMoreFragment () << " identification = " << (uint32_t)m_identification << " )";
+}
+
+uint32_t Ipv6ExtensionFragmentHeader::GetSerializedSize () const
+{
+ return 8;
+}
+
+void Ipv6ExtensionFragmentHeader::Serialize (Buffer::Iterator start) const
+{
+ Buffer::Iterator i = start;
+
+ i.WriteU8 (GetNextHeader ());
+ i.WriteU8 ((GetLength () >> 3) - 1);
+ i.WriteHtonU16 (m_offset);
+ i.WriteHtonU32 (m_identification);
+}
+
+uint32_t Ipv6ExtensionFragmentHeader::Deserialize (Buffer::Iterator start)
+{
+ Buffer::Iterator i = start;
+
+ SetNextHeader (i.ReadU8 ());
+ SetLength ((i.ReadU8 () + 1) << 3);
+ m_offset = i.ReadNtohU16 ();
+ m_identification = i.ReadNtohU32 ();
+
+ return GetSerializedSize ();
+}
+
+NS_OBJECT_ENSURE_REGISTERED (Ipv6ExtensionRoutingHeader);
+
+TypeId Ipv6ExtensionRoutingHeader::GetTypeId ()
+{
+ static TypeId tid = TypeId ("ns3::Ipv6ExtensionRoutingHeader")
+ .AddConstructor<Ipv6ExtensionRoutingHeader> ()
+ .SetParent<Ipv6ExtensionHeader> ()
+ ;
+ return tid;
+}
+
+TypeId Ipv6ExtensionRoutingHeader::GetInstanceTypeId () const
+{
+ return GetTypeId ();
+}
+
+Ipv6ExtensionRoutingHeader::Ipv6ExtensionRoutingHeader ()
+ : m_typeRouting (0),
+ m_segmentsLeft (0)
+{
+}
+
+Ipv6ExtensionRoutingHeader::~Ipv6ExtensionRoutingHeader ()
+{
+}
+
+void Ipv6ExtensionRoutingHeader::SetTypeRouting (uint8_t typeRouting)
+{
+ m_typeRouting = typeRouting;
+}
+
+uint8_t Ipv6ExtensionRoutingHeader::GetTypeRouting () const
+{
+ return m_typeRouting;
+}
+
+void Ipv6ExtensionRoutingHeader::SetSegmentsLeft (uint8_t segmentsLeft)
+{
+ m_segmentsLeft = segmentsLeft;
+}
+
+uint8_t Ipv6ExtensionRoutingHeader::GetSegmentsLeft () const
+{
+ return m_segmentsLeft;
+}
+
+void Ipv6ExtensionRoutingHeader::Print (std::ostream &os) const
+{
+ os << "( nextHeader = " << (uint32_t)GetNextHeader () << " length = " << (uint32_t)GetLength ()
+ << " typeRouting = " << (uint32_t)m_typeRouting << " segmentsLeft = " << (uint32_t)m_segmentsLeft << " )";
+}
+
+uint32_t Ipv6ExtensionRoutingHeader::GetSerializedSize () const
+{
+ return 4;
+}
+
+void Ipv6ExtensionRoutingHeader::Serialize (Buffer::Iterator start) const
+{
+ Buffer::Iterator i = start;
+
+ i.WriteU8 (GetNextHeader ());
+ i.WriteU8 ((GetLength () >> 3) - 1);
+ i.WriteU8 (m_typeRouting);
+ i.WriteU8 (m_segmentsLeft);
+}
+
+uint32_t Ipv6ExtensionRoutingHeader::Deserialize (Buffer::Iterator start)
+{
+ Buffer::Iterator i = start;
+
+ SetNextHeader (i.ReadU8 ());
+ SetLength ((i.ReadU8 () + 1) << 3);
+ m_typeRouting = i.ReadU8 ();
+ m_segmentsLeft = i.ReadU8 ();
+
+ return GetSerializedSize ();
+}
+
+NS_OBJECT_ENSURE_REGISTERED (Ipv6ExtensionLooseRoutingHeader);
+
+TypeId Ipv6ExtensionLooseRoutingHeader::GetTypeId ()
+{
+ static TypeId tid = TypeId ("ns3::Ipv6ExtensionLooseRoutingHeader")
+ .AddConstructor<Ipv6ExtensionLooseRoutingHeader> ()
+ .SetParent<Ipv6ExtensionRoutingHeader> ()
+ ;
+ return tid;
+}
+
+TypeId Ipv6ExtensionLooseRoutingHeader::GetInstanceTypeId () const
+{
+ return GetTypeId ();
+}
+
+Ipv6ExtensionLooseRoutingHeader::Ipv6ExtensionLooseRoutingHeader ()
+ : m_routersAddress (0)
+{
+}
+
+Ipv6ExtensionLooseRoutingHeader::~Ipv6ExtensionLooseRoutingHeader ()
+{
+}
+
+void Ipv6ExtensionLooseRoutingHeader::SetNumberAddress (uint8_t n)
+{
+ m_routersAddress.clear ();
+ m_routersAddress.assign (n, Ipv6Address (""));
+}
+
+void Ipv6ExtensionLooseRoutingHeader::SetRoutersAddress (std::vector<Ipv6Address> routersAddress)
+{
+ m_routersAddress = routersAddress;
+}
+
+std::vector<Ipv6Address> Ipv6ExtensionLooseRoutingHeader::GetRoutersAddress () const
+{
+ return m_routersAddress;
+}
+
+void Ipv6ExtensionLooseRoutingHeader::SetRouterAddress (uint8_t index, Ipv6Address addr)
+{
+ m_routersAddress.at (index) = addr;
+}
+
+Ipv6Address Ipv6ExtensionLooseRoutingHeader::GetRouterAddress (uint8_t index) const
+{
+ return m_routersAddress.at (index);
+}
+
+void Ipv6ExtensionLooseRoutingHeader::Print (std::ostream &os) const
+{
+ os << "( nextHeader = " << (uint32_t)GetNextHeader () << " length = " << (uint32_t)GetLength ()
+ << " typeRouting = " << (uint32_t)GetTypeRouting () << " segmentsLeft = " << (uint32_t)GetSegmentsLeft () << " ";
+
+ for (std::vector<Ipv6Address>::const_iterator it = m_routersAddress.begin (); it != m_routersAddress.end (); it++)
+ {
+ os << *it << " ";
+ }
+
+ os << " )";
+}
+
+uint32_t Ipv6ExtensionLooseRoutingHeader::GetSerializedSize () const
+{
+ return 8 + m_routersAddress.size () * 16;
+}
+
+void Ipv6ExtensionLooseRoutingHeader::Serialize (Buffer::Iterator start) const
+{
+ Buffer::Iterator i = start;
+ uint8_t buff[16];
+
+ i.WriteU8 (GetNextHeader ());
+ i.WriteU8 ((GetLength () >> 3) - 1);
+ i.WriteU8 (GetTypeRouting ());
+ i.WriteU8 (GetSegmentsLeft ());
+ i.WriteU32 (0);
+
+ for (VectorIpv6Address_t::const_iterator it = m_routersAddress.begin (); it != m_routersAddress.end () ; it++)
+ {
+ it->Serialize (buff);
+ i.Write (buff, 16);
+ }
+}
+
+uint32_t Ipv6ExtensionLooseRoutingHeader::Deserialize (Buffer::Iterator start)
+{
+ Buffer::Iterator i = start;
+ uint8_t buff[16];
+
+ SetNextHeader (i.ReadU8 ());
+ SetLength ((i.ReadU8 () + 1) << 3);
+ SetTypeRouting (i.ReadU8 ());
+ SetSegmentsLeft (i.ReadU8 ());
+ i.ReadU32 ();
+
+ for (std::vector<Ipv6Address>::iterator it = m_routersAddress.begin (); it != m_routersAddress.end (); it++)
+ {
+ i.Read (buff, 16);
+ it->Set (buff);
+ }
+
+ return GetSerializedSize ();
+}
+
+NS_OBJECT_ENSURE_REGISTERED (Ipv6ExtensionESPHeader);
+
+TypeId Ipv6ExtensionESPHeader::GetTypeId ()
+{
+ static TypeId tid = TypeId ("ns3::Ipv6ExtensionESPHeader")
+ .AddConstructor<Ipv6ExtensionESPHeader> ()
+ .SetParent<Ipv6ExtensionHeader> ()
+ ;
+ return tid;
+}
+
+TypeId Ipv6ExtensionESPHeader::GetInstanceTypeId () const
+{
+ return GetTypeId ();
+}
+
+Ipv6ExtensionESPHeader::Ipv6ExtensionESPHeader ()
+{
+}
+
+Ipv6ExtensionESPHeader::~Ipv6ExtensionESPHeader ()
+{
+}
+
+void Ipv6ExtensionESPHeader::Print (std::ostream &os) const
+{
+ /* TODO */
moatamri 2009/10/30 11:31:30 why they are left here if they are not done yet? t
ping67 2009/11/02 17:09:10 We (Strasbourg University) have no plans to addres
+}
+
+uint32_t Ipv6ExtensionESPHeader::GetSerializedSize () const
+{
+ /* TODO */
+ return 0;
+}
+
+void Ipv6ExtensionESPHeader::Serialize (Buffer::Iterator start) const
+{
+ /* TODO */
+}
+
+uint32_t Ipv6ExtensionESPHeader::Deserialize (Buffer::Iterator start)
+{
+ /* TODO */
+ return 0;
+}
+
+NS_OBJECT_ENSURE_REGISTERED (Ipv6ExtensionAHHeader);
+
+TypeId Ipv6ExtensionAHHeader::GetTypeId ()
+{
+ static TypeId tid = TypeId ("ns3::Ipv6ExtensionAHHeader")
+ .AddConstructor<Ipv6ExtensionAHHeader> ()
+ .SetParent<Ipv6ExtensionHeader> ()
+ ;
+ return tid;
+}
+
+TypeId Ipv6ExtensionAHHeader::GetInstanceTypeId () const
+{
+ return GetTypeId ();
+}
+
+Ipv6ExtensionAHHeader::Ipv6ExtensionAHHeader ()
+{
+}
+
+Ipv6ExtensionAHHeader::~Ipv6ExtensionAHHeader ()
+{
+}
+
+void Ipv6ExtensionAHHeader::Print (std::ostream &os) const
+{
+ /* TODO */
+}
+
+uint32_t Ipv6ExtensionAHHeader::GetSerializedSize () const
+{
+ /* TODO */
+ return 0;
+}
+
+void Ipv6ExtensionAHHeader::Serialize (Buffer::Iterator start) const
+{
+ /* TODO */
+}
+
+uint32_t Ipv6ExtensionAHHeader::Deserialize (Buffer::Iterator start)
+{
+ /* TODO */
+ return 0;
+}
+
+} /* namespace ns3 */
+

Powered by Google App Engine
RSS Feeds Recent Issues | This issue
This is Rietveld f62528b