internal override IpV6MobilityOption CreateInstance(DataSegment data)
        {
            if (data.Length < MinIdentifierLength || data.Length > MaxIdentifierLength)
                return null;

            return new IpV6MobilityOptionServiceSelection(data);
        }

        internal override IpV6Option CreateInstance(DataSegment data)
        {
            if (data.Length != OptionDataLength)
                return null;

            return new IpV6OptionTunnelEncapsulationLimit(data[0]);
        }

 internal override IpV6Option CreateInstance(DataSegment data)
 {
     if (data.Length != OptionDataLength)
         return null;
     IpV6Address homeAddress = data.ReadIpV6Address(0, Endianity.Big);
     return new IpV6OptionHomeAddress(homeAddress);
 }

        internal override IpV6MobilityOption CreateInstance(DataSegment data)
        {
            if (data.Length != OptionDataLength)
                return null;

            return new IpV6MobilityOptionBindingRefreshAdvice(data.ReadUShort(0, Endianity.Big));
        }

        internal override IpV6Option CreateInstance(DataSegment data)
        {
            if (data.Length != OptionDataLength)
                return null;

            return new IpV6OptionJumboPayload(data.ReadUInt(0, Endianity.Big));
        }

        internal override IpV6MobilityOption CreateInstance(DataSegment data)
        {
            if (data.Length != OptionDataLength)
                return null;

            return new IpV6MobilityOptionRedirectCapability();
        }

        internal override IpV6MobilityOption CreateInstance(DataSegment data)
        {
            if (data.Length != OptionDataLength)
                return null;

            return new IpV6MobilityOptionAlternateIpV4CareOfAddress(data.ReadIpV4Address(0, Endianity.Big));
        }

        internal override IpV6MobilityOption CreateInstance(DataSegment data)
        {
            if (data.Length < OptionDataMinimumLength)
                return null;

            IpV6LocalMobilityAnchorAddressCode code = (IpV6LocalMobilityAnchorAddressCode)data[Offset.Code];
            switch (code)
            {
                case IpV6LocalMobilityAnchorAddressCode.IpV6:
                {
                    if (data.Length != Offset.LocalMobilityAnchorAddress + IpV6Address.SizeOf)
                        return null;
                    IpV6Address localMobilityAnchorAddress = data.ReadIpV6Address(Offset.LocalMobilityAnchorAddress, Endianity.Big);
                    return new IpV6MobilityOptionLocalMobilityAnchorAddress(localMobilityAnchorAddress);
                }

                case IpV6LocalMobilityAnchorAddressCode.IpV4:
                {
                    if (data.Length != Offset.LocalMobilityAnchorAddress + IpV4Address.SizeOf)
                        return null;
                    IpV4Address localMobilityAnchorAddress = data.ReadIpV4Address(Offset.LocalMobilityAnchorAddress, Endianity.Big);
                    return new IpV6MobilityOptionLocalMobilityAnchorAddress(localMobilityAnchorAddress);
                }

                default:
                    return null;
            }
        }

 /// <summary>
 /// Creates an instance from status, remove and mobile node identity.
 /// </summary>
 /// <param name="status">
 /// Indicating the result of the dynamic DNS update procedure.
 /// This field must be set to 0 and ignored by the receiver when the DNS Update mobility option is included in a Binding Update message.
 /// When the DNS Update mobility option is included in the Binding Acknowledgement message, 
 /// values of the Status field less than 128 indicate that the dynamic DNS update was performed successfully by the Home Agent.
 /// Values greater than or equal to 128 indicate that the dynamic DNS update was not completed by the HA.
 /// </param>
 /// <param name="remove">
 /// Whether the Mobile Node is requesting the HA to remove the DNS entry identified by the FQDN specified in this option and the HoA of the Mobile Node.
 /// If false, the Mobile Node is requesting the HA to create or update a DNS entry with its HoA and the FQDN specified in the option.
 /// </param>
 /// <param name="mobileNodeIdentity">
 /// The identity of the Mobile Node in FQDN format to be used by the Home Agent to send a Dynamic DNS update.
 /// </param>
 public IpV6MobilityOptionDnsUpdate(IpV6DnsUpdateStatus status, bool remove, DataSegment mobileNodeIdentity)
     : base(IpV6MobilityOptionType.DnsUpdate)
 {
     Status = status;
     Remove = remove;
     MobileNodeIdentity = mobileNodeIdentity;
 }

 public IpV6ExtensionHeaderEncapsulatingSecurityPayload(uint securityParametersIndex, uint sequenceNumber, DataSegment encryptedDataAndAuthenticationData)
     : base(null)
 {
     SecurityParametersIndex = securityParametersIndex;
     SequenceNumber = sequenceNumber;
     EncryptedDataAndAuthenticationData = encryptedDataAndAuthenticationData;
 }

 /// <summary>
 /// Creates an instance from vendor id, subtype and data.
 /// </summary>
 /// <param name="vendorId">
 /// The SMI Network Management Private Enterprise Code of the IANA- maintained Private Enterprise Numbers registry.
 /// See http://www.iana.org/assignments/enterprise-numbers/enterprise-numbers
 /// </param>
 /// <param name="subtype">
 /// Indicating the type of vendor-specific information carried in the option.
 /// The administration of the Sub-type is done by the Vendor.
 /// </param>
 /// <param name="data">Vendor-specific data that is carried in this message.</param>
 public IpV6MobilityOptionVendorSpecific(uint vendorId, byte subtype, DataSegment data)
     : base(IpV6MobilityOptionType.VendorSpecific)
 {
     VendorId = vendorId;
     Subtype = subtype;
     Data = data;
 }

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

 public IpV6OptionSmfDpdSequenceHashAssistValue(DataSegment data)
 {
     byte[] hashAssistValueBuffer = new byte[data.Length - Offset.HashAssistValue];
     data.Buffer.BlockCopy(data.StartOffset + Offset.HashAssistValue, hashAssistValueBuffer, 0, hashAssistValueBuffer.Length);
     hashAssistValueBuffer[0] &= 0x7F;
     HashAssistValue = new DataSegment(hashAssistValueBuffer);
 }

 /// <summary>
 /// Creates an instance from subtype, mobility security parameter index and authentication data.
 /// </summary>
 /// <param name="subtype">A number assigned to identify the entity and/or mechanism to be used to authenticate the message.</param>
 /// <param name="mobilitySecurityParameterIndex">
 /// A number in the range [0-4294967296] used to index into the shared-key-based mobility security associations.
 /// </param>
 /// <param name="authenticationData">
 /// Has the information to authenticate the relevant mobility entity.
 /// This protects the message beginning at the Mobility Header up to and including the mobility SPI field.
 /// </param>
 public IpV6MobilityOptionAuthentication(IpV6AuthenticationSubtype subtype, uint mobilitySecurityParameterIndex, DataSegment authenticationData)
     : base(IpV6MobilityOptionType.Authentication)
 {
     Subtype = subtype;
     MobilitySecurityParameterIndex = mobilitySecurityParameterIndex;
     AuthenticationData = authenticationData;
 }

        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);
            }
        }

        internal override IpV6Option CreateInstance(DataSegment data)
        {
            if (data.Length != OptionDataLength)
                return null;

            return new IpV6OptionRouterAlert((IpV6RouterAlertType)data.ReadUShort(0, Endianity.Big));
        }

        internal override IpV6MobilityOption CreateInstance(DataSegment data)
        {
            if (data.Length < OptionDataMinimumLength)
                return null;

            bool isIpV4 = data.ReadBool(Offset.IsIpV4, Mask.IsIpV4);
            bool isIpV6 = data.ReadBool(Offset.IsIpV6, Mask.IsIpV6);

            if (isIpV4 && !isIpV6)
            {
                if (data.Length != OptionDataMinimumLength + IpV4Address.SizeOf)
                    return null;
                IpV4Address localMobilityAddress = data.ReadIpV4Address(Offset.LocalMobilityAddress, Endianity.Big);
                return new IpV6MobilityOptionRedirect(localMobilityAddress);
            }
            if (isIpV6 && !isIpV4)
            {
                if (data.Length != OptionDataMinimumLength + IpV6Address.SizeOf)
                    return null;
                IpV6Address localMobilityAddress = data.ReadIpV6Address(Offset.LocalMobilityAddress, Endianity.Big);
                return new IpV6MobilityOptionRedirect(localMobilityAddress);
            }

            return null;
        }

 public static void ReadData(DataSegment data, out IpV4OptionQuickStartFunction function, out byte rate, out byte ttl, out uint nonce)
 {
     function = (IpV4OptionQuickStartFunction)(data[Offset.Function] & Mask.Function);
     rate = (byte)(data[Offset.Rate] & Mask.Rate);
     ttl = data[Offset.Ttl];
     nonce = data.ReadUInt(Offset.Nonce, Endianity.Big);
 }

        internal override IpV6MobilityOption CreateInstance(DataSegment data)
        {
            if (data.Length != OptionDataLength)
                return null;

            return new IpV6MobilityOptionCryptographicallyGeneratedAddressParametersRequest();
        }

        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;
            }
        }