From ae5bc1b5271f6c09268ab211cfa379ed35bcb9e4 Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Mon, 21 Apr 2014 11:32:45 +0200 Subject: [PATCH] Bug 1818: FlowMonitor needs IPv6 support --- RELEASE_NOTES | 3 + .../bindings/modulegen__gcc_ILP32.py | 709 +++++++++++++++++- .../bindings/modulegen__gcc_LP64.py | 709 +++++++++++++++++- .../helper/flow-monitor-helper.cc | 41 +- src/flow-monitor/helper/flow-monitor-helper.h | 18 +- src/flow-monitor/model/flow-monitor.cc | 18 +- src/flow-monitor/model/flow-monitor.h | 6 +- .../model/ipv6-flow-classifier.cc | 218 ++++++ src/flow-monitor/model/ipv6-flow-classifier.h | 104 +++ src/flow-monitor/model/ipv6-flow-probe.cc | 409 ++++++++++ src/flow-monitor/model/ipv6-flow-probe.h | 120 +++ src/flow-monitor/wscript | 4 + src/internet/model/ipv6-l3-protocol.cc | 19 +- src/internet/model/ipv6-l3-protocol.h | 7 + 14 files changed, 2356 insertions(+), 29 deletions(-) create mode 100644 src/flow-monitor/model/ipv6-flow-classifier.cc create mode 100644 src/flow-monitor/model/ipv6-flow-classifier.h create mode 100644 src/flow-monitor/model/ipv6-flow-probe.cc create mode 100644 src/flow-monitor/model/ipv6-flow-probe.h diff --git a/RELEASE_NOTES b/RELEASE_NOTES index 6207b728f..88b9ab530 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -38,6 +38,8 @@ New user-visible features 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 @@ Bugs fixed - 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. diff --git a/src/flow-monitor/bindings/modulegen__gcc_ILP32.py b/src/flow-monitor/bindings/modulegen__gcc_ILP32.py index c77a63964..f602fb2aa 100644 --- a/src/flow-monitor/bindings/modulegen__gcc_ILP32.py +++ b/src/flow-monitor/bindings/modulegen__gcc_ILP32.py @@ -74,6 +74,12 @@ def register_types(module): 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 @@ def register_types(module): 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 @@ def register_types(module): 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 @@ def register_types(module): module.add_class('Ipv4Route', import_from_module='ns.internet', parent=root_module['ns3::SimpleRefCount< ns3::Ipv4Route, ns3::empty, ns3::DefaultDeleter >']) ## 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 @@ def register_methods(root_module): 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 @@ def register_methods(root_module): 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 @@ def register_methods(root_module): 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 >']) @@ -435,8 +466,14 @@ def register_methods(root_module): 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 @@ def register_Ns3FlowMonitorHelper_methods(root_module, cls): cls.add_method('GetClassifier', 'ns3::Ptr< ns3::FlowClassifier >', []) + ## flow-monitor-helper.h (module 'flow-monitor'): ns3::Ptr 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 @@ def register_Ns3Ipv6Address_methods(root_module, cls): [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 @@ def register_Ns3TagBuffer_methods(root_module, cls): [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 @@ def register_Ns3Ipv4Header_methods(root_module, cls): [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 @@ def register_Ns3Time_methods(root_module, cls): 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 @@ def register_Ns3FlowMonitor_methods(root_module, cls): 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 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 probe) [member function] cls.add_method('AddProbe', 'void', @@ -4069,10 +4287,6 @@ def register_Ns3FlowMonitor_methods(root_module, cls): 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 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 @@ def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls): 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 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 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::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::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::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 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 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): [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 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 monitor, ns3::Ptr classifier, ns3::Ptr 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 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 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 protocol) [member function] + cls.add_method('Remove', + 'void', + [param('ns3::Ptr< ns3::IpL4Protocol >', 'protocol')]) + ## ipv6-l3-protocol.h (module 'internet'): ns3::Ptr 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::Ipv6L3Protocol::CreateRawSocket() [member function] + cls.add_method('CreateRawSocket', + 'ns3::Ptr< ns3::Socket >', + []) + ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::DeleteRawSocket(ns3::Ptr 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 device, ns3::Ptr 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 packet, ns3::Ipv6Address source, ns3::Ipv6Address destination, uint8_t protocol, ns3::Ptr 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 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::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 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::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 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::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::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 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([]) diff --git a/src/flow-monitor/bindings/modulegen__gcc_LP64.py b/src/flow-monitor/bindings/modulegen__gcc_LP64.py index 80efc90f3..a572b59fb 100644 --- a/src/flow-monitor/bindings/modulegen__gcc_LP64.py +++ b/src/flow-monitor/bindings/modulegen__gcc_LP64.py @@ -74,6 +74,12 @@ def register_types(module): 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 @@ def register_types(module): 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 @@ def register_types(module): 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 @@ def register_types(module): module.add_class('Ipv4Route', import_from_module='ns.internet', parent=root_module['ns3::SimpleRefCount< ns3::Ipv4Route, ns3::empty, ns3::DefaultDeleter >']) ## 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 @@ def register_methods(root_module): 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 @@ def register_methods(root_module): 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 @@ def register_methods(root_module): 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 >']) @@ -435,8 +466,14 @@ def register_methods(root_module): 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 @@ def register_Ns3FlowMonitorHelper_methods(root_module, cls): cls.add_method('GetClassifier', 'ns3::Ptr< ns3::FlowClassifier >', []) + ## flow-monitor-helper.h (module 'flow-monitor'): ns3::Ptr 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 @@ def register_Ns3Ipv6Address_methods(root_module, cls): [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 @@ def register_Ns3TagBuffer_methods(root_module, cls): [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 @@ def register_Ns3Ipv4Header_methods(root_module, cls): [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 @@ def register_Ns3Time_methods(root_module, cls): 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 @@ def register_Ns3FlowMonitor_methods(root_module, cls): 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 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 probe) [member function] cls.add_method('AddProbe', 'void', @@ -4069,10 +4287,6 @@ def register_Ns3FlowMonitor_methods(root_module, cls): 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 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 @@ def register_Ns3Ipv4RoutingProtocol_methods(root_module, cls): 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 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 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::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::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::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 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 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): [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 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 monitor, ns3::Ptr classifier, ns3::Ptr 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 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 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 protocol) [member function] + cls.add_method('Remove', + 'void', + [param('ns3::Ptr< ns3::IpL4Protocol >', 'protocol')]) + ## ipv6-l3-protocol.h (module 'internet'): ns3::Ptr 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::Ipv6L3Protocol::CreateRawSocket() [member function] + cls.add_method('CreateRawSocket', + 'ns3::Ptr< ns3::Socket >', + []) + ## ipv6-l3-protocol.h (module 'internet'): void ns3::Ipv6L3Protocol::DeleteRawSocket(ns3::Ptr 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 device, ns3::Ptr 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 packet, ns3::Ipv6Address source, ns3::Ipv6Address destination, uint8_t protocol, ns3::Ptr 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 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::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 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::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 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::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::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 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([]) diff --git a/src/flow-monitor/helper/flow-monitor-helper.cc b/src/flow-monitor/helper/flow-monitor-helper.cc index dd55e96e5..0f2334fa3 100644 --- a/src/flow-monitor/helper/flow-monitor-helper.cc +++ b/src/flow-monitor/helper/flow-monitor-helper.cc @@ -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 @@ FlowMonitorHelper::~FlowMonitorHelper () { m_flowMonitor->Dispose (); m_flowMonitor = 0; - m_flowClassifier = 0; + m_flowClassifier4 = 0; + m_flowClassifier6 = 0; } } @@ -58,8 +62,10 @@ FlowMonitorHelper::GetMonitor () if (!m_flowMonitor) { m_flowMonitor = m_monitorFactory.Create (); - m_flowClassifier = Create (); - m_flowMonitor->SetFlowClassifier (m_flowClassifier); + m_flowClassifier4 = Create (); + m_flowMonitor->AddFlowClassifier (m_flowClassifier4); + m_flowClassifier6 = Create (); + m_flowMonitor->AddFlowClassifier (m_flowClassifier6); } return m_flowMonitor; } @@ -68,11 +74,22 @@ FlowMonitorHelper::GetMonitor () Ptr FlowMonitorHelper::GetClassifier () { - if (!m_flowClassifier) + if (!m_flowClassifier4) { - m_flowClassifier = Create (); + m_flowClassifier4 = Create (); } - return m_flowClassifier; + return m_flowClassifier4; +} + + +Ptr +FlowMonitorHelper::GetClassifier6 () +{ + if (!m_flowClassifier6) + { + m_flowClassifier6 = Create (); + } + return m_flowClassifier6; } @@ -88,6 +105,14 @@ FlowMonitorHelper::Install (Ptr node) DynamicCast (classifier), node); } + Ptr classifier6 = GetClassifier6 (); + Ptr ipv6 = node->GetObject (); + if (ipv6) + { + Ptr probe6 = Create (monitor, + DynamicCast (classifier6), + node); + } return m_flowMonitor; } @@ -98,7 +123,7 @@ FlowMonitorHelper::Install (NodeContainer nodes) for (NodeContainer::Iterator i = nodes.Begin (); i != nodes.End (); ++i) { Ptr node = *i; - if (node->GetObject ()) + if (node->GetObject () || node->GetObject ()) { Install (node); } @@ -112,7 +137,7 @@ FlowMonitorHelper::InstallAll () for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) { Ptr node = *i; - if (node->GetObject ()) + if (node->GetObject () || node->GetObject ()) { Install (node); } diff --git a/src/flow-monitor/helper/flow-monitor-helper.h b/src/flow-monitor/helper/flow-monitor-helper.h index 46b91b7b2..14db8f0c1 100644 --- a/src/flow-monitor/helper/flow-monitor-helper.h +++ b/src/flow-monitor/helper/flow-monitor-helper.h @@ -30,10 +30,11 @@ namespace ns3 { 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,11 +75,17 @@ public: Ptr 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 GetClassifier (); + /** + * \brief Retrieve the FlowClassifier object for IPv6 created by the Install* methods + * \returns a pointer to the FlowClassifier object + */ + Ptr GetClassifier6 (); + /** * Serializes the results to an std::ostream in XML format * \param os the output stream @@ -120,9 +127,10 @@ private: */ FlowMonitorHelper& operator= (const FlowMonitorHelper&); - ObjectFactory m_monitorFactory; //!< Object factory - Ptr m_flowMonitor; //!< the FlowMonitor object - Ptr m_flowClassifier; //!< the FlowClassifier object + ObjectFactory m_monitorFactory; //!< Object factory + Ptr m_flowMonitor; //!< the FlowMonitor object + Ptr m_flowClassifier4; //!< the FlowClassifier object for IPv4 + Ptr m_flowClassifier6; //!< the FlowClassifier object for IPv6 }; } // namespace ns3 diff --git a/src/flow-monitor/model/flow-monitor.cc b/src/flow-monitor/model/flow-monitor.cc index ab8e39625..42a30fc6a 100644 --- a/src/flow-monitor/model/flow-monitor.cc +++ b/src/flow-monitor/model/flow-monitor.cc @@ -90,7 +90,12 @@ FlowMonitor::FlowMonitor () void FlowMonitor::DoDispose (void) { - m_classifier = 0; + for (std::list >::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 @@ FlowMonitor::StopRightNow () } void -FlowMonitor::SetFlowClassifier (Ptr classifier) +FlowMonitor::AddFlowClassifier (Ptr classifier) { - m_classifier = classifier; + m_classifiers.push_back (classifier); } void @@ -456,7 +461,12 @@ FlowMonitor::SerializeToXmlStream (std::ostream &os, int indent, bool enableHist indent -= 2; INDENT (indent); os << "\n"; - m_classifier->SerializeToXmlStream (os, indent); + for (std::list >::iterator iter = m_classifiers.begin (); + iter != m_classifiers.end (); + iter ++) + { + (*iter)->SerializeToXmlStream (os, indent); + } if (enableProbes) { diff --git a/src/flow-monitor/model/flow-monitor.h b/src/flow-monitor/model/flow-monitor.h index eff979312..c742ba627 100644 --- a/src/flow-monitor/model/flow-monitor.h +++ b/src/flow-monitor/model/flow-monitor.h @@ -146,9 +146,9 @@ public: 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 classifier); + void AddFlowClassifier (Ptr 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 @@ private: std::vector< Ptr > m_flowProbes; //!< all the FlowProbes // note: this is needed only for serialization - Ptr m_classifier; //!< the FlowClassifier + std::list > m_classifiers; //!< the FlowClassifiers EventId m_startEvent; //!< Start event EventId m_stopEvent; //!< Stop event diff --git a/src/flow-monitor/model/ipv6-flow-classifier.cc b/src/flow-monitor/model/ipv6-flow-classifier.cc new file mode 100644 index 000000000..b5d82bf67 --- /dev/null +++ b/src/flow-monitor/model/ipv6-flow-classifier.cc @@ -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 +// Modifications: Tommaso Pecorella +// + +#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 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::iterator, bool> insert + = m_flowMap.insert (std::pair (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::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 << "\n"; + + indent += 2; + for (std::map::const_iterator + iter = m_flowMap.begin (); iter != m_flowMap.end (); iter++) + { + INDENT (indent); + os << "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 << "\n"; + +#undef INDENT +} + + +} // namespace ns3 + diff --git a/src/flow-monitor/model/ipv6-flow-classifier.h b/src/flow-monitor/model/ipv6-flow-classifier.h new file mode 100644 index 000000000..487e16444 --- /dev/null +++ b/src/flow-monitor/model/ipv6-flow-classifier.h @@ -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 +// Modifications: Tommaso Pecorella +// + +#ifndef IPV6_FLOW_CLASSIFIER_H +#define IPV6_FLOW_CLASSIFIER_H + +#include +#include + +#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 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 m_flowMap; + std::map 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 */ diff --git a/src/flow-monitor/model/ipv6-flow-probe.cc b/src/flow-monitor/model/ipv6-flow-probe.cc new file mode 100644 index 000000000..35125d2b8 --- /dev/null +++ b/src/flow-monitor/model/ipv6-flow-probe.cc @@ -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 +// Modifications: Tommaso Pecorella +// + +#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 () + .AddConstructor () + ; + 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 monitor, + Ptr classifier, + Ptr node) + : FlowProbe (monitor), + m_classifier (classifier) +{ + NS_LOG_FUNCTION (this << node->GetId ()); + + Ptr ipv6 = node->GetObject (); + + if (!ipv6->TraceConnectWithoutContext ("SendOutgoing", + MakeCallback (&Ipv6FlowProbe::SendOutgoingLogger, Ptr (this)))) + { + NS_FATAL_ERROR ("trace fail"); + } + if (!ipv6->TraceConnectWithoutContext ("UnicastForward", + MakeCallback (&Ipv6FlowProbe::ForwardLogger, Ptr (this)))) + { + NS_FATAL_ERROR ("trace fail"); + } + if (!ipv6->TraceConnectWithoutContext ("LocalDeliver", + MakeCallback (&Ipv6FlowProbe::ForwardUpLogger, Ptr (this)))) + { + NS_FATAL_ERROR ("trace fail"); + } + + if (!ipv6->TraceConnectWithoutContext ("Drop", + MakeCallback (&Ipv6FlowProbe::DropLogger, Ptr (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 (this))); +} + +Ipv6FlowProbe::~Ipv6FlowProbe () +{ +} + +void +Ipv6FlowProbe::DoDispose () +{ + FlowProbe::DoDispose (); +} + +void +Ipv6FlowProbe::SendOutgoingLogger (const Ipv6Header &ipHeader, Ptr 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 ("<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 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 ("<ReportForwarding (this, flowId, packetId, size); + } +} + +void +Ipv6FlowProbe::ForwardUpLogger (const Ipv6Header &ipHeader, Ptr 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 (ipPayload)->RemovePacketTag (fTag); + + if (found) + { + FlowId flowId = fTag.GetFlowId (); + FlowPacketId packetId = fTag.GetPacketId (); + + uint32_t size = (ipPayload->GetSize () + ipHeader.GetSerializedSize ()); + NS_LOG_DEBUG ("ReportLastRx ("<ReportLastRx (this, flowId, packetId, size); + } +} + +void +Ipv6FlowProbe::DropLogger (const Ipv6Header &ipHeader, Ptr ipPayload, + Ipv6L3Protocol::DropReason reason, Ptr 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 (ipPayload)->RemovePacketTag (fTag); + + if (found) + { + FlowId flowId = fTag.GetFlowId (); + FlowPacketId packetId = fTag.GetPacketId (); + + uint32_t size = (ipPayload->GetSize () + ipHeader.GetSerializedSize ()); + NS_LOG_DEBUG ("Drop ("<ReportDrop (this, flowId, packetId, size, myReason); + } +} + +void +Ipv6FlowProbe::QueueDropLogger (Ptr 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 (ipPayload)->RemovePacketTag (fTag); + if (!tagFound) + { + return; + } + + FlowId flowId = fTag.GetFlowId (); + FlowPacketId packetId = fTag.GetPacketId (); + uint32_t size = fTag.GetPacketSize (); + + NS_LOG_DEBUG ("Drop ("<ReportDrop (this, flowId, packetId, size, DROP_QUEUE); +} + +} // namespace ns3 + + diff --git a/src/flow-monitor/model/ipv6-flow-probe.h b/src/flow-monitor/model/ipv6-flow-probe.h new file mode 100644 index 000000000..9ee3577a7 --- /dev/null +++ b/src/flow-monitor/model/ipv6-flow-probe.h @@ -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 +// Modifications: Tommaso Pecorella +// + +#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 monitor, Ptr classifier, Ptr 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 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 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 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 ipPayload, + Ipv6L3Protocol::DropReason reason, Ptr ipv6, uint32_t ifIndex); + /// Log a packet being dropped by a queue + /// \param ipPayload IP payload + void QueueDropLogger (Ptr ipPayload); + + Ptr m_classifier; //!< the Ipv6FlowClassifier this probe is associated with +}; + + +} // namespace ns3 + +#endif /* IPV6_FLOW_PROBE_H */ diff --git a/src/flow-monitor/wscript b/src/flow-monitor/wscript index f92ccb1eb..6c191100b 100644 --- a/src/flow-monitor/wscript +++ b/src/flow-monitor/wscript @@ -8,6 +8,8 @@ def build(bld): '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 @@ def build(bld): '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") diff --git a/src/internet/model/ipv6-l3-protocol.cc b/src/internet/model/ipv6-l3-protocol.cc index a7d199eb7..9666823e7 100644 --- a/src/internet/model/ipv6-l3-protocol.cc +++ b/src/internet/model/ipv6-l3-protocol.cc @@ -83,6 +83,13 @@ TypeId Ipv6L3Protocol::GetTypeId () 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 @@ void Ipv6L3Protocol::Send (Ptr packet, Ipv6Address source, Ipv6Address d { 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 @@ void Ipv6L3Protocol::Send (Ptr packet, Ipv6Address source, Ipv6Address d 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 @@ void Ipv6L3Protocol::Send (Ptr packet, Ipv6Address source, Ipv6Address d if (newRoute) { + int32_t interface = GetInterfaceForDevice (newRoute->GetOutputDevice ()); + m_sendOutgoingTrace (hdr, packet, interface); SendRealOut (newRoute, packet, hdr); } else @@ -1120,7 +1133,8 @@ void Ipv6L3Protocol::IpForward (Ptr idev, Ptr rtentr 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 @@ void Ipv6L3Protocol::LocalDeliver (Ptr packet, Ipv6Header const& i /* L4 protocol */ Ptr copy = p->Copy (); + + m_localDeliverTrace (ip, p, iif); + enum IpL4Protocol::RxStatus status = protocol->Receive (p, ip, GetInterface (iif)); switch (status) diff --git a/src/internet/model/ipv6-l3-protocol.h b/src/internet/model/ipv6-l3-protocol.h index a0fe98e50..36907750a 100644 --- a/src/internet/model/ipv6-l3-protocol.h +++ b/src/internet/model/ipv6-l3-protocol.h @@ -444,6 +444,13 @@ private: */ TracedCallback, DropReason, Ptr, uint32_t> m_dropTrace; + /// Trace of sent packets + TracedCallback, uint32_t> m_sendOutgoingTrace; + /// Trace of unicast forwarded packets + TracedCallback, uint32_t> m_unicastForwardTrace; + /// Trace of locally delivered packets + TracedCallback, uint32_t> m_localDeliverTrace; + /** * \brief Copy constructor. *