Major RIP redesign

The new RIP implementation fixes plenty of old bugs and also adds support for many new features: ECMP support, link state support, BFD support, configurable split horizon and more. Most options are now per-interface.
author: Ondrej Zajicek (work) <santiago@crfreenet.org> 2015-10-05 12:14:50 +0200
committer: Ondrej Zajicek (work) <santiago@crfreenet.org> 2015-10-05 13:18:10 +0200
commit: 8465dccb06afffed171dc1e224e4eb5f67cc3326 (patch)
tree: 9e5209b312ba8b7eabd0f5a22aea4a0888cd8c9f
parent: c7b99a932cab1873042e356143ab71755920157a (diff)
18 files changed, 2364 insertions, 1286 deletions
diff --git a/client/commands.c b/client/commands.c
index 50fcba40..226ae048 100644
--- a/client/commands.c
+++ b/client/commands.c
@@ -67,7 +67,7 @@ cmd_build_tree(void)
 	      new->plastson = &new->son;
 	      new->len = c-d;
 	      memcpy(new->token, d, c-d);
-	      new->prio = (new->len == 3 && !memcmp(new->token, "roa", 3)) ? 0 : 1; /* Hack */
+	      new->prio = (new->len == 3 && (!memcmp(new->token, "roa", 3) || !memcmp(new->token, "rip", 3))) ? 0 : 1; /* Hack */
 	    }
 	  old = new;
 	  while (isspace(*c))
diff --git a/doc/bird.sgml b/doc/bird.sgml
index df83aacd..86df0456 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -2476,7 +2476,7 @@ protocol ospf &lt;name&gt; {
 	This option specifies whether OSPF is allowed to generate ECMP
 	(equal-cost multipath) routes. Such routes are used when there are
 	several directions to the destination, each with the same (computed)
-	cost. This option also allows to specify a limit on maximal number of
+	cost. This option also allows to specify a limit on maximum number of
 	nexthops in one route. By default, ECMP is disabled. If enabled,
 	default	value of the limit is 16.
 
@@ -3244,16 +3244,14 @@ one). After some time, the distance reaches infinity (that's 15 in RIP) and all
 routers know that network is unreachable. RIP tries to minimize situations where
 counting to infinity is necessary, because it is slow. Due to infinity being 16,
 you can't use RIP on networks where maximal distance is higher than 15
-hosts. You can read more about RIP at
-<HTMLURL URL="http://www.ietf.org/html.charters/rip-charter.html"
-name="http://www.ietf.org/html.charters/rip-charter.html">. Both IPv4
-(RFC 1723 <htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc1723.txt">) and IPv6
-(RFC 2080 <htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc2080.txt">) versions
-of RIP are supported by BIRD, historical RIPv1
-(RFC 1058 <htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc1058.txt">) is not
-currently supported. RIPv4 MD5 authentication
-(RFC 2082 <htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc2082.txt">) is
-supported.
+hosts.
+
+<p>BIRD supports RIPv1
+(RFC 1058<htmlurl url="http://www.rfc-editor.org/rfc/rfc1058.txt">),
+RIPv2 (RFC 2453<htmlurl url="http://www.rfc-editor.org/rfc/rfc2453.txt">),
+RIPng (RFC 2080<htmlurl url="http://www.rfc-editor.org/rfc/rfc2080.txt">),
+and RIP cryptographic authentication (SHA-1 not implemented)
+(RFC 4822<htmlurl url="http://www.rfc-editor.org/rfc/rfc4822.txt">).
 
 <p>RIP is a very simple protocol, and it has a lot of shortcomings. Slow
 convergence, big network load and inability to handle larger networks makes it
@@ -3261,39 +3259,156 @@ pretty much obsolete. It is still usable on very small networks.
 
 <sect1>Configuration
 
-<p>In addition to options common for all to other protocols, RIP supports the
-following ones:
+<p>RIP configuration consists mainly of common protocol options and interface
+definitions, most RIP options are interface specific.
+
+<code>
+protocol rip [&lt;name&gt;] {
+	infinity &lt;number&gt;;
+	ecmp &lt;switch&gt; [limit &lt;number&gt;];
+	interface &lt;interface pattern&gt; {
+		metric &lt;number&gt;;
+		mode multicast|broadcast;
+		passive &lt;switch&gt;;
+		address &lt;ip&gt;;
+		port &lt;number&gt;;
+		version 1|2;
+		split horizon &lt;switch&gt;;
+		poison reverse &lt;switch&gt;;
+		check zero &lt;switch&gt;;
+		update time &lt;number&gt;;
+		timeout time &lt;number&gt;;
+		garbage time &lt;number&gt;;
+		ecmp weight &lt;number&gt;;
+		ttl security &lt;switch&gt;; | tx only;
+		tx class|dscp &lt;number&gt;;
+		tx priority &lt;number&gt;;
+		rx buffer &lt;number&gt;;
+		tx length &lt;number&gt;;
+		check link &lt;switch&gt;;
+		authentication none|plaintext|cryptographic;
+		password "&lt;text&gt;";
+		password "&lt;text&gt;" {
+			id &lt;num&gt;;
+			generate from "&lt;date&gt;";
+			generate to "&lt;date&gt;";
+			accept from "&lt;date&gt;";
+			accept to "&lt;date&gt;";
+		};
+	};
+}
+</code>
 
 <descrip>
-	<tag>authentication none|plaintext|md5</tag>
-	Selects authentication method to be used. <cf/none/ means that packets
-	are not authenticated at all, <cf/plaintext/ means that a plaintext
-	password is embedded into each packet, and <cf/md5/ means that packets
-	are authenticated using a MD5 cryptographic hash. If you set
-	authentication to not-none, it is a good idea to add <cf>password</cf>
-	section. Default: none.
+	<tag>infinity <M>number</M></tag>
+	Selects the distance of infinity. Bigger values will make
+	protocol convergence even slower. The default value is 16.
 
-	<tag>honor always|neighbor|never</tag>
-	Specifies when should requests for dumping routing table be honored.
-	(Always, when sent from a host on a directly connected network or
-	never.) Routing table updates are honored only from neighbors, that is
-	not configurable. Default: never.
+	<tag>ecmp <M>switch</M> [limit <M>number</M>]</tag>
+	This option specifies whether RIP is allowed to generate ECMP
+	(equal-cost multipath) routes. Such routes are used when there are
+	several directions to the destination, each with the same (computed)
+	cost. This option also allows to specify a limit on maximum number of
+	nexthops in one route. By default, ECMP is disabled. If enabled,
+	default	value of the limit is 16.
+
+	<tag>interface <m/pattern [, ...]/ { <m/options/ }</tag>
+	Interface definitions specify a set of interfaces on which the
+	protocol is activated and contain interface specific options.
+	See <ref id="dsc-iface" name="interface"> common options for
+	detailed description.
 </descrip>
 
-<p>There are some options that can be specified per-interface:
+<p>Interface specific options:
 
 <descrip>
 	<tag>metric <m/num/</tag>
-	This option specifies the metric of the interface. Valid
+	This option specifies the metric of the interface. When a route is
+	received from the interface, its metric is increased by this value
+	before further processing. Valid values are 1-255, but values higher
+	than infinity has no further meaning. Default: 1.
+
+	<tag>mode multicast|broadcast</tag>
+	This option selects the mode for RIP to use on the interface. The
+	default is multicast mode for RIPv2 and broadcast mode for RIPv1.
+	RIPng always uses the multicast mode.
+
+	<tag>passive <m/switch/</tag>
+	Passive interfaces receive routing updates but do not transmit any
+	messages. Default: no.
+
+	<tag>address <m/ip/</tag>
+	This option specifies a destination address used for multicast or
+	broadcast messages, the default is the official RIP (224.0.0.9) or RIPng
+	(ff02::9) multicast address, or an appropriate broadcast address in the
+	broadcast mode.
+
+	<tag>port <m/number/</tag>
+	This option selects an UDP port to operate on, the default is the
+	official RIP (520) or RIPng (521) port.
+
+	<tag>version 1|2</tag>
+	This option selects the version of RIP used on the interface. For RIPv1,
+	automatic subnet aggregation is not implemented, only classful network
+	routes and host routes are propagated. Note that BIRD allows RIPv1 to be
+	configured with features that are defined for RIPv2 only, like
+	authentication or using multicast sockets. The default is RIPv2 for IPv4
+	RIP, the option is not supported for RIPng, as no further versions are
+	defined.
+
+	<tag>split horizon <m/switch/</tag>
+	Split horizon is a scheme for preventing routing loops. When split
+	horizon is active, routes are not regularly propagated back to the
+	interface from which they were received. They are either not propagated
+	back at all (plain split horizon) or propagated back with an infinity
+	metric (split horizon with poisoned reverse). Therefore, other routers
+	on the interface will not consider the router as a part of an
+	independent path to the destination of the route. Default: yes.
+
+	<tag>poison reverse <m/switch/</tag>
+	When split horizon is active, this option specifies whether the poisoned
+	reverse variant (propagating routes back with an infinity metric) is
+	used. The poisoned reverse has some advantages in faster convergence,
+	but uses more network traffic. Default: yes.
+
+	<tag>check zero <m/switch/</tag>
+	Received RIPv1 packets with non-zero values in reserved fields should
+	be discarded. This option specifies whether the check is performed or
+	such packets are just processed as usual. Default: yes.
+
+	<tag>update time <m/number/</tag>
+	Specifies the number of seconds between periodic updates. A lower number
+	will mean faster convergence but bigger network load. Default: 30.
+
+	<tag>timeout time <m/number/</tag>
+	Specifies the time interval (in seconds) between the last received route
+	announcement and the route expiration. After that, the network is
+	considered unreachable, but still is propagated with infinity distance.
+	Default: 180.
+
+	<tag>garbage time <m/number/</tag>
+	Specifies the time interval (in seconds) between the route expiration
+	and the removal of the unreachable network entry. The garbage interval,
+	when a route with infinity metric is propagated, is used for both
+	internal (after expiration) and external (after withdrawal) routes.
+	Default: 120.
+
+	<tag>ecmp weight <m/number/</tag>
+	When ECMP (multipath) routes are allowed, this value specifies a
+	relative weight used for nexthops going through the iface. Valid
+	values are 1-256. Default value is 1.
+
+	<tag>authentication none|plaintext|cryptographic</tag>
+	Selects authentication method to be used. <cf/none/ means that packets
+	are not authenticated at all, <cf/plaintext/ means that a plaintext
+	password is embedded into each packet, and <cf/cryptographic/ means that
+	packets are authenticated using a MD5 cryptographic hash. If you set
+	authentication to not-none, it is a good idea to add <cf>password</cf>
+	section. Default: none.
 
-	<tag>mode multicast|broadcast|quiet|nolisten|version1</tag>
-	This option selects the mode for RIP to use on the interface. If nothing
-	is specified, RIP runs in multicast mode. <cf/version1/ is currently
-	equivalent to <cf/broadcast/, and it makes RIP talk to a broadcast
-	address even through multicast mode is possible. <cf/quiet/ option means
-	that RIP will not transmit any periodic messages to this interface and
-	<cf/nolisten/ means that RIP will send to this interface butnot listen
-	to it.
+	<tag>password "<m/text/"</tag>
+	Specifies a password used for authentication. See <ref id="dsc-pass"
+	name="password"> common option for detailed description.
 
 	<tag>ttl security [<m/switch/ | tx only]</tag>
 	TTL security is a feature that protects routing protocols from remote
@@ -3309,43 +3424,31 @@ following ones:
 	compatibility with neighbors regardless of whether they use ttl
 	security.
 
-	Note that for RIPng, TTL security is a standard behavior (required by
-	RFC 2080), but BIRD uses <cf/tx only/ by default, for compatibility with
-	older versions. For IPv4 RIP, default value is no.
+	For RIPng, TTL security is a standard behavior (required by RFC 2080)
+	and therefore default value is yes. For IPv4 RIP, default value is no.
 
-	<tag>tx class|dscp|priority <m/num/</tag>
+	<tag>tx class|dscp|priority <m/number/</tag>
 	These options specify the ToS/DiffServ/Traffic class/Priority of the
 	outgoing RIP packets. See <ref id="dsc-prio" name="tx class"> common
 	option for detailed description.
-</descrip>
 
-<p>The following options generally override behavior specified in RFC. If you
-use any of these options, BIRD will no longer be RFC-compliant, which means it
-will not be able to talk to anything other than equally configured BIRD. I have
-warned you.
+	<tag>rx buffer <m/number/</tag>
+	This option specifies the size of buffers used for packet processing.
+	The buffer size should be bigger than maximal size of received packets.
+	The default value is 532 for IPv4 RIP and interface MTU value for RIPng.
 
-<descrip>
-	<tag>port <M>number</M></tag>
-	Selects IP port to operate on, default 520. (This is useful when testing
-	BIRD, if you set this to an address &gt;1024, you will not need to run
-	bird with UID==0).
+	<tag>tx length <m/number/</tag>
+	This option specifies the maximum length of generated RIP packets. To
+	avoid IP fragmentation, it should not exceed the interface MTU value.
+	The default value is 532 for IPv4 RIP and interface MTU value for RIPng.
 
-	<tag>infinity <M>number</M></tag>
-	Selects the value of infinity, default is 16. Bigger values will make
-	protocol convergence even slower.
-
-	<tag>period <M>number</M></tag>
-	Specifies the number of seconds between periodic updates. Default is 30
-	seconds. A lower number will mean faster convergence but bigger network
-	load. Do not use values lower than 12.
-
-	<tag>timeout time <M>number</M></tag>
-	Specifies how old route has to be to be considered unreachable.
-	Default is 4*<cf/period/.
-
-	<tag>garbage time <M>number</M></tag>
-	Specifies how old route has to be to be discarded. Default is
-	10*<cf/period/.
+	<tag>check link <m/switch/</tag>
+	If set, the hardware link state (as reported by OS) is taken into
+	consideration. When the link disappears (e.g. an ethernet cable is
+	unplugged), neighbors are immediately considered unreachable and all
+	routes received from them are withdrawn. It is possible that some
+	hardware drivers or platforms do not implement this feature. Default:
+	no.
 </descrip>
 
 <sect1>Attributes
@@ -3356,27 +3459,26 @@ warned you.
 	<tag>int <cf/rip_metric/</tag>
 	RIP metric of the route (ranging from 0 to <cf/infinity/).  When routes
 	from different RIP instances are available and all of them have the same
-	preference, BIRD prefers the route with lowest <cf/rip_metric/. When
-	importing a non-RIP route, the metric defaults to 5.
+	preference, BIRD prefers the route with lowest <cf/rip_metric/. When a
+	non-RIP route is exported to RIP, the default metric is 1.
 
 	<tag>int <cf/rip_tag/</tag>
 	RIP route tag: a 16-bit number which can be used to carry additional
 	information with the route (for example, an originating AS number in
-	case of external routes). When importing a non-RIP route, the tag
-	defaults to 0.
+	case of external routes). When a non-RIP route is exported to RIP, the
+	default tag is 0.
 </descrip>
 
 <sect1>Example
 
 <p><code>
-protocol rip MyRIP_test {
+protocol rip {
         debug all;
         port 1520;
         period 12;
         garbage time 60;
         interface "eth0" { metric 3; mode multicast; };
 	interface "eth*" { metric 2; mode broadcast; };
-        honor neighbor;
         authentication none;
         import filter { print "importing"; accept; };
         export filter { print "exporting"; accept; };
diff --git a/doc/reply_codes b/doc/reply_codes
index cd5f2620..79a7eb92 100644
--- a/doc/reply_codes
+++ b/doc/reply_codes
@@ -55,6 +55,8 @@ Reply codes of BIRD command-line interface
 1018	Show memory
 1019	Show ROA list
 1020	Show BFD sessions
+1021	Show RIP interface
+1022	Show RIP neighbors
 
 8000	Reply too long
 8001	Route not found
diff --git a/lib/ip.c b/lib/ip.c
index e1bfba49..3dc8919a 100644
--- a/lib/ip.c
+++ b/lib/ip.c
@@ -364,7 +364,9 @@ ip4_class_mask(ip4_addr ad)
 {
   u32 m, a = _I(ad);
 
-  if (a < 0x80000000)
+  if (a == 0x00000000)
+    m = 0x00000000;
+  else if (a < 0x80000000)
     m = 0xff000000;
   else if (a < 0xc0000000)
     m = 0xffff0000;
diff --git a/lib/ip.h b/lib/ip.h
index 90bb7f8a..9ac5798a 100644
--- a/lib/ip.h
+++ b/lib/ip.h
@@ -15,8 +15,11 @@
 #include "lib/unaligned.h"
 
 
+#define IP4_ALL_NODES		ipa_build4(224, 0, 0, 1)
+#define IP4_ALL_ROUTERS		ipa_build4(224, 0, 0, 2)
 #define IP4_OSPF_ALL_ROUTERS	ipa_build4(224, 0, 0, 5)
 #define IP4_OSPF_DES_ROUTERS	ipa_build4(224, 0, 0, 6)
+#define IP4_RIP_ROUTERS		ipa_build4(224, 0, 0, 9)
 
 #define IP6_ALL_NODES		ipa_build6(0xFF020000, 0, 0, 1)
 #define IP6_ALL_ROUTERS		ipa_build6(0xFF020000, 0, 0, 2)
@@ -32,6 +35,10 @@
 
 #define IP_PREC_INTERNET_CONTROL 0xc0
 
+#define IP4_HEADER_LENGTH	20
+#define IP6_HEADER_LENGTH	40
+#define UDP_HEADER_LENGTH	8
+
 
 #ifdef IPV6
 #define MAX_PREFIX_LENGTH 128
diff --git a/nest/password.c b/nest/password.c
index 21e42e0e..91aaa418 100644
--- a/nest/password.c
+++ b/nest/password.c
@@ -51,3 +51,18 @@ password_find_by_id(list *l, int id)
   return NULL;
 }
 
+struct password_item *
+password_find_by_value(list *l, char *pass, uint size)
+{
+  struct password_item *pi;
+
+  if (!l)
+    return NULL;
+
+  WALK_LIST(pi, *l)
+    if (password_verify(pi, pass, size) && (pi->accfrom <= now_real) && (now_real < pi->accto))
+      return pi;
+
+  return NULL;
+}
+
diff --git a/nest/password.h b/nest/password.h
index cd120d70..1d9de53c 100644
--- a/nest/password.h
+++ b/nest/password.h
@@ -11,8 +11,6 @@
 #define PASSWORD_H
 #include "lib/timer.h"
 
-#define MD5_AUTH_SIZE 16
-
 struct password_item {
   node n;
   char *password;
@@ -24,6 +22,7 @@ extern struct password_item *last_password_item;
 
 struct password_item *password_find(list *l, int first_fit);
 struct password_item *password_find_by_id(list *l, int id);
+struct password_item *password_find_by_value(list *l, char *pass, uint size);
 
 static inline int password_verify(struct password_item *p1, char *p2, uint size)
 {
diff --git a/nest/route.h b/nest/route.h
index 6067526d..285fb372 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -75,6 +75,8 @@ void fib_check(struct fib *);		/* Consistency check for debugging */
 void fit_init(struct fib_iterator *, struct fib *); /* Internal functions, don't call */
 struct fib_node *fit_get(struct fib *, struct fib_iterator *);
 void fit_put(struct fib_iterator *, struct fib_node *);
+void fit_put_next(struct fib *f, struct fib_iterator *i, struct fib_node *n, uint hpos);
+
 
 #define FIB_WALK(fib, z) do {					\
 	struct fib_node *z, **ff = (fib)->hash_table;		\
@@ -103,6 +105,11 @@ void fit_put(struct fib_iterator *, struct fib_node *);
 
 #define FIB_ITERATE_PUT(it, z) fit_put(it, z)
 
+#define FIB_ITERATE_PUT_NEXT(it, fib, z) fit_put_next(fib, it, z, hpos)
+
+#define FIB_ITERATE_UNLINK(it, fib) fit_get(fib, it)
+
+
 /*
  *	Master Routing Tables. Generally speaking, each of them contains a FIB
  *	with each entry pointing to a list of route entries representing routes
@@ -196,10 +203,9 @@ typedef struct rte {
   union {				/* Protocol-dependent data (metrics etc.) */
 #ifdef CONFIG_RIP
     struct {
-      node garbage;			/* List for garbage collection */
-      byte metric;			/* RIP metric */
+      struct iface *from;		/* Incoming iface */
+      u8 metric;			/* RIP metric */
       u16 tag;				/* External route tag */
-      struct rip_entry *entry;
     } rip;
 #endif
 #ifdef CONFIG_OSPF
diff --git a/nest/rt-fib.c b/nest/rt-fib.c
index aa5e2357..a73de1fd 100644
--- a/nest/rt-fib.c
+++ b/nest/rt-fib.c
@@ -430,6 +430,25 @@ fit_put(struct fib_iterator *i, struct fib_node *n)
   i->prev = (struct fib_iterator *) n;
 }
 
+void
+fit_put_next(struct fib *f, struct fib_iterator *i, struct fib_node *n, uint hpos)
+{
+  if (n = n->next)
+    goto found;
+
+  while (++hpos < f->hash_size)
+    if (n = f->hash_table[hpos])
+      goto found;
+
+  /* We are at the end */
+  i->prev = i->next = NULL;
+  i->node = NULL;
+  return;
+
+found:
+  fit_put(i, n);
+}
+
 #ifdef DEBUGGING
 
 /**
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 9e2c4e0d..b39f2a69 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -888,12 +888,6 @@ rte_recalculate(struct announce_hook *ah, net *net, rte *new, struct rte_src *sr
 		}
 
 	      rte_free_quick(new);
-#ifdef CONFIG_RIP
-	      /* lastmod is used internally by RIP as the last time
-		 when the route was received. */
-	      if (src->proto->proto == &proto_rip)
-		old->lastmod = now;
-#endif
 	      return;
 	    }
 	  *k = old->next;
diff --git a/proto/ospf/packet.c b/proto/ospf/packet.c
index fb63e61c..65842037 100644
--- a/proto/ospf/packet.c
+++ b/proto/ospf/packet.c
@@ -223,7 +223,7 @@ ospf_rx_hook(sock *sk, int len)
     return 1;
 
   DBG("OSPF: RX hook called (iface %s, src %I, dst %I)\n",
-      sk->ifname, sk->faddr, sk->laddr);
+      sk->iface->name, sk->faddr, sk->laddr);
 
   /* Initially, the packet is associated with the 'master' iface */
   struct ospf_iface *ifa = sk->data;
diff --git a/proto/rip/Doc b/proto/rip/Doc
index 2c7f4c8f..561b2153 100644
--- a/proto/rip/Doc
+++ b/proto/rip/Doc
@@ -1,2 +1,2 @@
 S rip.c
-S auth.c
+S packets.c
diff --git a/proto/rip/Makefile b/proto/rip/Makefile
index d03e3a90..d2d3c987 100644
--- a/proto/rip/Makefile
+++ b/proto/rip/Makefile
@@ -1,4 +1,4 @@
-source=rip.c auth.c
+source=rip.c packets.c
 root-rel=../../
 dir-name=proto/rip
 
diff --git a/proto/rip/auth.c b/proto/rip/auth.c
deleted file mode 100644
index 5634547a..00000000
--- a/proto/rip/auth.c
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- *	Rest in pieces - RIP protocol
- *
- *	Copyright (c) 1999 Pavel Machek <pavel@ucw.cz>
- *	Copyright (c) 2004 Ondrej Filip <feela@network.cz>
- *
- *	Bug fixes by Eric Leblond <eleblond@init-sys.com>, April 2003
- * 
- *	Can be freely distributed and used under the terms of the GNU GPL.
- */
-
-#undef LOCAL_DEBUG
-
-#include "nest/bird.h"
-#include "nest/iface.h"
-#include "nest/protocol.h"
-#include "nest/route.h"
-#include "lib/socket.h"
-#include "lib/resource.h"
-#include "lib/lists.h"
-#include "lib/timer.h"
-#include "lib/md5.h"
-#include "lib/string.h"
-
-#include "rip.h"
-
-#define P ((struct rip_proto *) p)
-#define P_CF ((struct rip_proto_config *)p->cf)
-
-#define PACKETLEN(num) (num * sizeof(struct rip_block) + sizeof(struct rip_packet_heading))
-
-/*
- * rip_incoming_authentication - check authentication of incomming packet and return 1 if there's problem.
- */
-int
-rip_incoming_authentication( struct proto *p, struct rip_block_auth *block, struct rip_packet *packet, int num, ip_addr whotoldme )
-{
-  DBG( "Incoming authentication: " );
-  switch (ntohs(block->authtype)) {	/* Authentication type */
-  case AT_PLAINTEXT: 
-    {
-      struct password_item *passwd = password_find(P_CF->passwords, 1);
-      DBG( "Plaintext passwd" );
-      if (!passwd) {
-	log( L_AUTH "No passwords set and password authentication came" );
-	return 1;
-      }
-      if (strncmp( (char *) (&block->packetlen), passwd->password, 16)) {
-	log( L_AUTH "Passwd authentication failed!" );
-	DBG( "Expected %s, got %.16s\n", passwd->password, &block->packetlen );
-	return 1;
-      }
-    }
-    break;
-  case AT_MD5:
-    DBG( "md5 password" );
-    {
-      struct password_item *pass = NULL, *ptmp;
-      struct rip_md5_tail *tail;
-      struct MD5Context ctxt;
-      char md5sum_packet[16];
-      char md5sum_computed[16];
-      struct neighbor *neigh = neigh_find(p, &whotoldme, 0);
-      list *l = P_CF->passwords;
-
-      if (ntohs(block->packetlen) != PACKETLEN(num) - sizeof(struct rip_md5_tail) ) {
-	log( L_ERR "Packet length in MD5 does not match computed value" );
-	return 1;
-      }
-
-      tail = (struct rip_md5_tail *) ((char *) packet + (ntohs(block->packetlen) ));
-      if ((tail->mustbeFFFF != 0xffff) || (tail->mustbe0001 != 0x0100)) {
-	log( L_ERR "MD5 tail signature is not there" );
-	return 1;
-      }
-
-      WALK_LIST(ptmp, *l)
-      {
-        if (block->keyid != ptmp->id) continue;
-        if ((ptmp->genfrom > now_real) || (ptmp->gento < now_real)) continue;
-        pass = ptmp;
-        break;
-      }
-
-      if(!pass) return 1;
-
-      if (!neigh) {
-        log( L_AUTH "Non-neighbour MD5 checksummed packet?" );
-      } else {
-	if (neigh->aux > block->seq) {
-	  log( L_AUTH "MD5 protected packet with lower numbers" );
-	  return 1;
-        }
-	neigh->aux = block->seq;
-      }
-
-      memcpy(md5sum_packet, tail->md5, 16);
-      strncpy(tail->md5, pass->password, 16);
-
-      MD5Init(&ctxt);
-      MD5Update(&ctxt, (char *) packet, ntohs(block->packetlen) +  sizeof(struct rip_block_auth) );
-      MD5Final(md5sum_computed, &ctxt);
-      if (memcmp(md5sum_packet, md5sum_computed, 16))
-        return 1;
-    }
-  }
-    
-  return 0;
-}
-
-/*
- * rip_outgoing_authentication - append authentication information to the packet.
- * %num: number of rip_blocks already in packets. This function returns size of packet to send.
- */
-int
-rip_outgoing_authentication( struct proto *p, struct rip_block_auth *block, struct rip_packet *packet, int num )
-{
-  struct password_item *passwd = password_find(P_CF->passwords, 1);
-
-  if (!P_CF->authtype)
-    return PACKETLEN(num);
-
-  DBG( "Outgoing authentication: " );
-
-  if (!passwd) {
-    log( L_ERR "No suitable password found for authentication" );
-    return PACKETLEN(num);
-  }
-
-  block->authtype = htons(P_CF->authtype);
-  block->mustbeFFFF = 0xffff;
-  switch (P_CF->authtype) {
-  case AT_PLAINTEXT:
-    strncpy( (char *) (&block->packetlen), passwd->password, 16);
-    return PACKETLEN(num);
-  case AT_MD5:
-    {
-      struct rip_md5_tail *tail;
-      struct MD5Context ctxt;
-      static u32 sequence = 0;
-
-      if (num > PACKET_MD5_MAX)
-	bug(  "We can not add MD5 authentication to this long packet" );
-
-      /* need to preset the sequence number to a sane value */
-      if (!sequence)
-	sequence = (u32) time(NULL);
-
-      block->keyid = passwd->id;
-      block->authlen = sizeof(struct rip_block_auth);
-      block->seq = sequence++;
-      block->zero0 = 0;
-      block->zero1 = 0;
-      block->packetlen = htons(PACKETLEN(num));
-      tail = (struct rip_md5_tail *) ((char *) packet + PACKETLEN(num) );
-      tail->mustbeFFFF = 0xffff;
-      tail->mustbe0001 = 0x0100;
-
-      strncpy(tail->md5, passwd->password, 16);
-      MD5Init(&ctxt);
-      MD5Update(&ctxt, (char *) packet, PACKETLEN(num) + sizeof(struct  rip_md5_tail));
-      MD5Final(tail->md5, &ctxt);
-      return PACKETLEN(num) + block->authlen;
-    }
-  default:
-    bug( "Unknown authtype in outgoing authentication?" );
-  }
-}
diff --git a/proto/rip/config.Y b/proto/rip/config.Y
index b2b99095..29ea7eb1 100644
--- a/proto/rip/config.Y
+++ b/proto/rip/config.Y
@@ -1,17 +1,14 @@
 /*
  *	BIRD -- RIP Configuration
  *
+ *	(c) 1998--1999 Pavel Machek <pavel@ucw.cz>
+ *	(c) 2004--2013 Ondrej Filip <feela@network.cz>
+ *	(c) 2009--2015 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2009--2015 CZ.NIC z.s.p.o.
+ *
  *	Can be freely distributed and used under the terms of the GNU GPL.
  */
 
-/*
-To add:
-
-version1 switch
-
-*/
-
-
 CF_HDR
 
 #include "proto/rip/rip.h"
@@ -19,76 +16,141 @@ CF_HDR
 
 CF_DEFINES
 
-#define RIP_CFG ((struct rip_proto_config *) this_proto)
-#define RIP_IPATT ((struct rip_patt *) this_ipatt)
+#define RIP_CFG ((struct rip_config *) this_proto)
+#define RIP_IFACE ((struct rip_iface_config *) this_ipatt)
+
+static inline int rip_cfg_is_v2(void) { return RIP_CFG->rip2; }
+static inline int rip_cfg_is_ng(void) { return ! RIP_CFG->rip2; }
+
+static inline void
+rip_check_auth(void)
+{
+  if (rip_cfg_is_ng())
+    cf_error("Authentication not supported in RIPng");
+}
 
-#ifdef IPV6
-#define RIP_DEFAULT_TTL_SECURITY 2
-#else
-#define RIP_DEFAULT_TTL_SECURITY 0
-#endif
 
 CF_DECLS
 
-CF_KEYWORDS(RIP, INFINITY, METRIC, PORT, PERIOD, GARBAGE, TIMEOUT,
-	    MODE, BROADCAST, MULTICAST, QUIET, NOLISTEN, VERSION1, 
-	    AUTHENTICATION, NONE, PLAINTEXT, MD5, TTL, SECURITY,
-	    HONOR, NEVER, NEIGHBOR, ALWAYS, TX, PRIORITY, ONLY,
-	    RIP_METRIC, RIP_TAG)
+CF_KEYWORDS(RIP, ECMP, LIMIT, WEIGHT, INFINITY, METRIC, UPDATE, TIMEOUT,
+	    GARBAGE, PORT, ADDRESS, MODE, BROADCAST, MULTICAST, PASSIVE,
+	    VERSION, SPLIT, HORIZON, POISON, REVERSE, CHECK, ZERO, TIME, BFD,
+	    AUTHENTICATION, NONE, PLAINTEXT, CRYPTOGRAPHIC, MD5, TTL, SECURITY,
+	    RX, TX, BUFFER, LENGTH, PRIORITY, ONLY, LINK, RIP_METRIC, RIP_TAG)
 
-%type <i> rip_mode rip_auth
+%type <i> rip_auth
 
 CF_GRAMMAR
 
-CF_ADDTO(proto, rip_cfg '}' { RIP_CFG->passwords = get_passwords(); } )
+CF_ADDTO(proto, rip_proto)
 
-rip_cfg_start: proto_start RIP {
-     this_proto = proto_config_new(&proto_rip, $1);
-     rip_init_config(RIP_CFG);
-   }
- ;
+rip_proto_start: proto_start RIP
+{
+  this_proto = proto_config_new(&proto_rip, $1);
+  init_list(&RIP_CFG->patt_list);
 
-rip_cfg:
-   rip_cfg_start proto_name '{'
- | rip_cfg proto_item ';'
- | rip_cfg INFINITY expr ';'	{ RIP_CFG->infinity = $3; }
- | rip_cfg PORT expr ';'	{ RIP_CFG->port = $3; }
- | rip_cfg PERIOD expr ';'	{ RIP_CFG->period = $3; }
- | rip_cfg GARBAGE TIME expr ';' { RIP_CFG->garbage_time = $4; }
- | rip_cfg TIMEOUT TIME expr ';' { RIP_CFG->timeout_time = $4; }
- | rip_cfg AUTHENTICATION rip_auth ';' {RIP_CFG->authtype = $3; }
- | rip_cfg password_list ';'
- | rip_cfg HONOR ALWAYS ';'    { RIP_CFG->honor = HO_ALWAYS; }
- | rip_cfg HONOR NEIGHBOR ';'    { RIP_CFG->honor = HO_NEIGHBOR; }
- | rip_cfg HONOR NEVER ';'    { RIP_CFG->honor = HO_NEVER; }
- | rip_cfg INTERFACE rip_iface ';'
- ;
+  RIP_CFG->rip2 = RIP_IS_V2;
+  RIP_CFG->infinity = RIP_DEFAULT_INFINITY;
 
-rip_auth:
-   PLAINTEXT { $$=AT_PLAINTEXT; }
- | MD5 { $$=AT_MD5; }
- | NONE { $$=AT_NONE; }
- ;
+  RIP_CFG->min_timeout_time = 60;
+  RIP_CFG->max_garbage_time = 60;
+};
 
+rip_proto_item:
+   proto_item
+ | ECMP bool		{ RIP_CFG->ecmp = $2 ? RIP_DEFAULT_ECMP_LIMIT : 0; }
+ | ECMP bool LIMIT expr	{ RIP_CFG->ecmp = $2 ? $4 : 0; if ($4 < 0) cf_error("ECMP limit cannot be negative"); }
+ | INFINITY expr	{ RIP_CFG->infinity = $2; }
+ | INTERFACE rip_iface
+ ;
 
-rip_mode: 
-    BROADCAST { $$=IM_BROADCAST; }
-  | MULTICAST { $$=0; }
-  | QUIET     { $$=IM_QUIET; }
-  | NOLISTEN  { $$=IM_NOLISTEN; }
-  | VERSION1  { $$=IM_VERSION1 | IM_BROADCAST; }
+rip_proto_opts:
+   /* empty */
+ | rip_proto_opts rip_proto_item ';'
  ;
 
+rip_proto:
+   rip_proto_start proto_name '{' rip_proto_opts '}';
+
+
+rip_iface_start:
+{
+  this_ipatt = cfg_allocz(sizeof(struct rip_iface_config));
+  add_tail(&RIP_CFG->patt_list, NODE this_ipatt);
+  init_list(&this_ipatt->ipn_list);
+  reset_passwords();
+
+  RIP_IFACE->metric = 1;
+  RIP_IFACE->port = rip_cfg_is_v2() ? RIP_PORT : RIP_NG_PORT;
+  RIP_IFACE->version = rip_cfg_is_v2() ? RIP_V2 : RIP_V1;
+  RIP_IFACE->split_horizon = 1;
+  RIP_IFACE->poison_reverse = 1;
+  RIP_IFACE->check_zero = 1;
+  RIP_IFACE->ttl_security = rip_cfg_is_v2() ? 0 : 1;
+  RIP_IFACE->rx_buffer = rip_cfg_is_v2() ? RIP_MAX_PKT_LENGTH : 0;
+  RIP_IFACE->tx_length = rip_cfg_is_v2() ? RIP_MAX_PKT_LENGTH : 0;
+  RIP_IFACE->tx_tos = IP_PREC_INTERNET_CONTROL;
+  RIP_IFACE->tx_priority = sk_priority_control;
+  RIP_IFACE->update_time = RIP_DEFAULT_UPDATE_TIME;
+  RIP_IFACE->timeout_time = RIP_DEFAULT_TIMEOUT_TIME;
+  RIP_IFACE->garbage_time = RIP_DEFAULT_GARBAGE_TIME;
+};
+
+rip_iface_finish:
+{
+  RIP_IFACE->passwords = get_passwords();
+
+  if (!RIP_IFACE->auth_type != !RIP_IFACE->passwords)
+    log(L_WARN "Authentication and password options should be used together");
+
+  /* Default mode is broadcast for RIPv1, multicast for RIPv2 and RIPng */
+  if (!RIP_IFACE->mode)
+    RIP_IFACE->mode = (rip_cfg_is_v2() && (RIP_IFACE->version == RIP_V1)) ?
+      RIP_IM_BROADCAST : RIP_IM_MULTICAST;
+
+  RIP_CFG->min_timeout_time = MIN_(RIP_CFG->min_timeout_time, RIP_IFACE->timeout_time);
+  RIP_CFG->max_garbage_time = MAX_(RIP_CFG->max_garbage_time, RIP_IFACE->garbage_time);
+};
+
 rip_iface_item:
- | METRIC expr { RIP_IPATT->metric = $2; }
- | MODE rip_mode { RIP_IPATT->mode |= $2; }
- | TX tos { RIP_IPATT->tx_tos = $2; }
- | TX PRIORITY expr { RIP_IPATT->tx_priority = $3; }
- | TTL SECURITY bool { RIP_IPATT->ttl_security = $3; }
- | TTL SECURITY TX ONLY { RIP_IPATT->ttl_security = 2; }
+   METRIC expr		{ RIP_IFACE->metric = $2; if (($2<1) || ($2>255)) cf_error("Metric must be in range 1-255"); }
+ | MODE MULTICAST	{ RIP_IFACE->mode = RIP_IM_MULTICAST; }
+ | MODE BROADCAST	{ RIP_IFACE->mode = RIP_IM_BROADCAST; if (rip_cfg_is_ng()) cf_error("Broadcast not supported in RIPng"); }
+ | PASSIVE bool		{ RIP_IFACE->passive = $2; }
+ | ADDRESS ipa		{ RIP_IFACE->address = $2; }
+ | PORT expr		{ RIP_IFACE->port = $2; if (($2<1) || ($2>65535)) cf_error("Invalid port number"); }
+ | VERSION expr		{ RIP_IFACE->version = $2;
+			  if (rip_cfg_is_ng()) cf_error("Version not supported in RIPng");
+			  if (($2 != RIP_V1) && ($2 != RIP_V2)) cf_error("Unsupported version");
+			}
+ | VERSION ONLY bool	{ RIP_IFACE->version_only = $3; }
+ | SPLIT HORIZON bool	{ RIP_IFACE->split_horizon = $3; }
+ | POISON REVERSE bool	{ RIP_IFACE->poison_reverse = $3; }
+ | CHECK ZERO bool	{ RIP_IFACE->check_zero = $3; }
+ | UPDATE TIME expr	{ RIP_IFACE->update_time = $3; if ($3<=0) cf_error("Update time must be positive"); }
+ | TIMEOUT TIME expr	{ RIP_IFACE->timeout_time = $3; if ($3<=0) cf_error("Timeout time must be positive"); }
+ | GARBAGE TIME expr	{ RIP_IFACE->garbage_time = $3; if ($3<=0) cf_error("Garbage time must be positive"); }
+ | ECMP WEIGHT expr	{ RIP_IFACE->ecmp_weight = $3 - 1; if (($3<1) || ($3>256)) cf_error("ECMP weight must be in range 1-256"); }
+ | RX BUFFER expr	{ RIP_IFACE->rx_buffer = $3; if (($3<256) || ($3>65535)) cf_error("TX length must be in range 256-65535"); }
+ | TX LENGTH expr	{ RIP_IFACE->tx_length = $3; if (($3<256) || ($3>65535)) cf_error("TX length must be in range 256-65535"); }
+ | TX tos		{ RIP_IFACE->tx_tos = $2; }
+ | TX PRIORITY expr	{ RIP_IFACE->tx_priority = $3; }
+ | TTL SECURITY bool	{ RIP_IFACE->ttl_security = $3; }
+ | TTL SECURITY TX ONLY	{ RIP_IFACE->ttl_security = 2; }
+ | CHECK LINK bool	{ RIP_IFACE->check_link = $3; }
+ | BFD bool		{ RIP_IFACE->bfd = $2; cf_check_bfd($2); }
+ | AUTHENTICATION rip_auth { RIP_IFACE->auth_type = $2; if ($2) rip_check_auth(); }
+ | password_list	{ rip_check_auth(); }
+;
+
+rip_auth:
+   NONE			{ $$ = RIP_AUTH_NONE; }
+ | PLAINTEXT		{ $$ = RIP_AUTH_PLAIN; }
+ | CRYPTOGRAPHIC	{ $$ = RIP_AUTH_CRYPTO; }
+ | MD5			{ $$ = RIP_AUTH_CRYPTO; }
  ;
 
-rip_iface_opts: 
+rip_iface_opts:
    /* empty */
  | rip_iface_opts rip_iface_item ';'
  ;
@@ -98,25 +160,22 @@ rip_iface_opt_list:
  | '{' rip_iface_opts '}'
  ;
 
-rip_iface_init:
-   /* EMPTY */ {
-     this_ipatt = cfg_allocz(sizeof(struct rip_patt));
-     add_tail(&RIP_CFG->iface_list, NODE this_ipatt);
-     init_list(&this_ipatt->ipn_list);
-     RIP_IPATT->metric = 1;
-     RIP_IPATT->tx_tos = IP_PREC_INTERNET_CONTROL;
-     RIP_IPATT->tx_priority = sk_priority_control;
-     RIP_IPATT->ttl_security = RIP_DEFAULT_TTL_SECURITY;
-   }
- ;
+rip_iface:
+  rip_iface_start iface_patt_list_nopx rip_iface_opt_list rip_iface_finish;
 
-rip_iface:	/* TODO: switch to iface_patt_list_nopx */
-   rip_iface_init iface_patt_list rip_iface_opt_list
- ;
 
 CF_ADDTO(dynamic_attr, RIP_METRIC { $$ = f_new_dynamic_attr(EAF_TYPE_INT | EAF_TEMP, T_INT, EA_RIP_METRIC); })
 CF_ADDTO(dynamic_attr, RIP_TAG { $$ = f_new_dynamic_attr(EAF_TYPE_INT | EAF_TEMP, T_INT, EA_RIP_TAG); })
 
+CF_CLI_HELP(SHOW RIP, ..., [[Show information about RIP protocol]]);
+
+CF_CLI(SHOW RIP INTERFACES, optsym opttext, [<name>] [\"<interface>\"], [[Show information about RIP interfaces]])
+{ rip_show_interfaces(proto_get_named($4, &proto_rip), $5); };
+
+CF_CLI(SHOW RIP NEIGHBORS, optsym opttext, [<name>] [\"<interface>\"], [[Show information about RIP neighbors]])
+{ rip_show_neighbors(proto_get_named($4, &proto_rip), $5); };
+
+
 CF_CODE
 
 CF_END
diff --git a/proto/rip/packets.c b/proto/rip/packets.c
new file mode 100644
index 00000000..be20734f
--- /dev/null
+++ b/proto/rip/packets.c
@@ -0,0 +1,772 @@
+/*
+ *	BIRD -- Routing Information Protocol (RIP)
+ *
+ *	(c) 1998--1999 Pavel Machek <pavel@ucw.cz>
+ *	(c) 2004--2013 Ondrej Filip <feela@network.cz>
+ *	(c) 2009--2015 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2009--2015 CZ.NIC z.s.p.o.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#include "rip.h"
+#include "lib/md5.h"
+
+
+#define RIP_CMD_REQUEST		1	/* want info */
+#define RIP_CMD_RESPONSE	2	/* responding to request */
+
+#define RIP_BLOCK_LENGTH	20
+
+#define RIP_PASSWD_LENGTH	16
+#define RIP_MD5_LENGTH		16
+
+#define RIP_AF_IPV4		2
+#define RIP_AF_AUTH		0xffff
+
+
+/* RIP packet header */
+struct rip_packet
+{
+  u8 command;
+  u8 version;
+  u16 unused;
+};
+
+/* RTE block for RIPv2 */
+struct rip_block_v2
+{
+  u16 family;
+  u16 tag;
+  ip4_addr network;
+  ip4_addr netmask;
+  ip4_addr next_hop;
+  u32 metric;
+};
+
+/* RTE block for RIPng */
+struct rip_block_ng
+{
+  ip6_addr prefix;
+  u16 tag;
+  u8 pxlen;
+  u8 metric;
+};
+
+/* Authentication block for RIPv2 */
+struct rip_block_auth
+{
+  u16 must_be_ffff;
+  u16 auth_type;
+  char password[0];
+  u16 packet_len;
+  u8 key_id;
+  u8 auth_len;
+  u32 seq_num;
+  u32 unused1;
+  u32 unused2;
+};
+
+/* Authentication tail, RFC 4822 */
+struct rip_auth_tail
+{
+  u16 must_be_ffff;
+  u16 must_be_0001;
+  byte auth_data[];
+};
+
+/* Internal representation of RTE block data */
+struct rip_block
+{
+  ip_addr prefix;
+  int pxlen;
+  u32 metric;
+  u16 tag;
+  u16 no_af;
+  ip_addr next_hop;
+};
+
+
+#define DROP(DSC,VAL) do { err_dsc = DSC; err_val = VAL; goto drop; } while(0)
+#define DROP1(DSC) do { err_dsc = DSC; goto drop; } while(0)
+#define SKIP(DSC) do { err_dsc = DSC; goto skip; } while(0)
+
+#define LOG_PKT(msg, args...) \
+  log_rl(&p->log_pkt_tbf, L_REMOTE "%s: " msg, p->p.name, args)
+
+#define LOG_PKT_AUTH(msg, args...) \
+  log_rl(&p->log_pkt_tbf, L_AUTH "%s: " msg, p->p.name, args)
+
+#define LOG_RTE(msg, args...) \
+  log_rl(&p->log_rte_tbf, L_REMOTE "%s: " msg, p->p.name, args)
+
+
+static inline void * rip_tx_buffer(struct rip_iface *ifa)
+{ return ifa->sk->tbuf; }
+
+static inline uint rip_pkt_hdrlen(struct rip_iface *ifa)
+{ return sizeof(struct rip_packet) + (ifa->cf->auth_type ? RIP_BLOCK_LENGTH : 0); }
+
+static inline void
+rip_put_block(struct rip_proto *p, byte *pos, struct rip_block *rte)
+{
+  if (rip_is_v2(p))
+  {
+    struct rip_block_v2 *block = (void *) pos;
+    block->family = rte->no_af ? 0 : htons(RIP_AF_IPV4);
+    block->tag = htons(rte->tag);
+    block->network = ip4_hton(ipa_to_ip4(rte->prefix));
+    block->netmask = ip4_hton(ip4_mkmask(rte->pxlen));
+    block->next_hop = ip4_hton(ipa_to_ip4(rte->next_hop));
+    block->metric = htonl(rte->metric);
+  }
+  else /* RIPng */
+  {
+    struct rip_block_ng *block = (void *) pos;
+    block->prefix = ip6_hton(ipa_to_ip6(rte->prefix));
+    block->tag = htons(rte->tag);
+    block->pxlen = rte->pxlen;
+    block->metric = rte->metric;
+  }
+}
+
+static inline void
+rip_put_next_hop(struct rip_proto *p, byte *pos, struct rip_block *rte)
+{
+  struct rip_block_ng *block = (void *) pos;
+  block->prefix = ip6_hton(ipa_to_ip6(rte->next_hop));
+  block->tag = 0;
+  block->pxlen = 0;
+  block->metric = 0xff;
+}
+
+static inline int
+rip_get_block(struct rip_proto *p, byte *pos, struct rip_block *rte)
+{
+  if (rip_is_v2(p))
+  {
+    struct rip_block_v2 *block = (void *) pos;
+
+    /* Skip blocks with strange AF, including authentication blocks */
+    if (block->family != (rte->no_af ? 0 : htons(RIP_AF_IPV4)))
+      return 0;
+
+    rte->prefix = ipa_from_ip4(ip4_ntoh(block->network));
+    rte->pxlen = ip4_masklen(ip4_ntoh(block->netmask));
+    rte->metric = ntohl(block->metric);
+    rte->tag = ntohs(block->tag);
+    rte->next_hop = ipa_from_ip4(ip4_ntoh(block->next_hop));
+
+    return 1;
+  }
+  else /* RIPng */
+  {
+    struct rip_block_ng *block = (void *) pos;
+
+    /* Handle and skip next hop blocks */
+    if (block->metric == 0xff)
+    {
+      rte->next_hop = ipa_from_ip6(ip6_ntoh(block->prefix));
+      if (!ipa_is_link_local(rte->next_hop)) rte->next_hop = IPA_NONE;
+      return 0;
+    }
+
+    rte->prefix = ipa_from_ip6(ip6_ntoh(block->prefix));
+    rte->pxlen = block->pxlen;
+    rte->metric = block->metric;
+    rte->tag = ntohs(block->tag);
+    /* rte->next_hop is deliberately kept unmodified */;
+
+    return 1;
+  }
+}
+
+static inline void
+rip_update_csn(struct rip_proto *p UNUSED, struct rip_iface *ifa)
+{
+  /*
+   * We update crypto sequence numbers at the beginning of update session to
+   * avoid issues with packet reordering, so packets inside one update session
+   * have the same CSN. We are using real time, but enforcing monotonicity.
+   */
+  if (ifa->cf->auth_type == RIP_AUTH_CRYPTO)
+    ifa->csn = (ifa->csn < (u32) now_real) ? (u32) now_real : ifa->csn + 1;
+}
+
+static void
+rip_fill_authentication(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint *plen)
+{
+  struct rip_block_auth *auth = (void *) (pkt + 1);
+  struct password_item *pass = password_find(ifa->cf->passwords, 0);
+
+  if (!pass)
+  {
+    /* FIXME: This should not happen */
+    log(L_ERR "%s: No suitable password found for authentication", p->p.name);
+    memset(auth, 0, sizeof(struct rip_block_auth));
+    return;
+  }
+
+  switch (ifa->cf->auth_type)
+  {
+  case RIP_AUTH_PLAIN:
+    auth->must_be_ffff = htons(0xffff);
+    auth->auth_type = htons(RIP_AUTH_PLAIN);
+    strncpy(auth->password, pass->password, RIP_PASSWD_LENGTH);
+    return;
+
+  case RIP_AUTH_CRYPTO:
+    auth->must_be_ffff = htons(0xffff);
+    auth->auth_type = htons(RIP_AUTH_CRYPTO);
+    auth->packet_len = htons(*plen);
+    auth->key_id = pass->id;
+    auth->auth_len = sizeof(struct rip_auth_tail) + RIP_MD5_LENGTH;
+    auth->seq_num = ifa->csn_ready ? htonl(ifa->csn) : 0;
+    auth->unused1 = 0;
+    auth->unused2 = 0;
+    ifa->csn_ready = 1;
+
+    /*
+     * Note that RFC 4822 is unclear whether auth_len should cover whole
+     * authentication trailer or just auth_data length.
+     *
+     * Crypto sequence numbers are increased by sender in rip_update_csn().
+     * First CSN should be zero, this is handled by csn_ready.
+     */
+
+    struct rip_auth_tail *tail = (void *) ((byte *) pkt + *plen);
+    tail->must_be_ffff = htons(0xffff);
+    tail->must_be_0001 = htons(0x0001);
+    strncpy(tail->auth_data, pass->password, RIP_MD5_LENGTH);
+
+    *plen += sizeof(struct rip_auth_tail) + RIP_MD5_LENGTH;
+
+    struct MD5Context ctxt;
+    MD5Init(&ctxt);
+    MD5Update(&ctxt, (byte *) pkt, *plen);
+    MD5Final(tail->auth_data, &ctxt);
+    return;
+
+  default:
+    bug("Unknown authentication type");
+  }
+}
+
+static int
+rip_check_authentication(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint *plen, struct rip_neighbor *n)
+{
+  struct rip_block_auth *auth = (void *) (pkt + 1);
+  struct password_item *pass = NULL;
+  const char *err_dsc = NULL;
+  uint err_val = 0;
+  uint auth_type = 0;
+
+  /* Check for authentication entry */
+  if ((*plen >= (sizeof(struct rip_packet) + sizeof(struct rip_block_auth))) &&
+      (auth->must_be_ffff == htons(0xffff)))
+    auth_type = ntohs(auth->auth_type);
+
+  if (auth_type != ifa->cf->auth_type)
+    DROP("authentication method mismatch", auth_type);
+
+  switch (auth_type)
+  {
+  case RIP_AUTH_NONE:
+    return 1;
+
+  case RIP_AUTH_PLAIN:
+    pass = password_find_by_value(ifa->cf->passwords, auth->password, RIP_PASSWD_LENGTH);
+    if (!pass)
+      DROP1("wrong password");
+
+    return 1;
+
+  case RIP_AUTH_CRYPTO:
+    pass = password_find_by_id(ifa->cf->passwords, auth->key_id);
+    if (!pass)
+      DROP("no suitable password found", auth->key_id);
+
+    uint data_len = ntohs(auth->packet_len);
+    uint auth_len = sizeof(struct rip_auth_tail) + RIP_MD5_LENGTH;
+
+    if (data_len + auth_len != *plen)
+      DROP("packet length mismatch", data_len);
+
+    if ((auth->auth_len != RIP_MD5_LENGTH) && (auth->auth_len != auth_len))
+      DROP("authentication data length mismatch", auth->auth_len);
+
+    struct rip_auth_tail *tail = (void *) ((byte *) pkt + data_len);
+    if ((tail->must_be_ffff != htons(0xffff)) || (tail->must_be_0001 != htons(0x0001)))
+      DROP1("authentication trailer is missing");
+
+    /* Accept higher sequence number, or zero if connectivity is lost */
+    /* FIXME: sequence number must be password/SA specific */
+    u32 rcv_csn = ntohl(auth->seq_num);
+    if ((rcv_csn < n->csn) && (rcv_csn || n->uc))
+    {
+      /* We want to report both new and old CSN */
+      LOG_PKT_AUTH("Authentication failed for %I on %s - "
+		   "lower sequence number (rcv %u, old %u)",
+		   n->nbr->addr, ifa->iface->name, rcv_csn, n->csn);
+      return 0;
+    }
+
+    char received[RIP_MD5_LENGTH];
+    char computed[RIP_MD5_LENGTH];
+
+    memcpy(received, tail->auth_data, RIP_MD5_LENGTH);
+    strncpy(tail->auth_data, pass->password, RIP_MD5_LENGTH);
+
+    struct MD5Context ctxt;
+    MD5Init(&ctxt);
+    MD5Update(&ctxt, (byte *) pkt, *plen);
+    MD5Final(computed, &ctxt);
+
+    if (memcmp(received, computed, RIP_MD5_LENGTH))
+      DROP("wrong MD5 digest", pass->id);
+
+    *plen = data_len;
+    n->csn = rcv_csn;
+
+    return 1;
+  }
+
+drop:
+  LOG_PKT_AUTH("Authentication failed for %I on %s - %s (%u)",
+	       n->nbr->addr, ifa->iface->name, err_dsc, err_val);
+
+  return 0;
+}
+
+static inline int
+rip_send_to(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint plen, ip_addr dst)
+{
+  if (ifa->cf->auth_type)
+    rip_fill_authentication(p, ifa, pkt, &plen);
+
+  return sk_send_to(ifa->sk, plen, dst, 0);
+}
+
+
+void
+rip_send_request(struct rip_proto *p, struct rip_iface *ifa)
+{
+  byte *pos = rip_tx_buffer(ifa);
+
+  struct rip_packet *pkt = (void *) pos;
+  pkt->command = RIP_CMD_REQUEST;
+  pkt->version = ifa->cf->version;
+  pkt->unused = 0;
+  pos += rip_pkt_hdrlen(ifa);
+
+  struct rip_block b = { .no_af = 1, .metric = p->infinity };
+  rip_put_block(p, pos, &b);
+  pos += RIP_BLOCK_LENGTH;
+
+  rip_update_csn(p, ifa);
+
+  TRACE(D_PACKETS, "Sending request via %s", ifa->iface->name);
+  rip_send_to(p, ifa, pkt, pos - (byte *) pkt, ifa->addr);
+}
+
+static void
+rip_receive_request(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint plen, struct rip_neighbor *from)
+{
+  TRACE(D_PACKETS, "Request received from %I on %s", from->nbr->addr, ifa->iface->name);
+
+  byte *pos = (byte *) pkt + rip_pkt_hdrlen(ifa);
+
+  /* We expect one regular block */
+  if (plen != (rip_pkt_hdrlen(ifa) + RIP_BLOCK_LENGTH))
+    return;
+
+  struct rip_block b = { .no_af = 1 };
+
+  if (!rip_get_block(p, pos, &b))
+    return;
+
+  /* Special case - zero prefix, infinity metric */
+  if (ipa_nonzero(b.prefix) || b.pxlen || (b.metric != p->infinity))
+    return;
+
+  /* We do nothing if TX is already active */
+  if (ifa->tx_active)
+  {
+    TRACE(D_EVENTS, "Skipping request from %I on %s, TX is busy", from->nbr->addr, ifa->iface->name);
+    return;
+  }
+
+  if (!ifa->cf->passive)
+    rip_send_table(p, ifa, from->nbr->addr, 0);
+}
+
+
+static int
+rip_send_response(struct rip_proto *p, struct rip_iface *ifa)
+{
+  if (! ifa->tx_active)
+    return 0;
+
+  byte *pos = rip_tx_buffer(ifa);
+  byte *max = rip_tx_buffer(ifa) + ifa->tx_plen -
+    (rip_is_v2(p) ? RIP_BLOCK_LENGTH : 2*RIP_BLOCK_LENGTH);
+  ip_addr last_next_hop = IPA_NONE;
+  int send = 0;
+
+  struct rip_packet *pkt = (void *) pos;
+  pkt->command = RIP_CMD_RESPONSE;
+  pkt->version = ifa->cf->version;
+  pkt->unused = 0;
+  pos += rip_pkt_hdrlen(ifa);
+
+  FIB_ITERATE_START(&p->rtable, &ifa->tx_fit, z)
+  {
+    struct rip_entry *en = (struct rip_entry *) z;
+
+    /* Dummy entries */
+    if (!en->valid)
+      goto next_entry;
+
+    /* Stale entries that should be removed */
+    if ((en->valid == RIP_ENTRY_STALE) &&
+	((en->changed + ifa->cf->garbage_time) <= now))
+      goto next_entry;
+
+    /* Triggered updates */
+    if (en->changed < ifa->tx_changed)
+      goto next_entry;
+
+    /* Not enough space for current entry */
+    if (pos > max)
+    {
+      FIB_ITERATE_PUT(&ifa->tx_fit, z);
+      goto break_loop;
+    }
+
+    struct rip_block rte = {
+      .prefix = en->n.prefix,
+      .pxlen = en->n.pxlen,
+      .metric = en->metric,
+      .tag = en->tag
+    };
+
+    if (en->iface == ifa->iface)
+      rte.next_hop = en->next_hop;
+
+    if (rip_is_v2(p) && (ifa->cf->version == RIP_V1))
+    {
+      /* Skipping subnets (i.e. not hosts, classful networks or default route) */
+      if (ip4_masklen(ip4_class_mask(ipa_to_ip4(en->n.prefix))) != en->n.pxlen)
+	goto next_entry;
+
+      rte.tag = 0;
+      rte.pxlen = 0;
+      rte.next_hop = IPA_NONE;
+    }
+
+    /* Split horizon */
+    if (en->from == ifa->iface && ifa->cf->split_horizon)
+    {
+      if (ifa->cf->poison_reverse)
+      {
+	rte.metric = p->infinity;
+	rte.next_hop = IPA_NONE;
+      }
+      else
+	goto next_entry;
+    }
+
+    // TRACE(D_PACKETS, "    %I/%d -> %I metric %d", rte.prefix, rte.pxlen, rte.next_hop, rte.metric);
+
+    /* RIPng next hop entry */
+    if (rip_is_ng(p) && !ipa_equal(rte.next_hop, last_next_hop))
+    {
+      last_next_hop = rte.next_hop;
+      rip_put_next_hop(p, pos, &rte);
+      pos += RIP_BLOCK_LENGTH;
+    }
+
+    rip_put_block(p, pos, &rte);
+    pos += RIP_BLOCK_LENGTH;
+    send = 1;
+
+  next_entry: ;
+  }
+  FIB_ITERATE_END(z);
+  ifa->tx_active = 0;
+
+  /* Do not send empty packet */
+  if (!send)
+    return 0;
+
+break_loop:
+  TRACE(D_PACKETS, "Sending response via %s", ifa->iface->name);
+  return rip_send_to(p, ifa, pkt, pos - (byte *) pkt, ifa->tx_addr);
+}
+
+/**
+ * rip_send_table - RIP interface timer hook
+ * @p: RIP instance
+ * @ifa: RIP interface
+ * @addr: destination IP address
+ * @changed: time limit for triggered updates
+ *
+ * The function activates an update session and starts sending routing update
+ * packets (using rip_send_response()). The session may be finished during the
+ * call or may continue in rip_tx_hook() until all appropriate routes are
+ * transmitted. Note that there may be at most one active update session per
+ * interface, the function will terminate the old active session before
+ * activating the new one.
+ */
+void
+rip_send_table(struct rip_proto *p, struct rip_iface *ifa, ip_addr addr, bird_clock_t changed)
+{
+  DBG("RIP: Opening TX session to %I on %s\n", dst, ifa->iface->name);
+
+  rip_reset_tx_session(p, ifa);
+
+  ifa->tx_active = 1;
+  ifa->tx_addr = addr;
+  ifa->tx_changed = changed;
+  FIB_ITERATE_INIT(&ifa->tx_fit, &p->rtable);
+
+  rip_update_csn(p, ifa);
+
+  while (rip_send_response(p, ifa) > 0)
+    ;
+}
+
+static void
+rip_tx_hook(sock *sk)
+{
+  struct rip_iface *ifa = sk->data;
+  struct rip_proto *p = ifa->rip;
+
+  DBG("RIP: TX hook called (iface %s, src %I, dst %I)\n",
+      sk->iface->name, sk->saddr, sk->daddr);
+
+  while (rip_send_response(p, ifa) > 0)
+    ;
+}
+
+static void
+rip_err_hook(sock *sk, int err)
+{
+  struct rip_iface *ifa = sk->data;
+  struct rip_proto *p = ifa->rip;
+
+  log(L_ERR "%s: Socket error on %s: %M", p->p.name, ifa->iface->name, err);
+
+  rip_reset_tx_session(p, ifa);
+}
+
+static void
+rip_receive_response(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint plen, struct rip_neighbor *from)
+{
+  struct rip_block rte = {};
+  const char *err_dsc = NULL;
+
+  TRACE(D_PACKETS, "Response received from %I on %s", from->nbr->addr, ifa->iface->name);
+
+  byte *pos = (byte *) pkt + sizeof(struct rip_packet);
+  byte *end = (byte *) pkt + plen;
+
+  for (; pos < end; pos += RIP_BLOCK_LENGTH)
+  {
+    /* Find next regular RTE */
+    if (!rip_get_block(p, pos, &rte))
+      continue;
+
+    int c = ipa_classify_net(rte.prefix);
+    if ((c < 0) || !(c & IADDR_HOST) || ((c & IADDR_SCOPE_MASK) <= SCOPE_LINK))
+      SKIP("invalid prefix");
+
+    if (rip_is_v2(p) && (pkt->version == RIP_V1))
+    {
+      if (ifa->cf->check_zero && (rte.tag || rte.pxlen || ipa_nonzero(rte.next_hop)))
+	SKIP("RIPv1 reserved field is nonzero");
+
+      rte.tag = 0;
+      rte.pxlen = ip4_masklen(ip4_class_mask(ipa_to_ip4(rte.prefix)));
+      rte.next_hop = IPA_NONE;
+    }
+
+    if ((rte.pxlen < 0) || (rte.pxlen > MAX_PREFIX_LENGTH))
+      SKIP("invalid prefix length");
+
+    if (rte.metric > p->infinity)
+      SKIP("invalid metric");
+
+    if (ipa_nonzero(rte.next_hop))
+    {
+      neighbor *nbr = neigh_find2(&p->p, &rte.next_hop, ifa->iface, 0);
+      if (!nbr || (nbr->scope <= 0))
+	rte.next_hop = IPA_NONE;
+    }
+
+    // TRACE(D_PACKETS, "    %I/%d -> %I metric %d", rte.prefix, rte.pxlen, rte.next_hop, rte.metric);
+
+    rte.metric += ifa->cf->metric;
+
+    if (rte.metric < p->infinity)
+    {
+      struct rip_rte new = {
+	.from = from,
+	.next_hop = ipa_nonzero(rte.next_hop) ? rte.next_hop : from->nbr->addr,
+	.metric = rte.metric,
+	.tag = rte.tag,
+	.expires = now + ifa->cf->timeout_time
+      };
+
+      rip_update_rte(p, &rte.prefix, rte.pxlen, &new);
+    }
+    else
+      rip_withdraw_rte(p, &rte.prefix, rte.pxlen, from);
+
+    continue;
+
+  skip:
+    LOG_RTE("Ignoring route %I/%d received from %I - %s",
+	    rte.prefix, rte.pxlen, from->nbr->addr, err_dsc);
+  }
+}
+
+static int
+rip_rx_hook(sock *sk, int len)
+{
+  struct rip_iface *ifa = sk->data;
+  struct rip_proto *p = ifa->rip;
+  const char *err_dsc = NULL;
+  uint err_val = 0;
+
+  if (sk->lifindex != sk->iface->index)
+    return 1;
+
+  DBG("RIP: RX hook called (iface %s, src %I, dst %I)\n",
+      sk->iface->name, sk->faddr, sk->laddr);
+
+  /* Silently ignore my own packets */
+  /* FIXME: Better local address check */
+  if (ipa_equal(ifa->iface->addr->ip, sk->faddr))
+    return 1;
+
+  if (rip_is_ng(p) && !ipa_is_link_local(sk->faddr))
+    DROP1("wrong src address");
+
+  struct rip_neighbor *n = rip_get_neighbor(p, &sk->faddr, ifa);
+
+  if (!n)
+    DROP1("not from neighbor");
+
+  if ((ifa->cf->ttl_security == 1) && (sk->rcv_ttl < 255))
+    DROP("wrong TTL", sk->rcv_ttl);
+
+  if (sk->fport != sk->dport)
+    DROP("wrong src port", sk->fport);
+
+  if (len < sizeof(struct rip_packet))
+    DROP("too short", len);
+
+  if (sk->flags & SKF_TRUNCATED)
+    DROP("truncated", len);
+
+  struct rip_packet *pkt = (struct rip_packet *) sk->rbuf;
+  uint plen = len;
+
+  if (!pkt->version || (ifa->cf->version_only && (pkt->version != ifa->cf->version)))
+    DROP("wrong version", pkt->version);
+
+  /* rip_check_authentication() has its own error logging */
+  if (rip_is_v2(p) && !rip_check_authentication(p, ifa, pkt, &plen, n))
+    return 1;
+
+  if ((plen - sizeof(struct rip_packet)) % RIP_BLOCK_LENGTH)
+    DROP("invalid length", plen);
+
+  n->last_seen = now;
+  rip_update_bfd(p, n);
+
+  switch (pkt->command)
+  {
+  case RIP_CMD_REQUEST:
+    rip_receive_request(p, ifa, pkt, plen, n);
+    break;
+
+  case RIP_CMD_RESPONSE:
+    rip_receive_response(p, ifa, pkt, plen, n);
+    break;
+
+  default:
+    DROP("unknown command", pkt->command);
+  }
+  return 1;
+
+drop:
+  LOG_PKT("Bad packet from %I via %s - %s (%u)",
+	  sk->faddr, sk->iface->name, err_dsc, err_val);
+
+  return 1;
+}
+
+int
+rip_open_socket(struct rip_iface *ifa)
+{
+  struct rip_proto *p = ifa->rip;
+
+  sock *sk = sk_new(p->p.pool);
+  sk->type = SK_UDP;
+  sk->sport = ifa->cf->port;
+  sk->dport = ifa->cf->port;
+  sk->iface = ifa->iface;
+
+  /*
+   * For RIPv2, we explicitly choose a primary address, mainly to ensure that
+   * RIP and BFD uses the same one. For RIPng, we left it to kernel, which
+   * should choose some link-local address based on the same scope rule.
+   */
+  if (rip_is_v2(p))
+    sk->saddr = ifa->iface->addr->ip;
+
+  sk->rx_hook = rip_rx_hook;
+  sk->tx_hook = rip_tx_hook;
+  sk->err_hook = rip_err_hook;
+  sk->data = ifa;
+
+  sk->tos = ifa->cf->tx_tos;
+  sk->priority = ifa->cf->tx_priority;
+  sk->ttl = ifa->cf->ttl_security ? 255 : 1;
+  sk->flags = SKF_LADDR_RX | ((ifa->cf->ttl_security == 1) ? SKF_TTL_RX : 0);
+
+  /* sk->rbsize and sk->tbsize are handled in rip_iface_update_buffers() */
+
+  if (sk_open(sk) < 0)
+    goto err;
+
+  if (ifa->cf->mode == RIP_IM_MULTICAST)
+  {
+    if (sk_setup_multicast(sk) < 0)
+      goto err;
+
+    if (sk_join_group(sk, ifa->addr) < 0)
+      goto err;
+  }
+  else /* Broadcast */
+  {
+    if (sk_setup_broadcast(sk) < 0)
+      goto err;
+
+    if (ipa_zero(ifa->addr))
+    {
+      sk->err = "Missing broadcast address";
+      goto err;
+    }
+  }
+
+  ifa->sk = sk;
+  return 1;
+
+err:
+  sk_log_error(sk, p->p.name);
+  rfree(sk);
+  return 0;
+}
diff --git a/proto/rip/rip.c b/proto/rip/rip.c
index b77cf409..c85fd69b 100644
--- a/proto/rip/rip.c
+++ b/proto/rip/rip.c
@@ -1,1047 +1,1275 @@
 /*
- *	Rest in pieces - RIP protocol
+ *	BIRD -- Routing Information Protocol (RIP)
  *
- *	Copyright (c) 1998, 1999 Pavel Machek <pavel@ucw.cz>
- *	              2004       Ondrej Filip <feela@network.cz>
+ *	(c) 1998--1999 Pavel Machek <pavel@ucw.cz>
+ *	(c) 2004--2013 Ondrej Filip <feela@network.cz>
+ *	(c) 2009--2015 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2009--2015 CZ.NIC z.s.p.o.
  *
  *	Can be freely distributed and used under the terms of the GNU GPL.
- *
- 	FIXME: IPv6 support: packet size
-	FIXME: (nonurgent) IPv6 support: receive "route using" blocks
-	FIXME: (nonurgent) IPv6 support: generate "nexthop" blocks
-		next hops are only advisory, and they are pretty ugly in IPv6.
-		I suggest just forgetting about them.
-
-	FIXME: (nonurgent): fold rip_connection into rip_interface?
-
-	FIXME: propagation of metric=infinity into main routing table may or may not be good idea.
  */
 
 /**
- * DOC: Routing Information Protocol
+ * DOC: Routing Information Protocol (RIP)
+ *
+ * The RIP protocol is implemented in two files: |rip.c| containing the protocol
+ * logic, route management and the protocol glue with BIRD core, and |packets.c|
+ * handling RIP packet processing, RX, TX and protocol sockets.
+ *
+ * Each instance of RIP is described by a structure &rip_proto, which contains
+ * an internal RIP routing table, a list of protocol interfaces and the main
+ * timer responsible for RIP routing table cleanup.
+ *
+ * RIP internal routing table contains incoming and outgoing routes. For each
+ * network (represented by structure &rip_entry) there is one outgoing route
+ * stored directly in &rip_entry and an one-way linked list of incoming routes
+ * (structures &rip_rte). The list contains incoming routes from different RIP
+ * neighbors, but only routes with the lowest metric are stored (i.e., all
+ * stored incoming routes have the same metric).
+ *
+ * Note that RIP itself does not select outgoing route, that is done by the core
+ * routing table. When a new incoming route is received, it is propagated to the
+ * RIP table by rip_update_rte() and possibly stored in the list of incoming
+ * routes. Then the change may be propagated to the core by rip_announce_rte().
+ * The core selects the best route and propagate it to RIP by rip_rt_notify(),
+ * which updates outgoing route part of &rip_entry and possibly triggers route
+ * propagation by rip_trigger_update().
  *
- * RIP is a pretty simple protocol, so about a half of its code is interface
- * with the core.
+ * RIP interfaces are represented by structures &rip_iface. A RIP interface
+ * contains a per-interface socket, a list of associated neighbors, interface
+ * configuration, and state information related to scheduled interface events
+ * and running update sessions. RIP interfaces are added and removed based on
+ * core interface notifications.
  *
- * We maintain our own linked list of &rip_entry structures -- it serves
- * as our small routing table. RIP never adds to this linked list upon
- * packet reception; instead, it lets the core know about data from the packet
- * and waits for the core to call rip_rt_notify().
+ * There are two RIP interface events - regular updates and triggered updates.
+ * Both are managed from the RIP interface timer (rip_iface_timer()). Regular
+ * updates are called at fixed interval and propagate the whole routing table,
+ * while triggered updates are scheduled by rip_trigger_update() due to some
+ * routing table change and propagate only the routes modified since the time
+ * they were scheduled. There are also unicast-destined requested updates, but
+ * these are sent directly as a reaction to received RIP request message. The
+ * update session is started by rip_send_table(). There may be at most one
+ * active update session per interface, as the associated state (including the
+ * fib iterator) is stored directly in &rip_iface structure.
  *
- * Within rip_tx(), the list is
- * walked and a packet is generated using rip_tx_prepare(). This gets
- * tricky because we may need to send more than one packet to one
- * destination. Struct &rip_connection is used to hold context information such as how
- * many of &rip_entry's we have already sent and it's also used to protect
- * against two concurrent sends to one destination. Each &rip_interface has
- * at most one &rip_connection.
+ * RIP neighbors are represented by structures &rip_neighbor. Compared to
+ * neighbor handling in other routing protocols, RIP does not have explicit
+ * neighbor discovery and adjacency maintenance, which makes the &rip_neighbor
+ * related code a bit peculiar. RIP neighbors are interlinked with core neighbor
+ * structures (&neighbor) and use core neighbor notifications to ensure that RIP
+ * neighbors are timely removed. RIP neighbors are added based on received route
+ * notifications and removed based on core neighbor and RIP interface events.
  *
- * We are not going to honor requests for sending part of
- * routing table. That would need to turn split horizon off etc.  
+ * RIP neighbors are linked by RIP routes and use counter to track the number of
+ * associated routes, but when these RIP routes timeout, associated RIP neighbor
+ * is still alive (with zero counter). When RIP neighbor is removed but still
+ * has some associated routes, it is not freed, just changed to detached state
+ * (core neighbors and RIP ifaces are unlinked), then during the main timer
+ * cleanup phase the associated routes are removed and the &rip_neighbor
+ * structure is finally freed.
  *
- * About triggered updates, RFC says: when a triggered update was sent,
- * don't send a new one for something between 1 and 5 seconds (and send one
- * after that). We do something else: each 5 seconds,
- * we look for any changed routes and broadcast them.
+ * Supported standards:
+ * - RFC 1058 - RIPv1
+ * - RFC 2453 - RIPv2
+ * - RFC 2080 - RIPng
+ * - RFC 4822 - RIP cryptographic authentication
  */
 
-#undef LOCAL_DEBUG
-#define LOCAL_DEBUG 1
-
-#include "nest/bird.h"
-#include "nest/iface.h"
-#include "nest/protocol.h"
-#include "nest/route.h"
-#include "lib/socket.h"
-#include "lib/resource.h"
-#include "lib/lists.h"
-#include "lib/timer.h"
-#include "lib/string.h"
-
+#include <stdlib.h>
 #include "rip.h"
 
-#define P ((struct rip_proto *) p)
-#define P_CF ((struct rip_proto_config *)p->cf)
 
-#undef TRACE
-#define TRACE(level, msg, args...) do { if (p->debug & level) { log(L_TRACE "%s: " msg, p->name , ## args); } } while(0)
+static inline void rip_lock_neighbor(struct rip_neighbor *n);
+static inline void rip_unlock_neighbor(struct rip_neighbor *n);
+static inline int rip_iface_link_up(struct rip_iface *ifa);
+static inline void rip_kick_timer(struct rip_proto *p);
+static inline void rip_iface_kick_timer(struct rip_iface *ifa);
+static void rip_iface_timer(timer *timer);
+static void rip_trigger_update(struct rip_proto *p);
 
-static struct rip_interface *new_iface(struct proto *p, struct iface *new, unsigned long flags, struct iface_patt *patt);
 
 /*
- * Output processing
- *
- * This part is responsible for getting packets out to the network.
+ *	RIP routes
  */
 
 static void
-rip_tx_err( sock *s, int err )
+rip_init_entry(struct fib_node *fn)
 {
-  struct rip_connection *c = ((struct rip_interface *)(s->data))->busy;
-  struct proto *p = c->proto;
-  log( L_ERR "%s: Unexpected error at rip transmit: %M", p->name, err );
+  // struct rip_entry *en = (void) *fn;
+
+  const uint offset = OFFSETOF(struct rip_entry, routes);
+  memset((byte *)fn + offset, 0, sizeof(struct rip_entry) - offset);
 }
 
-/*
- * rip_tx_prepare:
- * @e: rip entry that needs to be translated to form suitable for network
- * @b: block to be filled
- *
- * Fill one rip block with info that needs to go to the network. Handle
- * nexthop and split horizont correctly. (Next hop is ignored for IPv6,
- * that could be fixed but it is not real problem).
- */
-static int
-rip_tx_prepare(struct proto *p, struct rip_block *b, struct rip_entry *e, struct rip_interface *rif, int pos )
+static struct rip_rte *
+rip_add_rte(struct rip_proto *p, struct rip_rte **rp, struct rip_rte *src)
 {
-  int metric;
-  DBG( "." );
-  b->tag     = htons( e->tag );
-  b->network = e->n.prefix;
-  metric = e->metric;
-  if (neigh_connected_to(p, &e->whotoldme, rif->iface)) {
-    DBG( "(split horizon)" );
-    metric = P_CF->infinity;
-  }
-#ifndef IPV6
-  b->family  = htons( 2 ); /* AF_INET */
-  b->netmask = ipa_mkmask( e->n.pxlen );
-  ipa_hton( b->netmask );
+  struct rip_rte *rt = sl_alloc(p->rte_slab);
 
-  if (neigh_connected_to(p, &e->nexthop, rif->iface))
-    b->nexthop = e->nexthop;
-  else
-    b->nexthop = IPA_NONE;
-  ipa_hton( b->nexthop );  
-  b->metric  = htonl( metric );
-#else
-  b->pxlen = e->n.pxlen;
-  b->metric  = metric; /* it is u8 */
-#endif
+  memcpy(rt, src, sizeof(struct rip_rte));
+  rt->next = *rp;
+  *rp = rt;
 
-  ipa_hton( b->network );
+  rip_lock_neighbor(rt->from);
 
-  return pos+1;
+  return rt;
 }
 
-/*
- * rip_tx - send one rip packet to the network
+static inline void
+rip_remove_rte(struct rip_proto *p, struct rip_rte **rp)
+{
+  struct rip_rte *rt = *rp;
+
+  rip_unlock_neighbor(rt->from);
+
+  *rp = rt->next;
+  sl_free(p->rte_slab, rt);
+}
+
+static inline int rip_same_rte(struct rip_rte *a, struct rip_rte *b)
+{ return a->metric == b->metric && a->tag == b->tag && ipa_equal(a->next_hop, b->next_hop); }
+
+static inline int rip_valid_rte(struct rip_rte *rt)
+{ return rt->from->ifa != NULL; }
+
+/**
+ * rip_announce_rte - announce route from RIP routing table to the core
+ * @p: RIP instance
+ * @en: related network
+ *
+ * The function takes a list of incoming routes from @en, prepare appropriate
+ * &rte for the core and propagate it by rte_update().
  */
 static void
-rip_tx( sock *s )
+rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
 {
-  struct rip_interface *rif = s->data;
-  struct rip_connection *c = rif->busy;
-  struct proto *p = c->proto;
-  struct rip_packet *packet = (void *) s->tbuf;
-  int i, packetlen;
-  int maxi, nullupdate = 1;
-
-  DBG( "Sending to %I\n", s->daddr );
-  do {
-
-    if (c->done)
-      goto done;
-
-    DBG( "Preparing packet to send: " );
-
-    packet->heading.command = RIPCMD_RESPONSE;
-#ifndef IPV6
-    packet->heading.version = RIP_V2;
-#else
-    packet->heading.version = RIP_NG;
-#endif
-    packet->heading.unused  = 0;
-
-    i = !!P_CF->authtype;
-#ifndef IPV6
-    maxi = ((P_CF->authtype == AT_MD5) ? PACKET_MD5_MAX : PACKET_MAX);
-#else
-    maxi = 5; /* We need to have at least reserve of one at end of packet */
-#endif
-    
-    FIB_ITERATE_START(&P->rtable, &c->iter, z) {
-      struct rip_entry *e = (struct rip_entry *) z;
-
-      if (!rif->triggered || (!(e->updated < now-2))) {		/* FIXME: Should be probably 1 or some different algorithm */
-	nullupdate = 0;
-	i = rip_tx_prepare( p, packet->block + i, e, rif, i );
-	if (i >= maxi) {
-	  FIB_ITERATE_PUT(&c->iter, z);
-	  goto break_loop;
-	}
-      }
-    } FIB_ITERATE_END(z);
-    c->done = 1;
+  struct rip_rte *rt = en->routes;
+
+  /* Find first valid rte */
+  while (rt && !rip_valid_rte(rt))
+    rt = rt->next;
+
+  if (rt)
+  {
+    /* Update */
+    net *n = net_get(p->p.table, en->n.prefix, en->n.pxlen);
 
-  break_loop:
+    rta a0 = {
+      .src = p->p.main_source,
+      .source = RTS_RIP,
+      .scope = SCOPE_UNIVERSE,
+      .cast = RTC_UNICAST
+    };
 
-    packetlen = rip_outgoing_authentication(p, (void *) &packet->block[0], packet, i);
+    u8 rt_metric = rt->metric;
+    u16 rt_tag = rt->tag;
+    struct rip_rte *rt2 = rt->next;
+
+    /* Find second valid rte */
+    while (rt2 && !rip_valid_rte(rt2))
+      rt2 = rt2->next;
+
+    if (p->ecmp && rt2)
+    {
+      /* ECMP route */
+      struct mpnh *nhs = NULL;
+      struct mpnh **nhp = &nhs;
+      int num = 0;
 
-    DBG( ", sending %d blocks, ", i );
-    if (nullupdate) {
-      DBG( "not sending NULL update\n" );
-      c->done = 1;
-      goto done;
+      for (rt = en->routes; rt && (num < p->ecmp); rt = rt->next)
+      {
+	if (!rip_valid_rte(rt))
+	    continue;
+
+	struct mpnh *nh = alloca(sizeof(struct mpnh));
+	nh->gw = rt->next_hop;
+	nh->iface = rt->from->nbr->iface;
+	nh->weight = rt->from->ifa->cf->ecmp_weight;
+	nh->next = NULL;
+	*nhp = nh;
+	nhp = &(nh->next);
+	num++;
+
+	if (rt->tag != rt_tag)
+	  rt_tag = 0;
+      }
+
+      a0.dest = RTD_MULTIPATH;
+      a0.nexthops = nhs;
     }
-    if (ipa_nonzero(c->daddr))
-      i = sk_send_to( s, packetlen, c->daddr, c->dport );
     else
-      i = sk_send( s, packetlen );
-
-    DBG( "it wants more\n" );
-  
-  } while (i>0);
-  
-  if (i<0) rip_tx_err( s, i );
-  DBG( "blocked\n" );
-  return;
-
-done:
-  DBG( "Looks like I'm" );
-  c->rif->busy = NULL;
-  rem_node(NODE c);
-  mb_free(c);
-  DBG( " done\n" );
-  return;
-}
+    {
+      /* Unipath route */
+      a0.dest = RTD_ROUTER;
+      a0.gw = rt->next_hop;
+      a0.iface = rt->from->nbr->iface;
+      a0.from = rt->from->nbr->addr;
+    }
 
-/* 
- * rip_sendto - send whole routing table to selected destination
- * @rif: interface to use. Notice that we lock interface so that at
- * most one send to one interface is done.
- */
-static void
-rip_sendto( struct proto *p, ip_addr daddr, int dport, struct rip_interface *rif )
-{
-  struct iface *iface = rif->iface;
-  struct rip_connection *c;
-  static int num = 0;
+    rta *a = rta_lookup(&a0);
+    rte *e = rte_get_temp(a);
 
-  if (rif->busy) {
-    log (L_WARN "%s: Interface %s is much too slow, dropping request", p->name, iface->name);
-    return;
+    e->u.rip.from = a0.iface;
+    e->u.rip.metric = rt_metric;
+    e->u.rip.tag = rt_tag;
+
+    e->net = n;
+    e->pflags = 0;
+
+    rte_update(&p->p, n, e);
   }
-  c = mb_alloc( p->pool, sizeof( struct rip_connection ));
-  rif->busy = c;
-  
-  c->addr = daddr;
-  c->proto = p;
-  c->num = num++;
-  c->rif = rif;
-
-  c->dport = dport;
-  c->daddr = daddr;
-  if (c->rif->sock->data != rif)
-    bug("not enough send magic");
-
-  c->done = 0;
-  FIB_ITERATE_INIT( &c->iter, &P->rtable );
-  add_head( &P->connections, NODE c );
-  if (ipa_nonzero(daddr))
-    TRACE(D_PACKETS, "Sending my routing table to %I:%d on %s", daddr, dport, rif->iface->name );
   else
-    TRACE(D_PACKETS, "Broadcasting routing table to %s", rif->iface->name );
-
-  rip_tx(c->rif->sock);
+  {
+    /* Withdraw */
+    net *n = net_find(p->p.table, en->n.prefix, en->n.pxlen);
+    rte_update(&p->p, n, NULL);
+  }
 }
 
-static struct rip_interface*
-find_interface(struct proto *p, struct iface *what)
+/**
+ * rip_update_rte - enter a route update to RIP routing table
+ * @p: RIP instance
+ * @prefix: network prefix
+ * @pxlen: network prefix length
+ * @new: a &rip_rte representing the new route
+ *
+ * The function is called by the RIP packet processing code whenever it receives
+ * a reachable route. The appropriate routing table entry is found and the list
+ * of incoming routes is updated. Eventually, the change is also propagated to
+ * the core by rip_announce_rte(). Note that for unreachable routes,
+ * rip_withdraw_rte() should be called instead of rip_update_rte().
+ */
+void
+rip_update_rte(struct rip_proto *p, ip_addr *prefix, int pxlen, struct rip_rte *new)
 {
-  struct rip_interface *i;
+  struct rip_entry *en = fib_get(&p->rtable, prefix, pxlen);
+  struct rip_rte *rt, **rp;
+  int changed = 0;
+
+  /* If the new route is better, remove all current routes */
+  if (en->routes && new->metric < en->routes->metric)
+    while (en->routes)
+      rip_remove_rte(p, &en->routes);
+
+  /* Find the old route (also set rp for later) */
+  for (rp = &en->routes; rt = *rp; rp = &rt->next)
+    if (rt->from == new->from)
+    {
+      if (rip_same_rte(rt, new))
+      {
+	rt->expires = new->expires;
+	return;
+      }
 
-  WALK_LIST (i, P->interfaces)
-    if (i->iface == what)
-      return i;
-  return NULL;
+      /* Remove the old route */
+      rip_remove_rte(p, rp);
+      changed = 1;
+      break;
+    }
+
+  /* If the new route is optimal, add it to the list */
+  if (!en->routes || new->metric == en->routes->metric)
+  {
+    rt = rip_add_rte(p, rp, new);
+    changed = 1;
+  }
+
+  /* Announce change if on relevant position (the first or any for ECMP) */
+  if (changed && (rp == &en->routes || p->ecmp))
+    rip_announce_rte(p, en);
 }
 
-/*
- * Input processing
+/**
+ * rip_withdraw_rte - enter a route withdraw to RIP routing table
+ * @p: RIP instance
+ * @prefix: network prefix
+ * @pxlen: network prefix length
+ * @from: a &rip_neighbor propagating the withdraw
  *
- * This part is responsible for any updates that come from network 
+ * The function is called by the RIP packet processing code whenever it receives
+ * an unreachable route. The incoming route for given network from nbr @from is
+ * removed. Eventually, the change is also propagated by rip_announce_rte().
  */
+void
+rip_withdraw_rte(struct rip_proto *p, ip_addr *prefix, int pxlen, struct rip_neighbor *from)
+{
+  struct rip_entry *en = fib_find(&p->rtable, prefix, pxlen);
+  struct rip_rte *rt, **rp;
 
-static int rip_rte_better(struct rte *new, struct rte *old);
+  if (!en)
+    return;
 
-static void
-rip_rte_update_if_better(rtable *tab, net *net, struct proto *p, rte *new)
-{
-  rte *old;
+  /* Find the old route */
+  for (rp = &en->routes; rt = *rp; rp = &rt->next)
+    if (rt->from == from)
+      break;
 
-  old = rte_find(net, p->main_source);
-  if (!old || rip_rte_better(new, old) ||
-      (ipa_equal(old->attrs->from, new->attrs->from) &&
-      (old->u.rip.metric != new->u.rip.metric)) )
-    rte_update(p, net, new);
-  else
-    rte_free(new);
+  if (!rt)
+    return;
+
+  /* Remove the old route */
+  rip_remove_rte(p, rp);
+
+  /* Announce change if on relevant position */
+  if (rp == &en->routes || p->ecmp)
+    rip_announce_rte(p, en);
 }
 
 /*
- * advertise_entry - let main routing table know about our new entry
- * @b: entry in network format
- *
- * This basically translates @b to format used by bird core and feeds
- * bird core with this route.
+ * rip_rt_notify - core tells us about new route, so store
+ * it into our data structures.
  */
 static void
-advertise_entry( struct proto *p, struct rip_block *b, ip_addr whotoldme, struct iface *iface )
+rip_rt_notify(struct proto *P, struct rtable *table UNUSED, struct network *net, struct rte *new,
+	      struct rte *old UNUSED, struct ea_list *attrs)
 {
-  rta *a, A;
-  rte *r;
-  net *n;
-  neighbor *neighbor;
-  struct rip_interface *rif;
-  int pxlen;
-
-  bzero(&A, sizeof(A));
-  A.src= p->main_source;
-  A.source = RTS_RIP;
-  A.scope = SCOPE_UNIVERSE;
-  A.cast = RTC_UNICAST;
-  A.dest = RTD_ROUTER;
-  A.flags = 0;
-#ifndef IPV6
-  A.gw = ipa_nonzero(b->nexthop) ? b->nexthop : whotoldme;
-  pxlen = ipa_masklen(b->netmask);
-#else
-  /* FIXME: next hop is in other packet for v6 */
-  A.gw = whotoldme; 
-  pxlen = b->pxlen;
-#endif
-  A.from = whotoldme;
-
-  /* No need to look if destination looks valid - ie not net 0 or 127 -- core will do for us. */
-
-  neighbor = neigh_find2( p, &A.gw, iface, 0 );
-  if (!neighbor) {
-    log( L_REMOTE "%s: %I asked me to route %I/%d using not-neighbor %I.", p->name, A.from, b->network, pxlen, A.gw );
-    return;
-  }
-  if (neighbor->scope == SCOPE_HOST) {
-    DBG("Self-destined route, ignoring.\n");
-    return;
+  struct rip_proto *p = (struct rip_proto *) P;
+  struct rip_entry *en;
+  int old_metric;
+
+  if (new)
+  {
+    /* Update */
+    u32 rt_metric = ea_get_int(attrs, EA_RIP_METRIC, 1);
+    u32 rt_tag = ea_get_int(attrs, EA_RIP_TAG, 0);
+
+    if (rt_metric > p->infinity)
+    {
+      log(L_WARN "%s: Invalid rip_metric value %u for route %I/%d",
+	  p->p.name, rt_metric, net->n.prefix, net->n.pxlen);
+      rt_metric = p->infinity;
+    }
+
+    if (rt_tag > 0xffff)
+    {
+      log(L_WARN "%s: Invalid rip_tag value %u for route %I/%d",
+	  p->p.name, rt_tag, net->n.prefix, net->n.pxlen);
+      rt_metric = p->infinity;
+      rt_tag = 0;
+    }
+
+    /*
+     * Note that we accept exported routes with infinity metric (this could
+     * happen if rip_metric is modified in filters). Such entry has infinity
+     * metric but is RIP_ENTRY_VALID and therefore is not subject to garbage
+     * collection.
+     */
+
+    en = fib_get(&p->rtable, &net->n.prefix, net->n.pxlen);
+
+    old_metric = en->valid ? en->metric : -1;
+
+    en->valid = RIP_ENTRY_VALID;
+    en->metric = rt_metric;
+    en->tag = rt_tag;
+    en->from = (new->attrs->src->proto == P) ? new->u.rip.from : NULL;
+    en->iface = new->attrs->iface;
+    en->next_hop = new->attrs->gw;
   }
+  else
+  {
+    /* Withdraw */
+    en = fib_find(&p->rtable, &net->n.prefix, net->n.pxlen);
 
-  A.iface = neighbor->iface;
-  if (!(rif = neighbor->data)) {
-    rif = neighbor->data = find_interface(p, A.iface);
+    if (!en || en->valid != RIP_ENTRY_VALID)
+      return;
+
+    old_metric = en->metric;
+
+    en->valid = RIP_ENTRY_STALE;
+    en->metric = p->infinity;
+    en->tag = 0;
+    en->from = NULL;
+    en->iface = NULL;
+    en->next_hop = IPA_NONE;
   }
-  if (!rif)
-    bug("Route packet using unknown interface? No.");
-    
-  /* set to: interface of nexthop */
-  a = rta_lookup(&A);
-  if (pxlen==-1)  {
-    log( L_REMOTE "%s: %I gave me invalid pxlen/netmask for %I.", p->name, A.from, b->network );
-    return;
+
+  /* Activate triggered updates */
+  if (en->metric != old_metric)
+  {
+    en->changed = now;
+    rip_trigger_update(p);
   }
-  n = net_get( p->table, b->network, pxlen );
-  r = rte_get_temp(a);
-#ifndef IPV6
-  r->u.rip.metric = ntohl(b->metric) + rif->metric;
-#else  
-  r->u.rip.metric = b->metric + rif->metric;
-#endif
-
-  r->u.rip.entry = NULL;
-  if (r->u.rip.metric > P_CF->infinity) r->u.rip.metric = P_CF->infinity;
-  r->u.rip.tag = ntohl(b->tag);
-  r->net = n;
-  r->pflags = 0; /* Here go my flags */
-  rip_rte_update_if_better( p->table, n, p, r );
-  DBG( "done\n" );
 }
 
+
 /*
- * process_block - do some basic check and pass block to advertise_entry
+ *	RIP neighbors
  */
+
+struct rip_neighbor *
+rip_get_neighbor(struct rip_proto *p, ip_addr *a, struct rip_iface *ifa)
+{
+  neighbor *nbr = neigh_find2(&p->p, a, ifa->iface, 0);
+
+  if (!nbr || (nbr->scope == SCOPE_HOST) || !rip_iface_link_up(ifa))
+    return NULL;
+
+  if (nbr->data)
+    return nbr->data;
+
+  TRACE(D_EVENTS, "New neighbor %I on %s", *a, ifa->iface->name);
+
+  struct rip_neighbor *n = mb_allocz(p->p.pool, sizeof(struct rip_neighbor));
+  n->ifa = ifa;
+  n->nbr = nbr;
+  nbr->data = n;
+  n->csn = nbr->aux;
+
+  add_tail(&ifa->neigh_list, NODE n);
+
+  return n;
+}
+
 static void
-process_block( struct proto *p, struct rip_block *block, ip_addr whotoldme, struct iface *iface )
+rip_remove_neighbor(struct rip_proto *p, struct rip_neighbor *n)
 {
-  int metric, pxlen;
-
-#ifndef IPV6
-  metric = ntohl( block->metric );
-  pxlen = ipa_masklen(block->netmask);
-#else
-  metric = block->metric;
-  pxlen = block->pxlen;
-#endif
-  ip_addr network = block->network;
-
-  CHK_MAGIC;
-
-  TRACE(D_ROUTES, "block: %I tells me: %I/%d available, metric %d... ",
-      whotoldme, network, pxlen, metric );
-
-  if ((!metric) || (metric > P_CF->infinity)) {
-#ifdef IPV6 /* Someone is sending us nexthop and we are ignoring it */
-    if (metric == 0xff)
-      { DBG( "IPv6 nexthop ignored" ); return; }
-#endif
-    log( L_WARN "%s: Got metric %d from %I", p->name, metric, whotoldme );
-    return;
-  }
+  neighbor *nbr = n->nbr;
+
+  TRACE(D_EVENTS, "Removing neighbor %I on %s", nbr->addr, nbr->iface->name);
 
-  advertise_entry( p, block, whotoldme, iface );
+  rem_node(NODE n);
+  n->ifa = NULL;
+  n->nbr = NULL;
+  nbr->data = NULL;
+  nbr->aux = n->csn;
+
+  rfree(n->bfd_req);
+  n->bfd_req = NULL;
+  n->last_seen = 0;
+
+  if (!n->uc)
+    mb_free(n);
+
+  /* Related routes are removed in rip_timer() */
+  rip_kick_timer(p);
 }
 
-#define BAD( x ) { log( L_REMOTE "%s: " x, p->name ); return 1; }
+static inline void
+rip_lock_neighbor(struct rip_neighbor *n)
+{
+  n->uc++;
+}
 
-/*
- * rip_process_packet - this is main routine for incoming packets.
- */
-static int
-rip_process_packet( struct proto *p, struct rip_packet *packet, int num, ip_addr whotoldme, int port, struct iface *iface )
+static inline void
+rip_unlock_neighbor(struct rip_neighbor *n)
 {
-  int i;
-  int authenticated = 0;
-  neighbor *neighbor;
+  n->uc--;
+
+  if (!n->nbr && !n->uc)
+    mb_free(n);
+}
+
+static void
+rip_neigh_notify(struct neighbor *nbr)
+{
+  struct rip_proto *p = (struct rip_proto *) nbr->proto;
+  struct rip_neighbor *n = nbr->data;
+
+  if (!n)
+    return;
+
+  /*
+   * We assume that rip_neigh_notify() is called before rip_if_notify() for
+   * IF_CHANGE_DOWN and therefore n->ifa is still valid. We have no such
+   * ordering assumption for IF_CHANGE_LINK, so we test link state of the
+   * underlying iface instead of just rip_iface state.
+   */
+  if ((nbr->scope <= 0) || !rip_iface_link_up(n->ifa))
+    rip_remove_neighbor(p, n);
+}
+
+static void
+rip_bfd_notify(struct bfd_request *req)
+{
+  struct rip_neighbor *n = req->data;
+  struct rip_proto *p = n->ifa->rip;
 
-  switch( packet->heading.version ) {
-  case RIP_V1: DBG( "Rip1: " ); break;
-  case RIP_V2: DBG( "Rip2: " ); break;
-  default: BAD( "Unknown version" );
+  if (req->down)
+  {
+    TRACE(D_EVENTS, "BFD session down for nbr %I on %s",
+	  n->nbr->addr, n->ifa->iface->name);
+    rip_remove_neighbor(p, n);
   }
+}
+
+void
+rip_update_bfd(struct rip_proto *p, struct rip_neighbor *n)
+{
+  int use_bfd = n->ifa->cf->bfd && n->last_seen;
 
-  switch( packet->heading.command ) {
-  case RIPCMD_REQUEST: DBG( "Asked to send my routing table\n" ); 
-	  if (P_CF->honor == HO_NEVER)
-	    BAD( "They asked me to send routing table, but I was told not to do it" );
-
-	  if ((P_CF->honor == HO_NEIGHBOR) && (!neigh_find2( p, &whotoldme, iface, 0 )))
-	    BAD( "They asked me to send routing table, but he is not my neighbor" );
-    	  rip_sendto( p, whotoldme, port, HEAD(P->interfaces) ); /* no broadcast */
-          break;
-  case RIPCMD_RESPONSE: DBG( "*** Rtable from %I\n", whotoldme ); 
-          if (port != P_CF->port) {
-	    log( L_REMOTE "%s: %I send me routing info from port %d", p->name, whotoldme, port );
-	    return 1;
-	  }
-
-	  if (!(neighbor = neigh_find2( p, &whotoldme, iface, 0 )) || neighbor->scope == SCOPE_HOST) {
-	    log( L_REMOTE "%s: %I send me routing info but he is not my neighbor", p->name, whotoldme );
-	    return 0;
-	  }
-
-          for (i=0; i<num; i++) {
-	    struct rip_block *block = &packet->block[i];
-#ifndef IPV6
-	    /* Authentication is not defined for v6 */
-	    if (block->family == 0xffff) {
-	      if (i)
-		continue;	/* md5 tail has this family */
-	      if (rip_incoming_authentication(p, (void *) block, packet, num, whotoldme))
-		BAD( "Authentication failed" );
-	      authenticated = 1;
-	      continue;
-	    }
-#endif
-	    if ((!authenticated) && (P_CF->authtype != AT_NONE))
-	      BAD( "Packet is not authenticated and it should be" );
-	    ipa_ntoh( block->network );
-#ifndef IPV6
-	    ipa_ntoh( block->netmask );
-	    ipa_ntoh( block->nexthop );
-	    if (packet->heading.version == RIP_V1)	/* FIXME (nonurgent): switch to disable this? */
-	      block->netmask = ip4_class_mask(ipa_to_ip4(block->network));
-#endif
-	    process_block( p, block, whotoldme, iface );
-	  }
-          break;
-  case RIPCMD_TRACEON:
-  case RIPCMD_TRACEOFF: BAD( "I was asked for traceon/traceoff" );
-  case 5: BAD( "Some Sun extension around here" );
-  default: BAD( "Unknown command" );
+  if (use_bfd && !n->bfd_req)
+  {
+    /*
+     * For RIPv2, use the same address as rip_open_socket(). For RIPng, neighbor
+     * should contain an address from the same prefix, thus also link-local. It
+     * may cause problems if two link-local addresses are assigned to one iface.
+     */
+    ip_addr saddr = rip_is_v2(p) ? n->ifa->sk->saddr : n->nbr->ifa->ip;
+    n->bfd_req = bfd_request_session(p->p.pool, n->nbr->addr, saddr,
+				     n->nbr->iface, rip_bfd_notify, n);
   }
 
-  return 0;
+  if (!use_bfd && n->bfd_req)
+  {
+    rfree(n->bfd_req);
+    n->bfd_req = NULL;
+  }
 }
 
+
 /*
- * rip_rx - Receive hook: do basic checks and pass packet to rip_process_packet
+ *	RIP interfaces
  */
-static int
-rip_rx(sock *s, int size)
+
+static void
+rip_iface_start(struct rip_iface *ifa)
 {
-  struct rip_interface *i = s->data;
-  struct proto *p = i->proto;
-  struct iface *iface = NULL;
-  int num;
+  struct rip_proto *p = ifa->rip;
 
-  /* In non-listening mode, just ignore packet */
-  if (i->mode & IM_NOLISTEN)
-    return 1;
+  TRACE(D_EVENTS, "Starting interface %s", ifa->iface->name);
 
-#ifdef IPV6
-  if (! i->iface || s->lifindex != i->iface->index)
-    return 1;
+  ifa->next_regular = now + (random() % ifa->cf->update_time) + 1;
+  ifa->next_triggered = now;	/* Available immediately */
+  ifa->want_triggered = 1;	/* All routes in triggered update */
+  tm_start(ifa->timer, 1);	/* Or 100 ms */
+  ifa->up = 1;
 
-  iface = i->iface;
-#endif
+  if (!ifa->cf->passive)
+    rip_send_request(ifa->rip, ifa);
+}
 
-  if (i->check_ttl && (s->rcv_ttl < 255))
-  {
-    log( L_REMOTE "%s: Discarding packet with TTL %d (< 255) from %I on %s",
-	 p->name, s->rcv_ttl, s->faddr, i->iface->name);
-    return 1;
-  }
+static void
+rip_iface_stop(struct rip_iface *ifa)
+{
+  struct rip_proto *p = ifa->rip;
+  struct rip_neighbor *n;
 
+  TRACE(D_EVENTS, "Stopping interface %s", ifa->iface->name);
 
-  CHK_MAGIC;
-  DBG( "RIP: message came: %d bytes from %I via %s\n", size, s->faddr, i->iface ? i->iface->name : "(dummy)" );
-  size -= sizeof( struct rip_packet_heading );
-  if (size < 0) BAD( "Too small packet" );
-  if (size % sizeof( struct rip_block )) BAD( "Odd sized packet" );
-  num = size / sizeof( struct rip_block );
-  if (num>PACKET_MAX) BAD( "Too many blocks" );
+  rip_reset_tx_session(p, ifa);
 
-  if (ipa_equal(i->iface->addr->ip, s->faddr)) {
-    DBG("My own packet\n");
-    return 1;
-  }
+  WALK_LIST_FIRST(n, ifa->neigh_list)
+    rip_remove_neighbor(p, n);
 
-  rip_process_packet( p, (struct rip_packet *) s->rbuf, num, s->faddr, s->fport, iface );
-  return 1;
+  tm_stop(ifa->timer);
+  ifa->up = 0;
 }
 
-/*
- * Interface to BIRD core
- */
+static inline int
+rip_iface_link_up(struct rip_iface *ifa)
+{
+  return !ifa->cf->check_link || (ifa->iface->flags & IF_LINK_UP);
+}
 
 static void
-rip_dump_entry( struct rip_entry *e )
+rip_iface_update_state(struct rip_iface *ifa)
 {
-  debug( "%I told me %d/%d ago: to %I/%d go via %I, metric %d ", 
-  e->whotoldme, e->updated-now, e->changed-now, e->n.prefix, e->n.pxlen, e->nexthop, e->metric );
-  debug( "\n" );
-}
+  int up = ifa->sk && rip_iface_link_up(ifa);
 
-/**
- * rip_timer
- * @t: timer
- *
- * Broadcast routing tables periodically (using rip_tx) and kill
- * routes that are too old. RIP keeps a list of its own entries present
- * in the core table by a linked list (functions rip_rte_insert() and
- * rip_rte_delete() are responsible for that), it walks this list in the timer
- * and in case an entry is too old, it is discarded.
- */
+  if (up == ifa->up)
+    return;
+
+  if (up)
+    rip_iface_start(ifa);
+  else
+    rip_iface_stop(ifa);
+}
 
 static void
-rip_timer(timer *t)
+rip_iface_update_buffers(struct rip_iface *ifa)
 {
-  struct proto *p = t->data;
-  struct fib_node *e, *et;
+  if (!ifa->sk)
+    return;
 
-  CHK_MAGIC;
-  DBG( "RIP: tick tock\n" );
-  
-  WALK_LIST_DELSAFE( e, et, P->garbage ) {
-    rte *rte;
-    rte = SKIP_BACK( struct rte, u.rip.garbage, e );
+  uint rbsize = ifa->cf->rx_buffer ?: ifa->iface->mtu;
+  uint tbsize = ifa->cf->tx_length ?: ifa->iface->mtu;
+  rbsize = MAX(rbsize, tbsize);
 
-    CHK_MAGIC;
+  sk_set_rbsize(ifa->sk, rbsize);
+  sk_set_tbsize(ifa->sk, tbsize);
 
-    DBG( "Garbage: (%p)", rte ); rte_dump( rte );
+  uint headers = (rip_is_v2(ifa->rip) ? IP4_HEADER_LENGTH : IP6_HEADER_LENGTH) + UDP_HEADER_LENGTH;
+  ifa->tx_plen = tbsize - headers;
 
-    if (now - rte->lastmod > P_CF->timeout_time) {
-      TRACE(D_EVENTS, "entry is too old: %I", rte->net->n.prefix );
-      if (rte->u.rip.entry) {
-	rte->u.rip.entry->metric = P_CF->infinity;
-	rte->u.rip.metric = P_CF->infinity;
-      }
-    }
+  if (ifa->cf->auth_type == RIP_AUTH_CRYPTO)
+    ifa->tx_plen -= RIP_AUTH_TAIL_LENGTH;
+}
 
-    if (now - rte->lastmod > P_CF->garbage_time) {
-      TRACE(D_EVENTS, "entry is much too old: %I", rte->net->n.prefix );
-      rte_discard(p->table, rte);
-    }
-  }
+static inline void
+rip_iface_update_bfd(struct rip_iface *ifa)
+{
+  struct rip_proto *p = ifa->rip;
+  struct rip_neighbor *n;
+
+  WALK_LIST(n, ifa->neigh_list)
+    rip_update_bfd(p, n);
+}
+
+
+static void
+rip_iface_locked(struct object_lock *lock)
+{
+  struct rip_iface *ifa = lock->data;
+  struct rip_proto *p = ifa->rip;
 
-  DBG( "RIP: Broadcasting routing tables\n" );
+  if (!rip_open_socket(ifa))
   {
-    struct rip_interface *rif;
+    log(L_ERR "%s: Cannot open socket for %s", p->p.name, ifa->iface->name);
+    return;
+  }
 
-    if ( P_CF->period > 2 ) {		/* Bring some randomness into sending times */
-      if (! (P->tx_count % P_CF->period)) P->rnd_count = random_u32() % 2;
-    } else P->rnd_count = P->tx_count % P_CF->period;
+  rip_iface_update_buffers(ifa);
+  rip_iface_update_state(ifa);
+}
 
-    WALK_LIST( rif, P->interfaces ) {
-      struct iface *iface = rif->iface;
 
-      if (!iface) continue;
-      if (rif->mode & IM_QUIET) continue;
-      if (!(iface->flags & IF_UP)) continue;
-      rif->triggered = P->rnd_count;
+static struct rip_iface *
+rip_find_iface(struct rip_proto *p, struct iface *what)
+{
+  struct rip_iface *ifa;
 
-      rip_sendto( p, IPA_NONE, 0, rif );
-    }
-    P->tx_count++;
-    P->rnd_count--;
-  }
+  WALK_LIST(ifa, p->iface_list)
+    if (ifa->iface == what)
+      return ifa;
 
-  DBG( "RIP: tick tock done\n" );
+  return NULL;
 }
 
-/*
- * rip_start - initialize instance of rip
- */
-static int
-rip_start(struct proto *p)
+static void
+rip_add_iface(struct rip_proto *p, struct iface *iface, struct rip_iface_config *ic)
 {
-  struct rip_interface *rif;
-  DBG( "RIP: starting instance...\n" );
-
-  ASSERT(sizeof(struct rip_packet_heading) == 4);
-  ASSERT(sizeof(struct rip_block) == 20);
-  ASSERT(sizeof(struct rip_block_auth) == 20);
-
-#ifdef LOCAL_DEBUG
-  P->magic = RIP_MAGIC;
-#endif
-  fib_init( &P->rtable, p->pool, sizeof( struct rip_entry ), 0, NULL );
-  init_list( &P->connections );
-  init_list( &P->garbage );
-  init_list( &P->interfaces );
-  P->timer = tm_new( p->pool );
-  P->timer->data = p;
-  P->timer->recurrent = 1;
-  P->timer->hook = rip_timer;
-  tm_start( P->timer, 2 );
-  rif = new_iface(p, NULL, 0, NULL);	/* Initialize dummy interface */
-  add_head( &P->interfaces, NODE rif );
-  CHK_MAGIC;
-
-  DBG( "RIP: ...done\n");
-  return PS_UP;
+  struct rip_iface *ifa;
+
+  TRACE(D_EVENTS, "Adding interface %s", iface->name);
+
+  ifa = mb_allocz(p->p.pool, sizeof(struct rip_iface));
+  ifa->rip = p;
+  ifa->iface = iface;
+  ifa->cf = ic;
+
+  if (ipa_nonzero(ic->address))
+    ifa->addr = ic->address;
+  else if (ic->mode == RIP_IM_MULTICAST)
+    ifa->addr = rip_is_v2(p) ? IP4_RIP_ROUTERS : IP6_RIP_ROUTERS;
+  else /* Broadcast */
+    ifa->addr = iface->addr->brd;
+
+  init_list(&ifa->neigh_list);
+
+  add_tail(&p->iface_list, NODE ifa);
+
+  ifa->timer = tm_new_set(p->p.pool, rip_iface_timer, ifa, 0, 0);
+
+  struct object_lock *lock = olock_new(p->p.pool);
+  lock->type = OBJLOCK_UDP;
+  lock->port = ic->port;
+  lock->iface = iface;
+  lock->data = ifa;
+  lock->hook = rip_iface_locked;
+  ifa->lock = lock;
+
+  olock_acquire(lock);
 }
 
 static void
-rip_dump(struct proto *p)
+rip_remove_iface(struct rip_proto *p, struct rip_iface *ifa)
 {
-  int i;
-  node *w;
-  struct rip_interface *rif;
+  rip_iface_stop(ifa);
 
-  CHK_MAGIC;
-  WALK_LIST( w, P->connections ) {
-    struct rip_connection *n = (void *) w;
-    debug( "RIP: connection #%d: %I\n", n->num, n->addr );
-  }
-  i = 0;
-  FIB_WALK( &P->rtable, e ) {
-    debug( "RIP: entry #%d: ", i++ );
-    rip_dump_entry( (struct rip_entry *)e );
-  } FIB_WALK_END;
-  i = 0;
-  WALK_LIST( rif, P->interfaces ) {
-    debug( "RIP: interface #%d: %s, %I, busy = %x\n", i++, rif->iface?rif->iface->name:"(dummy)", rif->sock->daddr, rif->busy );
-  }
+  TRACE(D_EVENTS, "Removing interface %s", ifa->iface->name);
+
+  rem_node(NODE ifa);
+
+  rfree(ifa->sk);
+  rfree(ifa->lock);
+  rfree(ifa->timer);
+
+  mb_free(ifa);
+}
+
+static int
+rip_reconfigure_iface(struct rip_proto *p, struct rip_iface *ifa, struct rip_iface_config *new)
+{
+  struct rip_iface_config *old = ifa->cf;
+
+  /* Change of these options would require to reset the iface socket */
+  if ((new->mode != old->mode) ||
+      (new->port != old->port) ||
+      (new->tx_tos != old->tx_tos) ||
+      (new->tx_priority != old->tx_priority) ||
+      (new->ttl_security != old->ttl_security))
+    return 0;
+
+  TRACE(D_EVENTS, "Reconfiguring interface %s", ifa->iface->name);
+
+  ifa->cf = new;
+
+  if (ifa->next_regular > (now + new->update_time))
+    ifa->next_regular = now + (random() % new->update_time) + 1;
+
+  if ((new->tx_length != old->tx_length) || (new->rx_buffer != old->rx_buffer))
+    rip_iface_update_buffers(ifa);
+
+  if (new->check_link != old->check_link)
+    rip_iface_update_state(ifa);
+
+  if (new->bfd != old->bfd)
+    rip_iface_update_bfd(ifa);
+
+  if (ifa->up)
+    rip_iface_kick_timer(ifa);
+
+  return 1;
 }
 
 static void
-rip_get_route_info(rte *rte, byte *buf, ea_list *attrs)
+rip_reconfigure_ifaces(struct rip_proto *p, struct rip_config *cf)
 {
-  eattr *metric = ea_find(attrs, EA_RIP_METRIC);
-  eattr *tag = ea_find(attrs, EA_RIP_TAG);
+  struct iface *iface;
+
+  WALK_LIST(iface, iface_list)
+  {
+    if (! (iface->flags & IF_UP))
+      continue;
+
+    struct rip_iface *ifa = rip_find_iface(p, iface);
+    struct rip_iface_config *ic = (void *) iface_patt_find(&cf->patt_list, iface, NULL);
 
-  buf += bsprintf(buf, " (%d/%d)", rte->pref, metric ? metric->u.data : 0);
-  if (tag && tag->u.data)
-    bsprintf(buf, " t%04x", tag->u.data);
+    if (ifa && ic)
+    {
+      if (rip_reconfigure_iface(p, ifa, ic))
+	continue;
+
+      /* Hard restart */
+      log(L_INFO "%s: Restarting interface %s", p->p.name, ifa->iface->name);
+      rip_remove_iface(p, ifa);
+      rip_add_iface(p, iface, ic);
+    }
+
+    if (ifa && !ic)
+      rip_remove_iface(p, ifa);
+
+    if (!ifa && ic)
+      rip_add_iface(p, iface, ic);
+  }
 }
 
 static void
-kill_iface(struct rip_interface *i)
+rip_if_notify(struct proto *P, unsigned flags, struct iface *iface)
 {
-  DBG( "RIP: Interface %s disappeared\n", i->iface->name);
-  rfree(i->sock);
-  mb_free(i);
+  struct rip_proto *p = (void *) P;
+  struct rip_config *cf = (void *) P->cf;
+
+  if (iface->flags & IF_IGNORE)
+    return;
+
+  if (flags & IF_CHANGE_UP)
+  {
+    struct rip_iface_config *ic = (void *) iface_patt_find(&cf->patt_list, iface, NULL);
+
+    if (ic)
+      rip_add_iface(p, iface, ic);
+
+    return;
+  }
+
+  struct rip_iface *ifa = rip_find_iface(p, iface);
+
+  if (!ifa)
+    return;
+
+  if (flags & IF_CHANGE_DOWN)
+  {
+    rip_remove_iface(p, ifa);
+    return;
+  }
+
+  if (flags & IF_CHANGE_MTU)
+    rip_iface_update_buffers(ifa);
+
+  if (flags & IF_CHANGE_LINK)
+    rip_iface_update_state(ifa);
 }
 
+
+/*
+ *	RIP timer events
+ */
+
 /**
- * new_iface
- * @p: myself
- * @new: interface to be created or %NULL if we are creating a magic
- * socket. The magic socket is used for listening and also for
- * sending requested responses.
- * @flags: interface flags
- * @patt: pattern this interface matched, used for access to config options
+ * rip_timer - RIP main timer hook
+ * @t: timer
  *
- * Create an interface structure and start listening on the interface.
+ * The RIP main timer is responsible for routing table maintenance. Invalid or
+ * expired routes (&rip_rte) are removed and garbage collection of stale routing
+ * table entries (&rip_entry) is done. Changes are propagated to core tables,
+ * route reload is also done here. Note that garbage collection uses a maximal
+ * GC time, while interfaces maintain an illusion of per-interface GC times in
+ * rip_send_response().
+ *
+ * Keeping incoming routes and the selected outgoing route are two independent
+ * functions, therefore after garbage collection some entries now considered
+ * invalid (RIP_ENTRY_DUMMY) still may have non-empty list of incoming routes,
+ * while some valid entries (representing an outgoing route) may have that list
+ * empty.
+ *
+ * The main timer is not scheduled periodically but it uses the time of the
+ * current next event and the minimal interval of any possible event to compute
+ * the time of the next run.
  */
-static struct rip_interface *
-new_iface(struct proto *p, struct iface *new, unsigned long flags, struct iface_patt *patt )
+static void
+rip_timer(timer *t)
 {
-  struct rip_interface *rif;
-  struct rip_patt *PATT = (struct rip_patt *) patt;
-
-  rif = mb_allocz(p->pool, sizeof( struct rip_interface ));
-  rif->iface = new;
-  rif->proto = p;
-  rif->busy = NULL;
-  if (PATT) {
-    rif->mode = PATT->mode;
-    rif->metric = PATT->metric;
-    rif->multicast = (!(PATT->mode & IM_BROADCAST)) && (flags & IF_MULTICAST);
-    rif->check_ttl = (PATT->ttl_security == 1);
-  }
-  /* lookup multicasts over unnumbered links - no: rip is not defined over unnumbered links */
-
-  if (rif->multicast)
-    DBG( "Doing multicasts!\n" );
-
-  rif->sock = sk_new( p->pool );
-  rif->sock->type = SK_UDP;
-  rif->sock->sport = P_CF->port;
-  rif->sock->rx_hook = rip_rx;
-  rif->sock->data = rif;
-  rif->sock->rbsize = 10240;
-  rif->sock->iface = new;		/* Automagically works for dummy interface */
-  rif->sock->tbuf = mb_alloc( p->pool, sizeof( struct rip_packet ));
-  rif->sock->tx_hook = rip_tx;
-  rif->sock->err_hook = rip_tx_err;
-  rif->sock->daddr = IPA_NONE;
-  rif->sock->dport = P_CF->port;
-  if (new)
+  struct rip_proto *p = t->data;
+  struct rip_config *cf = (void *) (p->p.cf);
+  struct rip_iface *ifa;
+  struct rip_neighbor *n, *nn;
+  struct fib_iterator fit;
+  bird_clock_t next = now + MIN(cf->min_timeout_time, cf->max_garbage_time);
+  bird_clock_t expires = 0;
+
+  TRACE(D_EVENTS, "Main timer fired");
+
+  FIB_ITERATE_INIT(&fit, &p->rtable);
+
+  loop:
+  FIB_ITERATE_START(&p->rtable, &fit, node)
+  {
+    struct rip_entry *en = (struct rip_entry *) node;
+    struct rip_rte *rt, **rp;
+    int changed = 0;
+
+    /* Checking received routes for timeout and for dead neighbors */
+    for (rp = &en->routes; rt = *rp; /* rp = &rt->next */)
     {
-      rif->sock->tos = PATT->tx_tos;
-      rif->sock->priority = PATT->tx_priority;
-      rif->sock->ttl = PATT->ttl_security ? 255 : 1;
-      rif->sock->flags = SKF_LADDR_RX | (rif->check_ttl ? SKF_TTL_RX : 0);
-    }
+      if (!rip_valid_rte(rt) || (rt->expires <= now))
+      {
+	rip_remove_rte(p, rp);
+	changed = 1;
+	continue;
+      }
 
-  if (new) {
-    if (new->addr->flags & IA_PEER)
-      log( L_WARN "%s: rip is not defined over unnumbered links", p->name );
-    if (rif->multicast) {
-#ifndef IPV6
-      rif->sock->daddr = ipa_from_u32(0xe0000009);
-#else
-      rif->sock->daddr = IP6_RIP_ROUTERS;
-#endif
-    } else {
-      rif->sock->daddr = new->addr->brd;
+      next = MIN(next, rt->expires);
+      rp = &rt->next;
     }
-  }
 
-  if (!ipa_nonzero(rif->sock->daddr)) {
-    if (rif->iface)
-      log( L_WARN "%s: interface %s is too strange for me", p->name, rif->iface->name );
-  } else {
+    /* Propagating eventual change */
+    if (changed || p->rt_reload)
+    {
+      /*
+       * We have to restart the iteration because there may be a cascade of
+       * synchronous events rip_announce_rte() -> nest table change ->
+       * rip_rt_notify() -> p->rtable change, invalidating hidden variables.
+       */
+
+      FIB_ITERATE_PUT_NEXT(&fit, &p->rtable, node);
+      rip_announce_rte(p, en);
+      goto loop;
+    }
 
-    if (sk_open(rif->sock) < 0)
-      goto err;
+    /* Checking stale entries for garbage collection timeout */
+    if (en->valid == RIP_ENTRY_STALE)
+    {
+      expires = en->changed + cf->max_garbage_time;
 
-    if (rif->multicast)
+      if (expires <= now)
       {
-	if (sk_setup_multicast(rif->sock) < 0)
-	  goto err;
-	if (sk_join_group(rif->sock, rif->sock->daddr) < 0)
-	  goto err;
+	// TRACE(D_EVENTS, "entry is too old: %I/%d", en->n.prefix, en->n.pxlen);
+	en->valid = 0;
       }
-    else
+      else
+	next = MIN(next, expires);
+    }
+
+    /* Remove empty nodes */
+    if (!en->valid && !en->routes)
+    {
+      FIB_ITERATE_PUT(&fit, node);
+      fib_delete(&p->rtable, node);
+      goto loop;
+    }
+  }
+  FIB_ITERATE_END(node);
+
+  p->rt_reload = 0;
+
+  /* Handling neighbor expiration */
+  WALK_LIST(ifa, p->iface_list)
+    WALK_LIST_DELSAFE(n, nn, ifa->neigh_list)
+      if (n->last_seen)
       {
-	if (sk_setup_broadcast(rif->sock) < 0)
-	  goto err;
+	expires = n->last_seen + n->ifa->cf->timeout_time;
+
+	if (expires <= now)
+	  rip_remove_neighbor(p, n);
+	else
+	  next = MIN(next, expires);
       }
-  }
 
-  TRACE(D_EVENTS, "Listening on %s, port %d, mode %s (%I)", rif->iface ? rif->iface->name : "(dummy)", P_CF->port, rif->multicast ? "multicast" : "broadcast", rif->sock->daddr );
-  
-  return rif;
+  tm_start(p->timer, MAX(next - now, 1));
+}
+
+static inline void
+rip_kick_timer(struct rip_proto *p)
+{
+  if (p->timer->expires > (now + 1))
+    tm_start(p->timer, 1);	/* Or 100 ms */
+}
 
- err:
-  sk_log_error(rif->sock, p->name);
-  log(L_ERR "%s: Cannot open socket for %s", p->name, rif->iface ? rif->iface->name : "(dummy)" );
-  if (rif->iface) {
-    rfree(rif->sock);
-    mb_free(rif);
-    return NULL;
+/**
+ * rip_iface_timer - RIP interface timer hook
+ * @t: timer
+ *
+ * RIP interface timers are responsible for scheduling both regular and
+ * triggered updates. Fixed, delay-independent period is used for regular
+ * updates, while minimal separating interval is enforced for triggered updates.
+ * The function also ensures that a new update is not started when the old one
+ * is still running.
+ */
+static void
+rip_iface_timer(timer *t)
+{
+  struct rip_iface *ifa = t->data;
+  struct rip_proto *p = ifa->rip;
+  bird_clock_t period = ifa->cf->update_time;
+
+  if (ifa->cf->passive)
+    return;
+
+  TRACE(D_EVENTS, "Interface timer fired for %s", ifa->iface->name);
+
+  if (ifa->tx_active)
+  {
+    if (now < (ifa->next_regular + period))
+      { tm_start(ifa->timer, 1); return; }
+
+    /* We are too late, reset is done by rip_send_table() */
+    log(L_WARN "%s: Too slow update on %s, resetting", p->p.name, ifa->iface->name);
   }
-  /* On dummy, we just return non-working socket, so that user gets error every time anyone requests table */
-  return rif;
+
+  if (now >= ifa->next_regular)
+  {
+    /* Send regular update, set timer for next period (or following one if necessay) */
+    TRACE(D_EVENTS, "Sending regular updates for %s", ifa->iface->name);
+    rip_send_table(p, ifa, ifa->addr, 0);
+    ifa->next_regular += period * (1 + ((now - ifa->next_regular) / period));
+    ifa->want_triggered = 0;
+    p->triggered = 0;
+  }
+  else if (ifa->want_triggered && (now >= ifa->next_triggered))
+  {
+    /* Send triggered update, enforce interval between triggered updates */
+    TRACE(D_EVENTS, "Sending triggered updates for %s", ifa->iface->name);
+    rip_send_table(p, ifa, ifa->addr, ifa->want_triggered);
+    ifa->next_triggered = now + MIN(5, period / 2 + 1);
+    ifa->want_triggered = 0;
+    p->triggered = 0;
+  }
+
+  tm_start(ifa->timer, ifa->want_triggered ? 1 : (ifa->next_regular - now));
 }
 
-static void
-rip_real_if_add(struct object_lock *lock)
+static inline void
+rip_iface_kick_timer(struct rip_iface *ifa)
 {
-  struct iface *iface = lock->iface;
-  struct proto *p = lock->data;
-  struct rip_interface *rif;
-  struct iface_patt *k = iface_patt_find(&P_CF->iface_list, iface, iface->addr);
-
-  if (!k)
-    bug("This can not happen! It existed few seconds ago!" );
-  DBG("adding interface %s\n", iface->name );
-  rif = new_iface(p, iface, iface->flags, k);
-  if (rif) {
-    add_head( &P->interfaces, NODE rif );
-    DBG("Adding object lock of %p for %p\n", lock, rif);
-    rif->lock = lock;
-  } else { rfree(lock); }
+  if (ifa->timer->expires > (now + 1))
+    tm_start(ifa->timer, 1);	/* Or 100 ms */
 }
 
 static void
-rip_if_notify(struct proto *p, unsigned c, struct iface *iface)
+rip_trigger_update(struct rip_proto *p)
 {
-  DBG( "RIP: if notify\n" );
-  if (iface->flags & IF_IGNORE)
+  if (p->triggered)
     return;
-  if (c & IF_CHANGE_DOWN) {
-    struct rip_interface *i;
-    i = find_interface(p, iface);
-    if (i) {
-      rem_node(NODE i);
-      rfree(i->lock);
-      kill_iface(i);
-    }
-  }
-  if (c & IF_CHANGE_UP) {
-    struct iface_patt *k = iface_patt_find(&P_CF->iface_list, iface, iface->addr);
-    struct object_lock *lock;
-    struct rip_patt *PATT = (struct rip_patt *) k;
-
-    if (!k) return; /* We are not interested in this interface */
-
-    lock = olock_new( p->pool );
-    if (!(PATT->mode & IM_BROADCAST) && (iface->flags & IF_MULTICAST))
-#ifndef IPV6
-      lock->addr = ipa_from_u32(0xe0000009);
-#else
-      lock->addr = IP6_RIP_ROUTERS;
-#endif
-    else
-      lock->addr = iface->addr->brd;
-    lock->port = P_CF->port;
-    lock->iface = iface;
-    lock->hook = rip_real_if_add;
-    lock->data = p;
-    lock->type = OBJLOCK_UDP;
-    olock_acquire(lock);
+
+  struct rip_iface *ifa;
+  WALK_LIST(ifa, p->iface_list)
+  {
+    /* Interface not active */
+    if (! ifa->up)
+      continue;
+
+    /* Already scheduled */
+    if (ifa->want_triggered)
+      continue;
+
+    TRACE(D_EVENTS, "Scheduling triggered updates for %s", ifa->iface->name);
+    ifa->want_triggered = now;
+    rip_iface_kick_timer(ifa);
   }
+
+  p->triggered = 1;
 }
 
+
+/*
+ *	RIP protocol glue
+ */
+
 static struct ea_list *
-rip_gen_attrs(struct linpool *pool, int metric, u16 tag)
+rip_prepare_attrs(struct linpool *pool, ea_list *next, u8 metric, u16 tag)
 {
-  struct ea_list *l = lp_alloc(pool, sizeof(struct ea_list) + 2*sizeof(eattr));
+  struct ea_list *l = lp_alloc(pool, sizeof(struct ea_list) + 2 * sizeof(eattr));
 
-  l->next = NULL;
+  l->next = next;
   l->flags = EALF_SORTED;
   l->count = 2;
-  l->attrs[0].id = EA_RIP_TAG;
+
+  l->attrs[0].id = EA_RIP_METRIC;
   l->attrs[0].flags = 0;
   l->attrs[0].type = EAF_TYPE_INT | EAF_TEMP;
-  l->attrs[0].u.data = tag;
-  l->attrs[1].id = EA_RIP_METRIC;
+  l->attrs[0].u.data = metric;
+
+  l->attrs[1].id = EA_RIP_TAG;
   l->attrs[1].flags = 0;
   l->attrs[1].type = EAF_TYPE_INT | EAF_TEMP;
-  l->attrs[1].u.data = metric;
+  l->attrs[1].u.data = tag;
+
   return l;
 }
 
 static int
-rip_import_control(struct proto *p, struct rte **rt, struct ea_list **attrs, struct linpool *pool)
+rip_import_control(struct proto *P, struct rte **rt, struct ea_list **attrs, struct linpool *pool)
 {
-  if ((*rt)->attrs->src->proto == p)	/* My own must not be touched */
-    return 1;
+  /* Prepare attributes with initial values */
+  if ((*rt)->attrs->source != RTS_RIP)
+    *attrs = rip_prepare_attrs(pool, *attrs, 1, 0);
 
-  if ((*rt)->attrs->source != RTS_RIP) {
-    struct ea_list *new = rip_gen_attrs(pool, 1, 0);
-    new->next = *attrs;
-    *attrs = new;
-  }
   return 0;
 }
 
+static int
+rip_reload_routes(struct proto *P)
+{
+  struct rip_proto *p = (struct rip_proto *) P;
+
+  if (p->rt_reload)
+    return 1;
+
+  TRACE(D_EVENTS, "Scheduling route reload");
+  p->rt_reload = 1;
+  rip_kick_timer(p);
+
+  return 1;
+}
+
 static struct ea_list *
 rip_make_tmp_attrs(struct rte *rt, struct linpool *pool)
 {
-  return rip_gen_attrs(pool, rt->u.rip.metric, rt->u.rip.tag);
+  return rip_prepare_attrs(pool, NULL, rt->u.rip.metric, rt->u.rip.tag);
 }
 
-static void 
+static void
 rip_store_tmp_attrs(struct rte *rt, struct ea_list *attrs)
 {
-  rt->u.rip.tag = ea_get_int(attrs, EA_RIP_TAG, 0);
   rt->u.rip.metric = ea_get_int(attrs, EA_RIP_METRIC, 1);
+  rt->u.rip.tag = ea_get_int(attrs, EA_RIP_TAG, 0);
 }
 
-/*
- * rip_rt_notify - core tells us about new route (possibly our
- * own), so store it into our data structures. 
- */
-static void
-rip_rt_notify(struct proto *p, struct rtable *table UNUSED, struct network *net,
-	      struct rte *new, struct rte *old UNUSED, struct ea_list *attrs)
+static int
+rip_rte_better(struct rte *new, struct rte *old)
 {
-  CHK_MAGIC;
-  struct rip_entry *e;
-
-  e = fib_find( &P->rtable, &net->n.prefix, net->n.pxlen );
-  if (e)
-    fib_delete( &P->rtable, e );
-
-  if (new) {
-    e = fib_get( &P->rtable, &net->n.prefix, net->n.pxlen );
-
-    e->nexthop = new->attrs->gw;
-    e->metric = 0;
-    e->whotoldme = IPA_NONE;
-    new->u.rip.entry = e;
-
-    e->tag = ea_get_int(attrs, EA_RIP_TAG, 0);
-    e->metric = ea_get_int(attrs, EA_RIP_METRIC, 1);
-    if (e->metric > P_CF->infinity)
-      e->metric = P_CF->infinity;
-
-    if (new->attrs->src->proto == p)
-      e->whotoldme = new->attrs->from;
-
-    if (!e->metric)	/* That's okay: this way user can set his own value for external
-			   routes in rip. */
-      e->metric = 5;
-    e->updated = e->changed = now;
-    e->flags = 0;
-  }
+  return new->u.rip.metric < old->u.rip.metric;
 }
 
 static int
 rip_rte_same(struct rte *new, struct rte *old)
 {
-  /* new->attrs == old->attrs always */
-  return new->u.rip.metric == old->u.rip.metric;
+  return ((new->u.rip.metric == old->u.rip.metric) &&
+	  (new->u.rip.tag == old->u.rip.tag) &&
+	  (new->u.rip.from == old->u.rip.from));
 }
 
 
+static struct proto *
+rip_init(struct proto_config *cfg)
+{
+  struct proto *P = proto_new(cfg, sizeof(struct rip_proto));
+
+  P->accept_ra_types = RA_OPTIMAL;
+  P->if_notify = rip_if_notify;
+  P->rt_notify = rip_rt_notify;
+  P->neigh_notify = rip_neigh_notify;
+  P->import_control = rip_import_control;
+  P->reload_routes = rip_reload_routes;
+  P->make_tmp_attrs = rip_make_tmp_attrs;
+  P->store_tmp_attrs = rip_store_tmp_attrs;
+  P->rte_better = rip_rte_better;
+  P->rte_same = rip_rte_same;
+
+  return P;
+}
+
 static int
-rip_rte_better(struct rte *new, struct rte *old)
+rip_start(struct proto *P)
 {
-  struct proto *p = new->attrs->src->proto;
+  struct rip_proto *p = (void *) P;
+  struct rip_config *cf = (void *) (P->cf);
 
-  if (ipa_equal(old->attrs->from, new->attrs->from))
-    return 1;
+  init_list(&p->iface_list);
+  fib_init(&p->rtable, P->pool, sizeof(struct rip_entry), 0, rip_init_entry);
+  p->rte_slab = sl_new(P->pool, sizeof(struct rip_rte));
+  p->timer = tm_new_set(P->pool, rip_timer, p, 0, 0);
 
-  if (old->u.rip.metric < new->u.rip.metric)
-    return 0;
+  p->ecmp = cf->ecmp;
+  p->infinity = cf->infinity;
+  p->triggered = 0;
 
-  if (old->u.rip.metric > new->u.rip.metric)
-    return 1;
+  p->log_pkt_tbf = (struct tbf){ .rate = 1, .burst = 5 };
+  p->log_rte_tbf = (struct tbf){ .rate = 4, .burst = 20 };
 
-  if (old->attrs->src->proto == new->attrs->src->proto)		/* This does not make much sense for different protocols */
-    if ((old->u.rip.metric == new->u.rip.metric) &&
-	((now - old->lastmod) > (P_CF->timeout_time / 2)))
-      return 1;
+  tm_start(p->timer, MIN(cf->min_timeout_time, cf->max_garbage_time));
 
-  return 0;
+  return PS_UP;
 }
 
-/*
- * rip_rte_insert - we maintain linked list of "our" entries in main
- * routing table, so that we can timeout them correctly. rip_timer()
- * walks the list.
- */
-static void
-rip_rte_insert(net *net UNUSED, rte *rte)
+static int
+rip_reconfigure(struct proto *P, struct proto_config *c)
 {
-  struct proto *p = rte->attrs->src->proto;
-  CHK_MAGIC;
-  DBG( "rip_rte_insert: %p\n", rte );
-  add_head( &P->garbage, &rte->u.rip.garbage );
-}
+  struct rip_proto *p = (void *) P;
+  struct rip_config *new = (void *) c;
+  // struct rip_config *old = (void *) (P->cf);
 
-/*
- * rip_rte_remove - link list maintenance
- */
-static void
-rip_rte_remove(net *net UNUSED, rte *rte)
-{
-#ifdef LOCAL_DEBUG
-  struct proto *p = rte->attrs->src->proto;
-  CHK_MAGIC;
-  DBG( "rip_rte_remove: %p\n", rte );
-#endif
-  rem_node( &rte->u.rip.garbage );
-}
+  if (new->infinity != p->infinity)
+    return 0;
 
-static struct proto *
-rip_init(struct proto_config *cfg)
-{
-  struct proto *p = proto_new(cfg, sizeof(struct rip_proto));
-
-  p->accept_ra_types = RA_OPTIMAL;
-  p->if_notify = rip_if_notify;
-  p->rt_notify = rip_rt_notify;
-  p->import_control = rip_import_control;
-  p->make_tmp_attrs = rip_make_tmp_attrs;
-  p->store_tmp_attrs = rip_store_tmp_attrs;
-  p->rte_better = rip_rte_better;
-  p->rte_same = rip_rte_same;
-  p->rte_insert = rip_rte_insert;
-  p->rte_remove = rip_rte_remove;
-
-  return p;
+  TRACE(D_EVENTS, "Reconfiguring");
+
+  p->p.cf = c;
+  p->ecmp = new->ecmp;
+  rip_reconfigure_ifaces(p, new);
+
+  p->rt_reload = 1;
+  rip_kick_timer(p);
+
+  return 1;
 }
 
-void
-rip_init_config(struct rip_proto_config *c)
+static void
+rip_get_route_info(rte *rte, byte *buf, ea_list *attrs)
 {
-  init_list(&c->iface_list);
-  c->infinity	= 16;
-  c->port	= RIP_PORT;
-  c->period	= 30;
-  c->garbage_time = 120+180;
-  c->timeout_time = 120;
-  c->passwords	= NULL;
-  c->authtype	= AT_NONE;
+  buf += bsprintf(buf, " (%d/%d)", rte->pref, rte->u.rip.metric);
+
+  if (rte->u.rip.tag)
+    bsprintf(buf, " [%04x]", rte->u.rip.tag);
 }
 
 static int
 rip_get_attr(eattr *a, byte *buf, int buflen UNUSED)
 {
-  switch (a->id) {
-  case EA_RIP_METRIC: bsprintf( buf, "metric: %d", a->u.data ); return GA_FULL;
-  case EA_RIP_TAG:    bsprintf( buf, "tag: %d", a->u.data );    return GA_FULL;
-  default: return GA_UNKNOWN;
+  switch (a->id)
+  {
+  case EA_RIP_METRIC:
+    bsprintf(buf, "metric: %d", a->u.data);
+    return GA_FULL;
+
+  case EA_RIP_TAG:
+    bsprintf(buf, "tag: %04x", a->u.data);
+    return GA_FULL;
+
+  default:
+    return GA_UNKNOWN;
   }
 }
 
-static int
-rip_pat_compare(struct rip_patt *a, struct rip_patt *b)
+void
+rip_show_interfaces(struct proto *P, char *iff)
 {
-  return ((a->metric == b->metric) &&
-	  (a->mode == b->mode) &&
-	  (a->tx_tos == b->tx_tos) &&
-	  (a->tx_priority == b->tx_priority));
+  struct rip_proto *p = (void *) P;
+  struct rip_iface *ifa = NULL;
+  struct rip_neighbor *n = NULL;
+
+  if (p->p.proto_state != PS_UP)
+  {
+    cli_msg(-1021, "%s: is not up", p->p.name);
+    cli_msg(0, "");
+    return;
+  }
+
+  cli_msg(-1021, "%s:", p->p.name);
+  cli_msg(-1021, "%-10s %-6s %6s %6s %6s",
+	  "Interface", "State", "Metric", "Nbrs", "Timer");
+
+  WALK_LIST(ifa, p->iface_list)
+  {
+    if (iff && !patmatch(iff, ifa->iface->name))
+      continue;
+
+    int nbrs = 0;
+    WALK_LIST(n, ifa->neigh_list)
+      if (n->last_seen)
+	nbrs++;
+
+    int timer = MAX(ifa->next_regular - now, 0);
+    cli_msg(-1021, "%-10s %-6s %6u %6u %6u",
+	    ifa->iface->name, (ifa->up ? "Up" : "Down"), ifa->cf->metric, nbrs, timer);
+  }
+
+  cli_msg(0, "");
 }
 
-static int
-rip_reconfigure(struct proto *p, struct proto_config *c)
+void
+rip_show_neighbors(struct proto *P, char *iff)
 {
-  struct rip_proto_config *new = (struct rip_proto_config *) c;
-  int generic = sizeof(struct proto_config) + sizeof(list) /* + sizeof(struct password_item *) */;
+  struct rip_proto *p = (void *) P;
+  struct rip_iface *ifa = NULL;
+  struct rip_neighbor *n = NULL;
 
-  if (!iface_patts_equal(&P_CF->iface_list, &new->iface_list, (void *) rip_pat_compare))
-    return 0;
-  return !memcmp(((byte *) P_CF) + generic,
-                 ((byte *) new) + generic,
-                 sizeof(struct rip_proto_config) - generic);
+  if (p->p.proto_state != PS_UP)
+  {
+    cli_msg(-1022, "%s: is not up", p->p.name);
+    cli_msg(0, "");
+    return;
+  }
+
+  cli_msg(-1022, "%s:", p->p.name);
+  cli_msg(-1022, "%-25s %-10s %6s %6s %6s",
+	  "IP address", "Interface", "Metric", "Routes", "Seen");
+
+  WALK_LIST(ifa, p->iface_list)
+  {
+    if (iff && !patmatch(iff, ifa->iface->name))
+      continue;
+
+    WALK_LIST(n, ifa->neigh_list)
+    {
+      if (!n->last_seen)
+	continue;
+
+      int timer = now - n->last_seen;
+      cli_msg(-1022, "%-25I %-10s %6u %6u %6u",
+	      n->nbr->addr, ifa->iface->name, ifa->cf->metric, n->uc, timer);
+    }
+  }
+
+  cli_msg(0, "");
 }
 
 static void
-rip_copy_config(struct proto_config *dest, struct proto_config *src)
+rip_dump(struct proto *P)
 {
-  /* Shallow copy of everything */
-  proto_copy_rest(dest, src, sizeof(struct rip_proto_config));
+  struct rip_proto *p = (struct rip_proto *) P;
+  struct rip_iface *ifa;
+  int i;
 
-  /* We clean up iface_list, ifaces are non-sharable */
-  init_list(&((struct rip_proto_config *) dest)->iface_list);
+  i = 0;
+  FIB_WALK(&p->rtable, e)
+  {
+    struct rip_entry *en = (struct rip_entry *) e;
+    debug("RIP: entry #%d: %I/%d via %I dev %s valid %d metric %d age %d s\n",
+	  i++, en->n.prefix, en->n.pxlen, en->next_hop, en->iface->name,
+	  en->valid, en->metric, now - en->changed);
+  }
+  FIB_WALK_END;
 
-  /* Copy of passwords is OK, it just will be replaced in dest when used */
+  i = 0;
+  WALK_LIST(ifa, p->iface_list)
+  {
+    debug("RIP: interface #%d: %s, %I, up = %d, busy = %d\n",
+	  i++, ifa->iface->name, ifa->sk ? ifa->sk->daddr : IPA_NONE,
+	  ifa->up, ifa->tx_active);
+  }
 }
 
 
@@ -1050,12 +1278,11 @@ struct protocol proto_rip = {
   .template =		"rip%d",
   .attr_class =		EAP_RIP,
   .preference =		DEF_PREF_RIP,
-  .config_size =	sizeof(struct rip_proto_config),
+  .config_size =	sizeof(struct rip_config),
   .init =		rip_init,
   .dump =		rip_dump,
   .start =		rip_start,
   .reconfigure =	rip_reconfigure,
-  .copy_config =	rip_copy_config,
   .get_route_info =	rip_get_route_info,
   .get_attr =		rip_get_attr
 };
diff --git a/proto/rip/rip.h b/proto/rip/rip.h
index 2a327260..f245e612 100644
--- a/proto/rip/rip.h
+++ b/proto/rip/rip.h
@@ -1,185 +1,227 @@
 /*
- * Structures for RIP protocol
+ *	BIRD -- Routing Information Protocol (RIP)
  *
-   FIXME: in V6, they insert additional entry whenever next hop differs. Such entry is identified by 0xff in metric.
+ *	(c) 1998--1999 Pavel Machek <pavel@ucw.cz>
+ *	(c) 2004--2013 Ondrej Filip <feela@network.cz>
+ *	(c) 2009--2015 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2009--2015 CZ.NIC z.s.p.o.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
  */
 
+#ifndef _BIRD_RIP_H_
+#define _BIRD_RIP_H_
+
+#include "nest/bird.h"
+#include "nest/cli.h"
+#include "nest/iface.h"
+#include "nest/protocol.h"
 #include "nest/route.h"
 #include "nest/password.h"
 #include "nest/locks.h"
+#include "nest/bfd.h"
+#include "lib/lists.h"
+#include "lib/resource.h"
+#include "lib/socket.h"
+#include "lib/string.h"
+#include "lib/timer.h"
 
-#define EA_RIP_TAG	EA_CODE(EAP_RIP, 0)
-#define EA_RIP_METRIC	EA_CODE(EAP_RIP, 1)
 
-#define PACKET_MAX	25
-#define PACKET_MD5_MAX	18	/* FIXME */
+#ifdef IPV6
+#define RIP_IS_V2 0
+#else
+#define RIP_IS_V2 1
+#endif
 
+#define RIP_V1			1
+#define RIP_V2			2
 
-#define RIP_V1		1
-#define RIP_V2		2
-#define RIP_NG		1	/* A new version numbering */
+#define RIP_PORT		520	/* RIP for IPv4 */
+#define RIP_NG_PORT		521	/* RIPng */
 
-#ifndef IPV6
-#define RIP_PORT	520	/* RIP for IPv4 */
-#else
-#define RIP_PORT	521	/* RIPng */
-#endif
+#define RIP_MAX_PKT_LENGTH	532	/* 512 + IP4_HEADER_LENGTH */
+#define RIP_AUTH_TAIL_LENGTH	20	/* 4 + MD5 length */
 
-struct rip_connection {
-  node n;
+#define RIP_DEFAULT_ECMP_LIMIT	16
+#define RIP_DEFAULT_INFINITY	16
+#define RIP_DEFAULT_UPDATE_TIME	30
+#define RIP_DEFAULT_TIMEOUT_TIME 180
+#define RIP_DEFAULT_GARBAGE_TIME 120
 
-  int num;
-  struct proto *proto;
-  ip_addr addr;
-  sock *send;
-  struct rip_interface *rif;
-  struct fib_iterator iter;
 
-  ip_addr daddr;
-  int dport;
-  int done;
-};
+struct rip_config
+{
+  struct proto_config c;
+  list patt_list;			/* List of iface configs (struct rip_iface_config) */
 
-struct rip_packet_heading {		/* 4 bytes */
-  u8 command;
-#define RIPCMD_REQUEST          1       /* want info */
-#define RIPCMD_RESPONSE         2       /* responding to request */
-#define RIPCMD_TRACEON          3       /* turn tracing on */
-#define RIPCMD_TRACEOFF         4       /* turn it off */
-#define RIPCMD_MAX              5
-  u8 version;
-#define RIP_V1			1
-#define RIP_V2			2
-#define RIP_NG 			1	/* this is verion 1 of RIPng */
-  u16 unused;
+  u8 rip2;				/* RIPv2 (IPv4) or RIPng (IPv6) */
+  u8 ecmp;				/* Maximum number of nexthops in ECMP route, or 0 */
+  u8 infinity;				/* Maximum metric value, representing infinity */
+
+  u32 min_timeout_time;			/* Minimum of interface timeout_time */
+  u32 max_garbage_time;			/* Maximum of interface garbage_time */
 };
 
-#ifndef IPV6
-struct rip_block {	/* 20 bytes */
-  u16 family;	/* 0xffff on first message means this is authentication */
-  u16 tag;
-  ip_addr network;
-  ip_addr netmask;
-  ip_addr nexthop;
-  u32 metric;
+struct rip_iface_config
+{
+  struct iface_patt i;
+  ip_addr address;			/* Configured dst address */
+  u16 port;				/* Src+dst port */
+  u8 metric;				/* Incoming metric */
+  u8 mode;				/* Interface mode (RIP_IM_*) */
+  u8 passive;				/* Passive iface - no packets are sent */
+  u8 version;				/* RIP version used for outgoing packets */
+  u8 version_only;	/* FIXXX */
+  u8 split_horizon;			/* Split horizon is used in route updates */
+  u8 poison_reverse;			/* Poisoned reverse is used in route updates */
+  u8 check_zero;			/* Validation of RIPv1 reserved fields */
+  u8 ecmp_weight;			/* Weight for ECMP routes*/
+  u8 auth_type;				/* Authentication type (RIP_AUTH_*) */
+  u8 ttl_security;			/* bool + 2 for TX only (send, but do not check on RX) */
+  u8 check_link;			/* Whether iface link change is used */
+  u8 bfd;				/* Use BFD on iface */
+  u16 rx_buffer;			/* RX buffer size, 0 for MTU */
+  u16 tx_length;			/* TX packet length limit (including headers), 0 for MTU */
+  int tx_tos;
+  int tx_priority;
+  u32 update_time;			/* Periodic update interval */
+  u32 timeout_time;			/* Route expiration timeout */
+  u32 garbage_time;			/* Unreachable entry GC timeout */
+  list *passwords;			/* Passwords for authentication */
 };
-#else
-struct rip_block { /* IPv6 version!, 20 bytes, too */
-  ip_addr network;
-  u16 tag;
-  u8 pxlen;
-  u8 metric;
+
+struct rip_proto
+{
+  struct proto p;
+  struct fib rtable;			/* Internal routing table */
+  list iface_list;			/* List of interfaces (struct rip_iface) */
+  slab *rte_slab;			/* Slab for internal routes (struct rip_rte) */
+  timer *timer;				/* Main protocol timer */
+
+  u8 ecmp;				/* Maximum number of nexthops in ECMP route, or 0 */
+  u8 infinity;				/* Maximum metric value, representing infinity */
+  u8 triggered;				/* Logical AND of interface want_triggered values */
+  u8 rt_reload;				/* Route reload is scheduled */
+
+  struct tbf log_pkt_tbf;		/* TBF for packet messages */
+  struct tbf log_rte_tbf;		/* TBF for RTE messages */
 };
-#endif
 
-struct rip_block_auth { /* 20 bytes */
-  u16 mustbeFFFF;
-  u16 authtype;
-  u16 packetlen;
-  u8 keyid;
-  u8 authlen;
-  u32 seq;
-  u32 zero0;
-  u32 zero1;
+struct rip_iface
+{
+  node n;
+  struct rip_proto *rip;
+  struct iface *iface;			/* Underyling core interface */
+  struct rip_iface_config *cf;		/* Related config, must be updated in reconfigure */
+  struct object_lock *lock;		/* Interface lock */
+  timer *timer;				/* Interface timer */
+  sock *sk;				/* UDP socket */
+
+  u8 up;				/* Interface is active */
+  u8 csn_ready;				/* Nonzero CSN can be used */
+  u16 tx_plen;				/* Max TX packet data length */
+  u32 csn;				/* Last used crypto sequence number */
+  ip_addr addr;				/* Destination multicast/broadcast address */
+  list neigh_list;			/* List of iface neighbors (struct rip_neighbor) */
+
+  /* Update scheduling */
+  bird_clock_t next_regular;		/* Next time when regular update should be called */
+  bird_clock_t next_triggered;		/* Next time when triggerd update may be called */
+  bird_clock_t want_triggered;		/* Nonzero if triggered update is scheduled */
+
+  /* Active update */
+  int tx_active;			/* Update session is active */
+  ip_addr tx_addr;			/* Update session destination address */
+  bird_clock_t tx_changed;		/* Minimal changed time for triggered update */
+  struct fib_iterator tx_fit;		/* FIB iterator in RIP routing table (p.rtable) */
 };
 
-struct rip_md5_tail {	/* 20 bytes */
-  u16 mustbeFFFF;
-  u16 mustbe0001;
-  char md5[16];
+struct rip_neighbor
+{
+  node n;
+  struct rip_iface *ifa;		/* Associated interface, may be NULL if stale */
+  struct neighbor *nbr;			/* Associaded core neighbor, may be NULL if stale */
+  struct bfd_request *bfd_req;		/* BFD request, if BFD is used */
+  bird_clock_t last_seen;		/* Time of last received and accepted message */
+  u32 uc;				/* Use count, number of routes linking the neighbor */
+  u32 csn;				/* Last received crypto sequence number */
 };
 
-struct rip_entry {
+struct rip_entry
+{
   struct fib_node n;
+  struct rip_rte *routes;		/* List of incoming routes */
 
-  ip_addr whotoldme;
-  ip_addr nexthop;
-  int metric;
-  u16 tag;
+  u8 valid;				/* Entry validity state (RIP_ENTRY_*) */
+  u8 metric;				/* Outgoing route metric */
+  u16 tag;				/* Outgoing route tag */
+  struct iface *from;			/* Outgoing route from, NULL if from  proto */
+  struct iface *iface;			/* Outgoing route iface (for next hop) */
+  ip_addr next_hop;			/* Outgoing route next hop */
 
-  bird_clock_t updated, changed;
-  int flags;
+  bird_clock_t changed;			/* Last time when the outgoing route metric changed */
 };
 
-struct rip_packet {
-  struct rip_packet_heading heading;
-  struct rip_block block[PACKET_MAX];
-};
+struct rip_rte
+{
+  struct rip_rte *next;
 
-struct rip_interface {
-  node n;
-  struct proto *proto;
-  struct iface *iface;
-  sock *sock;
-  struct rip_connection *busy;
-  int metric;			/* You don't want to put struct rip_patt *patt here -- think about reconfigure */
-  int mode;
-  int check_ttl;		/* Check incoming packets for TTL 255 */
-  int triggered;
-  struct object_lock *lock;
-  int multicast;
+  struct rip_neighbor *from;		/* Advertising router */
+  ip_addr next_hop;			/* Route next hop (iface is from->nbr->iface) */
+  u16 metric;				/* Route metric (after increase) */
+  u16 tag;				/* Route tag */
+
+  bird_clock_t expires;			/* Time of route expiration */
 };
 
-struct rip_patt {
-  struct iface_patt i;
 
-  int metric;		/* If you add entries here, don't forget to modify patt_compare! */
-  int mode;
-#define IM_BROADCAST 2
-#define IM_QUIET 4
-#define IM_NOLISTEN 8
-#define IM_VERSION1 16
-  int tx_tos;
-  int tx_priority;
-  int ttl_security;	/* bool + 2 for TX only (send, but do not check on RX) */
-};
+#define RIP_AUTH_NONE		0
+#define RIP_AUTH_PLAIN		2
+#define RIP_AUTH_CRYPTO		3
 
-struct rip_proto_config {
-  struct proto_config c;
-  list iface_list;	/* Patterns configured -- keep it first; see rip_reconfigure why */
-  list *passwords;	/* Passwords, keep second */
-
-  int infinity;		/* User configurable data; must be comparable with memcmp */
-  int port;
-  int period;
-  int garbage_time;
-  int timeout_time;
-
-  int authtype;
-#define AT_NONE 0
-#define AT_PLAINTEXT 2
-#define AT_MD5 3
-  int honor;
-#define HO_NEVER 0
-#define HO_NEIGHBOR 1
-#define HO_ALWAYS 2
-};
+#define RIP_IM_MULTICAST	1
+#define RIP_IM_BROADCAST	2
 
-struct rip_proto {
-  struct proto inherited;
-  timer *timer;
-  list connections;
-  struct fib rtable;
-  list garbage;
-  list interfaces;	/* Interfaces we really know about */
-#ifdef LOCAL_DEBUG
-  int magic;
-#endif
-  int tx_count;		/* Do one regular update once in a while */
-  int rnd_count;	/* Randomize sending time */
-};
+#define RIP_ENTRY_DUMMY		0	/* Only used to store list of incoming routes */
+#define RIP_ENTRY_VALID		1	/* Valid outgoing route */
+#define RIP_ENTRY_STALE		2	/* Stale outgoing route, waiting for GC */
 
-#ifdef LOCAL_DEBUG
-#define RIP_MAGIC 81861253
-#define CHK_MAGIC do { if (P->magic != RIP_MAGIC) bug( "Not enough magic" ); } while (0)
-#else
-#define CHK_MAGIC do { } while (0)
-#endif
+#define EA_RIP_METRIC		EA_CODE(EAP_RIP, 0)
+#define EA_RIP_TAG		EA_CODE(EAP_RIP, 1)
 
+#define rip_is_v2(X) RIP_IS_V2
+#define rip_is_ng(X) (!RIP_IS_V2)
 
-void rip_init_config(struct rip_proto_config *c);
+/*
+static inline int rip_is_v2(struct rip_proto *p)
+{ return p->rip2; }
+
+static inline int rip_is_ng(struct rip_proto *p)
+{ return ! p->rip2; }
+*/
+
+static inline void
+rip_reset_tx_session(struct rip_proto *p, struct rip_iface *ifa)
+{
+  if (ifa->tx_active)
+  {
+    FIB_ITERATE_UNLINK(&ifa->tx_fit, &p->rtable);
+    ifa->tx_active = 0;
+  }
+}
+
+/* rip.c */
+void rip_update_rte(struct rip_proto *p, ip_addr *prefix, int pxlen, struct rip_rte *new);
+void rip_withdraw_rte(struct rip_proto *p, ip_addr *prefix, int pxlen, struct rip_neighbor *from);
+struct rip_neighbor * rip_get_neighbor(struct rip_proto *p, ip_addr *a, struct rip_iface *ifa);
+void rip_update_bfd(struct rip_proto *p, struct rip_neighbor *n);
+void rip_show_interfaces(struct proto *P, char *iff);
+void rip_show_neighbors(struct proto *P, char *iff);
+
+/* packets.c */
+void rip_send_request(struct rip_proto *p, struct rip_iface *ifa);
+void rip_send_table(struct rip_proto *p, struct rip_iface *ifa, ip_addr addr, bird_clock_t changed);
+int rip_open_socket(struct rip_iface *ifa);
 
-/* Authentication functions */
 
-int rip_incoming_authentication( struct proto *p, struct rip_block_auth *block, struct rip_packet *packet, int num, ip_addr whotoldme );
-int rip_outgoing_authentication( struct proto *p, struct rip_block_auth *block, struct rip_packet *packet, int num );
+#endif
author	Ondrej Zajicek (work) <santiago@crfreenet.org>	2015-10-05 12:14:50 +0200
committer	Ondrej Zajicek (work) <santiago@crfreenet.org>	2015-10-05 13:18:10 +0200
commit	8465dccb06afffed171dc1e224e4eb5f67cc3326 (patch)
tree	9e5209b312ba8b7eabd0f5a22aea4a0888cd8c9f
parent	c7b99a932cab1873042e356143ab71755920157a (diff)