@node Overview, Installation, Top, Top
@comment  node-name,  next,  previous,  up
@chapter Overview
@cindex Overview

  Quagga is a routing software package that provides TCP/IP based
routing services with routing protocols support such as RIPv1, RIPv2,
RIPng, OSPFv2, OSPFv3, BGP-4, and BGP-4+ (@pxref{Supported RFC}).
Quagga also supports special BGP Route Reflector and Route Server
behavior.  In addition to traditional IPv4 routing protocols, Quagga
also supports IPv6 routing protocols.  With SNMP daemon which supports
SMUX protocol, Quagga provides routing protocol MIBs (@pxref{SNMP
Support}).

  Quagga uses an advanced software architecture to provide you with a
high quality, multi server routing engine.  Quagga has an interactive
user interface for each routing protocol and supports common client
commands.  Due to this design, you can add new protocol daemons to Quagga
easily.  You can use Quagga library as your program's client user
interface.

  Zebra is distributed under the @sc{gnu} General Public License.

@menu
* About Quagga::                 Basic information about Quagga
* System Architecture::         The Quagga system architecture
* Supported Platforms::         Supported platforms and future plans
* Supported RFC::               Supported RFCs
* How to get Quagga::            
* Mailing List::                Mailing list information
* Bug Reports::                 Mail address for bug data
@end menu

@node About Quagga, System Architecture, Overview, Overview
@comment  node-name,  next,  previous,  up
@section About Quagga
@cindex About Quagga

  Today, TCP/IP networks are covering all of the world.  The Internet
has been deployed in many countries, companies, and to the home.  When
you connect to the Internet your packet will pass many routers which
have TCP/IP routing functionality.

  A system with Quagga installed acts as a dedicated router.  With Quagga,
your machine exchanges routing information with other routers using
routing protocols.  Quagga uses this information to update the kernel
routing table so that the right data goes to the right place.  You can
dynamically change the configuration and you may view routing table
information from the Quagga terminal interface.

  Adding to routing protocol support, Quagga can setup interface's flags,
interface's address, static routes and so on.  If you have a small
network, or a stub network, or xDSL connection, configuring the Quagga
routing software is very easy.  The only thing you have to do is to set
up the interfaces and put a few commands about static routes and/or
default routes.  If the network is rather large, or if the network
structure changes frequently, you will want to take advantage of Quagga's
dynamic routing protocol support for protocols such as RIP, OSPF or BGP.
Quagga is with you.

  Traditionally, UNIX based router configuration is done by
@command{ifconfig} and @command{route} commands.  Status of routing
table is displayed by @command{netstat} utility.  Almost of these
commands work only if the user has root privileges.  Quagga has a different
system administration method.  There are two user modes in Quagga.  One is
normal mode, the other is enable mode.  Normal mode user can only view
system status, enable mode user can change system configuration.  This
UNIX account independent feature will be great help to the router
administrator.

  Currently, Quagga supports common unicast routing protocols.  Multicast
routing protocols such as BGMP, PIM-SM, PIM-DM may be supported in
Quagga 2.0.  MPLS support is going on.  In the future, TCP/IP filtering
control, QoS control, diffserv configuration will be added to Quagga.
Quagga project's final goal is making a productive, quality free TCP/IP
routing software.

@node System Architecture, Supported Platforms, About Quagga, Overview
@comment  node-name,  next,  previous,  up
@section System Architecture
@cindex System architecture
@cindex Software architecture
@cindex Software internals

  Traditional routing software is made as a one process program which
provides all of the routing protocol functionalities.  Quagga takes a
different approach.  It is made from a collection of several daemons
that work together to build the routing table.  There may be several
protocol-specific routing daemons and zebra the kernel routing manager.

  The @command{ripd} daemon handles the RIP protocol, while
@command{ospfd} is a daemon which supports OSPF version 2.
@command{bgpd} supports the BGP-4 protocol.  For changing the kernel
routing table and for redistribution of routes between different routing
protocols, there is a kernel routing table manager @command{zebra}
daemon.  It is easy to add a new routing protocol daemons to the entire
routing system without affecting any other software.  You need to run only
the protocol daemon associated with routing protocols in use.  Thus,
user may run a specific daemon and send routing reports to a central
routing console.

  There is no need for these daemons to be running on the same machine.
You can even run several same protocol daemons on the same machine.  This
architecture creates new possibilities for the routing system.

@example
@group
+----+  +----+  +-----+  +-----+
|bgpd|  |ripd|  |ospfd|  |zebra|
+----+  +----+  +-----+  +-----+
                            |
+---------------------------|--+
|                           v  |
|  UNIX Kernel  routing table  |
|                              |
+------------------------------+

    Quagga System Architecture
@end group
@end example

  Multi-process architecture brings extensibility, modularity and
maintainability.  At the same time it also brings many configuration
files and terminal interfaces.  Each daemon has it's own configuration
file and terminal interface.  When you configure a static route, it must
be done in @command{zebra} configuration file.  When you configure BGP
network it must be done in @command{bgpd} configuration file.  This can be a
very annoying thing.  To resolve the problem, Quagga provides integrated
user interface shell called @command{vtysh}.  @command{vtysh} connects to
each daemon with UNIX domain socket and then works as a proxy for user input.

  Quagga was planned to use multi-threaded mechanism when it runs with a
kernel that supports multi-threads.  But at the moment, the thread
library which comes with @sc{gnu}/Linux or FreeBSD has some problems with
running reliable services such as routing software, so we don't use
threads at all.  Instead we use the @command{select(2)} system call for
multiplexing the events.

  When @command{zebra} runs under a @sc{gnu} Hurd kernel it will act as a
kernel routing table itself.  Under @sc{gnu} Hurd, all TCP/IP services are
provided by user processes called @command{pfinet}.  Quagga will provide
all the routing selection mechanisms for the process.  This feature will
be implemented when @sc{gnu} Hurd becomes stable.

@node Supported Platforms, Supported RFC, System Architecture, Overview
@comment  node-name,  next,  previous,  up
@section Supported Platforms

@cindex Supported platforms
@cindex Quagga on other systems
@cindex Compatibility with other systems
@cindex Operating systems that support Quagga

  Currently Quagga supports @sc{gnu}/Linux, BSD and Solaris.  Below is a list
of OS versions on which Quagga runs.  Porting Quagga to other platforms is
not so too difficult.  Platform dependent codes exist only in
@command{zebra} daemon.  Protocol daemons are platform independent.
Please let us know when you find out Quagga runs on a platform which is not
listed below.

@sp 1
@itemize @bullet
@item
GNU/Linux 2.0.37
@item
GNU/Linux 2.2.x and higher
@item
FreeBSD 2.2.8
@item
FreeBSD 3.x
@item
FreeBSD 4.x
@item
NetBSD 1.4
@item
OpenBSD 2.5
@item
Solaris 2.6
@item
Solaris 7
@end itemize

@sp 1
  Some IPv6 stacks are in development.  Quagga supports following IPv6
stacks.  For BSD, we recommend KAME IPv6 stack.  Solaris IPv6 stack is
not yet supported.
@sp 1
@itemize @bullet
@item
Linux IPv6 stack for GNU/Linux 2.2.x and higher.
@item
KAME IPv6 stack for BSD.
@item
INRIA IPv6 stack for BSD.
@end itemize

@node Supported RFC, How to get Quagga, Supported Platforms, Overview
@comment  node-name,  next,  previous,  up
@section Supported RFC

  Below is the list of currently supported RFC's.

@table @asis
@item @asis{RFC1058}
@cite{Routing Information Protocol. C.L. Hedrick. Jun-01-1988.}

@item @asis{RF2082}
@cite{RIP-2 MD5 Authentication. F. Baker, R. Atkinson. January 1997.}

@item @asis{RFC2453}
@cite{RIP Version 2. G. Malkin. November 1998.}

@item @asis{RFC2080}
@cite{RIPng for IPv6. G. Malkin, R. Minnear. January 1997.}

@item @asis{RFC2328}
@cite{OSPF Version 2. J. Moy. April 1998.}

@item @asis{RFC2740}
@cite{OSPF for IPv6. R. Coltun, D. Ferguson, J. Moy. December 1999.}

@item @asis{RFC1771} 
@cite{A Border Gateway Protocol 4 (BGP-4). Y. Rekhter & T. Li. March 1995.}

@item @asis{RFC1965}
@cite{Autonomous System Confederations for BGP. P. Traina. June 1996.}

@item @asis{RFC1997}
@cite{BGP Communities Attribute. R. Chandra, P. Traina & T. Li. August 1996.}

@item @asis{RFC2545}
@cite{Use of BGP-4 Multiprotocol Extensions for IPv6 Inter-Domain Routing. P. Marques, F. Dupont. March 1999.}

@item @asis{RFC2796}
@cite{BGP Route Reflection An alternative to full mesh IBGP. T. Bates & R. Chandrasekeran. June 1996.}

@item @asis{RFC2858}
@cite{Multiprotocol Extensions for BGP-4. T. Bates, Y. Rekhter, R. Chandra, D. Katz. June 2000.}

@item @asis{RFC2842}
@cite{Capabilities Advertisement with BGP-4. R. Chandra, J. Scudder. May 2000.}

@end table

  When SNMP support is enabled, below RFC is also supported.

@table @asis

@item @asis{RFC1227}
@cite{SNMP MUX protocol and MIB. M.T. Rose. May-01-1991.}

@item @asis{RFC1657}
@cite{Definitions of Managed Objects for the Fourth Version of the
Border Gateway Protocol (BGP-4) using SMIv2. S. Willis, J. Burruss,
J. Chu, Editor. July 1994.}

@item @asis{RFC1724}
@cite{RIP Version 2 MIB Extension. G. Malkin & F. Baker. November 1994.}

@item @asis{RFC1850}
@cite{OSPF Version 2 Management Information Base. F. Baker, R. Coltun.
November 1995.}

@end table

@node How to get Quagga, Mailing List, Supported RFC, Overview
@comment  node-name,  next,  previous,  up
@section How to get Quagga

  Quagga is still beta software and there is no officially released
version. Once Quagga is released you can get it from @sc{gnu} FTP
site and its mirror sites.  We are planning Quagga-1.0 as the first
released version.

  Zebra's official web page is located at:

@url{http://www.gnu.org/software/zebra/zebra.html}.

  The original Zebra web site is located at: 

@url{http://www.zebra.org/}.

  As of this writing, development by zebra.org on Zebra has slowed down.
Some work is being done by third-parties to try maintain bug-fixes and
enhancements to the current Zebra code-base, which has resulted in a fork of
Zebra called Quagga, see:

@url{http://www.quagga.net/}.

for further information, as well as links to additional zebra resources.

@node Mailing List, Bug Reports, How to get Quagga, Overview
@comment  node-name,  next,  previous,  up
@section Mailing List
@cindex How to get in touch with Quagga
@cindex Mailing Quagga
@cindex Contact information
@cindex Mailing lists

  There is a mailing list for discussions about Quagga.  If you have any
comments or suggestions to Quagga, please subscribe to
@url{http://lists.quagga.net/mailman/listinfo/quagga-users}.

  There is an additional mailing list, @email{znog@@dishone.st,ZNOG} for
general discussion of zebra related issues and network operation. To
subscribe send an email to @email{znog-subscribe@@dishone.st} with a message
body that includes only:

@quotation
subscribe znog
@end quotation

 To unsubscribe, send an email to @email{znog-unsubscribe@@dishone.st}
with a message body that includes only:

@quotation
unsubscribe znog
@end quotation

 Alternatively, you may use the web interface located at
@url{http://www.dishone.st/mailman/listinfo/znog}. Links to archives of the
znog list are available at this URL.

@node Bug Reports,  , Mailing List, Overview
@comment  node-name,  next,  previous,  up
@section Bug Reports

@cindex Bug Reports
@cindex Bug hunting
@cindex Found a bug?
@cindex Reporting bugs
@cindex Reporting software errors
@cindex Errors in the software

  If you think you have found a bug, please send a bug report to
@url{http://bugzilla.quagga.net}.  When you send a bug report, please be
careful about the points below.

@itemize @bullet
@item 
Please note what kind of OS you are using.  If you use the IPv6 stack
please note that as well.
@item
Please show us the results of @code{netstat -rn} and @code{ifconfig -a}.
Information from zebra's VTY command @code{show ip route} will also be
helpful.
@item
Please send your configuration file with the report.  If you specify
arguments to the configure script please note that too.
@end itemize

  Bug reports are very important for us to improve the quality of Quagga.
Quagga is still in the development stage, but please don't hesitate to
send a bug report to @url{http://bugzilla.quagga.net}.