@node IPv6 Support
@chapter IPv6 Support

Quagga fully supports IPv6 routing.  As described so far, Quagga supports
RIPng, OSPFv3, Babel and BGP-4+.  You can give IPv6 addresses to an interface
and configure static IPv6 routing information.  Quagga IPv6 also provides
automatic address configuration via a feature called @code{address
auto configuration}.  To do it, the router must send router advertisement
messages to the all nodes that exist on the network.

@menu
* Router Advertisement::        
@end menu

@node Router Advertisement
@section Router Advertisement

@deffn {Interface Command} {no ipv6 nd suppress-ra} {}
Send router advertisment messages.
@end deffn

@deffn {Interface Command} {ipv6 nd suppress-ra} {}
Don't send router advertisment messages.
@end deffn

@deffn {Interface Command} {ipv6 nd prefix @var{ipv6prefix} [@var{valid-lifetime}] [@var{preferred-lifetime}] [off-link] [no-autoconfig] [router-address]} {}
Configuring the IPv6 prefix to include in router advertisements. Several prefix
specific optional parameters and flags may follow:
@itemize @bullet
@item
@var{valid-lifetime} - the length of time in seconds during what the prefix is
valid for the purpose of on-link determination. Value @var{infinite} represents
infinity (i.e. a value of all one bits (@code{0xffffffff})).

Range: @code{<0-4294967295>}  Default: @code{2592000}

@item
@var{preferred-lifetime} - the length of time in seconds during what addresses
generated from the prefix remain preferred. Value @var{infinite} represents
infinity.

Range: @code{<0-4294967295>}  Default: @code{604800}

@item
@var{off-link} - indicates that advertisement makes no statement about on-link or
off-link properties of the prefix.

Default: not set, i.e. this prefix can be used for on-link determination.

@item
@var{no-autoconfig} - indicates to hosts on the local link that the specified prefix
cannot be used for IPv6 autoconfiguration.

Default: not set, i.e. prefix can be used for autoconfiguration.

@item
@var{router-address} - indicates to hosts on the local link that the specified 
prefix 
contains a complete IP address by setting R flag.

Default: not set, i.e. hosts do not assume a complete IP address is placed.
@end itemize
@end deffn

@deffn {Interface Command} {ipv6 nd ra-interval <1-1800>} {}
@deffnx {Interface Command} {no ipv6 nd ra-interval [<1-1800>]} {}
The  maximum  time allowed between sending unsolicited multicast router
advertisements from the interface, in seconds.

Default: @code{600}
@end deffn

@deffn {Interface Command} {ipv6 nd ra-interval msec <70-1800000>} {}
@deffnx {Interface Command} {no ipv6 nd ra-interval [msec <70-1800000>]} {}
The  maximum  time allowed between sending unsolicited multicast router
advertisements from the interface, in milliseconds.

Default: @code{600000}
@end deffn

@deffn {Interface Command} {ipv6 nd ra-lifetime <0-9000>} {}
@deffnx {Interface Command} {no ipv6 nd ra-lifetime [<0-9000>]} {}
The value to be placed in the Router Lifetime field of router advertisements
sent from the interface, in seconds. Indicates the usefulness of the router
as a default router on this interface. Setting the value to zero indicates
that the router should not be considered a default router on this interface.
Must be either zero or between value specified with @var{ipv6 nd ra-interval}
(or default) and 9000 seconds.

Default: @code{1800}
@end deffn

@deffn {Interface Command} {ipv6 nd reachable-time <1-3600000>} {}
@deffnx {Interface Command} {no ipv6 nd reachable-time [<1-3600000>]} {}
The value to be placed in the Reachable Time field in the Router Advertisement
messages sent by the router, in milliseconds. The configured time enables the
router to detect unavailable neighbors. The value zero means unspecified (by
this router).

Default: @code{0}
@end deffn

@deffn {Interface Command} {ipv6 nd managed-config-flag} {}
@deffnx {Interface Command} {no ipv6 nd managed-config-flag} {}
Set/unset flag in IPv6 router advertisements which indicates to hosts that they
should use managed (stateful) protocol for addresses autoconfiguration in
addition to any addresses autoconfigured using stateless address
autoconfiguration.

Default: not set
@end deffn

@deffn {Interface Command} {ipv6 nd other-config-flag} {}
@deffnx {Interface Command} {no ipv6 nd other-config-flag} {}
Set/unset flag in IPv6 router advertisements which indicates to hosts that
they should use administered (stateful) protocol to obtain autoconfiguration
information other than addresses.

Default: not set
@end deffn

@deffn {Interface Command} {ipv6 nd home-agent-config-flag} {}
@deffnx {Interface Command} {no ipv6 nd home-agent-config-flag} {}
Set/unset flag in IPv6 router advertisements which indicates to hosts that
the router acts as a Home Agent and includes a Home Agent Option.

Default: not set
@end deffn

@deffn {Interface Command} {ipv6 nd home-agent-preference <0-65535>} {}
@deffnx {Interface Command} {no ipv6 nd home-agent-preference [<0-65535>]} {}
The value to be placed in Home Agent Option, when Home Agent config flag is set, 
which indicates to hosts Home Agent preference. The default value of 0 stands
for the lowest preference possible.

Default: 0
@end deffn

+@deffn {Interface Command} {ipv6 nd home-agent-lifetime <0-65520>} {}
+@deffnx {Interface Command} {no ipv6 nd home-agent-lifetime [<0-65520>]} {}
The value to be placed in Home Agent Option, when Home Agent config flag is set, 
which indicates to hosts Home Agent Lifetime. The default value of 0 means to
place the current Router Lifetime value.

Default: 0
@end deffn

@deffn {Interface Command} {ipv6 nd adv-interval-option} {}
@deffnx {Interface Command} {no ipv6 nd adv-interval-option} {}
Include an Advertisement Interval option which indicates to hosts the maximum time, 
in milliseconds, between successive unsolicited Router Advertisements.

Default: not set
@end deffn

@deffn {Interface Command} {ipv6 nd router-preference (high|medium|low)} {}
@deffnx {Interface Command} {no ipv6 nd router-preference [(high|medium|low)]} {}
Set default router preference in IPv6 router advertisements per RFC4191.

Default: medium
@end deffn

@deffn {Interface Command} {ipv6 nd mtu <1-65535>} {}
@deffnx {Interface Command} {no ipv6 nd mtu [<1-65535>]} {}
Include an MTU (type 5) option in each RA packet to assist the attached hosts
in proper interface configuration. The announced value is not verified to be
consistent with router interface MTU.

Default: don't advertise any MTU option
@end deffn

@example
@group
interface eth0
 no ipv6 nd suppress-ra
 ipv6 nd prefix 2001:0DB8:5009::/64
@end group
@end example

For more information see @cite{RFC2462 (IPv6 Stateless Address Autoconfiguration)}
, @cite{RFC4861 (Neighbor Discovery for IP Version 6 (IPv6))}
, @cite{RFC6275 (Mobility Support in IPv6)}
and @cite{RFC4191 (Default Router Preferences and More-Specific Routes)}.
