/// <summary>
 /// Creates an instance from next header, checksum, status, home address and options.
 /// </summary>
 /// <param name="nextHeader">
 /// Identifies the type of header immediately following this extension header.
 /// </param>
 /// <param name="checksum">
 /// Contains the checksum of the Mobility Header.
 /// The checksum is calculated from the octet string consisting of a "pseudo-header"
 /// followed by the entire Mobility Header starting with the Payload Proto field.
 /// The checksum is the 16-bit one's complement of the one's complement sum of this string.
 /// </param>
 /// <param name="status">Indicating the reason for this message.</param>
 /// <param name="homeAddress">
 /// The home address that was contained in the Home Address destination option.
 /// The mobile node uses this information to determine which binding does not exist, in cases where the mobile node has several home addresses.
 /// </param>
 /// <param name="options">
 /// Zero or more TLV-encoded mobility options.
 /// </param>
 public IpV6ExtensionHeaderMobilityBindingError(IpV4Protocol? nextHeader, ushort checksum, IpV6BindingErrorStatus status, IpV6Address homeAddress,
                                                IpV6MobilityOptions options)
     : base(nextHeader, checksum, options, MessageDataOffset.Options)
 {
     Status = status;
     HomeAddress = homeAddress;
 }

 internal IpV6ExtensionHeaderOptions(IpV4Protocol? nextHeader, IpV6Options options)
     : base(nextHeader)
 {
     if (options.BytesLength % 8 != 6)
         options = options.Pad((14 - options.BytesLength % 8) % 8);
     Options = options;
 }

 /// <summary>
 /// Creates an instance from next header, checksum, sequence number, code and options.
 /// </summary>
 /// <param name="nextHeader">Identifies the type of header immediately following this extension header.</param>
 /// <param name="checksum">
 /// Contains the checksum of the Mobility Header.
 /// The checksum is calculated from the octet string consisting of a "pseudo-header"
 /// followed by the entire Mobility Header starting with the Payload Proto field.
 /// The checksum is the 16-bit one's complement of the one's complement sum of this string.
 /// </param>
 /// <param name="sequenceNumber">
 /// Copied from the corresponding field in the Handover Initiate message to which this message is a response,
 /// to enable the receiver to match this Handover Acknowledge message with an outstanding Handover Initiate message.
 /// </param>
 /// <param name="code">Describes whether the handover was accepted or not and more details.</param>
 /// <param name="options">Zero or more TLV-encoded mobility options.</param>
 public IpV6ExtensionHeaderMobilityHandoverAcknowledgeMessage(IpV4Protocol? nextHeader, ushort checksum, ushort sequenceNumber,
                                                              IpV6MobilityHandoverAcknowledgeCode code, IpV6MobilityOptions options)
     : base(nextHeader, checksum, options, MessageDataOffset.Options)
 {
     SequenceNumber = sequenceNumber;
     Code = code;
 }

 public ConnId(ushort lPort, IpV4Address rIp, ushort rPort, IpV4Protocol protocol)
 {
     this.lPort = lPort;
     this.rIp = rIp;
     this.rPort = rPort;
     this.protocol = protocol;
 }

 internal IpV6ExtensionHeaderMobilityLocalizedRouting(IpV4Protocol? nextHeader, ushort checksum, ushort sequenceNumber, ushort lifetime,
                                                    IpV6MobilityOptions options)
     : base(nextHeader, checksum, options, MessageDataOffset.Options)
 {
     SequenceNumber = sequenceNumber;
     Lifetime = lifetime;
 }

        internal static IpV6ExtensionHeaderRouting ParseData(IpV4Protocol nextHeader, DataSegment data)
        {
            if (data.Length < DataMinimumLength)
                return null;
            IpV6RoutingType routingType = (IpV6RoutingType)data[DataOffset.RoutingType];
            byte segmentsLeft = data[DataOffset.SegmentsLeft];
            DataSegment routingData = data.Subsegment(DataOffset.TypeSpecificData, data.Length - DataOffset.TypeSpecificData);
            switch (routingType)
            {
                case IpV6RoutingType.SourceRoute:
                    return IpV6ExtensionHeaderRoutingSourceRoute.ParseRoutingData(nextHeader, segmentsLeft, routingData);

                case IpV6RoutingType.Nimrod:
                    // Unused.
                    return null;

                case IpV6RoutingType.Type2RoutingHeader:
                    return IpV6ExtensionHeaderRoutingHomeAddress.ParseRoutingData(nextHeader, segmentsLeft, routingData);

                case IpV6RoutingType.RoutingProtocolLowPowerAndLossyNetworksSourceRouteHeader:
                    return IpV6ExtensionHeaderRoutingProtocolLowPowerAndLossyNetworks.ParseRoutingData(nextHeader, segmentsLeft, routingData);

                default:
                    return null;
            }
        }

        private static IpV6ExtensionHeader CreateStandardInstance(IpV4Protocol nextHeader, DataSegment extensionHeaderData, out int numBytesRead)
        {
            numBytesRead = 0;
            if (extensionHeaderData.Length < MinimumLength)
                return null;
            IpV4Protocol nextNextHeader = (IpV4Protocol)extensionHeaderData[Offset.NextHeader];
            int length = (extensionHeaderData[Offset.HeaderExtensionLength] + 1) * 8;
            if (extensionHeaderData.Length < length)
                return null;

            DataSegment data = extensionHeaderData.Subsegment(Offset.Data, length - Offset.Data);
            numBytesRead = data.Length;

            switch (nextHeader)
            {
                case IpV4Protocol.IpV6HopByHopOption: // 0
                    return IpV6ExtensionHeaderHopByHopOptions.ParseData(nextNextHeader, data);

                case IpV4Protocol.IpV6Route: // 43
                    return IpV6ExtensionHeaderRouting.ParseData(nextNextHeader, data);

                case IpV4Protocol.FragmentHeaderForIpV6: // 44
                    return IpV6ExtensionHeaderFragmentData.ParseData(nextNextHeader, data);
                
                case IpV4Protocol.IpV6Opts:                     // 60
                    return IpV6ExtensionHeaderDestinationOptions.ParseData(nextNextHeader, data);

                case IpV4Protocol.MobilityHeader:        // 135
                    return IpV6ExtensionHeaderMobility.ParseData(nextNextHeader, data);

                default:
                    throw new InvalidOperationException("Invalid nextHeader value" + nextHeader);
            }
        }

 public IpV6ExtensionHeaderAuthentication(IpV4Protocol nextHeader, uint securityParametersIndex, uint sequenceNumber, DataSegment authenticationData)
     : base(nextHeader)
 {
     SecurityParametersIndex = securityParametersIndex;
     SequenceNumber = sequenceNumber;
     AuthenticationData = authenticationData;
 }

 /// <summary>
 /// Creates an instance from next header, checksum, status, sequence number, proxy binding, IPv4 home address binding only, global and options.
 /// </summary>
 /// <param name="nextHeader">
 /// Identifies the type of header immediately following this extension header.
 /// </param>
 /// <param name="checksum">
 /// Contains the checksum of the Mobility Header.
 /// The checksum is calculated from the octet string consisting of a "pseudo-header"
 /// followed by the entire Mobility Header starting with the Payload Proto field.
 /// The checksum is the 16-bit one's complement of the one's complement sum of this string.
 /// </param>
 /// <param name="status">
 /// Indicating the result of processing the Binding Revocation Indication message by the responder.
 /// </param>
 /// <param name="sequenceNumber">
 /// Copied from the Sequence Number field in the Binding Revocation Indication.
 /// It is used by the initiator, e.g., HA, LMA, MAG, in matching this Binding Revocation Acknowledgement 
 /// with the outstanding Binding Revocation Indication.
 /// </param>
 /// <param name="proxyBinding">
 /// Set if set in the corresponding Binding Revocation Indication message.
 /// </param>
 /// <param name="ipV4HomeAddressBindingOnly">
 /// Set if the it is set in the corresponding Binding Revocation Indication message.
 /// </param>
 /// <param name="global">
 /// Set if it is set in the corresponding Binding Revocation Indication message.
 /// </param>
 /// <param name="options">
 /// Zero or more TLV-encoded mobility options.
 /// </param>
 public IpV6ExtensionHeaderMobilityBindingRevocationAcknowledgementMessage(IpV4Protocol? nextHeader, ushort checksum,
                                                                           Ipv6MobilityBindingRevocationStatus status, ushort sequenceNumber,
                                                                           bool proxyBinding, bool ipV4HomeAddressBindingOnly, bool global,
                                                                           IpV6MobilityOptions options)
     : base(nextHeader, checksum, sequenceNumber, proxyBinding, ipV4HomeAddressBindingOnly, global, options)
 {
     Status = status;
 }

 /// <summary>
 /// Creates an instance from next header, checksum, care of nonce index, care of init cookie, care of keygen token and options.
 /// </summary>
 /// <param name="nextHeader">Identifies the type of header immediately following this extension header.</param>
 /// <param name="checksum">
 /// Contains the checksum of the Mobility Header.
 /// The checksum is calculated from the octet string consisting of a "pseudo-header"
 /// followed by the entire Mobility Header starting with the Payload Proto field.
 /// The checksum is the 16-bit one's complement of the one's complement sum of this string.
 /// </param>
 /// <param name="careOfNonceIndex">Will be echoed back by the mobile node to the correspondent node in a subsequent Binding Update.</param>
 /// <param name="careOfInitCookie">Contains the care-of init cookie.</param>
 /// <param name="careOfKeygenToken">Contains the 64-bit care-of keygen token used in the return routability procedure.</param>
 /// <param name="options">Zero or more TLV-encoded mobility options.</param>
 public IpV6ExtensionHeaderMobilityCareOfTest(IpV4Protocol? nextHeader, ushort checksum, ushort careOfNonceIndex, ulong careOfInitCookie,
                                              ulong careOfKeygenToken, IpV6MobilityOptions options)
     : base(nextHeader, checksum, options, MessageDataOffset.Options)
 {
     CareOfNonceIndex = careOfNonceIndex;
     CareOfInitCookie = careOfInitCookie;
     CareOfKeygenToken = careOfKeygenToken;
 }

 /// <summary>
 /// Creates an instance from next header, checksum, is unsolicited heartbeat response, is response, sequence number and options.
 /// </summary>
 /// <param name="nextHeader">Identifies the type of header immediately following this extension header.</param>
 /// <param name="checksum">
 /// Contains the checksum of the Mobility Header.
 /// The checksum is calculated from the octet string consisting of a "pseudo-header"
 /// followed by the entire Mobility Header starting with the Payload Proto field.
 /// The checksum is the 16-bit one's complement of the one's complement sum of this string.
 /// </param>
 /// <param name="isUnsolicitedHeartbeatResponse">Set to true in Unsolicited Heartbeat Response.</param>
 /// <param name="isResponse">
 /// Indicates whether the message is a request or a response. 
 /// When it's set to false, it indicates that the Heartbeat message is a request.
 /// When it's set to true, it indicates that the Heartbeat message is a response.
 /// </param>
 /// <param name="sequenceNumber">Sequence number used for matching the request to the reply.</param>
 /// <param name="options">Zero or more TLV-encoded mobility options.</param>
 public IpV6ExtensionHeaderMobilityHeartbeatMessage(IpV4Protocol? nextHeader, ushort checksum, bool isUnsolicitedHeartbeatResponse, bool isResponse,
                                                    uint sequenceNumber, IpV6MobilityOptions options)
     : base(nextHeader, checksum, options, MessageDataOffset.MobilityOptions)
 {
     IsUnsolicitedHeartbeatResponse = isUnsolicitedHeartbeatResponse;
     IsResponse = isResponse;
     SequenceNumber = sequenceNumber;
 }

 /// <summary>
 /// Creates an instance from next header, checksum, sequence number, unsolicited, status, lifetime and options.
 /// </summary>
 /// <param name="nextHeader">Identifies the type of header immediately following this extension header.</param>
 /// <param name="checksum">
 /// Contains the checksum of the Mobility Header.
 /// The checksum is calculated from the octet string consisting of a "pseudo-header"
 /// followed by the entire Mobility Header starting with the Payload Proto field.
 /// The checksum is the 16-bit one's complement of the one's complement sum of this string.
 /// </param>
 /// <param name="sequenceNumber">Copied from the sequence number field of the LRI message being responded to.</param>
 /// <param name="unsolicited">
 /// When true, the LRA message is sent unsolicited.
 /// The Lifetime field indicates a new requested value.
 /// The MAG must wait for the regular LRI message to confirm that the request is acceptable to the LMA.
 /// </param>
 /// <param name="status">The acknowledgement status.</param>
 /// <param name="lifetime">
 /// The time in seconds for which the local forwarding is supported.
 /// Typically copied from the corresponding field in the LRI message.
 /// </param>
 /// <param name="options">Zero or more TLV-encoded mobility options.</param>
 public IpV6ExtensionHeaderMobilityLocalizedRoutingAcknowledgement(IpV4Protocol? nextHeader, ushort checksum, ushort sequenceNumber, bool unsolicited,
                                                                   IpV6MobilityLocalizedRoutingAcknowledgementStatus status, ushort lifetime,
                                                                   IpV6MobilityOptions options)
     : base(nextHeader, checksum, sequenceNumber, lifetime, options)
 {
     Status = status;
     Unsolicited = unsolicited;
 }

 /// <summary>
 /// Creates an instance from next header, checksum, revocation trigger, sequence number, proxy binding, IPv4 home address binding only, global 
 /// and options.
 /// </summary>
 /// <param name="nextHeader">
 /// Identifies the type of header immediately following this extension header.
 /// </param>
 /// <param name="checksum">
 /// Contains the checksum of the Mobility Header.
 /// The checksum is calculated from the octet string consisting of a "pseudo-header"
 /// followed by the entire Mobility Header starting with the Payload Proto field.
 /// The checksum is the 16-bit one's complement of the one's complement sum of this string.
 /// </param>
 /// <param name="revocationTrigger">
 /// Indicating the event that triggered the initiator to send the BRI message.
 /// </param>
 /// <param name="sequenceNumber">
 /// Used by the initiator to match a returned Binding Revocation Acknowledgement with this Binding Revocation Indication.
 /// This sequence number could be a random number.
 /// At any time, implementations must ensure there is no collision between the sequence numbers of all outstanding Binding Revocation Indication 
 /// Messages.
 /// </param>
 /// <param name="proxyBinding">
 /// Set by the initiator to indicate that the revoked binding(s) is a PMIPv6 binding.
 /// </param>
 /// <param name="ipV4HomeAddressBindingOnly">
 /// Set by the initiator, home agent, or local mobility anchor to indicate to the receiving mobility entity the termination
 /// of the IPv4 Home Address binding only as in Home Agent Operation and Local Mobility Anchor Operation.
 /// </param>
 /// <param name="global">
 /// Set by the initiator, LMA or MAG, to indicate the termination of all Per-Peer mobility Bindings or Multiple Bindings that share 
 /// a common identifier(s) and are served by the initiator and responder as in Local Mobility Anchor Operation and Mobile Access Gateway Operation.
 /// </param>
 /// <param name="options">
 /// Zero or more TLV-encoded mobility options.
 /// </param>
 public IpV6ExtensionHeaderMobilityBindingRevocationIndicationMessage(IpV4Protocol? nextHeader, ushort checksum,
                                                                      Ipv6MobilityBindingRevocationTrigger revocationTrigger, ushort sequenceNumber,
                                                                      bool proxyBinding, bool ipV4HomeAddressBindingOnly, bool global,
                                                                      IpV6MobilityOptions options)
     : base(nextHeader, checksum, sequenceNumber, proxyBinding, ipV4HomeAddressBindingOnly, global, options)
 {
     RevocationTrigger = revocationTrigger;
 }

 internal sealed override void Write(byte[] buffer, ref int offset, IpV4Protocol nextHeader)
 {
     buffer.Write(offset + Offset.NextHeader, (byte)nextHeader);
     int length = Length;
     buffer.Write(offset + Offset.HeaderExtensionLength, (byte)((length / 8) - 1));
     WriteData(buffer, offset + Offset.Data);
     offset += length;
 }

 /// <summary>
 /// Creates an instance from next header, checksum, home nonce index, home init cookie, home keygen token and options.
 /// </summary>
 /// <param name="nextHeader">Identifies the type of header immediately following this extension header.</param>
 /// <param name="checksum">
 /// Contains the checksum of the Mobility Header.
 /// The checksum is calculated from the octet string consisting of a "pseudo-header"
 /// followed by the entire Mobility Header starting with the Payload Proto field.
 /// The checksum is the 16-bit one's complement of the one's complement sum of this string.
 /// </param>
 /// <param name="homeNonceIndex">Will be echoed back by the mobile node to the correspondent node in a subsequent Binding Update.</param>
 /// <param name="homeInitCookie">Contains the home init cookie.</param>
 /// <param name="homeKeygenToken">Contains the 64-bit home keygen token used in the return routability procedure.</param>
 /// <param name="options">Zero or more TLV-encoded mobility options.</param>
 public IpV6ExtensionHeaderMobilityHomeTest(IpV4Protocol? nextHeader, ushort checksum, ushort homeNonceIndex, ulong homeInitCookie, ulong homeKeygenToken,
                                            IpV6MobilityOptions options)
     : base(nextHeader, checksum, options, MessageDataOffset.Options)
 {
     HomeNonceIndex = homeNonceIndex;
     HomeInitCookie = homeInitCookie;
     HomeKeygenToken = homeKeygenToken;
 }

        internal static IpV6ExtensionHeaderRoutingHomeAddress ParseRoutingData(IpV4Protocol nextHeader, byte segmentsLeft, DataSegment routingData)
        {
            if (routingData.Length != RoutingDataLength)
                return null;

            IpV6Address homeAddress = routingData.ReadIpV6Address(RoutingDataOffset.HomeAddress, Endianity.Big);
            return new IpV6ExtensionHeaderRoutingHomeAddress(nextHeader, segmentsLeft, homeAddress);
        }

        internal static IpV6ExtensionHeaderMobilityFastNeighborAdvertisement ParseMessageData(IpV4Protocol nextHeader, ushort checksum, DataSegment messageData)
        {
            if (messageData.Length < MinimumMessageDataLength)
                return null;

            IpV6MobilityOptions options = new IpV6MobilityOptions(messageData.Subsegment(MessageDataOffset.Options, messageData.Length - MessageDataOffset.Options));
            return new IpV6ExtensionHeaderMobilityFastNeighborAdvertisement(nextHeader, checksum, options);
        }

 /// <summary>
 /// Creates an instance from next header, checksum, status, key management mobility capability, mobile router, proxy registration, TLV header format,
 /// sequence number, lifetime and options.
 /// </summary>
 /// <param name="nextHeader">Identifies the type of header immediately following this extension header.</param>
 /// <param name="checksum">
 /// Contains the checksum of the Mobility Header.
 /// The checksum is calculated from the octet string consisting of a "pseudo-header"
 /// followed by the entire Mobility Header starting with the Payload Proto field.
 /// The checksum is the 16-bit one's complement of the one's complement sum of this string.
 /// </param>
 /// <param name="status">
 /// Indicating the disposition of the Binding Update.
 /// Values of the Status field less than 128 indicate that the Binding Update was accepted by the receiving node.
 /// Values greater than or equal to 128 indicate that the Binding Update was rejected by the receiving node.
 /// </param>
 /// <param name="keyManagementMobilityCapability">
 /// If this is cleared, the protocol used by the home agent for establishing the IPsec security associations between the mobile node and the home agent
 /// does not survive movements.
 /// It may then have to be rerun.
 /// (Note that the IPsec security associations themselves are expected to survive movements.)
 /// </param>
 /// <param name="mobileRouter">
 /// Indicates that the Home Agent that processed the Binding Update supports Mobile Routers.
 /// True only if the corresponding Binding Update had the Mobile Router set to true.
 /// </param>
 /// <param name="proxyRegistration">
 /// Indicates that the local mobility anchor that processed the corresponding Proxy Binding Update message supports proxy registrations.
 /// True only if the corresponding Proxy Binding Update had the Proxy Registration set to true.
 /// </param>
 /// <param name="typeLengthValueHeaderFormat">
 /// Indicates that the sender of the Proxy Binding Acknowledgement, the LMA, supports tunneling IPv6-or-IPv4 in IPv4 using TLV-header format.
 /// </param>
 /// <param name="sequenceNumber">
 /// Copied from the Sequence Number field in the Binding Update.
 /// It is used by the mobile node in matching this Binding Acknowledgement with an outstanding Binding Update.
 /// </param>
 /// <param name="lifetime">
 /// The granted lifetime, in time units of 4 seconds for Binding Acknowledgement and 1 second for Fast Binding Acknowledgement, 
 /// for which this node should retain the entry for this mobile node in its Binding Cache.
 /// </param>
 /// <param name="options">Zero or more TLV-encoded mobility options.</param>
 public IpV6ExtensionHeaderMobilityBindingAcknowledgement(IpV4Protocol? nextHeader, ushort checksum, IpV6BindingAcknowledgementStatus status,
                                                          bool keyManagementMobilityCapability, bool mobileRouter, bool proxyRegistration,
                                                          bool typeLengthValueHeaderFormat, ushort sequenceNumber, ushort lifetime, IpV6MobilityOptions options)
     : base(nextHeader, checksum, status, keyManagementMobilityCapability, sequenceNumber, lifetime, options)
 {
     MobileRouter = mobileRouter;
     ProxyRegistration = proxyRegistration;
     TypeLengthValueHeaderFormat = typeLengthValueHeaderFormat;
 }

 public IpV6ExtensionHeaderFragmentData(IpV4Protocol nextHeader, ushort fragmentOffset, bool moreFragments, uint identification)
     : base(nextHeader)
 {
     if (fragmentOffset > MaxFragmentOffset)
         throw new ArgumentOutOfRangeException("fragmentOffset", fragmentOffset, "Max value is " + MaxFragmentOffset);
     FragmentOffset = fragmentOffset;
     MoreFragments = moreFragments;
     Identification = identification;
 }

 /// <summary>
 /// Creates an instance from next header, checksum, home agent addresses and options.
 /// </summary>
 /// <param name="nextHeader">Identifies the type of header immediately following this extension header.</param>
 /// <param name="checksum">
 /// Contains the checksum of the Mobility Header.
 /// The checksum is calculated from the octet string consisting of a "pseudo-header"
 /// followed by the entire Mobility Header starting with the Payload Proto field.
 /// The checksum is the 16-bit one's complement of the one's complement sum of this string.
 /// </param>
 /// <param name="homeAgentAddresses">A list of alternate home agent addresses for the mobile node.</param>
 /// <param name="options">Zero or more TLV-encoded mobility options.</param>
 public IpV6ExtensionHeaderMobilityHomeAgentSwitchMessage(IpV4Protocol? nextHeader, ushort checksum, ReadOnlyCollection<IpV6Address> homeAgentAddresses,
                                                          IpV6MobilityOptions options)
     : base(nextHeader, checksum, options,
            MessageDataOffset.HomeAgentAddresses + (homeAgentAddresses == null ? 0 : homeAgentAddresses.Count) * IpV6Address.SizeOf)
 {
     if (homeAgentAddresses == null)
         throw new ArgumentNullException("homeAgentAddresses");
     HomeAgentAddresses = homeAgentAddresses;
 }