--- a/RELEASE_NOTES Tue Apr 08 14:07:33 2014 -0700
+++ b/RELEASE_NOTES Mon Apr 21 11:32:45 2014 +0200
@@ -38,6 +38,8 @@
its original design.
- A new IPv6 routing protocol has been added: RIPng. This protocol is
an Interior Gateway Protocol and it is available in the Internet module.
+- FlowMonitor can now track IPv6 packets.
+
Bugs fixed
----------
@@ -48,6 +50,7 @@
- Bug 1787 - Runtime error when using AnimationInterface::EnablePacketMetadata() to fetch metadata of CSMA packet
- Bug 1792 - Parameter logger constructor
- Bug 1808 - FlowMon relies on IPv4's Identification field to trace packets
+- Bug 1818 - FlowMonitor needs IPv6 support
- Bug 1821 - Setting an interface to Down state will cause various asserts in IPv6
- Bug 1837 - AODV crashes when using multiple interfaces
- Bug 1838 - FlowMonitorHelper must not be copied.
--- a/src/flow-monitor/bindings/modulegen__gcc_ILP32.py Tue Apr 08 14:07:33 2014 -0700
+++ b/src/flow-monitor/bindings/modulegen__gcc_ILP32.py Mon Apr 21 11:32:45 2014 +0200
@@ -74,6 +74,12 @@
module.add_class('Ipv6Address', import_from_module='ns.network')
## ipv6-address.h (module 'network'): ns3::Ipv6Address [class]
root_module['ns3::Ipv6Address'].implicitly_converts_to(root_module['ns3::Address'])
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress [class]
+ module.add_class('Ipv6InterfaceAddress', import_from_module='ns.internet')
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::State_e [enumeration]
+ module.add_enum('State_e', ['TENTATIVE', 'DEPRECATED', 'PREFERRED', 'PERMANENT', 'HOMEADDRESS', 'TENTATIVE_OPTIMISTIC', 'INVALID'], outer_class=root_module['ns3::Ipv6InterfaceAddress'], import_from_module='ns.internet')
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Scope_e [enumeration]
+ module.add_enum('Scope_e', ['HOST', 'LINKLOCAL', 'GLOBAL'], outer_class=root_module['ns3::Ipv6InterfaceAddress'], import_from_module='ns.internet')
## ipv6-address.h (module 'network'): ns3::Ipv6Prefix [class]
module.add_class('Ipv6Prefix', import_from_module='ns.network')
## node-container.h (module 'network'): ns3::NodeContainer [class]
@@ -110,6 +116,8 @@
module.add_class('Tag', import_from_module='ns.network', parent=root_module['ns3::ObjectBase'])
## tag-buffer.h (module 'network'): ns3::TagBuffer [class]
module.add_class('TagBuffer', import_from_module='ns.network')
+ ## nstime.h (module 'core'): ns3::TimeWithUnit [class]
+ module.add_class('TimeWithUnit', import_from_module='ns.core')
## type-id.h (module 'core'): ns3::TypeId [class]
module.add_class('TypeId', import_from_module='ns.core')
## type-id.h (module 'core'): ns3::TypeId::AttributeFlag [enumeration]
@@ -134,6 +142,10 @@
module.add_enum('DscpType', ['DscpDefault', 'DSCP_CS1', 'DSCP_AF11', 'DSCP_AF12', 'DSCP_AF13', 'DSCP_CS2', 'DSCP_AF21', 'DSCP_AF22', 'DSCP_AF23', 'DSCP_CS3', 'DSCP_AF31', 'DSCP_AF32', 'DSCP_AF33', 'DSCP_CS4', 'DSCP_AF41', 'DSCP_AF42', 'DSCP_AF43', 'DSCP_CS5', 'DSCP_EF', 'DSCP_CS6', 'DSCP_CS7'], outer_class=root_module['ns3::Ipv4Header'], import_from_module='ns.internet')
## ipv4-header.h (module 'internet'): ns3::Ipv4Header::EcnType [enumeration]
module.add_enum('EcnType', ['ECN_NotECT', 'ECN_ECT1', 'ECN_ECT0', 'ECN_CE'], outer_class=root_module['ns3::Ipv4Header'], import_from_module='ns.internet')
+ ## ipv6-header.h (module 'internet'): ns3::Ipv6Header [class]
+ module.add_class('Ipv6Header', import_from_module='ns.internet', parent=root_module['ns3::Header'])
+ ## ipv6-header.h (module 'internet'): ns3::Ipv6Header::NextHeader_e [enumeration]
+ module.add_enum('NextHeader_e', ['IPV6_EXT_HOP_BY_HOP', 'IPV6_IPV4', 'IPV6_TCP', 'IPV6_UDP', 'IPV6_IPV6', 'IPV6_EXT_ROUTING', 'IPV6_EXT_FRAGMENTATION', 'IPV6_EXT_CONFIDENTIALITY', 'IPV6_EXT_AUTHENTIFICATION', 'IPV6_ICMPV6', 'IPV6_EXT_END', 'IPV6_EXT_DESTINATION', 'IPV6_SCTP', 'IPV6_EXT_MOBILITY', 'IPV6_UDP_LITE'], outer_class=root_module['ns3::Ipv6Header'], import_from_module='ns.internet')
## object.h (module 'core'): ns3::Object [class]
module.add_class('Object', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])
## object.h (module 'core'): ns3::Object::AggregateIterator [class]
@@ -246,10 +258,26 @@
module.add_class('Ipv4Route', import_from_module='ns.internet', parent=root_module['ns3::SimpleRefCount< ns3::Ipv4Route, ns3::empty, ns3::DefaultDeleter<ns3::Ipv4Route> >'])
## ipv4-routing-protocol.h (module 'internet'): ns3::Ipv4RoutingProtocol [class]
module.add_class('Ipv4RoutingProtocol', import_from_module='ns.internet', parent=root_module['ns3::Object'])
+ ## ipv6.h (module 'internet'): ns3::Ipv6 [class]
+ module.add_class('Ipv6', import_from_module='ns.internet', parent=root_module['ns3::Object'])
## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker [class]
module.add_class('Ipv6AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue [class]
module.add_class('Ipv6AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier [class]
+ module.add_class('Ipv6FlowClassifier', parent=root_module['ns3::FlowClassifier'])
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple [struct]
+ module.add_class('FiveTuple', outer_class=root_module['ns3::Ipv6FlowClassifier'])
+ ## ipv6-flow-probe.h (module 'flow-monitor'): ns3::Ipv6FlowProbe [class]
+ module.add_class('Ipv6FlowProbe', parent=root_module['ns3::FlowProbe'])
+ ## ipv6-flow-probe.h (module 'flow-monitor'): ns3::Ipv6FlowProbe::DropReason [enumeration]
+ module.add_enum('DropReason', ['DROP_NO_ROUTE', 'DROP_TTL_EXPIRE', 'DROP_BAD_CHECKSUM', 'DROP_QUEUE', 'DROP_INTERFACE_DOWN', 'DROP_ROUTE_ERROR', 'DROP_UNKNOWN_PROTOCOL', 'DROP_UNKNOWN_OPTION', 'DROP_MALFORMED_HEADER', 'DROP_FRAGMENT_TIMEOUT', 'DROP_INVALID_REASON'], outer_class=root_module['ns3::Ipv6FlowProbe'])
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ipv6L3Protocol [class]
+ module.add_class('Ipv6L3Protocol', import_from_module='ns.internet', parent=root_module['ns3::Ipv6'])
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ipv6L3Protocol::DropReason [enumeration]
+ module.add_enum('DropReason', ['DROP_TTL_EXPIRED', 'DROP_NO_ROUTE', 'DROP_INTERFACE_DOWN', 'DROP_ROUTE_ERROR', 'DROP_UNKNOWN_PROTOCOL', 'DROP_UNKNOWN_OPTION', 'DROP_MALFORMED_HEADER', 'DROP_FRAGMENT_TIMEOUT'], outer_class=root_module['ns3::Ipv6L3Protocol'], import_from_module='ns.internet')
+ ## ipv6-pmtu-cache.h (module 'internet'): ns3::Ipv6PmtuCache [class]
+ module.add_class('Ipv6PmtuCache', import_from_module='ns.internet', parent=root_module['ns3::Object'])
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker [class]
module.add_class('Ipv6PrefixChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue [class]
@@ -361,6 +389,7 @@
register_Ns3Ipv4InterfaceAddress_methods(root_module, root_module['ns3::Ipv4InterfaceAddress'])
register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
register_Ns3Ipv6Address_methods(root_module, root_module['ns3::Ipv6Address'])
+ register_Ns3Ipv6InterfaceAddress_methods(root_module, root_module['ns3::Ipv6InterfaceAddress'])
register_Ns3Ipv6Prefix_methods(root_module, root_module['ns3::Ipv6Prefix'])
register_Ns3NodeContainer_methods(root_module, root_module['ns3::NodeContainer'])
register_Ns3ObjectBase_methods(root_module, root_module['ns3::ObjectBase'])
@@ -377,6 +406,7 @@
register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator'])
register_Ns3Tag_methods(root_module, root_module['ns3::Tag'])
register_Ns3TagBuffer_methods(root_module, root_module['ns3::TagBuffer'])
+ register_Ns3TimeWithUnit_methods(root_module, root_module['ns3::TimeWithUnit'])
register_Ns3TypeId_methods(root_module, root_module['ns3::TypeId'])
register_Ns3TypeIdAttributeInformation_methods(root_module, root_module['ns3::TypeId::AttributeInformation'])
register_Ns3TypeIdTraceSourceInformation_methods(root_module, root_module['ns3::TypeId::TraceSourceInformation'])
@@ -385,6 +415,7 @@
register_Ns3Chunk_methods(root_module, root_module['ns3::Chunk'])
register_Ns3Header_methods(root_module, root_module['ns3::Header'])
register_Ns3Ipv4Header_methods(root_module, root_module['ns3::Ipv4Header'])
+ register_Ns3Ipv6Header_methods(root_module, root_module['ns3::Ipv6Header'])
register_Ns3Object_methods(root_module, root_module['ns3::Object'])
register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])
register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])
@@ -435,8 +466,14 @@
register_Ns3Ipv4MulticastRoute_methods(root_module, root_module['ns3::Ipv4MulticastRoute'])
register_Ns3Ipv4Route_methods(root_module, root_module['ns3::Ipv4Route'])
register_Ns3Ipv4RoutingProtocol_methods(root_module, root_module['ns3::Ipv4RoutingProtocol'])
+ register_Ns3Ipv6_methods(root_module, root_module['ns3::Ipv6'])
register_Ns3Ipv6AddressChecker_methods(root_module, root_module['ns3::Ipv6AddressChecker'])
register_Ns3Ipv6AddressValue_methods(root_module, root_module['ns3::Ipv6AddressValue'])
+ register_Ns3Ipv6FlowClassifier_methods(root_module, root_module['ns3::Ipv6FlowClassifier'])
+ register_Ns3Ipv6FlowClassifierFiveTuple_methods(root_module, root_module['ns3::Ipv6FlowClassifier::FiveTuple'])
+ register_Ns3Ipv6FlowProbe_methods(root_module, root_module['ns3::Ipv6FlowProbe'])
+ register_Ns3Ipv6L3Protocol_methods(root_module, root_module['ns3::Ipv6L3Protocol'])
+ register_Ns3Ipv6PmtuCache_methods(root_module, root_module['ns3::Ipv6PmtuCache'])
register_Ns3Ipv6PrefixChecker_methods(root_module, root_module['ns3::Ipv6PrefixChecker'])
register_Ns3Ipv6PrefixValue_methods(root_module, root_module['ns3::Ipv6PrefixValue'])
register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice'])
@@ -1016,6 +1053,10 @@
cls.add_method('GetClassifier',
'ns3::Ptr< ns3::FlowClassifier >',
[])
+ ## flow-monitor-helper.h (module 'flow-monitor'): ns3::Ptr<ns3::FlowClassifier> ns3::FlowMonitorHelper::GetClassifier6() [member function]
+ cls.add_method('GetClassifier6',
+ 'ns3::Ptr< ns3::FlowClassifier >',
+ [])
## flow-monitor-helper.h (module 'flow-monitor'): void ns3::FlowMonitorHelper::SerializeToXmlStream(std::ostream & os, int indent, bool enableHistograms, bool enableProbes) [member function]
cls.add_method('SerializeToXmlStream',
'void',
@@ -1620,6 +1661,66 @@
[param('uint8_t *', 'address')])
return
+def register_Ns3Ipv6InterfaceAddress_methods(root_module, cls):
+ cls.add_binary_comparison_operator('!=')
+ cls.add_output_stream_operator()
+ cls.add_binary_comparison_operator('==')
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress() [constructor]
+ cls.add_constructor([])
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress(ns3::Ipv6Address address) [constructor]
+ cls.add_constructor([param('ns3::Ipv6Address', 'address')])
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress(ns3::Ipv6Address address, ns3::Ipv6Prefix prefix) [constructor]
+ cls.add_constructor([param('ns3::Ipv6Address', 'address'), param('ns3::Ipv6Prefix', 'prefix')])
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress(ns3::Ipv6InterfaceAddress const & o) [copy constructor]
+ cls.add_constructor([param('ns3::Ipv6InterfaceAddress const &', 'o')])
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6Address ns3::Ipv6InterfaceAddress::GetAddress() const [member function]
+ cls.add_method('GetAddress',
+ 'ns3::Ipv6Address',
+ [],
+ is_const=True)
+ ## ipv6-interface-address.h (module 'internet'): uint32_t ns3::Ipv6InterfaceAddress::GetNsDadUid() const [member function]
+ cls.add_method('GetNsDadUid',
+ 'uint32_t',
+ [],
+ is_const=True)
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6Prefix ns3::Ipv6InterfaceAddress::GetPrefix() const [member function]
+ cls.add_method('GetPrefix',
+ 'ns3::Ipv6Prefix',
+ [],
+ is_const=True)
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Scope_e ns3::Ipv6InterfaceAddress::GetScope() const [member function]
+ cls.add_method('GetScope',
+ 'ns3::Ipv6InterfaceAddress::Scope_e',
+ [],
+ is_const=True)
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::State_e ns3::Ipv6InterfaceAddress::GetState() const [member function]
+ cls.add_method('GetState',
+ 'ns3::Ipv6InterfaceAddress::State_e',
+ [],
+ is_const=True)
+ ## ipv6-interface-address.h (module 'internet'): bool ns3::Ipv6InterfaceAddress::IsInSameSubnet(ns3::Ipv6Address b) const [member function]
+ cls.add_method('IsInSameSubnet',
+ 'bool',
+ [param('ns3::Ipv6Address', 'b')],
+ is_const=True)
+ ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetAddress(ns3::Ipv6Address address) [member function]
+ cls.add_method('SetAddress',
+ 'void',
+ [param('ns3::Ipv6Address', 'address')])
+ ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetNsDadUid(uint32_t uid) [member function]
+ cls.add_method('SetNsDadUid',
+ 'void',
+ [param('uint32_t', 'uid')])
+ ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetScope(ns3::Ipv6InterfaceAddress::Scope_e scope) [member function]
+ cls.add_method('SetScope',
+ 'void',
+ [param('ns3::Ipv6InterfaceAddress::Scope_e', 'scope')])
+ ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetState(ns3::Ipv6InterfaceAddress::State_e state) [member function]
+ cls.add_method('SetState',
+ 'void',
+ [param('ns3::Ipv6InterfaceAddress::State_e', 'state')])
+ return
+
def register_Ns3Ipv6Prefix_methods(root_module, cls):
cls.add_binary_comparison_operator('!=')
cls.add_output_stream_operator()
@@ -2229,6 +2330,14 @@
[param('uint8_t', 'v')])
return
+def register_Ns3TimeWithUnit_methods(root_module, cls):
+ cls.add_output_stream_operator()
+ ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::TimeWithUnit const &', 'arg0')])
+ ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::Time const time, ns3::Time::Unit const unit) [constructor]
+ cls.add_constructor([param('ns3::Time const', 'time'), param('ns3::Time::Unit const', 'unit')])
+ return
+
def register_Ns3TypeId_methods(root_module, cls):
cls.add_binary_comparison_operator('<')
cls.add_binary_comparison_operator('!=')
@@ -2719,6 +2828,106 @@
[param('uint8_t', 'ttl')])
return
+def register_Ns3Ipv6Header_methods(root_module, cls):
+ ## ipv6-header.h (module 'internet'): ns3::Ipv6Header::Ipv6Header(ns3::Ipv6Header const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::Ipv6Header const &', 'arg0')])
+ ## ipv6-header.h (module 'internet'): ns3::Ipv6Header::Ipv6Header() [constructor]
+ cls.add_constructor([])
+ ## ipv6-header.h (module 'internet'): uint32_t ns3::Ipv6Header::Deserialize(ns3::Buffer::Iterator start) [member function]
+ cls.add_method('Deserialize',
+ 'uint32_t',
+ [param('ns3::Buffer::Iterator', 'start')],
+ is_virtual=True)
+ ## ipv6-header.h (module 'internet'): ns3::Ipv6Address ns3::Ipv6Header::GetDestinationAddress() const [member function]
+ cls.add_method('GetDestinationAddress',
+ 'ns3::Ipv6Address',
+ [],
+ is_const=True)
+ ## ipv6-header.h (module 'internet'): uint32_t ns3::Ipv6Header::GetFlowLabel() const [member function]
+ cls.add_method('GetFlowLabel',
+ 'uint32_t',
+ [],
+ is_const=True)
+ ## ipv6-header.h (module 'internet'): uint8_t ns3::Ipv6Header::GetHopLimit() const [member function]
+ cls.add_method('GetHopLimit',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## ipv6-header.h (module 'internet'): ns3::TypeId ns3::Ipv6Header::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## ipv6-header.h (module 'internet'): uint8_t ns3::Ipv6Header::GetNextHeader() const [member function]
+ cls.add_method('GetNextHeader',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## ipv6-header.h (module 'internet'): uint16_t ns3::Ipv6Header::GetPayloadLength() const [member function]
+ cls.add_method('GetPayloadLength',
+ 'uint16_t',
+ [],
+ is_const=True)
+ ## ipv6-header.h (module 'internet'): uint32_t ns3::Ipv6Header::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## ipv6-header.h (module 'internet'): ns3::Ipv6Address ns3::Ipv6Header::GetSourceAddress() const [member function]
+ cls.add_method('GetSourceAddress',
+ 'ns3::Ipv6Address',
+ [],
+ is_const=True)
+ ## ipv6-header.h (module 'internet'): uint8_t ns3::Ipv6Header::GetTrafficClass() const [member function]
+ cls.add_method('GetTrafficClass',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## ipv6-header.h (module 'internet'): static ns3::TypeId ns3::Ipv6Header::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::Serialize(ns3::Buffer::Iterator start) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::Buffer::Iterator', 'start')],
+ is_const=True, is_virtual=True)
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::SetDestinationAddress(ns3::Ipv6Address dst) [member function]
+ cls.add_method('SetDestinationAddress',
+ 'void',
+ [param('ns3::Ipv6Address', 'dst')])
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::SetFlowLabel(uint32_t flow) [member function]
+ cls.add_method('SetFlowLabel',
+ 'void',
+ [param('uint32_t', 'flow')])
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::SetHopLimit(uint8_t limit) [member function]
+ cls.add_method('SetHopLimit',
+ 'void',
+ [param('uint8_t', 'limit')])
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::SetNextHeader(uint8_t next) [member function]
+ cls.add_method('SetNextHeader',
+ 'void',
+ [param('uint8_t', 'next')])
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::SetPayloadLength(uint16_t len) [member function]
+ cls.add_method('SetPayloadLength',
+ 'void',
+ [param('uint16_t', 'len')])
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::SetSourceAddress(ns3::Ipv6Address src) [member function]
+ cls.add_method('SetSourceAddress',
+ 'void',
+ [param('ns3::Ipv6Address', 'src')])
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::SetTrafficClass(uint8_t traffic) [member function]
+ cls.add_method('SetTrafficClass',
+ 'void',
+ [param('uint8_t', 'traffic')])
+ return
+
def register_Ns3Object_methods(root_module, cls):
## object.h (module 'core'): ns3::Object::Object() [constructor]
cls.add_constructor([])
@@ -3588,6 +3797,11 @@
cls.add_constructor([param('std::string const &', 's')])
## nstime.h (module 'core'): ns3::Time::Time(ns3::int64x64_t const & value) [constructor]
cls.add_constructor([param('ns3::int64x64_t const &', 'value')])
+ ## nstime.h (module 'core'): ns3::TimeWithUnit ns3::Time::As(ns3::Time::Unit const unit) const [member function]
+ cls.add_method('As',
+ 'ns3::TimeWithUnit',
+ [param('ns3::Time::Unit const', 'unit')],
+ is_const=True)
## nstime.h (module 'core'): int ns3::Time::Compare(ns3::Time const & o) const [member function]
cls.add_method('Compare',
'int',
@@ -4009,6 +4223,10 @@
cls.add_constructor([param('ns3::FlowMonitor const &', 'arg0')])
## flow-monitor.h (module 'flow-monitor'): ns3::FlowMonitor::FlowMonitor() [constructor]
cls.add_constructor([])
+ ## flow-monitor.h (module 'flow-monitor'): void ns3::FlowMonitor::AddFlowClassifier(ns3::Ptr<ns3::FlowClassifier> classifier) [member function]
+ cls.add_method('AddFlowClassifier',
+ 'void',
+ [param('ns3::Ptr< ns3::FlowClassifier >', 'classifier')])
## flow-monitor.h (module 'flow-monitor'): void ns3::FlowMonitor::AddProbe(ns3::Ptr<ns3::FlowProbe> probe) [member function]
cls.add_method('AddProbe',
'void',
@@ -4069,10 +4287,6 @@
cls.add_method('SerializeToXmlString',
'std::string',
[param('int', 'indent'), param('bool', 'enableHistograms'), param('bool', 'enableProbes')])
- ## flow-monitor.h (module 'flow-monitor'): void ns3::FlowMonitor::SetFlowClassifier(ns3::Ptr<ns3::FlowClassifier> classifier) [member function]
- cls.add_method('SetFlowClassifier',
- 'void',
- [param('ns3::Ptr< ns3::FlowClassifier >', 'classifier')])
## flow-monitor.h (module 'flow-monitor'): void ns3::FlowMonitor::Start(ns3::Time const & time) [member function]
cls.add_method('Start',
'void',
@@ -4860,6 +5074,170 @@
is_pure_virtual=True, is_virtual=True)
return
+def register_Ns3Ipv6_methods(root_module, cls):
+ ## ipv6.h (module 'internet'): ns3::Ipv6::Ipv6(ns3::Ipv6 const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::Ipv6 const &', 'arg0')])
+ ## ipv6.h (module 'internet'): ns3::Ipv6::Ipv6() [constructor]
+ cls.add_constructor([])
+ ## ipv6.h (module 'internet'): bool ns3::Ipv6::AddAddress(uint32_t interface, ns3::Ipv6InterfaceAddress address) [member function]
+ cls.add_method('AddAddress',
+ 'bool',
+ [param('uint32_t', 'interface'), param('ns3::Ipv6InterfaceAddress', 'address')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): uint32_t ns3::Ipv6::AddInterface(ns3::Ptr<ns3::NetDevice> device) [member function]
+ cls.add_method('AddInterface',
+ 'uint32_t',
+ [param('ns3::Ptr< ns3::NetDevice >', 'device')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): ns3::Ipv6InterfaceAddress ns3::Ipv6::GetAddress(uint32_t interface, uint32_t addressIndex) const [member function]
+ cls.add_method('GetAddress',
+ 'ns3::Ipv6InterfaceAddress',
+ [param('uint32_t', 'interface'), param('uint32_t', 'addressIndex')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): int32_t ns3::Ipv6::GetInterfaceForAddress(ns3::Ipv6Address address) const [member function]
+ cls.add_method('GetInterfaceForAddress',
+ 'int32_t',
+ [param('ns3::Ipv6Address', 'address')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): int32_t ns3::Ipv6::GetInterfaceForDevice(ns3::Ptr<const ns3::NetDevice> device) const [member function]
+ cls.add_method('GetInterfaceForDevice',
+ 'int32_t',
+ [param('ns3::Ptr< ns3::NetDevice const >', 'device')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): int32_t ns3::Ipv6::GetInterfaceForPrefix(ns3::Ipv6Address address, ns3::Ipv6Prefix mask) const [member function]
+ cls.add_method('GetInterfaceForPrefix',
+ 'int32_t',
+ [param('ns3::Ipv6Address', 'address'), param('ns3::Ipv6Prefix', 'mask')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): uint16_t ns3::Ipv6::GetMetric(uint32_t interface) const [member function]
+ cls.add_method('GetMetric',
+ 'uint16_t',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): uint16_t ns3::Ipv6::GetMtu(uint32_t interface) const [member function]
+ cls.add_method('GetMtu',
+ 'uint16_t',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): uint32_t ns3::Ipv6::GetNAddresses(uint32_t interface) const [member function]
+ cls.add_method('GetNAddresses',
+ 'uint32_t',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): uint32_t ns3::Ipv6::GetNInterfaces() const [member function]
+ cls.add_method('GetNInterfaces',
+ 'uint32_t',
+ [],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): ns3::Ptr<ns3::NetDevice> ns3::Ipv6::GetNetDevice(uint32_t interface) [member function]
+ cls.add_method('GetNetDevice',
+ 'ns3::Ptr< ns3::NetDevice >',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): ns3::Ptr<ns3::IpL4Protocol> ns3::Ipv6::GetProtocol(int protocolNumber) const [member function]
+ cls.add_method('GetProtocol',
+ 'ns3::Ptr< ns3::IpL4Protocol >',
+ [param('int', 'protocolNumber')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): ns3::Ptr<ns3::Ipv6RoutingProtocol> ns3::Ipv6::GetRoutingProtocol() const [member function]
+ cls.add_method('GetRoutingProtocol',
+ 'ns3::Ptr< ns3::Ipv6RoutingProtocol >',
+ [],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): static ns3::TypeId ns3::Ipv6::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## ipv6.h (module 'internet'): bool ns3::Ipv6::IsForwarding(uint32_t interface) const [member function]
+ cls.add_method('IsForwarding',
+ 'bool',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): bool ns3::Ipv6::IsUp(uint32_t interface) const [member function]
+ cls.add_method('IsUp',
+ 'bool',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::RegisterExtensions() [member function]
+ cls.add_method('RegisterExtensions',
+ 'void',
+ [],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::RegisterOptions() [member function]
+ cls.add_method('RegisterOptions',
+ 'void',
+ [],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): bool ns3::Ipv6::RemoveAddress(uint32_t interface, uint32_t addressIndex) [member function]
+ cls.add_method('RemoveAddress',
+ 'bool',
+ [param('uint32_t', 'interface'), param('uint32_t', 'addressIndex')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): bool ns3::Ipv6::RemoveAddress(uint32_t interface, ns3::Ipv6Address address) [member function]
+ cls.add_method('RemoveAddress',
+ 'bool',
+ [param('uint32_t', 'interface'), param('ns3::Ipv6Address', 'address')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetDown(uint32_t interface) [member function]
+ cls.add_method('SetDown',
+ 'void',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetForwarding(uint32_t interface, bool val) [member function]
+ cls.add_method('SetForwarding',
+ 'void',
+ [param('uint32_t', 'interface'), param('bool', 'val')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetMetric(uint32_t interface, uint16_t metric) [member function]
+ cls.add_method('SetMetric',
+ 'void',
+ [param('uint32_t', 'interface'), param('uint16_t', 'metric')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetPmtu(ns3::Ipv6Address dst, uint32_t pmtu) [member function]
+ cls.add_method('SetPmtu',
+ 'void',
+ [param('ns3::Ipv6Address', 'dst'), param('uint32_t', 'pmtu')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetRoutingProtocol(ns3::Ptr<ns3::Ipv6RoutingProtocol> routingProtocol) [member function]
+ cls.add_method('SetRoutingProtocol',
+ 'void',
+ [param('ns3::Ptr< ns3::Ipv6RoutingProtocol >', 'routingProtocol')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetUp(uint32_t interface) [member function]
+ cls.add_method('SetUp',
+ 'void',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): ns3::Ipv6Address ns3::Ipv6::SourceAddressSelection(uint32_t interface, ns3::Ipv6Address dest) [member function]
+ cls.add_method('SourceAddressSelection',
+ 'ns3::Ipv6Address',
+ [param('uint32_t', 'interface'), param('ns3::Ipv6Address', 'dest')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): ns3::Ipv6::IF_ANY [variable]
+ cls.add_static_attribute('IF_ANY', 'uint32_t const', is_const=True)
+ ## ipv6.h (module 'internet'): bool ns3::Ipv6::GetIpForward() const [member function]
+ cls.add_method('GetIpForward',
+ 'bool',
+ [],
+ is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
+ ## ipv6.h (module 'internet'): bool ns3::Ipv6::GetMtuDiscover() const [member function]
+ cls.add_method('GetMtuDiscover',
+ 'bool',
+ [],
+ is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetIpForward(bool forward) [member function]
+ cls.add_method('SetIpForward',
+ 'void',
+ [param('bool', 'forward')],
+ is_pure_virtual=True, visibility='private', is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetMtuDiscover(bool mtuDiscover) [member function]
+ cls.add_method('SetMtuDiscover',
+ 'void',
+ [param('bool', 'mtuDiscover')],
+ is_pure_virtual=True, visibility='private', is_virtual=True)
+ return
+
def register_Ns3Ipv6AddressChecker_methods(root_module, cls):
## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker() [constructor]
cls.add_constructor([])
@@ -4900,6 +5278,329 @@
[param('ns3::Ipv6Address const &', 'value')])
return
+def register_Ns3Ipv6FlowClassifier_methods(root_module, cls):
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::Ipv6FlowClassifier() [constructor]
+ cls.add_constructor([])
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): bool ns3::Ipv6FlowClassifier::Classify(ns3::Ipv6Header const & ipHeader, ns3::Ptr<const ns3::Packet> ipPayload, uint32_t * out_flowId, uint32_t * out_packetId) [member function]
+ cls.add_method('Classify',
+ 'bool',
+ [param('ns3::Ipv6Header const &', 'ipHeader'), param('ns3::Ptr< ns3::Packet const >', 'ipPayload'), param('uint32_t *', 'out_flowId'), param('uint32_t *', 'out_packetId')])
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple ns3::Ipv6FlowClassifier::FindFlow(ns3::FlowId flowId) const [member function]
+ cls.add_method('FindFlow',
+ 'ns3::Ipv6FlowClassifier::FiveTuple',
+ [param('ns3::FlowId', 'flowId')],
+ is_const=True)
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): void ns3::Ipv6FlowClassifier::SerializeToXmlStream(std::ostream & os, int indent) const [member function]
+ cls.add_method('SerializeToXmlStream',
+ 'void',
+ [param('std::ostream &', 'os'), param('int', 'indent')],
+ is_const=True, is_virtual=True)
+ return
+
+def register_Ns3Ipv6FlowClassifierFiveTuple_methods(root_module, cls):
+ cls.add_binary_comparison_operator('<')
+ cls.add_binary_comparison_operator('==')
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple::FiveTuple() [constructor]
+ cls.add_constructor([])
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple::FiveTuple(ns3::Ipv6FlowClassifier::FiveTuple const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::Ipv6FlowClassifier::FiveTuple const &', 'arg0')])
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple::destinationAddress [variable]
+ cls.add_instance_attribute('destinationAddress', 'ns3::Ipv6Address', is_const=False)
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple::destinationPort [variable]
+ cls.add_instance_attribute('destinationPort', 'uint16_t', is_const=False)
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple::protocol [variable]
+ cls.add_instance_attribute('protocol', 'uint8_t', is_const=False)
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple::sourceAddress [variable]
+ cls.add_instance_attribute('sourceAddress', 'ns3::Ipv6Address', is_const=False)
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple::sourcePort [variable]
+ cls.add_instance_attribute('sourcePort', 'uint16_t', is_const=False)
+ return
+
+def register_Ns3Ipv6FlowProbe_methods(root_module, cls):
+ ## ipv6-flow-probe.h (module 'flow-monitor'): ns3::Ipv6FlowProbe::Ipv6FlowProbe(ns3::Ptr<ns3::FlowMonitor> monitor, ns3::Ptr<ns3::Ipv6FlowClassifier> classifier, ns3::Ptr<ns3::Node> node) [constructor]
+ cls.add_constructor([param('ns3::Ptr< ns3::FlowMonitor >', 'monitor'), param('ns3::Ptr< ns3::Ipv6FlowClassifier >', 'classifier'), param('ns3::Ptr< ns3::Node >', 'node')])
+ ## ipv6-flow-probe.h (module 'flow-monitor'): void ns3::Ipv6FlowProbe::DoDispose() [member function]
+ cls.add_method('DoDispose',
+ 'void',
+ [],
+ visibility='protected', is_virtual=True)
+ return
+
+def register_Ns3Ipv6L3Protocol_methods(root_module, cls):
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ipv6L3Protocol::PROT_NUMBER [variable]
+ cls.add_static_attribute('PROT_NUMBER', 'uint16_t const', is_const=True)
+ ## ipv6-l3-protocol.h (module 'internet'): static ns3::TypeId ns3::Ipv6L3Protocol::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ipv6L3Protocol::Ipv6L3Protocol() [constructor]
+ cls.add_constructor([])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetNode(ns3::Ptr<ns3::Node> node) [member function]
+ cls.add_method('SetNode',
+ 'void',
+ [param('ns3::Ptr< ns3::Node >', 'node')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::Insert(ns3::Ptr<ns3::IpL4Protocol> protocol) [member function]
+ cls.add_method('Insert',
+ 'void',
+ [param('ns3::Ptr< ns3::IpL4Protocol >', 'protocol')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::Remove(ns3::Ptr<ns3::IpL4Protocol> protocol) [member function]
+ cls.add_method('Remove',
+ 'void',
+ [param('ns3::Ptr< ns3::IpL4Protocol >', 'protocol')])
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ptr<ns3::IpL4Protocol> ns3::Ipv6L3Protocol::GetProtocol(int protocolNumber) const [member function]
+ cls.add_method('GetProtocol',
+ 'ns3::Ptr< ns3::IpL4Protocol >',
+ [param('int', 'protocolNumber')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ptr<ns3::Socket> ns3::Ipv6L3Protocol::CreateRawSocket() [member function]
+ cls.add_method('CreateRawSocket',
+ 'ns3::Ptr< ns3::Socket >',
+ [])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::DeleteRawSocket(ns3::Ptr<ns3::Socket> socket) [member function]
+ cls.add_method('DeleteRawSocket',
+ 'void',
+ [param('ns3::Ptr< ns3::Socket >', 'socket')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetDefaultTtl(uint8_t ttl) [member function]
+ cls.add_method('SetDefaultTtl',
+ 'void',
+ [param('uint8_t', 'ttl')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetDefaultTclass(uint8_t tclass) [member function]
+ cls.add_method('SetDefaultTclass',
+ 'void',
+ [param('uint8_t', 'tclass')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::Receive(ns3::Ptr<ns3::NetDevice> device, ns3::Ptr<const ns3::Packet> p, uint16_t protocol, ns3::Address const & from, ns3::Address const & to, ns3::NetDevice::PacketType packetType) [member function]
+ cls.add_method('Receive',
+ 'void',
+ [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::Packet const >', 'p'), param('uint16_t', 'protocol'), param('ns3::Address const &', 'from'), param('ns3::Address const &', 'to'), param('ns3::NetDevice::PacketType', 'packetType')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::Send(ns3::Ptr<ns3::Packet> packet, ns3::Ipv6Address source, ns3::Ipv6Address destination, uint8_t protocol, ns3::Ptr<ns3::Ipv6Route> route) [member function]
+ cls.add_method('Send',
+ 'void',
+ [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Ipv6Address', 'source'), param('ns3::Ipv6Address', 'destination'), param('uint8_t', 'protocol'), param('ns3::Ptr< ns3::Ipv6Route >', 'route')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetRoutingProtocol(ns3::Ptr<ns3::Ipv6RoutingProtocol> routingProtocol) [member function]
+ cls.add_method('SetRoutingProtocol',
+ 'void',
+ [param('ns3::Ptr< ns3::Ipv6RoutingProtocol >', 'routingProtocol')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ptr<ns3::Ipv6RoutingProtocol> ns3::Ipv6L3Protocol::GetRoutingProtocol() const [member function]
+ cls.add_method('GetRoutingProtocol',
+ 'ns3::Ptr< ns3::Ipv6RoutingProtocol >',
+ [],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): uint32_t ns3::Ipv6L3Protocol::AddInterface(ns3::Ptr<ns3::NetDevice> device) [member function]
+ cls.add_method('AddInterface',
+ 'uint32_t',
+ [param('ns3::Ptr< ns3::NetDevice >', 'device')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ptr<ns3::Ipv6Interface> ns3::Ipv6L3Protocol::GetInterface(uint32_t i) const [member function]
+ cls.add_method('GetInterface',
+ 'ns3::Ptr< ns3::Ipv6Interface >',
+ [param('uint32_t', 'i')],
+ is_const=True)
+ ## ipv6-l3-protocol.h (module 'internet'): uint32_t ns3::Ipv6L3Protocol::GetNInterfaces() const [member function]
+ cls.add_method('GetNInterfaces',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): int32_t ns3::Ipv6L3Protocol::GetInterfaceForAddress(ns3::Ipv6Address addr) const [member function]
+ cls.add_method('GetInterfaceForAddress',
+ 'int32_t',
+ [param('ns3::Ipv6Address', 'addr')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): int32_t ns3::Ipv6L3Protocol::GetInterfaceForPrefix(ns3::Ipv6Address addr, ns3::Ipv6Prefix mask) const [member function]
+ cls.add_method('GetInterfaceForPrefix',
+ 'int32_t',
+ [param('ns3::Ipv6Address', 'addr'), param('ns3::Ipv6Prefix', 'mask')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): int32_t ns3::Ipv6L3Protocol::GetInterfaceForDevice(ns3::Ptr<const ns3::NetDevice> device) const [member function]
+ cls.add_method('GetInterfaceForDevice',
+ 'int32_t',
+ [param('ns3::Ptr< ns3::NetDevice const >', 'device')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::AddAddress(uint32_t i, ns3::Ipv6InterfaceAddress address) [member function]
+ cls.add_method('AddAddress',
+ 'bool',
+ [param('uint32_t', 'i'), param('ns3::Ipv6InterfaceAddress', 'address')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ipv6InterfaceAddress ns3::Ipv6L3Protocol::GetAddress(uint32_t interfaceIndex, uint32_t addressIndex) const [member function]
+ cls.add_method('GetAddress',
+ 'ns3::Ipv6InterfaceAddress',
+ [param('uint32_t', 'interfaceIndex'), param('uint32_t', 'addressIndex')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): uint32_t ns3::Ipv6L3Protocol::GetNAddresses(uint32_t interface) const [member function]
+ cls.add_method('GetNAddresses',
+ 'uint32_t',
+ [param('uint32_t', 'interface')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::RemoveAddress(uint32_t interfaceIndex, uint32_t addressIndex) [member function]
+ cls.add_method('RemoveAddress',
+ 'bool',
+ [param('uint32_t', 'interfaceIndex'), param('uint32_t', 'addressIndex')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::RemoveAddress(uint32_t interfaceIndex, ns3::Ipv6Address address) [member function]
+ cls.add_method('RemoveAddress',
+ 'bool',
+ [param('uint32_t', 'interfaceIndex'), param('ns3::Ipv6Address', 'address')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetMetric(uint32_t i, uint16_t metric) [member function]
+ cls.add_method('SetMetric',
+ 'void',
+ [param('uint32_t', 'i'), param('uint16_t', 'metric')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): uint16_t ns3::Ipv6L3Protocol::GetMetric(uint32_t i) const [member function]
+ cls.add_method('GetMetric',
+ 'uint16_t',
+ [param('uint32_t', 'i')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): uint16_t ns3::Ipv6L3Protocol::GetMtu(uint32_t i) const [member function]
+ cls.add_method('GetMtu',
+ 'uint16_t',
+ [param('uint32_t', 'i')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetPmtu(ns3::Ipv6Address dst, uint32_t pmtu) [member function]
+ cls.add_method('SetPmtu',
+ 'void',
+ [param('ns3::Ipv6Address', 'dst'), param('uint32_t', 'pmtu')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::IsUp(uint32_t i) const [member function]
+ cls.add_method('IsUp',
+ 'bool',
+ [param('uint32_t', 'i')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetUp(uint32_t i) [member function]
+ cls.add_method('SetUp',
+ 'void',
+ [param('uint32_t', 'i')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetDown(uint32_t i) [member function]
+ cls.add_method('SetDown',
+ 'void',
+ [param('uint32_t', 'i')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::IsForwarding(uint32_t i) const [member function]
+ cls.add_method('IsForwarding',
+ 'bool',
+ [param('uint32_t', 'i')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetForwarding(uint32_t i, bool val) [member function]
+ cls.add_method('SetForwarding',
+ 'void',
+ [param('uint32_t', 'i'), param('bool', 'val')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ipv6Address ns3::Ipv6L3Protocol::SourceAddressSelection(uint32_t interface, ns3::Ipv6Address dest) [member function]
+ cls.add_method('SourceAddressSelection',
+ 'ns3::Ipv6Address',
+ [param('uint32_t', 'interface'), param('ns3::Ipv6Address', 'dest')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ptr<ns3::NetDevice> ns3::Ipv6L3Protocol::GetNetDevice(uint32_t i) [member function]
+ cls.add_method('GetNetDevice',
+ 'ns3::Ptr< ns3::NetDevice >',
+ [param('uint32_t', 'i')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ptr<ns3::Icmpv6L4Protocol> ns3::Ipv6L3Protocol::GetIcmpv6() const [member function]
+ cls.add_method('GetIcmpv6',
+ 'ns3::Ptr< ns3::Icmpv6L4Protocol >',
+ [],
+ is_const=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::AddAutoconfiguredAddress(uint32_t interface, ns3::Ipv6Address network, ns3::Ipv6Prefix mask, uint8_t flags, uint32_t validTime, uint32_t preferredTime, ns3::Ipv6Address defaultRouter=ns3::Ipv6Address::GetZero( )) [member function]
+ cls.add_method('AddAutoconfiguredAddress',
+ 'void',
+ [param('uint32_t', 'interface'), param('ns3::Ipv6Address', 'network'), param('ns3::Ipv6Prefix', 'mask'), param('uint8_t', 'flags'), param('uint32_t', 'validTime'), param('uint32_t', 'preferredTime'), param('ns3::Ipv6Address', 'defaultRouter', default_value='ns3::Ipv6Address::GetZero( )')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::RemoveAutoconfiguredAddress(uint32_t interface, ns3::Ipv6Address network, ns3::Ipv6Prefix mask, ns3::Ipv6Address defaultRouter) [member function]
+ cls.add_method('RemoveAutoconfiguredAddress',
+ 'void',
+ [param('uint32_t', 'interface'), param('ns3::Ipv6Address', 'network'), param('ns3::Ipv6Prefix', 'mask'), param('ns3::Ipv6Address', 'defaultRouter')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::RegisterExtensions() [member function]
+ cls.add_method('RegisterExtensions',
+ 'void',
+ [],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::RegisterOptions() [member function]
+ cls.add_method('RegisterOptions',
+ 'void',
+ [],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::ReportDrop(ns3::Ipv6Header ipHeader, ns3::Ptr<ns3::Packet> p, ns3::Ipv6L3Protocol::DropReason dropReason) [member function]
+ cls.add_method('ReportDrop',
+ 'void',
+ [param('ns3::Ipv6Header', 'ipHeader'), param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv6L3Protocol::DropReason', 'dropReason')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::DoDispose() [member function]
+ cls.add_method('DoDispose',
+ 'void',
+ [],
+ visibility='protected', is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::NotifyNewAggregate() [member function]
+ cls.add_method('NotifyNewAggregate',
+ 'void',
+ [],
+ visibility='protected', is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetIpForward(bool forward) [member function]
+ cls.add_method('SetIpForward',
+ 'void',
+ [param('bool', 'forward')],
+ visibility='private', is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::GetIpForward() const [member function]
+ cls.add_method('GetIpForward',
+ 'bool',
+ [],
+ is_const=True, visibility='private', is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetMtuDiscover(bool mtuDiscover) [member function]
+ cls.add_method('SetMtuDiscover',
+ 'void',
+ [param('bool', 'mtuDiscover')],
+ visibility='private', is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::GetMtuDiscover() const [member function]
+ cls.add_method('GetMtuDiscover',
+ 'bool',
+ [],
+ is_const=True, visibility='private', is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetSendIcmpv6Redirect(bool sendIcmpv6Redirect) [member function]
+ cls.add_method('SetSendIcmpv6Redirect',
+ 'void',
+ [param('bool', 'sendIcmpv6Redirect')],
+ visibility='private', is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::GetSendIcmpv6Redirect() const [member function]
+ cls.add_method('GetSendIcmpv6Redirect',
+ 'bool',
+ [],
+ is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3Ipv6PmtuCache_methods(root_module, cls):
+ ## ipv6-pmtu-cache.h (module 'internet'): ns3::Ipv6PmtuCache::Ipv6PmtuCache(ns3::Ipv6PmtuCache const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::Ipv6PmtuCache const &', 'arg0')])
+ ## ipv6-pmtu-cache.h (module 'internet'): ns3::Ipv6PmtuCache::Ipv6PmtuCache() [constructor]
+ cls.add_constructor([])
+ ## ipv6-pmtu-cache.h (module 'internet'): void ns3::Ipv6PmtuCache::DoDispose() [member function]
+ cls.add_method('DoDispose',
+ 'void',
+ [],
+ is_virtual=True)
+ ## ipv6-pmtu-cache.h (module 'internet'): uint32_t ns3::Ipv6PmtuCache::GetPmtu(ns3::Ipv6Address dst) [member function]
+ cls.add_method('GetPmtu',
+ 'uint32_t',
+ [param('ns3::Ipv6Address', 'dst')])
+ ## ipv6-pmtu-cache.h (module 'internet'): ns3::Time ns3::Ipv6PmtuCache::GetPmtuValidityTime() const [member function]
+ cls.add_method('GetPmtuValidityTime',
+ 'ns3::Time',
+ [],
+ is_const=True)
+ ## ipv6-pmtu-cache.h (module 'internet'): static ns3::TypeId ns3::Ipv6PmtuCache::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## ipv6-pmtu-cache.h (module 'internet'): void ns3::Ipv6PmtuCache::SetPmtu(ns3::Ipv6Address dst, uint32_t pmtu) [member function]
+ cls.add_method('SetPmtu',
+ 'void',
+ [param('ns3::Ipv6Address', 'dst'), param('uint32_t', 'pmtu')])
+ ## ipv6-pmtu-cache.h (module 'internet'): bool ns3::Ipv6PmtuCache::SetPmtuValidityTime(ns3::Time validity) [member function]
+ cls.add_method('SetPmtuValidityTime',
+ 'bool',
+ [param('ns3::Time', 'validity')])
+ return
+
def register_Ns3Ipv6PrefixChecker_methods(root_module, cls):
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker() [constructor]
cls.add_constructor([])
--- a/src/flow-monitor/bindings/modulegen__gcc_LP64.py Tue Apr 08 14:07:33 2014 -0700
+++ b/src/flow-monitor/bindings/modulegen__gcc_LP64.py Mon Apr 21 11:32:45 2014 +0200
@@ -74,6 +74,12 @@
module.add_class('Ipv6Address', import_from_module='ns.network')
## ipv6-address.h (module 'network'): ns3::Ipv6Address [class]
root_module['ns3::Ipv6Address'].implicitly_converts_to(root_module['ns3::Address'])
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress [class]
+ module.add_class('Ipv6InterfaceAddress', import_from_module='ns.internet')
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::State_e [enumeration]
+ module.add_enum('State_e', ['TENTATIVE', 'DEPRECATED', 'PREFERRED', 'PERMANENT', 'HOMEADDRESS', 'TENTATIVE_OPTIMISTIC', 'INVALID'], outer_class=root_module['ns3::Ipv6InterfaceAddress'], import_from_module='ns.internet')
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Scope_e [enumeration]
+ module.add_enum('Scope_e', ['HOST', 'LINKLOCAL', 'GLOBAL'], outer_class=root_module['ns3::Ipv6InterfaceAddress'], import_from_module='ns.internet')
## ipv6-address.h (module 'network'): ns3::Ipv6Prefix [class]
module.add_class('Ipv6Prefix', import_from_module='ns.network')
## node-container.h (module 'network'): ns3::NodeContainer [class]
@@ -110,6 +116,8 @@
module.add_class('Tag', import_from_module='ns.network', parent=root_module['ns3::ObjectBase'])
## tag-buffer.h (module 'network'): ns3::TagBuffer [class]
module.add_class('TagBuffer', import_from_module='ns.network')
+ ## nstime.h (module 'core'): ns3::TimeWithUnit [class]
+ module.add_class('TimeWithUnit', import_from_module='ns.core')
## type-id.h (module 'core'): ns3::TypeId [class]
module.add_class('TypeId', import_from_module='ns.core')
## type-id.h (module 'core'): ns3::TypeId::AttributeFlag [enumeration]
@@ -134,6 +142,10 @@
module.add_enum('DscpType', ['DscpDefault', 'DSCP_CS1', 'DSCP_AF11', 'DSCP_AF12', 'DSCP_AF13', 'DSCP_CS2', 'DSCP_AF21', 'DSCP_AF22', 'DSCP_AF23', 'DSCP_CS3', 'DSCP_AF31', 'DSCP_AF32', 'DSCP_AF33', 'DSCP_CS4', 'DSCP_AF41', 'DSCP_AF42', 'DSCP_AF43', 'DSCP_CS5', 'DSCP_EF', 'DSCP_CS6', 'DSCP_CS7'], outer_class=root_module['ns3::Ipv4Header'], import_from_module='ns.internet')
## ipv4-header.h (module 'internet'): ns3::Ipv4Header::EcnType [enumeration]
module.add_enum('EcnType', ['ECN_NotECT', 'ECN_ECT1', 'ECN_ECT0', 'ECN_CE'], outer_class=root_module['ns3::Ipv4Header'], import_from_module='ns.internet')
+ ## ipv6-header.h (module 'internet'): ns3::Ipv6Header [class]
+ module.add_class('Ipv6Header', import_from_module='ns.internet', parent=root_module['ns3::Header'])
+ ## ipv6-header.h (module 'internet'): ns3::Ipv6Header::NextHeader_e [enumeration]
+ module.add_enum('NextHeader_e', ['IPV6_EXT_HOP_BY_HOP', 'IPV6_IPV4', 'IPV6_TCP', 'IPV6_UDP', 'IPV6_IPV6', 'IPV6_EXT_ROUTING', 'IPV6_EXT_FRAGMENTATION', 'IPV6_EXT_CONFIDENTIALITY', 'IPV6_EXT_AUTHENTIFICATION', 'IPV6_ICMPV6', 'IPV6_EXT_END', 'IPV6_EXT_DESTINATION', 'IPV6_SCTP', 'IPV6_EXT_MOBILITY', 'IPV6_UDP_LITE'], outer_class=root_module['ns3::Ipv6Header'], import_from_module='ns.internet')
## object.h (module 'core'): ns3::Object [class]
module.add_class('Object', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])
## object.h (module 'core'): ns3::Object::AggregateIterator [class]
@@ -246,10 +258,26 @@
module.add_class('Ipv4Route', import_from_module='ns.internet', parent=root_module['ns3::SimpleRefCount< ns3::Ipv4Route, ns3::empty, ns3::DefaultDeleter<ns3::Ipv4Route> >'])
## ipv4-routing-protocol.h (module 'internet'): ns3::Ipv4RoutingProtocol [class]
module.add_class('Ipv4RoutingProtocol', import_from_module='ns.internet', parent=root_module['ns3::Object'])
+ ## ipv6.h (module 'internet'): ns3::Ipv6 [class]
+ module.add_class('Ipv6', import_from_module='ns.internet', parent=root_module['ns3::Object'])
## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker [class]
module.add_class('Ipv6AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue [class]
module.add_class('Ipv6AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier [class]
+ module.add_class('Ipv6FlowClassifier', parent=root_module['ns3::FlowClassifier'])
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple [struct]
+ module.add_class('FiveTuple', outer_class=root_module['ns3::Ipv6FlowClassifier'])
+ ## ipv6-flow-probe.h (module 'flow-monitor'): ns3::Ipv6FlowProbe [class]
+ module.add_class('Ipv6FlowProbe', parent=root_module['ns3::FlowProbe'])
+ ## ipv6-flow-probe.h (module 'flow-monitor'): ns3::Ipv6FlowProbe::DropReason [enumeration]
+ module.add_enum('DropReason', ['DROP_NO_ROUTE', 'DROP_TTL_EXPIRE', 'DROP_BAD_CHECKSUM', 'DROP_QUEUE', 'DROP_INTERFACE_DOWN', 'DROP_ROUTE_ERROR', 'DROP_UNKNOWN_PROTOCOL', 'DROP_UNKNOWN_OPTION', 'DROP_MALFORMED_HEADER', 'DROP_FRAGMENT_TIMEOUT', 'DROP_INVALID_REASON'], outer_class=root_module['ns3::Ipv6FlowProbe'])
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ipv6L3Protocol [class]
+ module.add_class('Ipv6L3Protocol', import_from_module='ns.internet', parent=root_module['ns3::Ipv6'])
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ipv6L3Protocol::DropReason [enumeration]
+ module.add_enum('DropReason', ['DROP_TTL_EXPIRED', 'DROP_NO_ROUTE', 'DROP_INTERFACE_DOWN', 'DROP_ROUTE_ERROR', 'DROP_UNKNOWN_PROTOCOL', 'DROP_UNKNOWN_OPTION', 'DROP_MALFORMED_HEADER', 'DROP_FRAGMENT_TIMEOUT'], outer_class=root_module['ns3::Ipv6L3Protocol'], import_from_module='ns.internet')
+ ## ipv6-pmtu-cache.h (module 'internet'): ns3::Ipv6PmtuCache [class]
+ module.add_class('Ipv6PmtuCache', import_from_module='ns.internet', parent=root_module['ns3::Object'])
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker [class]
module.add_class('Ipv6PrefixChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue [class]
@@ -361,6 +389,7 @@
register_Ns3Ipv4InterfaceAddress_methods(root_module, root_module['ns3::Ipv4InterfaceAddress'])
register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
register_Ns3Ipv6Address_methods(root_module, root_module['ns3::Ipv6Address'])
+ register_Ns3Ipv6InterfaceAddress_methods(root_module, root_module['ns3::Ipv6InterfaceAddress'])
register_Ns3Ipv6Prefix_methods(root_module, root_module['ns3::Ipv6Prefix'])
register_Ns3NodeContainer_methods(root_module, root_module['ns3::NodeContainer'])
register_Ns3ObjectBase_methods(root_module, root_module['ns3::ObjectBase'])
@@ -377,6 +406,7 @@
register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator'])
register_Ns3Tag_methods(root_module, root_module['ns3::Tag'])
register_Ns3TagBuffer_methods(root_module, root_module['ns3::TagBuffer'])
+ register_Ns3TimeWithUnit_methods(root_module, root_module['ns3::TimeWithUnit'])
register_Ns3TypeId_methods(root_module, root_module['ns3::TypeId'])
register_Ns3TypeIdAttributeInformation_methods(root_module, root_module['ns3::TypeId::AttributeInformation'])
register_Ns3TypeIdTraceSourceInformation_methods(root_module, root_module['ns3::TypeId::TraceSourceInformation'])
@@ -385,6 +415,7 @@
register_Ns3Chunk_methods(root_module, root_module['ns3::Chunk'])
register_Ns3Header_methods(root_module, root_module['ns3::Header'])
register_Ns3Ipv4Header_methods(root_module, root_module['ns3::Ipv4Header'])
+ register_Ns3Ipv6Header_methods(root_module, root_module['ns3::Ipv6Header'])
register_Ns3Object_methods(root_module, root_module['ns3::Object'])
register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])
register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])
@@ -435,8 +466,14 @@
register_Ns3Ipv4MulticastRoute_methods(root_module, root_module['ns3::Ipv4MulticastRoute'])
register_Ns3Ipv4Route_methods(root_module, root_module['ns3::Ipv4Route'])
register_Ns3Ipv4RoutingProtocol_methods(root_module, root_module['ns3::Ipv4RoutingProtocol'])
+ register_Ns3Ipv6_methods(root_module, root_module['ns3::Ipv6'])
register_Ns3Ipv6AddressChecker_methods(root_module, root_module['ns3::Ipv6AddressChecker'])
register_Ns3Ipv6AddressValue_methods(root_module, root_module['ns3::Ipv6AddressValue'])
+ register_Ns3Ipv6FlowClassifier_methods(root_module, root_module['ns3::Ipv6FlowClassifier'])
+ register_Ns3Ipv6FlowClassifierFiveTuple_methods(root_module, root_module['ns3::Ipv6FlowClassifier::FiveTuple'])
+ register_Ns3Ipv6FlowProbe_methods(root_module, root_module['ns3::Ipv6FlowProbe'])
+ register_Ns3Ipv6L3Protocol_methods(root_module, root_module['ns3::Ipv6L3Protocol'])
+ register_Ns3Ipv6PmtuCache_methods(root_module, root_module['ns3::Ipv6PmtuCache'])
register_Ns3Ipv6PrefixChecker_methods(root_module, root_module['ns3::Ipv6PrefixChecker'])
register_Ns3Ipv6PrefixValue_methods(root_module, root_module['ns3::Ipv6PrefixValue'])
register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice'])
@@ -1016,6 +1053,10 @@
cls.add_method('GetClassifier',
'ns3::Ptr< ns3::FlowClassifier >',
[])
+ ## flow-monitor-helper.h (module 'flow-monitor'): ns3::Ptr<ns3::FlowClassifier> ns3::FlowMonitorHelper::GetClassifier6() [member function]
+ cls.add_method('GetClassifier6',
+ 'ns3::Ptr< ns3::FlowClassifier >',
+ [])
## flow-monitor-helper.h (module 'flow-monitor'): void ns3::FlowMonitorHelper::SerializeToXmlStream(std::ostream & os, int indent, bool enableHistograms, bool enableProbes) [member function]
cls.add_method('SerializeToXmlStream',
'void',
@@ -1620,6 +1661,66 @@
[param('uint8_t *', 'address')])
return
+def register_Ns3Ipv6InterfaceAddress_methods(root_module, cls):
+ cls.add_binary_comparison_operator('!=')
+ cls.add_output_stream_operator()
+ cls.add_binary_comparison_operator('==')
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress() [constructor]
+ cls.add_constructor([])
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress(ns3::Ipv6Address address) [constructor]
+ cls.add_constructor([param('ns3::Ipv6Address', 'address')])
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress(ns3::Ipv6Address address, ns3::Ipv6Prefix prefix) [constructor]
+ cls.add_constructor([param('ns3::Ipv6Address', 'address'), param('ns3::Ipv6Prefix', 'prefix')])
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Ipv6InterfaceAddress(ns3::Ipv6InterfaceAddress const & o) [copy constructor]
+ cls.add_constructor([param('ns3::Ipv6InterfaceAddress const &', 'o')])
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6Address ns3::Ipv6InterfaceAddress::GetAddress() const [member function]
+ cls.add_method('GetAddress',
+ 'ns3::Ipv6Address',
+ [],
+ is_const=True)
+ ## ipv6-interface-address.h (module 'internet'): uint32_t ns3::Ipv6InterfaceAddress::GetNsDadUid() const [member function]
+ cls.add_method('GetNsDadUid',
+ 'uint32_t',
+ [],
+ is_const=True)
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6Prefix ns3::Ipv6InterfaceAddress::GetPrefix() const [member function]
+ cls.add_method('GetPrefix',
+ 'ns3::Ipv6Prefix',
+ [],
+ is_const=True)
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::Scope_e ns3::Ipv6InterfaceAddress::GetScope() const [member function]
+ cls.add_method('GetScope',
+ 'ns3::Ipv6InterfaceAddress::Scope_e',
+ [],
+ is_const=True)
+ ## ipv6-interface-address.h (module 'internet'): ns3::Ipv6InterfaceAddress::State_e ns3::Ipv6InterfaceAddress::GetState() const [member function]
+ cls.add_method('GetState',
+ 'ns3::Ipv6InterfaceAddress::State_e',
+ [],
+ is_const=True)
+ ## ipv6-interface-address.h (module 'internet'): bool ns3::Ipv6InterfaceAddress::IsInSameSubnet(ns3::Ipv6Address b) const [member function]
+ cls.add_method('IsInSameSubnet',
+ 'bool',
+ [param('ns3::Ipv6Address', 'b')],
+ is_const=True)
+ ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetAddress(ns3::Ipv6Address address) [member function]
+ cls.add_method('SetAddress',
+ 'void',
+ [param('ns3::Ipv6Address', 'address')])
+ ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetNsDadUid(uint32_t uid) [member function]
+ cls.add_method('SetNsDadUid',
+ 'void',
+ [param('uint32_t', 'uid')])
+ ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetScope(ns3::Ipv6InterfaceAddress::Scope_e scope) [member function]
+ cls.add_method('SetScope',
+ 'void',
+ [param('ns3::Ipv6InterfaceAddress::Scope_e', 'scope')])
+ ## ipv6-interface-address.h (module 'internet'): void ns3::Ipv6InterfaceAddress::SetState(ns3::Ipv6InterfaceAddress::State_e state) [member function]
+ cls.add_method('SetState',
+ 'void',
+ [param('ns3::Ipv6InterfaceAddress::State_e', 'state')])
+ return
+
def register_Ns3Ipv6Prefix_methods(root_module, cls):
cls.add_binary_comparison_operator('!=')
cls.add_output_stream_operator()
@@ -2229,6 +2330,14 @@
[param('uint8_t', 'v')])
return
+def register_Ns3TimeWithUnit_methods(root_module, cls):
+ cls.add_output_stream_operator()
+ ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::TimeWithUnit const &', 'arg0')])
+ ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::Time const time, ns3::Time::Unit const unit) [constructor]
+ cls.add_constructor([param('ns3::Time const', 'time'), param('ns3::Time::Unit const', 'unit')])
+ return
+
def register_Ns3TypeId_methods(root_module, cls):
cls.add_binary_comparison_operator('<')
cls.add_binary_comparison_operator('!=')
@@ -2719,6 +2828,106 @@
[param('uint8_t', 'ttl')])
return
+def register_Ns3Ipv6Header_methods(root_module, cls):
+ ## ipv6-header.h (module 'internet'): ns3::Ipv6Header::Ipv6Header(ns3::Ipv6Header const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::Ipv6Header const &', 'arg0')])
+ ## ipv6-header.h (module 'internet'): ns3::Ipv6Header::Ipv6Header() [constructor]
+ cls.add_constructor([])
+ ## ipv6-header.h (module 'internet'): uint32_t ns3::Ipv6Header::Deserialize(ns3::Buffer::Iterator start) [member function]
+ cls.add_method('Deserialize',
+ 'uint32_t',
+ [param('ns3::Buffer::Iterator', 'start')],
+ is_virtual=True)
+ ## ipv6-header.h (module 'internet'): ns3::Ipv6Address ns3::Ipv6Header::GetDestinationAddress() const [member function]
+ cls.add_method('GetDestinationAddress',
+ 'ns3::Ipv6Address',
+ [],
+ is_const=True)
+ ## ipv6-header.h (module 'internet'): uint32_t ns3::Ipv6Header::GetFlowLabel() const [member function]
+ cls.add_method('GetFlowLabel',
+ 'uint32_t',
+ [],
+ is_const=True)
+ ## ipv6-header.h (module 'internet'): uint8_t ns3::Ipv6Header::GetHopLimit() const [member function]
+ cls.add_method('GetHopLimit',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## ipv6-header.h (module 'internet'): ns3::TypeId ns3::Ipv6Header::GetInstanceTypeId() const [member function]
+ cls.add_method('GetInstanceTypeId',
+ 'ns3::TypeId',
+ [],
+ is_const=True, is_virtual=True)
+ ## ipv6-header.h (module 'internet'): uint8_t ns3::Ipv6Header::GetNextHeader() const [member function]
+ cls.add_method('GetNextHeader',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## ipv6-header.h (module 'internet'): uint16_t ns3::Ipv6Header::GetPayloadLength() const [member function]
+ cls.add_method('GetPayloadLength',
+ 'uint16_t',
+ [],
+ is_const=True)
+ ## ipv6-header.h (module 'internet'): uint32_t ns3::Ipv6Header::GetSerializedSize() const [member function]
+ cls.add_method('GetSerializedSize',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## ipv6-header.h (module 'internet'): ns3::Ipv6Address ns3::Ipv6Header::GetSourceAddress() const [member function]
+ cls.add_method('GetSourceAddress',
+ 'ns3::Ipv6Address',
+ [],
+ is_const=True)
+ ## ipv6-header.h (module 'internet'): uint8_t ns3::Ipv6Header::GetTrafficClass() const [member function]
+ cls.add_method('GetTrafficClass',
+ 'uint8_t',
+ [],
+ is_const=True)
+ ## ipv6-header.h (module 'internet'): static ns3::TypeId ns3::Ipv6Header::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::Print(std::ostream & os) const [member function]
+ cls.add_method('Print',
+ 'void',
+ [param('std::ostream &', 'os')],
+ is_const=True, is_virtual=True)
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::Serialize(ns3::Buffer::Iterator start) const [member function]
+ cls.add_method('Serialize',
+ 'void',
+ [param('ns3::Buffer::Iterator', 'start')],
+ is_const=True, is_virtual=True)
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::SetDestinationAddress(ns3::Ipv6Address dst) [member function]
+ cls.add_method('SetDestinationAddress',
+ 'void',
+ [param('ns3::Ipv6Address', 'dst')])
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::SetFlowLabel(uint32_t flow) [member function]
+ cls.add_method('SetFlowLabel',
+ 'void',
+ [param('uint32_t', 'flow')])
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::SetHopLimit(uint8_t limit) [member function]
+ cls.add_method('SetHopLimit',
+ 'void',
+ [param('uint8_t', 'limit')])
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::SetNextHeader(uint8_t next) [member function]
+ cls.add_method('SetNextHeader',
+ 'void',
+ [param('uint8_t', 'next')])
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::SetPayloadLength(uint16_t len) [member function]
+ cls.add_method('SetPayloadLength',
+ 'void',
+ [param('uint16_t', 'len')])
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::SetSourceAddress(ns3::Ipv6Address src) [member function]
+ cls.add_method('SetSourceAddress',
+ 'void',
+ [param('ns3::Ipv6Address', 'src')])
+ ## ipv6-header.h (module 'internet'): void ns3::Ipv6Header::SetTrafficClass(uint8_t traffic) [member function]
+ cls.add_method('SetTrafficClass',
+ 'void',
+ [param('uint8_t', 'traffic')])
+ return
+
def register_Ns3Object_methods(root_module, cls):
## object.h (module 'core'): ns3::Object::Object() [constructor]
cls.add_constructor([])
@@ -3588,6 +3797,11 @@
cls.add_constructor([param('std::string const &', 's')])
## nstime.h (module 'core'): ns3::Time::Time(ns3::int64x64_t const & value) [constructor]
cls.add_constructor([param('ns3::int64x64_t const &', 'value')])
+ ## nstime.h (module 'core'): ns3::TimeWithUnit ns3::Time::As(ns3::Time::Unit const unit) const [member function]
+ cls.add_method('As',
+ 'ns3::TimeWithUnit',
+ [param('ns3::Time::Unit const', 'unit')],
+ is_const=True)
## nstime.h (module 'core'): int ns3::Time::Compare(ns3::Time const & o) const [member function]
cls.add_method('Compare',
'int',
@@ -4009,6 +4223,10 @@
cls.add_constructor([param('ns3::FlowMonitor const &', 'arg0')])
## flow-monitor.h (module 'flow-monitor'): ns3::FlowMonitor::FlowMonitor() [constructor]
cls.add_constructor([])
+ ## flow-monitor.h (module 'flow-monitor'): void ns3::FlowMonitor::AddFlowClassifier(ns3::Ptr<ns3::FlowClassifier> classifier) [member function]
+ cls.add_method('AddFlowClassifier',
+ 'void',
+ [param('ns3::Ptr< ns3::FlowClassifier >', 'classifier')])
## flow-monitor.h (module 'flow-monitor'): void ns3::FlowMonitor::AddProbe(ns3::Ptr<ns3::FlowProbe> probe) [member function]
cls.add_method('AddProbe',
'void',
@@ -4069,10 +4287,6 @@
cls.add_method('SerializeToXmlString',
'std::string',
[param('int', 'indent'), param('bool', 'enableHistograms'), param('bool', 'enableProbes')])
- ## flow-monitor.h (module 'flow-monitor'): void ns3::FlowMonitor::SetFlowClassifier(ns3::Ptr<ns3::FlowClassifier> classifier) [member function]
- cls.add_method('SetFlowClassifier',
- 'void',
- [param('ns3::Ptr< ns3::FlowClassifier >', 'classifier')])
## flow-monitor.h (module 'flow-monitor'): void ns3::FlowMonitor::Start(ns3::Time const & time) [member function]
cls.add_method('Start',
'void',
@@ -4860,6 +5074,170 @@
is_pure_virtual=True, is_virtual=True)
return
+def register_Ns3Ipv6_methods(root_module, cls):
+ ## ipv6.h (module 'internet'): ns3::Ipv6::Ipv6(ns3::Ipv6 const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::Ipv6 const &', 'arg0')])
+ ## ipv6.h (module 'internet'): ns3::Ipv6::Ipv6() [constructor]
+ cls.add_constructor([])
+ ## ipv6.h (module 'internet'): bool ns3::Ipv6::AddAddress(uint32_t interface, ns3::Ipv6InterfaceAddress address) [member function]
+ cls.add_method('AddAddress',
+ 'bool',
+ [param('uint32_t', 'interface'), param('ns3::Ipv6InterfaceAddress', 'address')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): uint32_t ns3::Ipv6::AddInterface(ns3::Ptr<ns3::NetDevice> device) [member function]
+ cls.add_method('AddInterface',
+ 'uint32_t',
+ [param('ns3::Ptr< ns3::NetDevice >', 'device')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): ns3::Ipv6InterfaceAddress ns3::Ipv6::GetAddress(uint32_t interface, uint32_t addressIndex) const [member function]
+ cls.add_method('GetAddress',
+ 'ns3::Ipv6InterfaceAddress',
+ [param('uint32_t', 'interface'), param('uint32_t', 'addressIndex')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): int32_t ns3::Ipv6::GetInterfaceForAddress(ns3::Ipv6Address address) const [member function]
+ cls.add_method('GetInterfaceForAddress',
+ 'int32_t',
+ [param('ns3::Ipv6Address', 'address')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): int32_t ns3::Ipv6::GetInterfaceForDevice(ns3::Ptr<const ns3::NetDevice> device) const [member function]
+ cls.add_method('GetInterfaceForDevice',
+ 'int32_t',
+ [param('ns3::Ptr< ns3::NetDevice const >', 'device')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): int32_t ns3::Ipv6::GetInterfaceForPrefix(ns3::Ipv6Address address, ns3::Ipv6Prefix mask) const [member function]
+ cls.add_method('GetInterfaceForPrefix',
+ 'int32_t',
+ [param('ns3::Ipv6Address', 'address'), param('ns3::Ipv6Prefix', 'mask')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): uint16_t ns3::Ipv6::GetMetric(uint32_t interface) const [member function]
+ cls.add_method('GetMetric',
+ 'uint16_t',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): uint16_t ns3::Ipv6::GetMtu(uint32_t interface) const [member function]
+ cls.add_method('GetMtu',
+ 'uint16_t',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): uint32_t ns3::Ipv6::GetNAddresses(uint32_t interface) const [member function]
+ cls.add_method('GetNAddresses',
+ 'uint32_t',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): uint32_t ns3::Ipv6::GetNInterfaces() const [member function]
+ cls.add_method('GetNInterfaces',
+ 'uint32_t',
+ [],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): ns3::Ptr<ns3::NetDevice> ns3::Ipv6::GetNetDevice(uint32_t interface) [member function]
+ cls.add_method('GetNetDevice',
+ 'ns3::Ptr< ns3::NetDevice >',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): ns3::Ptr<ns3::IpL4Protocol> ns3::Ipv6::GetProtocol(int protocolNumber) const [member function]
+ cls.add_method('GetProtocol',
+ 'ns3::Ptr< ns3::IpL4Protocol >',
+ [param('int', 'protocolNumber')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): ns3::Ptr<ns3::Ipv6RoutingProtocol> ns3::Ipv6::GetRoutingProtocol() const [member function]
+ cls.add_method('GetRoutingProtocol',
+ 'ns3::Ptr< ns3::Ipv6RoutingProtocol >',
+ [],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): static ns3::TypeId ns3::Ipv6::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## ipv6.h (module 'internet'): bool ns3::Ipv6::IsForwarding(uint32_t interface) const [member function]
+ cls.add_method('IsForwarding',
+ 'bool',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): bool ns3::Ipv6::IsUp(uint32_t interface) const [member function]
+ cls.add_method('IsUp',
+ 'bool',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_const=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::RegisterExtensions() [member function]
+ cls.add_method('RegisterExtensions',
+ 'void',
+ [],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::RegisterOptions() [member function]
+ cls.add_method('RegisterOptions',
+ 'void',
+ [],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): bool ns3::Ipv6::RemoveAddress(uint32_t interface, uint32_t addressIndex) [member function]
+ cls.add_method('RemoveAddress',
+ 'bool',
+ [param('uint32_t', 'interface'), param('uint32_t', 'addressIndex')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): bool ns3::Ipv6::RemoveAddress(uint32_t interface, ns3::Ipv6Address address) [member function]
+ cls.add_method('RemoveAddress',
+ 'bool',
+ [param('uint32_t', 'interface'), param('ns3::Ipv6Address', 'address')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetDown(uint32_t interface) [member function]
+ cls.add_method('SetDown',
+ 'void',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetForwarding(uint32_t interface, bool val) [member function]
+ cls.add_method('SetForwarding',
+ 'void',
+ [param('uint32_t', 'interface'), param('bool', 'val')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetMetric(uint32_t interface, uint16_t metric) [member function]
+ cls.add_method('SetMetric',
+ 'void',
+ [param('uint32_t', 'interface'), param('uint16_t', 'metric')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetPmtu(ns3::Ipv6Address dst, uint32_t pmtu) [member function]
+ cls.add_method('SetPmtu',
+ 'void',
+ [param('ns3::Ipv6Address', 'dst'), param('uint32_t', 'pmtu')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetRoutingProtocol(ns3::Ptr<ns3::Ipv6RoutingProtocol> routingProtocol) [member function]
+ cls.add_method('SetRoutingProtocol',
+ 'void',
+ [param('ns3::Ptr< ns3::Ipv6RoutingProtocol >', 'routingProtocol')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetUp(uint32_t interface) [member function]
+ cls.add_method('SetUp',
+ 'void',
+ [param('uint32_t', 'interface')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): ns3::Ipv6Address ns3::Ipv6::SourceAddressSelection(uint32_t interface, ns3::Ipv6Address dest) [member function]
+ cls.add_method('SourceAddressSelection',
+ 'ns3::Ipv6Address',
+ [param('uint32_t', 'interface'), param('ns3::Ipv6Address', 'dest')],
+ is_pure_virtual=True, is_virtual=True)
+ ## ipv6.h (module 'internet'): ns3::Ipv6::IF_ANY [variable]
+ cls.add_static_attribute('IF_ANY', 'uint32_t const', is_const=True)
+ ## ipv6.h (module 'internet'): bool ns3::Ipv6::GetIpForward() const [member function]
+ cls.add_method('GetIpForward',
+ 'bool',
+ [],
+ is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
+ ## ipv6.h (module 'internet'): bool ns3::Ipv6::GetMtuDiscover() const [member function]
+ cls.add_method('GetMtuDiscover',
+ 'bool',
+ [],
+ is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetIpForward(bool forward) [member function]
+ cls.add_method('SetIpForward',
+ 'void',
+ [param('bool', 'forward')],
+ is_pure_virtual=True, visibility='private', is_virtual=True)
+ ## ipv6.h (module 'internet'): void ns3::Ipv6::SetMtuDiscover(bool mtuDiscover) [member function]
+ cls.add_method('SetMtuDiscover',
+ 'void',
+ [param('bool', 'mtuDiscover')],
+ is_pure_virtual=True, visibility='private', is_virtual=True)
+ return
+
def register_Ns3Ipv6AddressChecker_methods(root_module, cls):
## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker() [constructor]
cls.add_constructor([])
@@ -4900,6 +5278,329 @@
[param('ns3::Ipv6Address const &', 'value')])
return
+def register_Ns3Ipv6FlowClassifier_methods(root_module, cls):
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::Ipv6FlowClassifier() [constructor]
+ cls.add_constructor([])
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): bool ns3::Ipv6FlowClassifier::Classify(ns3::Ipv6Header const & ipHeader, ns3::Ptr<const ns3::Packet> ipPayload, uint32_t * out_flowId, uint32_t * out_packetId) [member function]
+ cls.add_method('Classify',
+ 'bool',
+ [param('ns3::Ipv6Header const &', 'ipHeader'), param('ns3::Ptr< ns3::Packet const >', 'ipPayload'), param('uint32_t *', 'out_flowId'), param('uint32_t *', 'out_packetId')])
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple ns3::Ipv6FlowClassifier::FindFlow(ns3::FlowId flowId) const [member function]
+ cls.add_method('FindFlow',
+ 'ns3::Ipv6FlowClassifier::FiveTuple',
+ [param('ns3::FlowId', 'flowId')],
+ is_const=True)
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): void ns3::Ipv6FlowClassifier::SerializeToXmlStream(std::ostream & os, int indent) const [member function]
+ cls.add_method('SerializeToXmlStream',
+ 'void',
+ [param('std::ostream &', 'os'), param('int', 'indent')],
+ is_const=True, is_virtual=True)
+ return
+
+def register_Ns3Ipv6FlowClassifierFiveTuple_methods(root_module, cls):
+ cls.add_binary_comparison_operator('<')
+ cls.add_binary_comparison_operator('==')
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple::FiveTuple() [constructor]
+ cls.add_constructor([])
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple::FiveTuple(ns3::Ipv6FlowClassifier::FiveTuple const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::Ipv6FlowClassifier::FiveTuple const &', 'arg0')])
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple::destinationAddress [variable]
+ cls.add_instance_attribute('destinationAddress', 'ns3::Ipv6Address', is_const=False)
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple::destinationPort [variable]
+ cls.add_instance_attribute('destinationPort', 'uint16_t', is_const=False)
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple::protocol [variable]
+ cls.add_instance_attribute('protocol', 'uint8_t', is_const=False)
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple::sourceAddress [variable]
+ cls.add_instance_attribute('sourceAddress', 'ns3::Ipv6Address', is_const=False)
+ ## ipv6-flow-classifier.h (module 'flow-monitor'): ns3::Ipv6FlowClassifier::FiveTuple::sourcePort [variable]
+ cls.add_instance_attribute('sourcePort', 'uint16_t', is_const=False)
+ return
+
+def register_Ns3Ipv6FlowProbe_methods(root_module, cls):
+ ## ipv6-flow-probe.h (module 'flow-monitor'): ns3::Ipv6FlowProbe::Ipv6FlowProbe(ns3::Ptr<ns3::FlowMonitor> monitor, ns3::Ptr<ns3::Ipv6FlowClassifier> classifier, ns3::Ptr<ns3::Node> node) [constructor]
+ cls.add_constructor([param('ns3::Ptr< ns3::FlowMonitor >', 'monitor'), param('ns3::Ptr< ns3::Ipv6FlowClassifier >', 'classifier'), param('ns3::Ptr< ns3::Node >', 'node')])
+ ## ipv6-flow-probe.h (module 'flow-monitor'): void ns3::Ipv6FlowProbe::DoDispose() [member function]
+ cls.add_method('DoDispose',
+ 'void',
+ [],
+ visibility='protected', is_virtual=True)
+ return
+
+def register_Ns3Ipv6L3Protocol_methods(root_module, cls):
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ipv6L3Protocol::PROT_NUMBER [variable]
+ cls.add_static_attribute('PROT_NUMBER', 'uint16_t const', is_const=True)
+ ## ipv6-l3-protocol.h (module 'internet'): static ns3::TypeId ns3::Ipv6L3Protocol::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ipv6L3Protocol::Ipv6L3Protocol() [constructor]
+ cls.add_constructor([])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetNode(ns3::Ptr<ns3::Node> node) [member function]
+ cls.add_method('SetNode',
+ 'void',
+ [param('ns3::Ptr< ns3::Node >', 'node')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::Insert(ns3::Ptr<ns3::IpL4Protocol> protocol) [member function]
+ cls.add_method('Insert',
+ 'void',
+ [param('ns3::Ptr< ns3::IpL4Protocol >', 'protocol')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::Remove(ns3::Ptr<ns3::IpL4Protocol> protocol) [member function]
+ cls.add_method('Remove',
+ 'void',
+ [param('ns3::Ptr< ns3::IpL4Protocol >', 'protocol')])
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ptr<ns3::IpL4Protocol> ns3::Ipv6L3Protocol::GetProtocol(int protocolNumber) const [member function]
+ cls.add_method('GetProtocol',
+ 'ns3::Ptr< ns3::IpL4Protocol >',
+ [param('int', 'protocolNumber')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ptr<ns3::Socket> ns3::Ipv6L3Protocol::CreateRawSocket() [member function]
+ cls.add_method('CreateRawSocket',
+ 'ns3::Ptr< ns3::Socket >',
+ [])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::DeleteRawSocket(ns3::Ptr<ns3::Socket> socket) [member function]
+ cls.add_method('DeleteRawSocket',
+ 'void',
+ [param('ns3::Ptr< ns3::Socket >', 'socket')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetDefaultTtl(uint8_t ttl) [member function]
+ cls.add_method('SetDefaultTtl',
+ 'void',
+ [param('uint8_t', 'ttl')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetDefaultTclass(uint8_t tclass) [member function]
+ cls.add_method('SetDefaultTclass',
+ 'void',
+ [param('uint8_t', 'tclass')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::Receive(ns3::Ptr<ns3::NetDevice> device, ns3::Ptr<const ns3::Packet> p, uint16_t protocol, ns3::Address const & from, ns3::Address const & to, ns3::NetDevice::PacketType packetType) [member function]
+ cls.add_method('Receive',
+ 'void',
+ [param('ns3::Ptr< ns3::NetDevice >', 'device'), param('ns3::Ptr< ns3::Packet const >', 'p'), param('uint16_t', 'protocol'), param('ns3::Address const &', 'from'), param('ns3::Address const &', 'to'), param('ns3::NetDevice::PacketType', 'packetType')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::Send(ns3::Ptr<ns3::Packet> packet, ns3::Ipv6Address source, ns3::Ipv6Address destination, uint8_t protocol, ns3::Ptr<ns3::Ipv6Route> route) [member function]
+ cls.add_method('Send',
+ 'void',
+ [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Ipv6Address', 'source'), param('ns3::Ipv6Address', 'destination'), param('uint8_t', 'protocol'), param('ns3::Ptr< ns3::Ipv6Route >', 'route')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetRoutingProtocol(ns3::Ptr<ns3::Ipv6RoutingProtocol> routingProtocol) [member function]
+ cls.add_method('SetRoutingProtocol',
+ 'void',
+ [param('ns3::Ptr< ns3::Ipv6RoutingProtocol >', 'routingProtocol')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ptr<ns3::Ipv6RoutingProtocol> ns3::Ipv6L3Protocol::GetRoutingProtocol() const [member function]
+ cls.add_method('GetRoutingProtocol',
+ 'ns3::Ptr< ns3::Ipv6RoutingProtocol >',
+ [],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): uint32_t ns3::Ipv6L3Protocol::AddInterface(ns3::Ptr<ns3::NetDevice> device) [member function]
+ cls.add_method('AddInterface',
+ 'uint32_t',
+ [param('ns3::Ptr< ns3::NetDevice >', 'device')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ptr<ns3::Ipv6Interface> ns3::Ipv6L3Protocol::GetInterface(uint32_t i) const [member function]
+ cls.add_method('GetInterface',
+ 'ns3::Ptr< ns3::Ipv6Interface >',
+ [param('uint32_t', 'i')],
+ is_const=True)
+ ## ipv6-l3-protocol.h (module 'internet'): uint32_t ns3::Ipv6L3Protocol::GetNInterfaces() const [member function]
+ cls.add_method('GetNInterfaces',
+ 'uint32_t',
+ [],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): int32_t ns3::Ipv6L3Protocol::GetInterfaceForAddress(ns3::Ipv6Address addr) const [member function]
+ cls.add_method('GetInterfaceForAddress',
+ 'int32_t',
+ [param('ns3::Ipv6Address', 'addr')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): int32_t ns3::Ipv6L3Protocol::GetInterfaceForPrefix(ns3::Ipv6Address addr, ns3::Ipv6Prefix mask) const [member function]
+ cls.add_method('GetInterfaceForPrefix',
+ 'int32_t',
+ [param('ns3::Ipv6Address', 'addr'), param('ns3::Ipv6Prefix', 'mask')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): int32_t ns3::Ipv6L3Protocol::GetInterfaceForDevice(ns3::Ptr<const ns3::NetDevice> device) const [member function]
+ cls.add_method('GetInterfaceForDevice',
+ 'int32_t',
+ [param('ns3::Ptr< ns3::NetDevice const >', 'device')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::AddAddress(uint32_t i, ns3::Ipv6InterfaceAddress address) [member function]
+ cls.add_method('AddAddress',
+ 'bool',
+ [param('uint32_t', 'i'), param('ns3::Ipv6InterfaceAddress', 'address')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ipv6InterfaceAddress ns3::Ipv6L3Protocol::GetAddress(uint32_t interfaceIndex, uint32_t addressIndex) const [member function]
+ cls.add_method('GetAddress',
+ 'ns3::Ipv6InterfaceAddress',
+ [param('uint32_t', 'interfaceIndex'), param('uint32_t', 'addressIndex')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): uint32_t ns3::Ipv6L3Protocol::GetNAddresses(uint32_t interface) const [member function]
+ cls.add_method('GetNAddresses',
+ 'uint32_t',
+ [param('uint32_t', 'interface')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::RemoveAddress(uint32_t interfaceIndex, uint32_t addressIndex) [member function]
+ cls.add_method('RemoveAddress',
+ 'bool',
+ [param('uint32_t', 'interfaceIndex'), param('uint32_t', 'addressIndex')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::RemoveAddress(uint32_t interfaceIndex, ns3::Ipv6Address address) [member function]
+ cls.add_method('RemoveAddress',
+ 'bool',
+ [param('uint32_t', 'interfaceIndex'), param('ns3::Ipv6Address', 'address')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetMetric(uint32_t i, uint16_t metric) [member function]
+ cls.add_method('SetMetric',
+ 'void',
+ [param('uint32_t', 'i'), param('uint16_t', 'metric')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): uint16_t ns3::Ipv6L3Protocol::GetMetric(uint32_t i) const [member function]
+ cls.add_method('GetMetric',
+ 'uint16_t',
+ [param('uint32_t', 'i')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): uint16_t ns3::Ipv6L3Protocol::GetMtu(uint32_t i) const [member function]
+ cls.add_method('GetMtu',
+ 'uint16_t',
+ [param('uint32_t', 'i')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetPmtu(ns3::Ipv6Address dst, uint32_t pmtu) [member function]
+ cls.add_method('SetPmtu',
+ 'void',
+ [param('ns3::Ipv6Address', 'dst'), param('uint32_t', 'pmtu')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::IsUp(uint32_t i) const [member function]
+ cls.add_method('IsUp',
+ 'bool',
+ [param('uint32_t', 'i')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetUp(uint32_t i) [member function]
+ cls.add_method('SetUp',
+ 'void',
+ [param('uint32_t', 'i')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetDown(uint32_t i) [member function]
+ cls.add_method('SetDown',
+ 'void',
+ [param('uint32_t', 'i')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::IsForwarding(uint32_t i) const [member function]
+ cls.add_method('IsForwarding',
+ 'bool',
+ [param('uint32_t', 'i')],
+ is_const=True, is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetForwarding(uint32_t i, bool val) [member function]
+ cls.add_method('SetForwarding',
+ 'void',
+ [param('uint32_t', 'i'), param('bool', 'val')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ipv6Address ns3::Ipv6L3Protocol::SourceAddressSelection(uint32_t interface, ns3::Ipv6Address dest) [member function]
+ cls.add_method('SourceAddressSelection',
+ 'ns3::Ipv6Address',
+ [param('uint32_t', 'interface'), param('ns3::Ipv6Address', 'dest')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ptr<ns3::NetDevice> ns3::Ipv6L3Protocol::GetNetDevice(uint32_t i) [member function]
+ cls.add_method('GetNetDevice',
+ 'ns3::Ptr< ns3::NetDevice >',
+ [param('uint32_t', 'i')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): ns3::Ptr<ns3::Icmpv6L4Protocol> ns3::Ipv6L3Protocol::GetIcmpv6() const [member function]
+ cls.add_method('GetIcmpv6',
+ 'ns3::Ptr< ns3::Icmpv6L4Protocol >',
+ [],
+ is_const=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::AddAutoconfiguredAddress(uint32_t interface, ns3::Ipv6Address network, ns3::Ipv6Prefix mask, uint8_t flags, uint32_t validTime, uint32_t preferredTime, ns3::Ipv6Address defaultRouter=ns3::Ipv6Address::GetZero( )) [member function]
+ cls.add_method('AddAutoconfiguredAddress',
+ 'void',
+ [param('uint32_t', 'interface'), param('ns3::Ipv6Address', 'network'), param('ns3::Ipv6Prefix', 'mask'), param('uint8_t', 'flags'), param('uint32_t', 'validTime'), param('uint32_t', 'preferredTime'), param('ns3::Ipv6Address', 'defaultRouter', default_value='ns3::Ipv6Address::GetZero( )')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::RemoveAutoconfiguredAddress(uint32_t interface, ns3::Ipv6Address network, ns3::Ipv6Prefix mask, ns3::Ipv6Address defaultRouter) [member function]
+ cls.add_method('RemoveAutoconfiguredAddress',
+ 'void',
+ [param('uint32_t', 'interface'), param('ns3::Ipv6Address', 'network'), param('ns3::Ipv6Prefix', 'mask'), param('ns3::Ipv6Address', 'defaultRouter')])
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::RegisterExtensions() [member function]
+ cls.add_method('RegisterExtensions',
+ 'void',
+ [],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::RegisterOptions() [member function]
+ cls.add_method('RegisterOptions',
+ 'void',
+ [],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::ReportDrop(ns3::Ipv6Header ipHeader, ns3::Ptr<ns3::Packet> p, ns3::Ipv6L3Protocol::DropReason dropReason) [member function]
+ cls.add_method('ReportDrop',
+ 'void',
+ [param('ns3::Ipv6Header', 'ipHeader'), param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ipv6L3Protocol::DropReason', 'dropReason')],
+ is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::DoDispose() [member function]
+ cls.add_method('DoDispose',
+ 'void',
+ [],
+ visibility='protected', is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::NotifyNewAggregate() [member function]
+ cls.add_method('NotifyNewAggregate',
+ 'void',
+ [],
+ visibility='protected', is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetIpForward(bool forward) [member function]
+ cls.add_method('SetIpForward',
+ 'void',
+ [param('bool', 'forward')],
+ visibility='private', is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::GetIpForward() const [member function]
+ cls.add_method('GetIpForward',
+ 'bool',
+ [],
+ is_const=True, visibility='private', is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetMtuDiscover(bool mtuDiscover) [member function]
+ cls.add_method('SetMtuDiscover',
+ 'void',
+ [param('bool', 'mtuDiscover')],
+ visibility='private', is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::GetMtuDiscover() const [member function]
+ cls.add_method('GetMtuDiscover',
+ 'bool',
+ [],
+ is_const=True, visibility='private', is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::SetSendIcmpv6Redirect(bool sendIcmpv6Redirect) [member function]
+ cls.add_method('SetSendIcmpv6Redirect',
+ 'void',
+ [param('bool', 'sendIcmpv6Redirect')],
+ visibility='private', is_virtual=True)
+ ## ipv6-l3-protocol.h (module 'internet'): bool ns3::Ipv6L3Protocol::GetSendIcmpv6Redirect() const [member function]
+ cls.add_method('GetSendIcmpv6Redirect',
+ 'bool',
+ [],
+ is_const=True, visibility='private', is_virtual=True)
+ return
+
+def register_Ns3Ipv6PmtuCache_methods(root_module, cls):
+ ## ipv6-pmtu-cache.h (module 'internet'): ns3::Ipv6PmtuCache::Ipv6PmtuCache(ns3::Ipv6PmtuCache const & arg0) [copy constructor]
+ cls.add_constructor([param('ns3::Ipv6PmtuCache const &', 'arg0')])
+ ## ipv6-pmtu-cache.h (module 'internet'): ns3::Ipv6PmtuCache::Ipv6PmtuCache() [constructor]
+ cls.add_constructor([])
+ ## ipv6-pmtu-cache.h (module 'internet'): void ns3::Ipv6PmtuCache::DoDispose() [member function]
+ cls.add_method('DoDispose',
+ 'void',
+ [],
+ is_virtual=True)
+ ## ipv6-pmtu-cache.h (module 'internet'): uint32_t ns3::Ipv6PmtuCache::GetPmtu(ns3::Ipv6Address dst) [member function]
+ cls.add_method('GetPmtu',
+ 'uint32_t',
+ [param('ns3::Ipv6Address', 'dst')])
+ ## ipv6-pmtu-cache.h (module 'internet'): ns3::Time ns3::Ipv6PmtuCache::GetPmtuValidityTime() const [member function]
+ cls.add_method('GetPmtuValidityTime',
+ 'ns3::Time',
+ [],
+ is_const=True)
+ ## ipv6-pmtu-cache.h (module 'internet'): static ns3::TypeId ns3::Ipv6PmtuCache::GetTypeId() [member function]
+ cls.add_method('GetTypeId',
+ 'ns3::TypeId',
+ [],
+ is_static=True)
+ ## ipv6-pmtu-cache.h (module 'internet'): void ns3::Ipv6PmtuCache::SetPmtu(ns3::Ipv6Address dst, uint32_t pmtu) [member function]
+ cls.add_method('SetPmtu',
+ 'void',
+ [param('ns3::Ipv6Address', 'dst'), param('uint32_t', 'pmtu')])
+ ## ipv6-pmtu-cache.h (module 'internet'): bool ns3::Ipv6PmtuCache::SetPmtuValidityTime(ns3::Time validity) [member function]
+ cls.add_method('SetPmtuValidityTime',
+ 'bool',
+ [param('ns3::Time', 'validity')])
+ return
+
def register_Ns3Ipv6PrefixChecker_methods(root_module, cls):
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker() [constructor]
cls.add_constructor([])
--- a/src/flow-monitor/helper/flow-monitor-helper.cc Tue Apr 08 14:07:33 2014 -0700
+++ b/src/flow-monitor/helper/flow-monitor-helper.cc Mon Apr 21 11:32:45 2014 +0200
@@ -24,6 +24,9 @@
#include "ns3/ipv4-flow-classifier.h"
#include "ns3/ipv4-flow-probe.h"
#include "ns3/ipv4-l3-protocol.h"
+#include "ns3/ipv6-flow-classifier.h"
+#include "ns3/ipv6-flow-probe.h"
+#include "ns3/ipv6-l3-protocol.h"
#include "ns3/node.h"
#include "ns3/node-list.h"
@@ -41,7 +44,8 @@
{
m_flowMonitor->Dispose ();
m_flowMonitor = 0;
- m_flowClassifier = 0;
+ m_flowClassifier4 = 0;
+ m_flowClassifier6 = 0;
}
}
@@ -58,8 +62,10 @@
if (!m_flowMonitor)
{
m_flowMonitor = m_monitorFactory.Create<FlowMonitor> ();
- m_flowClassifier = Create<Ipv4FlowClassifier> ();
- m_flowMonitor->SetFlowClassifier (m_flowClassifier);
+ m_flowClassifier4 = Create<Ipv4FlowClassifier> ();
+ m_flowMonitor->AddFlowClassifier (m_flowClassifier4);
+ m_flowClassifier6 = Create<Ipv6FlowClassifier> ();
+ m_flowMonitor->AddFlowClassifier (m_flowClassifier6);
}
return m_flowMonitor;
}
@@ -68,11 +74,22 @@
Ptr<FlowClassifier>
FlowMonitorHelper::GetClassifier ()
{
- if (!m_flowClassifier)
+ if (!m_flowClassifier4)
{
- m_flowClassifier = Create<Ipv4FlowClassifier> ();
+ m_flowClassifier4 = Create<Ipv4FlowClassifier> ();
}
- return m_flowClassifier;
+ return m_flowClassifier4;
+}
+
+
+Ptr<FlowClassifier>
+FlowMonitorHelper::GetClassifier6 ()
+{
+ if (!m_flowClassifier6)
+ {
+ m_flowClassifier6 = Create<Ipv6FlowClassifier> ();
+ }
+ return m_flowClassifier6;
}
@@ -88,6 +105,14 @@
DynamicCast<Ipv4FlowClassifier> (classifier),
node);
}
+ Ptr<FlowClassifier> classifier6 = GetClassifier6 ();
+ Ptr<Ipv6L3Protocol> ipv6 = node->GetObject<Ipv6L3Protocol> ();
+ if (ipv6)
+ {
+ Ptr<Ipv6FlowProbe> probe6 = Create<Ipv6FlowProbe> (monitor,
+ DynamicCast<Ipv6FlowClassifier> (classifier6),
+ node);
+ }
return m_flowMonitor;
}
@@ -98,7 +123,7 @@
for (NodeContainer::Iterator i = nodes.Begin (); i != nodes.End (); ++i)
{
Ptr<Node> node = *i;
- if (node->GetObject<Ipv4L3Protocol> ())
+ if (node->GetObject<Ipv4L3Protocol> () || node->GetObject<Ipv6L3Protocol> ())
{
Install (node);
}
@@ -112,7 +137,7 @@
for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
{
Ptr<Node> node = *i;
- if (node->GetObject<Ipv4L3Protocol> ())
+ if (node->GetObject<Ipv4L3Protocol> () || node->GetObject<Ipv6L3Protocol> ())
{
Install (node);
}
--- a/src/flow-monitor/helper/flow-monitor-helper.h Tue Apr 08 14:07:33 2014 -0700
+++ b/src/flow-monitor/helper/flow-monitor-helper.h Mon Apr 21 11:32:45 2014 +0200
@@ -30,10 +30,11 @@
class AttributeValue;
class Ipv4FlowClassifier;
+class Ipv6FlowClassifier;
/**
* \ingroup flow-monitor
- * \brief Helper to enable IPv4 flow monitoring on a set of Nodes
+ * \brief Helper to enable IP flow monitoring on a set of Nodes
*/
class FlowMonitorHelper
{
@@ -74,12 +75,18 @@
Ptr<FlowMonitor> GetMonitor ();
/**
- * \brief Retrieve the FlowClassifier object created by the Install* methods
+ * \brief Retrieve the FlowClassifier object for IPv4 created by the Install* methods
* \returns a pointer to the FlowClassifier object
*/
Ptr<FlowClassifier> GetClassifier ();
/**
+ * \brief Retrieve the FlowClassifier object for IPv6 created by the Install* methods
+ * \returns a pointer to the FlowClassifier object
+ */
+ Ptr<FlowClassifier> GetClassifier6 ();
+
+ /**
* Serializes the results to an std::ostream in XML format
* \param os the output stream
* \param indent number of spaces to use as base indentation level
@@ -120,9 +127,10 @@
*/
FlowMonitorHelper& operator= (const FlowMonitorHelper&);
- ObjectFactory m_monitorFactory; //!< Object factory
- Ptr<FlowMonitor> m_flowMonitor; //!< the FlowMonitor object
- Ptr<FlowClassifier> m_flowClassifier; //!< the FlowClassifier object
+ ObjectFactory m_monitorFactory; //!< Object factory
+ Ptr<FlowMonitor> m_flowMonitor; //!< the FlowMonitor object
+ Ptr<FlowClassifier> m_flowClassifier4; //!< the FlowClassifier object for IPv4
+ Ptr<FlowClassifier> m_flowClassifier6; //!< the FlowClassifier object for IPv6
};
} // namespace ns3
--- a/src/flow-monitor/model/flow-monitor.cc Tue Apr 08 14:07:33 2014 -0700
+++ b/src/flow-monitor/model/flow-monitor.cc Mon Apr 21 11:32:45 2014 +0200
@@ -90,7 +90,12 @@
void
FlowMonitor::DoDispose (void)
{
- m_classifier = 0;
+ for (std::list<Ptr<FlowClassifier> >::iterator iter = m_classifiers.begin ();
+ iter != m_classifiers.end ();
+ iter ++)
+ {
+ *iter = 0;
+ }
for (uint32_t i = 0; i < m_flowProbes.size (); i++)
{
m_flowProbes[i]->Dispose ();
@@ -389,9 +394,9 @@
}
void
-FlowMonitor::SetFlowClassifier (Ptr<FlowClassifier> classifier)
+FlowMonitor::AddFlowClassifier (Ptr<FlowClassifier> classifier)
{
- m_classifier = classifier;
+ m_classifiers.push_back (classifier);
}
void
@@ -456,7 +461,12 @@
indent -= 2;
INDENT (indent); os << "</FlowStats>\n";
- m_classifier->SerializeToXmlStream (os, indent);
+ for (std::list<Ptr<FlowClassifier> >::iterator iter = m_classifiers.begin ();
+ iter != m_classifiers.end ();
+ iter ++)
+ {
+ (*iter)->SerializeToXmlStream (os, indent);
+ }
if (enableProbes)
{
--- a/src/flow-monitor/model/flow-monitor.h Tue Apr 08 14:07:33 2014 -0700
+++ b/src/flow-monitor/model/flow-monitor.h Mon Apr 21 11:32:45 2014 +0200
@@ -146,9 +146,9 @@
TypeId GetInstanceTypeId () const;
FlowMonitor ();
- /// Set the FlowClassifier to be used by the flow monitor.
+ /// Add a FlowClassifier to be used by the flow monitor.
/// \param classifier the FlowClassifier
- void SetFlowClassifier (Ptr<FlowClassifier> classifier);
+ void AddFlowClassifier (Ptr<FlowClassifier> classifier);
/// Set the time, counting from the current time, from which to start monitoring flows.
/// \param time delta time to start
@@ -266,7 +266,7 @@
std::vector< Ptr<FlowProbe> > m_flowProbes; //!< all the FlowProbes
// note: this is needed only for serialization
- Ptr<FlowClassifier> m_classifier; //!< the FlowClassifier
+ std::list<Ptr<FlowClassifier> > m_classifiers; //!< the FlowClassifiers
EventId m_startEvent; //!< Start event
EventId m_stopEvent; //!< Stop event
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/flow-monitor/model/ipv6-flow-classifier.cc Mon Apr 21 11:32:45 2014 +0200
@@ -0,0 +1,218 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+//
+// Copyright (c) 2009 INESC Porto
+//
+// 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: Gustavo J. A. M. Carneiro <gjc@inescporto.pt> <gjcarneiro@gmail.com>
+// Modifications: Tommaso Pecorella <tommaso.pecorella@unifi.it>
+//
+
+#include "ns3/packet.h"
+
+#include "ipv6-flow-classifier.h"
+#include "ns3/udp-header.h"
+#include "ns3/tcp-header.h"
+
+namespace ns3 {
+
+/* see http://www.iana.org/assignments/protocol-numbers */
+const uint8_t TCP_PROT_NUMBER = 6; //!< TCP Protocol number
+const uint8_t UDP_PROT_NUMBER = 17; //!< UDP Protocol number
+
+
+
+bool operator < (const Ipv6FlowClassifier::FiveTuple &t1,
+ const Ipv6FlowClassifier::FiveTuple &t2)
+{
+ if (t1.sourceAddress < t2.sourceAddress)
+ {
+ return true;
+ }
+ if (t1.sourceAddress != t2.sourceAddress)
+ {
+ return false;
+ }
+
+ if (t1.destinationAddress < t2.destinationAddress)
+ {
+ return true;
+ }
+ if (t1.destinationAddress != t2.destinationAddress)
+ {
+ return false;
+ }
+
+ if (t1.protocol < t2.protocol)
+ {
+ return true;
+ }
+ if (t1.protocol != t2.protocol)
+ {
+ return false;
+ }
+
+ if (t1.sourcePort < t2.sourcePort)
+ {
+ return true;
+ }
+ if (t1.sourcePort != t2.sourcePort)
+ {
+ return false;
+ }
+
+ if (t1.destinationPort < t2.destinationPort)
+ {
+ return true;
+ }
+ if (t1.destinationPort != t2.destinationPort)
+ {
+ return false;
+ }
+
+ return false;
+}
+
+bool operator == (const Ipv6FlowClassifier::FiveTuple &t1,
+ const Ipv6FlowClassifier::FiveTuple &t2)
+{
+ return (t1.sourceAddress == t2.sourceAddress &&
+ t1.destinationAddress == t2.destinationAddress &&
+ t1.protocol == t2.protocol &&
+ t1.sourcePort == t2.sourcePort &&
+ t1.destinationPort == t2.destinationPort);
+}
+
+
+
+Ipv6FlowClassifier::Ipv6FlowClassifier ()
+{
+}
+
+bool
+Ipv6FlowClassifier::Classify (const Ipv6Header &ipHeader, Ptr<const Packet> ipPayload,
+ uint32_t *out_flowId, uint32_t *out_packetId)
+{
+ if (ipHeader.GetDestinationAddress ().IsMulticast ())
+ {
+ // we are not prepared to handle multicast yet
+ return false;
+ }
+
+ FiveTuple tuple;
+ tuple.sourceAddress = ipHeader.GetSourceAddress ();
+ tuple.destinationAddress = ipHeader.GetDestinationAddress ();
+ tuple.protocol = ipHeader.GetNextHeader ();
+
+ if ((tuple.protocol != UDP_PROT_NUMBER) && (tuple.protocol != TCP_PROT_NUMBER))
+ {
+ return false;
+ }
+
+ if (ipPayload->GetSize () < 4)
+ {
+ // the packet doesn't carry enough bytes
+ return false;
+ }
+
+ // we rely on the fact that for both TCP and UDP the ports are
+ // carried in the first 4 octects.
+ // This allows to read the ports even on fragmented packets
+ // not carrying a full TCP or UDP header.
+
+ uint8_t data[4];
+ ipPayload->CopyData (data, 4);
+
+ uint16_t srcPort = 0;
+ srcPort |= data[0];
+ srcPort <<= 8;
+ srcPort |= data[1];
+
+ uint16_t dstPort = 0;
+ dstPort |= data[2];
+ dstPort <<= 8;
+ dstPort |= data[3];
+
+ tuple.sourcePort = srcPort;
+ tuple.destinationPort = dstPort;
+
+ // try to insert the tuple, but check if it already exists
+ std::pair<std::map<FiveTuple, FlowId>::iterator, bool> insert
+ = m_flowMap.insert (std::pair<FiveTuple, FlowId> (tuple, 0));
+
+ // if the insertion succeeded, we need to assign this tuple a new flow identifier
+ if (insert.second)
+ {
+ FlowId newFlowId = GetNewFlowId ();
+ insert.first->second = newFlowId;
+ m_flowPktIdMap[newFlowId] = 0;
+ }
+ else
+ {
+ m_flowPktIdMap[insert.first->second] ++;
+ }
+
+ *out_flowId = insert.first->second;
+ *out_packetId = m_flowPktIdMap[*out_flowId];
+
+ return true;
+}
+
+
+Ipv6FlowClassifier::FiveTuple
+Ipv6FlowClassifier::FindFlow (FlowId flowId) const
+{
+ for (std::map<FiveTuple, FlowId>::const_iterator
+ iter = m_flowMap.begin (); iter != m_flowMap.end (); iter++)
+ {
+ if (iter->second == flowId)
+ {
+ return iter->first;
+ }
+ }
+ NS_FATAL_ERROR ("Could not find the flow with ID " << flowId);
+ FiveTuple retval = { Ipv6Address::GetZero (), Ipv6Address::GetZero (), 0, 0, 0 };
+ return retval;
+}
+
+void
+Ipv6FlowClassifier::SerializeToXmlStream (std::ostream &os, int indent) const
+{
+#define INDENT(level) for (int __xpto = 0; __xpto < level; __xpto++) os << ' ';
+
+ INDENT (indent); os << "<Ipv6FlowClassifier>\n";
+
+ indent += 2;
+ for (std::map<FiveTuple, FlowId>::const_iterator
+ iter = m_flowMap.begin (); iter != m_flowMap.end (); iter++)
+ {
+ INDENT (indent);
+ os << "<Flow flowId=\"" << iter->second << "\""
+ << " sourceAddress=\"" << iter->first.sourceAddress << "\""
+ << " destinationAddress=\"" << iter->first.destinationAddress << "\""
+ << " protocol=\"" << int(iter->first.protocol) << "\""
+ << " sourcePort=\"" << iter->first.sourcePort << "\""
+ << " destinationPort=\"" << iter->first.destinationPort << "\""
+ << " />\n";
+ }
+
+ indent -= 2;
+ INDENT (indent); os << "</Ipv6FlowClassifier>\n";
+
+#undef INDENT
+}
+
+
+} // namespace ns3
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/flow-monitor/model/ipv6-flow-classifier.h Mon Apr 21 11:32:45 2014 +0200
@@ -0,0 +1,104 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+//
+// Copyright (c) 2009 INESC Porto
+//
+// 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: Gustavo J. A. M. Carneiro <gjc@inescporto.pt> <gjcarneiro@gmail.com>
+// Modifications: Tommaso Pecorella <tommaso.pecorella@unifi.it>
+//
+
+#ifndef IPV6_FLOW_CLASSIFIER_H
+#define IPV6_FLOW_CLASSIFIER_H
+
+#include <stdint.h>
+#include <map>
+
+#include "ns3/ipv6-header.h"
+#include "ns3/flow-classifier.h"
+
+namespace ns3 {
+
+class Packet;
+
+/// Classifies packets by looking at their IP and TCP/UDP headers.
+/// From these packet headers, a tuple (source-ip, destination-ip,
+/// protocol, source-port, destination-port) is created, and a unique
+/// flow identifier is assigned for each different tuple combination
+class Ipv6FlowClassifier : public FlowClassifier
+{
+public:
+
+ /// Structure to classify a packet
+ struct FiveTuple
+ {
+ Ipv6Address sourceAddress; //!< Source address
+ Ipv6Address destinationAddress; //!< Destination address
+ uint8_t protocol; //!< Protocol
+ uint16_t sourcePort; //!< Source port
+ uint16_t destinationPort; //!< Destination port
+ };
+
+ Ipv6FlowClassifier ();
+
+ /// \brief try to classify the packet into flow-id and packet-id
+ ///
+ /// \warning: it must be called only once per packet, from SendOutgoingLogger.
+ ///
+ /// \return true if the packet was classified, false if not (i.e. it
+ /// does not appear to be part of a flow).
+ /// \param ipHeader packet's IP header
+ /// \param ipPayload packet's IP payload
+ /// \param out_flowId packet's FlowId
+ /// \param out_packetId packet's identifier
+ bool Classify (const Ipv6Header &ipHeader, Ptr<const Packet> ipPayload,
+ uint32_t *out_flowId, uint32_t *out_packetId);
+
+ /// Searches for the FiveTuple corresponding to the given flowId
+ /// \param flowId the FlowId to search for
+ /// \returns the FiveTuple corresponding to flowId
+ FiveTuple FindFlow (FlowId flowId) const;
+
+ virtual void SerializeToXmlStream (std::ostream &os, int indent) const;
+
+private:
+
+ /// Map to Flows Identifiers to FlowIds
+ std::map<FiveTuple, FlowId> m_flowMap;
+ std::map<FlowId, FlowPacketId> m_flowPktIdMap;
+
+};
+
+/**
+ * \brief Less than operator.
+ *
+ * \param t1 the first operand
+ * \param t2 the first operand
+ * \returns true if the operands are equal
+ */
+bool operator < (const Ipv6FlowClassifier::FiveTuple &t1, const Ipv6FlowClassifier::FiveTuple &t2);
+
+/**
+ * \brief Equal to operator.
+ *
+ * \param t1 the first operand
+ * \param t2 the first operand
+ * \returns true if the operands are equal
+ */
+bool operator == (const Ipv6FlowClassifier::FiveTuple &t1, const Ipv6FlowClassifier::FiveTuple &t2);
+
+
+} // namespace ns3
+
+#endif /* IPV6_FLOW_CLASSIFIER_H */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/flow-monitor/model/ipv6-flow-probe.cc Mon Apr 21 11:32:45 2014 +0200
@@ -0,0 +1,409 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+//
+// Copyright (c) 2009 INESC Porto
+//
+// 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: Gustavo J. A. M. Carneiro <gjc@inescporto.pt> <gjcarneiro@gmail.com>
+// Modifications: Tommaso Pecorella <tommaso.pecorella@unifi.it>
+//
+
+#include "ns3/ipv6-flow-probe.h"
+#include "ns3/ipv6-flow-classifier.h"
+#include "ns3/node.h"
+#include "ns3/packet.h"
+#include "ns3/flow-monitor.h"
+#include "ns3/log.h"
+#include "ns3/pointer.h"
+#include "ns3/config.h"
+#include "ns3/flow-id-tag.h"
+
+namespace ns3 {
+
+NS_LOG_COMPONENT_DEFINE ("Ipv6FlowProbe")
+ ;
+
+//////////////////////////////////////
+// Ipv6FlowProbeTag class implementation //
+//////////////////////////////////////
+
+/**
+ * \ingroup flow-monitor
+ *
+ * \brief Tag used to allow a fast identification of the packet
+ *
+ * This tag is added by FlowMonitor when a packet is seen for
+ * the first time, and it is then used to classify the packet in
+ * the following hops.
+ */
+class Ipv6FlowProbeTag : public Tag
+{
+public:
+ /**
+ * \brief Get the type ID.
+ * \return the object TypeId
+ */
+ static TypeId GetTypeId (void);
+ virtual TypeId GetInstanceTypeId (void) const;
+ virtual uint32_t GetSerializedSize (void) const;
+ virtual void Serialize (TagBuffer buf) const;
+ virtual void Deserialize (TagBuffer buf);
+ virtual void Print (std::ostream &os) const;
+ Ipv6FlowProbeTag ();
+ /**
+ * \brief Consructor
+ * \param flowId the flow identifier
+ * \param packetId the packet identifier
+ * \param packetSize the packet size
+ */
+ Ipv6FlowProbeTag (uint32_t flowId, uint32_t packetId, uint32_t packetSize);
+ /**
+ * \brief Set the flow identifier
+ * \param flowId the flow identifier
+ */
+ void SetFlowId (uint32_t flowId);
+ /**
+ * \brief Set the packet identifier
+ * \param packetId the packet identifier
+ */
+ void SetPacketId (uint32_t packetId);
+ /**
+ * \brief Set the packet size
+ * \param packetSize the packet size
+ */
+ void SetPacketSize (uint32_t packetSize);
+ /**
+ * \brief Set the flow identifier
+ * \returns the flow identifier
+ */
+ uint32_t GetFlowId (void) const;
+ /**
+ * \brief Set the packet identifier
+ * \returns the packet identifier
+ */
+ uint32_t GetPacketId (void) const;
+ /**
+ * \brief Get the packet size
+ * \returns the packet size
+ */
+ uint32_t GetPacketSize (void) const;
+private:
+ uint32_t m_flowId; //!< flow identifier
+ uint32_t m_packetId; //!< packet identifier
+ uint32_t m_packetSize; //!< packet size
+
+};
+
+TypeId
+Ipv6FlowProbeTag::GetTypeId (void)
+{
+ static TypeId tid = TypeId ("ns3::Ipv6FlowProbeTag")
+ .SetParent<Tag> ()
+ .AddConstructor<Ipv6FlowProbeTag> ()
+ ;
+ return tid;
+}
+TypeId
+Ipv6FlowProbeTag::GetInstanceTypeId (void) const
+{
+ return GetTypeId ();
+}
+uint32_t
+Ipv6FlowProbeTag::GetSerializedSize (void) const
+{
+ return 4 + 4 + 4;
+}
+void
+Ipv6FlowProbeTag::Serialize (TagBuffer buf) const
+{
+ buf.WriteU32 (m_flowId);
+ buf.WriteU32 (m_packetId);
+ buf.WriteU32 (m_packetSize);
+}
+void
+Ipv6FlowProbeTag::Deserialize (TagBuffer buf)
+{
+ m_flowId = buf.ReadU32 ();
+ m_packetId = buf.ReadU32 ();
+ m_packetSize = buf.ReadU32 ();
+}
+void
+Ipv6FlowProbeTag::Print (std::ostream &os) const
+{
+ os << "FlowId=" << m_flowId;
+ os << "PacketId=" << m_packetId;
+ os << "PacketSize=" << m_packetSize;
+}
+Ipv6FlowProbeTag::Ipv6FlowProbeTag ()
+ : Tag ()
+{
+}
+
+Ipv6FlowProbeTag::Ipv6FlowProbeTag (uint32_t flowId, uint32_t packetId, uint32_t packetSize)
+ : Tag (), m_flowId (flowId), m_packetId (packetId), m_packetSize (packetSize)
+{
+}
+
+void
+Ipv6FlowProbeTag::SetFlowId (uint32_t id)
+{
+ m_flowId = id;
+}
+void
+Ipv6FlowProbeTag::SetPacketId (uint32_t id)
+{
+ m_packetId = id;
+}
+void
+Ipv6FlowProbeTag::SetPacketSize (uint32_t size)
+{
+ m_packetSize = size;
+}
+uint32_t
+Ipv6FlowProbeTag::GetFlowId (void) const
+{
+ return m_flowId;
+}
+uint32_t
+Ipv6FlowProbeTag::GetPacketId (void) const
+{
+ return m_packetId;
+}
+uint32_t
+Ipv6FlowProbeTag::GetPacketSize (void) const
+{
+ return m_packetSize;
+}
+
+////////////////////////////////////////
+// Ipv6FlowProbe class implementation //
+////////////////////////////////////////
+
+Ipv6FlowProbe::Ipv6FlowProbe (Ptr<FlowMonitor> monitor,
+ Ptr<Ipv6FlowClassifier> classifier,
+ Ptr<Node> node)
+ : FlowProbe (monitor),
+ m_classifier (classifier)
+{
+ NS_LOG_FUNCTION (this << node->GetId ());
+
+ Ptr<Ipv6L3Protocol> ipv6 = node->GetObject<Ipv6L3Protocol> ();
+
+ if (!ipv6->TraceConnectWithoutContext ("SendOutgoing",
+ MakeCallback (&Ipv6FlowProbe::SendOutgoingLogger, Ptr<Ipv6FlowProbe> (this))))
+ {
+ NS_FATAL_ERROR ("trace fail");
+ }
+ if (!ipv6->TraceConnectWithoutContext ("UnicastForward",
+ MakeCallback (&Ipv6FlowProbe::ForwardLogger, Ptr<Ipv6FlowProbe> (this))))
+ {
+ NS_FATAL_ERROR ("trace fail");
+ }
+ if (!ipv6->TraceConnectWithoutContext ("LocalDeliver",
+ MakeCallback (&Ipv6FlowProbe::ForwardUpLogger, Ptr<Ipv6FlowProbe> (this))))
+ {
+ NS_FATAL_ERROR ("trace fail");
+ }
+
+ if (!ipv6->TraceConnectWithoutContext ("Drop",
+ MakeCallback (&Ipv6FlowProbe::DropLogger, Ptr<Ipv6FlowProbe> (this))))
+ {
+ NS_FATAL_ERROR ("trace fail");
+ }
+
+ // code copied from point-to-point-helper.cc
+ std::ostringstream oss;
+ oss << "/NodeList/" << node->GetId () << "/DeviceList/*/TxQueue/Drop";
+ Config::ConnectWithoutContext (oss.str (), MakeCallback (&Ipv6FlowProbe::QueueDropLogger, Ptr<Ipv6FlowProbe> (this)));
+}
+
+Ipv6FlowProbe::~Ipv6FlowProbe ()
+{
+}
+
+void
+Ipv6FlowProbe::DoDispose ()
+{
+ FlowProbe::DoDispose ();
+}
+
+void
+Ipv6FlowProbe::SendOutgoingLogger (const Ipv6Header &ipHeader, Ptr<const Packet> ipPayload, uint32_t interface)
+{
+ FlowId flowId;
+ FlowPacketId packetId;
+
+ if (m_classifier->Classify (ipHeader, ipPayload, &flowId, &packetId))
+ {
+ uint32_t size = (ipPayload->GetSize () + ipHeader.GetSerializedSize ());
+ NS_LOG_DEBUG ("ReportFirstTx ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<"); "
+ << ipHeader << *ipPayload);
+ m_flowMonitor->ReportFirstTx (this, flowId, packetId, size);
+
+ // tag the packet with the flow id and packet id, so that the packet can be identified even
+ // when Ipv6Header is not accessible at some non-IPv6 protocol layer
+ Ipv6FlowProbeTag fTag (flowId, packetId, size);
+ ipPayload->AddPacketTag (fTag);
+ }
+}
+
+void
+Ipv6FlowProbe::ForwardLogger (const Ipv6Header &ipHeader, Ptr<const Packet> ipPayload, uint32_t interface)
+{
+ // peek the tags that are added by Ipv6FlowProbe::SendOutgoingLogger ()
+ Ipv6FlowProbeTag fTag;
+
+ bool found = ipPayload->PeekPacketTag (fTag);
+
+ if (found)
+ {
+ FlowId flowId = fTag.GetFlowId ();
+ FlowPacketId packetId = fTag.GetPacketId ();
+
+ uint32_t size = (ipPayload->GetSize () + ipHeader.GetSerializedSize ());
+ NS_LOG_DEBUG ("ReportForwarding ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<");");
+ m_flowMonitor->ReportForwarding (this, flowId, packetId, size);
+ }
+}
+
+void
+Ipv6FlowProbe::ForwardUpLogger (const Ipv6Header &ipHeader, Ptr<const Packet> ipPayload, uint32_t interface)
+{
+ // remove the tags that are added by Ipv6FlowProbe::SendOutgoingLogger ()
+ Ipv6FlowProbeTag fTag;
+
+ // ConstCast: see http://www.nsnam.org/bugzilla/show_bug.cgi?id=904
+ bool found = ConstCast<Packet> (ipPayload)->RemovePacketTag (fTag);
+
+ if (found)
+ {
+ FlowId flowId = fTag.GetFlowId ();
+ FlowPacketId packetId = fTag.GetPacketId ();
+
+ uint32_t size = (ipPayload->GetSize () + ipHeader.GetSerializedSize ());
+ NS_LOG_DEBUG ("ReportLastRx ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<");");
+ m_flowMonitor->ReportLastRx (this, flowId, packetId, size);
+ }
+}
+
+void
+Ipv6FlowProbe::DropLogger (const Ipv6Header &ipHeader, Ptr<const Packet> ipPayload,
+ Ipv6L3Protocol::DropReason reason, Ptr<Ipv6> ipv6, uint32_t ifIndex)
+{
+#if 0
+ switch (reason)
+ {
+ case Ipv6L3Protocol::DROP_NO_ROUTE:
+ break;
+
+ case Ipv6L3Protocol::DROP_TTL_EXPIRED:
+ case Ipv6L3Protocol::DROP_BAD_CHECKSUM:
+ Ipv6Address addri = m_ipv6->GetAddress (ifIndex);
+ Ipv6Mask maski = m_ipv6->GetNetworkMask (ifIndex);
+ Ipv6Address bcast = addri.GetSubnetDirectedBroadcast (maski);
+ if (ipHeader.GetDestination () == bcast) // we don't want broadcast packets
+ {
+ return;
+ }
+ }
+#endif
+
+ // remove the tags that are added by Ipv6FlowProbe::SendOutgoingLogger ()
+ Ipv6FlowProbeTag fTag;
+
+ // ConstCast: see http://www.nsnam.org/bugzilla/show_bug.cgi?id=904
+ bool found = ConstCast<Packet> (ipPayload)->RemovePacketTag (fTag);
+
+ if (found)
+ {
+ FlowId flowId = fTag.GetFlowId ();
+ FlowPacketId packetId = fTag.GetPacketId ();
+
+ uint32_t size = (ipPayload->GetSize () + ipHeader.GetSerializedSize ());
+ NS_LOG_DEBUG ("Drop ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<", " << reason
+ << ", destIp=" << ipHeader.GetDestinationAddress () << "); "
+ << "HDR: " << ipHeader << " PKT: " << *ipPayload);
+
+ DropReason myReason;
+
+
+ switch (reason)
+ {
+ case Ipv6L3Protocol::DROP_TTL_EXPIRED:
+ myReason = DROP_TTL_EXPIRE;
+ NS_LOG_DEBUG ("DROP_TTL_EXPIRE");
+ break;
+ case Ipv6L3Protocol::DROP_NO_ROUTE:
+ myReason = DROP_NO_ROUTE;
+ NS_LOG_DEBUG ("DROP_NO_ROUTE");
+ break;
+ case Ipv6L3Protocol::DROP_INTERFACE_DOWN:
+ myReason = DROP_INTERFACE_DOWN;
+ NS_LOG_DEBUG ("DROP_INTERFACE_DOWN");
+ break;
+ case Ipv6L3Protocol::DROP_ROUTE_ERROR:
+ myReason = DROP_ROUTE_ERROR;
+ NS_LOG_DEBUG ("DROP_ROUTE_ERROR");
+ break;
+ case Ipv6L3Protocol::DROP_UNKNOWN_PROTOCOL:
+ myReason = DROP_UNKNOWN_PROTOCOL;
+ NS_LOG_DEBUG ("DROP_UNKNOWN_PROTOCOL");
+ break;
+ case Ipv6L3Protocol::DROP_UNKNOWN_OPTION:
+ myReason = DROP_UNKNOWN_OPTION;
+ NS_LOG_DEBUG ("DROP_UNKNOWN_OPTION");
+ break;
+ case Ipv6L3Protocol::DROP_MALFORMED_HEADER:
+ myReason = DROP_MALFORMED_HEADER;
+ NS_LOG_DEBUG ("DROP_MALFORMED_HEADER");
+ break;
+ case Ipv6L3Protocol::DROP_FRAGMENT_TIMEOUT:
+ myReason = DROP_FRAGMENT_TIMEOUT;
+ NS_LOG_DEBUG ("DROP_FRAGMENT_TIMEOUT");
+ break;
+ default:
+ myReason = DROP_INVALID_REASON;
+ NS_FATAL_ERROR ("Unexpected drop reason code " << reason);
+ }
+
+ m_flowMonitor->ReportDrop (this, flowId, packetId, size, myReason);
+ }
+}
+
+void
+Ipv6FlowProbe::QueueDropLogger (Ptr<const Packet> ipPayload)
+{
+ // remove the tags that are added by Ipv6FlowProbe::SendOutgoingLogger ()
+ Ipv6FlowProbeTag fTag;
+
+ // ConstCast: see http://www.nsnam.org/bugzilla/show_bug.cgi?id=904
+ bool tagFound = ConstCast<Packet> (ipPayload)->RemovePacketTag (fTag);
+ if (!tagFound)
+ {
+ return;
+ }
+
+ FlowId flowId = fTag.GetFlowId ();
+ FlowPacketId packetId = fTag.GetPacketId ();
+ uint32_t size = fTag.GetPacketSize ();
+
+ NS_LOG_DEBUG ("Drop ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<", " << DROP_QUEUE
+ << "); ");
+
+ m_flowMonitor->ReportDrop (this, flowId, packetId, size, DROP_QUEUE);
+}
+
+} // namespace ns3
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/flow-monitor/model/ipv6-flow-probe.h Mon Apr 21 11:32:45 2014 +0200
@@ -0,0 +1,120 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+//
+// Copyright (c) 2009 INESC Porto
+//
+// 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: Gustavo J. A. M. Carneiro <gjc@inescporto.pt> <gjcarneiro@gmail.com>
+// Modifications: Tommaso Pecorella <tommaso.pecorella@unifi.it>
+//
+
+#ifndef IPV6_FLOW_PROBE_H
+#define IPV6_FLOW_PROBE_H
+
+#include "ns3/flow-probe.h"
+#include "ns3/ipv6-flow-classifier.h"
+#include "ns3/ipv6-l3-protocol.h"
+
+namespace ns3 {
+
+class FlowMonitor;
+class Node;
+
+/// \ingroup flow-monitor
+/// \brief Class that monitors flows at the IPv6 layer of a Node
+///
+/// For each node in the simulation, one instance of the class
+/// Ipv4FlowProbe is created to monitor that node. Ipv4FlowProbe
+/// accomplishes this by connecting callbacks to trace sources in the
+/// Ipv6L3Protocol interface of the node.
+class Ipv6FlowProbe : public FlowProbe
+{
+
+public:
+ /// \brief Constructor
+ /// \param monitor the FlowMonitor this probe is associated with
+ /// \param classifier the Ipv4FlowClassifier this probe is associated with
+ /// \param node the Node this probe is associated with
+ Ipv6FlowProbe (Ptr<FlowMonitor> monitor, Ptr<Ipv6FlowClassifier> classifier, Ptr<Node> node);
+ virtual ~Ipv6FlowProbe ();
+
+ /// \brief enumeration of possible reasons why a packet may be dropped
+ enum DropReason
+ {
+ /// Packet dropped due to missing route to the destination
+ DROP_NO_ROUTE = 0,
+
+ /// Packet dropped due to TTL decremented to zero during IPv4 forwarding
+ DROP_TTL_EXPIRE,
+
+ /// Packet dropped due to invalid checksum in the IPv4 header
+ DROP_BAD_CHECKSUM,
+
+ /// Packet dropped due to queue overflow. Note: only works for
+ /// NetDevices that provide a TxQueue attribute of type Queue
+ /// with a Drop trace source. It currently works with Csma and
+ /// PointToPoint devices, but not with WiFi or WiMax.
+ DROP_QUEUE,
+
+ DROP_INTERFACE_DOWN, /**< Interface is down so can not send packet */
+ DROP_ROUTE_ERROR, /**< Route error */
+
+ DROP_UNKNOWN_PROTOCOL, /**< Unknown L4 protocol */
+ DROP_UNKNOWN_OPTION, /**< Unknown option */
+ DROP_MALFORMED_HEADER, /**< Malformed header */
+
+ DROP_FRAGMENT_TIMEOUT, /**< Fragment timeout exceeded */
+
+ DROP_INVALID_REASON, /**< Fallback reason (no known reason) */
+ };
+
+protected:
+
+ virtual void DoDispose (void);
+
+private:
+ /// Log a packet being sent
+ /// \param ipHeader IP header
+ /// \param ipPayload IP payload
+ /// \param interface outgoing interface
+ void SendOutgoingLogger (const Ipv6Header &ipHeader, Ptr<const Packet> ipPayload, uint32_t interface);
+ /// Log a packet being forwarded
+ /// \param ipHeader IP header
+ /// \param ipPayload IP payload
+ /// \param interface incoming interface
+ void ForwardLogger (const Ipv6Header &ipHeader, Ptr<const Packet> ipPayload, uint32_t interface);
+ /// Log a packet being received by the destination
+ /// \param ipHeader IP header
+ /// \param ipPayload IP payload
+ /// \param interface incoming interface
+ void ForwardUpLogger (const Ipv6Header &ipHeader, Ptr<const Packet> ipPayload, uint32_t interface);
+ /// Log a packet being dropped
+ /// \param ipHeader IP header
+ /// \param ipPayload IP payload
+ /// \param reason drop reason
+ /// \param ipv6 pointer to the IP object dropping the packet
+ /// \param ifIndex interface index
+ void DropLogger (const Ipv6Header &ipHeader, Ptr<const Packet> ipPayload,
+ Ipv6L3Protocol::DropReason reason, Ptr<Ipv6> ipv6, uint32_t ifIndex);
+ /// Log a packet being dropped by a queue
+ /// \param ipPayload IP payload
+ void QueueDropLogger (Ptr<const Packet> ipPayload);
+
+ Ptr<Ipv6FlowClassifier> m_classifier; //!< the Ipv6FlowClassifier this probe is associated with
+};
+
+
+} // namespace ns3
+
+#endif /* IPV6_FLOW_PROBE_H */
--- a/src/flow-monitor/wscript Tue Apr 08 14:07:33 2014 -0700
+++ b/src/flow-monitor/wscript Mon Apr 21 11:32:45 2014 +0200
@@ -8,6 +8,8 @@
'flow-probe.cc',
'ipv4-flow-classifier.cc',
'ipv4-flow-probe.cc',
+ 'ipv6-flow-classifier.cc',
+ 'ipv6-flow-probe.cc',
'histogram.cc',
]]
obj.source.append("helper/flow-monitor-helper.cc")
@@ -25,6 +27,8 @@
'flow-classifier.h',
'ipv4-flow-classifier.h',
'ipv4-flow-probe.h',
+ 'ipv6-flow-classifier.h',
+ 'ipv6-flow-probe.h',
'histogram.h',
]]
headers.source.append("helper/flow-monitor-helper.h")
--- a/src/internet/model/ipv6-l3-protocol.cc Tue Apr 08 14:07:33 2014 -0700
+++ b/src/internet/model/ipv6-l3-protocol.cc Mon Apr 21 11:32:45 2014 +0200
@@ -83,6 +83,13 @@
MakeTraceSourceAccessor (&Ipv6L3Protocol::m_rxTrace))
.AddTraceSource ("Drop", "Drop IPv6 packet",
MakeTraceSourceAccessor (&Ipv6L3Protocol::m_dropTrace))
+
+ .AddTraceSource ("SendOutgoing", "A newly-generated packet by this node is about to be queued for transmission",
+ MakeTraceSourceAccessor (&Ipv6L3Protocol::m_sendOutgoingTrace))
+ .AddTraceSource ("UnicastForward", "A unicast IPv6 packet was received by this node and is being forwarded to another node",
+ MakeTraceSourceAccessor (&Ipv6L3Protocol::m_unicastForwardTrace))
+ .AddTraceSource ("LocalDeliver", "An IPv6 packet was received by/for this node, and it is being forward up the stack",
+ MakeTraceSourceAccessor (&Ipv6L3Protocol::m_localDeliverTrace))
;
return tid;
}
@@ -784,6 +791,8 @@
{
NS_LOG_LOGIC ("Ipv6L3Protocol::Send case 1: passed in with a route");
hdr = BuildHeader (source, destination, protocol, packet->GetSize (), ttl, tclass);
+ int32_t interface = GetInterfaceForDevice (route->GetOutputDevice ());
+ m_sendOutgoingTrace (hdr, packet, interface);
SendRealOut (route, packet, hdr);
return;
}
@@ -794,6 +803,8 @@
NS_LOG_LOGIC ("Ipv6L3Protocol::Send case 1: probably sent to machine on same IPv6 network");
/* NS_FATAL_ERROR ("This case is not yet implemented"); */
hdr = BuildHeader (source, destination, protocol, packet->GetSize (), ttl, tclass);
+ int32_t interface = GetInterfaceForDevice (route->GetOutputDevice ());
+ m_sendOutgoingTrace (hdr, packet, interface);
SendRealOut (route, packet, hdr);
return;
}
@@ -823,6 +834,8 @@
if (newRoute)
{
+ int32_t interface = GetInterfaceForDevice (newRoute->GetOutputDevice ());
+ m_sendOutgoingTrace (hdr, packet, interface);
SendRealOut (newRoute, packet, hdr);
}
else
@@ -1120,7 +1133,8 @@
icmpv6->SendRedirection (copy, linkLocal, src, target, dst, Address ());
}
}
-
+ int32_t interface = GetInterfaceForDevice (rtentry->GetOutputDevice ());
+ m_unicastForwardTrace (ipHeader, packet, interface);
SendRealOut (rtentry, packet, ipHeader);
}
@@ -1238,6 +1252,9 @@
/* L4 protocol */
Ptr<Packet> copy = p->Copy ();
+
+ m_localDeliverTrace (ip, p, iif);
+
enum IpL4Protocol::RxStatus status = protocol->Receive (p, ip, GetInterface (iif));
switch (status)
--- a/src/internet/model/ipv6-l3-protocol.h Tue Apr 08 14:07:33 2014 -0700
+++ b/src/internet/model/ipv6-l3-protocol.h Mon Apr 21 11:32:45 2014 +0200
@@ -444,6 +444,13 @@
*/
TracedCallback<const Ipv6Header &, Ptr<const Packet>, DropReason, Ptr<Ipv6>, uint32_t> m_dropTrace;
+ /// Trace of sent packets
+ TracedCallback<const Ipv6Header &, Ptr<const Packet>, uint32_t> m_sendOutgoingTrace;
+ /// Trace of unicast forwarded packets
+ TracedCallback<const Ipv6Header &, Ptr<const Packet>, uint32_t> m_unicastForwardTrace;
+ /// Trace of locally delivered packets
+ TracedCallback<const Ipv6Header &, Ptr<const Packet>, uint32_t> m_localDeliverTrace;
+
/**
* \brief Copy constructor.
*