New example config.

diff --git a/doc/bird.conf.example b/doc/bird.conf.example
index cf3b36b6a7f518c617183823281fa15c048bba0f..f30ce8df258433f8f186f78c49030122cf3829fc 100644 (file)
--- a/doc/bird.conf.example
+++ b/doc/bird.conf.example
@@ -2,61 +2,67 @@
  *     This is an example configuration file.
  */
 
-# Yet another comment
+# Yes, even shell-like comments work...
 
-#log syslog { error };
+# Configure logging
+#log syslog { debug, trace, info, remote, warning, error, auth, fatal, bug };
+#log stderr all;
 #log "tmp" all;
 
+# Override router ID
 #router id 62.168.0.1;
 
+# You can define your own symbols...
 #define xyzzy = 120+10;
 
+# Define a route filter...
+filter test_filter {
+       if net ~ 10.0.0.0/16 then accept;
+       else reject;
+}
+
 #filter sink { reject; }
 #filter okay { accept; }
 
+# Define another routing table
 #table testable;
 
-debug protocols all;
-
-#protocol rip MyRIP_test {
-#      preference xyzzy;
-#      debug all;
-#      port 1520;
-#      period 7;
-#      garbagetime 60;
-#      interface "*" { mode broadcast; };
-#      honour neighbour;
-#      passwords { password "ahoj" from 0 to 10;
-#              password "nazdar" from 10;
-#      }
-#      authentication none;
-#      import filter { print "importing"; accept; };
-#      export filter { print "exporting"; accept; };
-#}
+# Turn on global debugging of all protocols
+#debug protocols all;
 
+# The direct protocol automatically generates device routes to
+# all network interfaces. Can exist in as many instances as you wish
+# if you want to populate multiple routing tables with device routes.
 protocol direct {
-#      disabled;
-#      interface "-eth*", "*";
+#      interface "-eth*", "*"; # Restrict network interfaces it works with
 }
 
+# This pseudo-protocol performs synchronization between BIRD's routing
+# tables and the kernel. If your kernel supports multiple routing tables
+# (as Linux 2.2.x does), you can run multiple instances of the kernel
+# protocol and synchronize different kernel tables with different BIRD tables.
 protocol kernel {
-#      disabled;
-#      learn;                  # Learn all routes from the kernel
+#      learn;                  # Learn all alien routes from the kernel
        persist;                # Don't remove routes on bird shutdown
        scan time 20;           # Scan kernel routing table every 20 seconds
-#      async off;              # Netlink: Disable asynchronous events
 #      import none;            # Default is import all
        export all;             # Default is export none
 #      kernel table 5;         # Kernel table to synchronize with (default: main)
 }
 
+# This pseudo-protocol watches all interface up/down events.
 protocol device {
        scan time 10;           # Scan interfaces every 10 seconds
 }
 
+# Static routes (again, there can be multiple instances, so that you
+# can disable/enable various groups of static routes on the fly).
 protocol static {
-#      disabled;
-#      table testable;
+#      disabled;               # Disable by default
+#      table testable;         # Connect to a non-default table
+#      preference 1000;        # Default preference of routes
+#      debug { states, routes, filters, interfaces, events, packets };
+#      debug all;
 #      route 0.0.0.0/0 via 62.168.0.13;
 #      route 62.168.0.0/25 reject;
 #      route 10.0.0.0/8 reject;
@@ -66,8 +72,68 @@ protocol static {
 #      route 10.2.0.0/24 via "arc0";
 }
 
+# Pipe protocol connects two routing tables... Beware of loops.
 #protocol pipe {
 #      peer table testable;
-#      import all;
-#      export all;
+# Define what routes do we export to this protocol / import from it.
+#      import all;             # default is all
+#      export all;             # default is none
+#      import none;            # If you wish to disable imports
+#      import filter test_filter;              # Use named filter
+#      import where source = RTS_DEVICE;       # Use explicit filter
+#}
+
+# RIP aka Rest In Pieces...
+#protocol rip MyRIP {  # You can also use an explicit name
+#      preference xyzzy;
+#      debug all;
+#      port 1520;
+#      period 7;
+#      infinity 16;
+#      garbagetime 60;
+#      interface "*" { mode broadcast; };
+#      honor neighbor;         # To whom do we agree to send the routing table
+#      honor always;
+#      honor never;
+#      passwords { password "ahoj" from 0 to 10;
+#              password "nazdar" from 10;
+#      }
+#      authentication none;
+#      import filter { print "importing"; accept; };
+#      export filter { print "exporting"; accept; };
+#}
+
+#protocol bgp {
+#      disabled;
+#      local as 65000;
+#      neighbor 62.168.0.130 as 5588;
+#      multihop 20 via 62.168.0.13;
+#      hold time 240;
+#      startup hold time 240;
+#      connect retry time 120;
+#      keepalive time 80;      # defaults to hold time / 3
+#      start delay time 5;     # How long do we wait before initial connect
+#      error wait time 60, 300;# Minimum and maximum time we wait after an error (when consecutive
+#                              # errors occur, we increase the delay exponentially ...
+#      error forget time 300;  # ... until this timeout expires)
+#      disable after error;    # Disable the protocol automatically when an error occurs
+#      next hop self;          # Disable next hop processing and always advertise our local address as nexthop
+#      path metric 1;          # Prefer routes with shorter paths (like Cisco does)
+#      default bgp_med 0;      # MED value we use for comparison when none is defined
+#      default bgp_local_pref 0;       # The same for local preference
+#      source address 62.168.0.14;     # What local address we use for the TCP connection
+#      export where source=RTS_STATIC;
+#      export filter {
+#              if source = RTS_STATIC then {
+##                     bgp_community = -empty-; bgp_community = add(bgp_community,(65000,5678));
+##                     bgp_origin = 0;
+#                      bgp_community = -empty-; bgp_community.add((65000,5678));
+##                     if (65000,5678) ~ bgp_community then
+##                             bgp_community.add((0, 1));
+#                      if bgp_path ~ / 65000 / then
+#                              bgp_path.prepend(65000);
+#                      accept;
+#              }
+#              reject;
+#      };
 #}