*: add VRF ID in the API message header

The API messages are used by zebra to exchange the interfaces, addresses,
routes and router-id information with its clients. To distinguish which
VRF the information belongs to, a new field "VRF ID" is added in the
message header. And hence the message version is increased to 3.

* The new field "VRF ID" in the message header:

    Length    (2 bytes)
    Marker    (1 byte)
    Version   (1 byte)
    VRF ID    (2 bytes, newly added)
    Command   (2 bytes)

  - Client side:

    - zclient_create_header() adds the VRF ID in the message header.
    - zclient_read() extracts and validates the VRF ID from the header,
      and passes the VRF ID to the callback functions registered to
      the API messages.
    - All relative functions are appended with a new parameter "vrf_id",
      including all the callback functions.
    - "vrf_id" is also added to "struct zapi_ipv4" and "struct zapi_ipv6".
      Clients need to correctly set the VRF ID when using the API
      functions zapi_ipv4_route() and zapi_ipv6_route().
    - Till now all messages sent from a client have the default VRF ID
      "0" in the header.
    - The HELLO message is special, which is used as the heart-beat of
      a client, and has no relation with VRF. The VRF ID in the HELLO
      message header will always be 0 and ignored by zebra.

  - Zebra side:

    - zserv_create_header() adds the VRF ID in the message header.
    - zebra_client_read() extracts and validates the VRF ID from the
      header, and passes the VRF ID to the functions which process
      the received messages.
    - All relative functions are appended with a new parameter "vrf_id".

* Suppress the messages in a VRF which a client does not care:

  Some clients may not care about the information in the VRF X, and
  zebra should not send the messages in the VRF X to those clients.

  Extra flags are used to indicate which VRF is registered by a client,
  and a new message ZEBRA_VRF_UNREGISTER is introduced to let a client
  can unregister a VRF when it does not need any information in that
  VRF.

  A client sends any message other than ZEBRA_VRF_UNREGISTER in a VRF
  will automatically register to that VRF.

  - lib/vrf:

    A new utility "VRF bit-map" is provided to manage the flags for
    VRFs, one bit per VRF ID.

    - Use vrf_bitmap_init()/vrf_bitmap_free() to initialize/free a
      bit-map;
    - Use vrf_bitmap_set()/vrf_bitmap_unset() to set/unset a flag
      in the given bit-map, corresponding to the given VRF ID;
    - Use vrf_bitmap_check() to test whether the flag, in the given
      bit-map and for the given VRF ID, is set.

  - Client side:

    - In "struct zclient", the following flags are changed from
      "u_char" to "vrf_bitmap_t":
          redist[ZEBRA_ROUTE_MAX]
          default_information
      These flags are extended for each VRF, and controlled by the
      clients themselves (or with the help of zclient_redistribute()
      and zclient_redistribute_default()).

  - Zebra side:

    - In "struct zserv", the following flags are changed from
      "u_char" to "vrf_bitmap_t":
          redist[ZEBRA_ROUTE_MAX]
          redist_default
          ifinfo
          ridinfo

      These flags are extended for each VRF, as the VRF registration
      flags. They are maintained on receiving a ZEBRA_XXX_ADD or
      ZEBRA_XXX_DELETE message.

      When sending an interface/address/route/router-id message in
      a VRF to a client, if the corresponding VRF registration flag
      is not set, this message will not be dropped by zebra.

    - A new function zread_vrf_unregister() is introduced to process
      the new command ZEBRA_VRF_UNREGISTER. All the VRF registration
      flags are cleared for the requested VRF.

  Those clients, who support only the default VRF, will never receive
  a message in a non-default VRF, thanks to the filter in zebra.

* New callback for the event of successful connection to zebra:

  - zclient_start() is splitted, keeping only the code of connecting
    to zebra.

  - Now zclient_init()=>zclient_connect()=>zclient_start() operations
    are purely dealing with the connection to zbera.

  - Once zebra is successfully connected, at the end of zclient_start(),
    a new callback is used to inform the client about connection.

  - Till now, in the callback of connect-to-zebra event, all clients
    send messages to zebra to request the router-id/interface/routes
    information in the default VRF.

    Of corse in future the client can do anything it wants in this
    callback. For example, it may send requests for both default VRF
    and some non-default VRFs.

Signed-off-by: Feng Lu <lu.feng@6wind.com>
Reviewed-by: Alain Ritoux <alain.ritoux@6wind.com>
Signed-off-by: Nicolas Dichtel <nicolas.dichtel@6wind.com>
Acked-by: Donald Sharp <sharpd@cumulusnetworks.com>

6 files changed, 241 insertions, 83 deletions

diff --git a/lib/memtypes.c b/lib/memtypes.c
index 60f24e6a..ab3c1f8e 100644
--- a/lib/memtypes.c
+++ b/lib/memtypes.c
@@ -71,6 +71,7 @@ struct memory_list memory_list_lib[] =
   { MTYPE_HOST,			"Host config"			},
   { MTYPE_VRF,			"VRF"				},
   { MTYPE_VRF_NAME,		"VRF name"			},
+  { MTYPE_VRF_BITMAP,		"VRF bit-map"			},
   { -1, NULL },
 };
 
diff --git a/lib/vrf.c b/lib/vrf.c
index d11a9826..683026e5 100644
--- a/lib/vrf.c
+++ b/lib/vrf.c
@@ -336,6 +336,99 @@ vrf_iflist_get (vrf_id_t vrf_id)
    return vrf->iflist;
 }
 
+/*
+ * VRF bit-map
+ */
+
+#define VRF_BITMAP_NUM_OF_GROUPS            8
+#define VRF_BITMAP_NUM_OF_BITS_IN_GROUP \
+    (UINT16_MAX / VRF_BITMAP_NUM_OF_GROUPS)
+#define VRF_BITMAP_NUM_OF_BYTES_IN_GROUP \
+    (VRF_BITMAP_NUM_OF_BITS_IN_GROUP / CHAR_BIT + 1) /* +1 for ensure */
+
+#define VRF_BITMAP_GROUP(_id) \
+    ((_id) / VRF_BITMAP_NUM_OF_BITS_IN_GROUP)
+#define VRF_BITMAP_BIT_OFFSET(_id) \
+    ((_id) % VRF_BITMAP_NUM_OF_BITS_IN_GROUP)
+
+#define VRF_BITMAP_INDEX_IN_GROUP(_bit_offset) \
+    ((_bit_offset) / CHAR_BIT)
+#define VRF_BITMAP_FLAG(_bit_offset) \
+    (((u_char)1) << ((_bit_offset) % CHAR_BIT))
+
+struct vrf_bitmap
+{
+  u_char *groups[VRF_BITMAP_NUM_OF_GROUPS];
+};
+
+vrf_bitmap_t
+vrf_bitmap_init (void)
+{
+  return (vrf_bitmap_t) XCALLOC (MTYPE_VRF_BITMAP, sizeof (struct vrf_bitmap));
+}
+
+void
+vrf_bitmap_free (vrf_bitmap_t bmap)
+{
+  struct vrf_bitmap *bm = (struct vrf_bitmap *) bmap;
+  int i;
+
+  if (bmap == VRF_BITMAP_NULL)
+    return;
+
+  for (i = 0; i < VRF_BITMAP_NUM_OF_GROUPS; i++)
+    if (bm->groups[i])
+      XFREE (MTYPE_VRF_BITMAP, bm->groups[i]);
+
+  XFREE (MTYPE_VRF_BITMAP, bm);
+}
+
+void
+vrf_bitmap_set (vrf_bitmap_t bmap, vrf_id_t vrf_id)
+{
+  struct vrf_bitmap *bm = (struct vrf_bitmap *) bmap;
+  u_char group = VRF_BITMAP_GROUP (vrf_id);
+  u_char offset = VRF_BITMAP_BIT_OFFSET (vrf_id);
+
+  if (bmap == VRF_BITMAP_NULL)
+    return;
+
+  if (bm->groups[group] == NULL)
+    bm->groups[group] = XCALLOC (MTYPE_VRF_BITMAP,
+                                 VRF_BITMAP_NUM_OF_BYTES_IN_GROUP);
+
+  SET_FLAG (bm->groups[group][VRF_BITMAP_INDEX_IN_GROUP (offset)],
+            VRF_BITMAP_FLAG (offset));
+}
+
+void
+vrf_bitmap_unset (vrf_bitmap_t bmap, vrf_id_t vrf_id)
+{
+  struct vrf_bitmap *bm = (struct vrf_bitmap *) bmap;
+  u_char group = VRF_BITMAP_GROUP (vrf_id);
+  u_char offset = VRF_BITMAP_BIT_OFFSET (vrf_id);
+
+  if (bmap == VRF_BITMAP_NULL || bm->groups[group] == NULL)
+    return;
+
+  UNSET_FLAG (bm->groups[group][VRF_BITMAP_INDEX_IN_GROUP (offset)],
+              VRF_BITMAP_FLAG (offset));
+}
+
+int
+vrf_bitmap_check (vrf_bitmap_t bmap, vrf_id_t vrf_id)
+{
+  struct vrf_bitmap *bm = (struct vrf_bitmap *) bmap;
+  u_char group = VRF_BITMAP_GROUP (vrf_id);
+  u_char offset = VRF_BITMAP_BIT_OFFSET (vrf_id);
+
+  if (bmap == VRF_BITMAP_NULL || bm->groups[group] == NULL)
+    return 0;
+
+  return CHECK_FLAG (bm->groups[group][VRF_BITMAP_INDEX_IN_GROUP (offset)],
+                     VRF_BITMAP_FLAG (offset)) ? 1 : 0;
+}
+
 /* Initialize VRF module. */
 void
 vrf_init (void)
diff --git a/lib/vrf.h b/lib/vrf.h
index 653fabf9..8b29b809 100644
--- a/lib/vrf.h
+++ b/lib/vrf.h
@@ -110,6 +110,19 @@ extern struct list *vrf_iflist (vrf_id_t);
 extern struct list *vrf_iflist_get (vrf_id_t);
 
 /*
+ * VRF bit-map: maintaining flags, one bit per VRF ID
+ */
+
+typedef void *              vrf_bitmap_t;
+#define VRF_BITMAP_NULL     NULL
+
+extern vrf_bitmap_t vrf_bitmap_init (void);
+extern void vrf_bitmap_free (vrf_bitmap_t);
+extern void vrf_bitmap_set (vrf_bitmap_t, vrf_id_t);
+extern void vrf_bitmap_unset (vrf_bitmap_t, vrf_id_t);
+extern int vrf_bitmap_check (vrf_bitmap_t, vrf_id_t);
+
+/*
  * VRF initializer/destructor
  */
 /* Please add hooks before calling vrf_init(). */
diff --git a/lib/zclient.c b/lib/zclient.c
index 71da87c6..8e443e28 100644
--- a/lib/zclient.c
+++ b/lib/zclient.c
@@ -93,15 +93,14 @@ zclient_init (struct zclient *zclient, int redist_default)
 
   /* Clear redistribution flags. */
   for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
-    zclient->redist[i] = 0;
+    zclient->redist[i] = vrf_bitmap_init ();
 
   /* Set unwanted redistribute route.  bgpd does not need BGP route
      redistribution. */
   zclient->redist_default = redist_default;
-  zclient->redist[redist_default] = 1;
 
   /* Set default-information redistribute to zero. */
-  zclient->default_information = 0;
+  zclient->default_information = vrf_bitmap_init ();
 
   /* Schedule first zclient connection. */
   if (zclient_debug)
@@ -293,18 +292,19 @@ zclient_send_message(struct zclient *zclient)
 }
 
 void
-zclient_create_header (struct stream *s, uint16_t command)
+zclient_create_header (struct stream *s, uint16_t command, vrf_id_t vrf_id)
 {
   /* length placeholder, caller can update */
   stream_putw (s, ZEBRA_HEADER_SIZE);
   stream_putc (s, ZEBRA_HEADER_MARKER);
   stream_putc (s, ZSERV_VERSION);
+  stream_putw (s, vrf_id);
   stream_putw (s, command);
 }
 
 /* Send simple Zebra message. */
 static int
-zebra_message_send (struct zclient *zclient, int command)
+zebra_message_send (struct zclient *zclient, int command, vrf_id_t vrf_id)
 {
   struct stream *s;
 
@@ -313,7 +313,7 @@ zebra_message_send (struct zclient *zclient, int command)
   stream_reset (s);
 
   /* Send very simple command only Zebra message. */
-  zclient_create_header (s, command);
+  zclient_create_header (s, command, vrf_id);
   
   return zclient_send_message(zclient);
 }
@@ -328,7 +328,8 @@ zebra_hello_send (struct zclient *zclient)
       s = zclient->obuf;
       stream_reset (s);
 
-      zclient_create_header (s, ZEBRA_HELLO);
+      /* The VRF ID in the HELLO message is always 0. */
+      zclient_create_header (s, ZEBRA_HELLO, VRF_DEFAULT);
       stream_putc (s, zclient->redist_default);
       stream_putw_at (s, 0, stream_get_endp (s));
       return zclient_send_message(zclient);
@@ -337,12 +338,47 @@ zebra_hello_send (struct zclient *zclient)
   return 0;
 }
 
+/* Send requests to zebra daemon for the information in a VRF. */
+void
+zclient_send_requests (struct zclient *zclient, vrf_id_t vrf_id)
+{
+  int i;
+
+  /* zclient is disabled. */
+  if (! zclient->enable)
+    return;
+
+  /* If not connected to the zebra yet. */
+  if (zclient->sock < 0)
+    return;
+
+  if (zclient_debug)
+    zlog_debug ("%s: send messages for VRF %u", __func__, vrf_id);
+
+  /* We need router-id information. */
+  zebra_message_send (zclient, ZEBRA_ROUTER_ID_ADD, vrf_id);
+
+  /* We need interface information. */
+  zebra_message_send (zclient, ZEBRA_INTERFACE_ADD, vrf_id);
+
+  /* Set unwanted redistribute route. */
+  vrf_bitmap_set (zclient->redist[zclient->redist_default], vrf_id);
+
+  /* Flush all redistribute request. */
+  for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
+    if (i != zclient->redist_default &&
+        vrf_bitmap_check (zclient->redist[i], vrf_id))
+      zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD, zclient, i, vrf_id);
+
+  /* If default information is needed. */
+  if (vrf_bitmap_check (zclient->default_information, VRF_DEFAULT))
+    zebra_message_send (zclient, ZEBRA_REDISTRIBUTE_DEFAULT_ADD, vrf_id);
+}
+
 /* Make connection to zebra daemon. */
 int
 zclient_start (struct zclient *zclient)
 {
-  int i;
-
   if (zclient_debug)
     zlog_debug ("zclient_start is called");
 
@@ -380,20 +416,9 @@ zclient_start (struct zclient *zclient)
 
   zebra_hello_send (zclient);
 
-  /* We need router-id information. */
-  zebra_message_send (zclient, ZEBRA_ROUTER_ID_ADD);
-
-  /* We need interface information. */
-  zebra_message_send (zclient, ZEBRA_INTERFACE_ADD);
-
-  /* Flush all redistribute request. */
-  for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
-    if (i != zclient->redist_default && zclient->redist[i])
-      zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD, zclient, i);
-
-  /* If default information is needed. */
-  if (zclient->default_information)
-    zebra_message_send (zclient, ZEBRA_REDISTRIBUTE_DEFAULT_ADD);
+  /* Inform the successful connection. */
+  if (zclient->zebra_connected)
+    (*zclient->zebra_connected) (zclient);
 
   return 0;
 }
@@ -469,8 +494,8 @@ zapi_ipv4_route (u_char cmd, struct zclient *zclient, struct prefix_ipv4 *p,
   /* Reset stream. */
   s = zclient->obuf;
   stream_reset (s);
-  
-  zclient_create_header (s, cmd);
+
+  zclient_create_header (s, cmd, api->vrf_id);
   
   /* Put type and nexthop. */
   stream_putc (s, api->type);
@@ -532,7 +557,7 @@ zapi_ipv6_route (u_char cmd, struct zclient *zclient, struct prefix_ipv6 *p,
   s = zclient->obuf;
   stream_reset (s);
 
-  zclient_create_header (s, cmd);
+  zclient_create_header (s, cmd, api->vrf_id);
 
   /* Put type and nexthop. */
   stream_putc (s, api->type);
@@ -581,14 +606,15 @@ zapi_ipv6_route (u_char cmd, struct zclient *zclient, struct prefix_ipv6 *p,
  * sending client
  */
 int
-zebra_redistribute_send (int command, struct zclient *zclient, int type)
+zebra_redistribute_send (int command, struct zclient *zclient, int type,
+    vrf_id_t vrf_id)
 {
   struct stream *s;
 
   s = zclient->obuf;
   stream_reset(s);
   
-  zclient_create_header (s, command);
+  zclient_create_header (s, command, vrf_id);
   stream_putc (s, type);
   
   stream_putw_at (s, 0, stream_get_endp (s));
@@ -643,7 +669,7 @@ zebra_router_id_update_read (struct stream *s, struct prefix *rid)
  */
 
 struct interface *
-zebra_interface_add_read (struct stream *s)
+zebra_interface_add_read (struct stream *s, vrf_id_t vrf_id)
 {
   struct interface *ifp;
   char ifname_tmp[INTERFACE_NAMSIZ];
@@ -652,7 +678,9 @@ zebra_interface_add_read (struct stream *s)
   stream_get (ifname_tmp, s, INTERFACE_NAMSIZ);
 
   /* Lookup/create interface by name. */
-  ifp = if_get_by_name_len (ifname_tmp, strnlen(ifname_tmp, INTERFACE_NAMSIZ));
+  ifp = if_get_by_name_len_vrf (ifname_tmp,
+                                strnlen (ifname_tmp, INTERFACE_NAMSIZ),
+                                vrf_id);
 
   zebra_interface_if_set_value (s, ifp);
 
@@ -667,7 +695,7 @@ zebra_interface_add_read (struct stream *s)
  * is sent at the tail of the message.
  */
 struct interface *
-zebra_interface_state_read (struct stream *s)
+zebra_interface_state_read (struct stream *s, vrf_id_t vrf_id)
 {
   struct interface *ifp;
   char ifname_tmp[INTERFACE_NAMSIZ];
@@ -676,8 +704,9 @@ zebra_interface_state_read (struct stream *s)
   stream_get (ifname_tmp, s, INTERFACE_NAMSIZ);
 
   /* Lookup this by interface index. */
-  ifp = if_lookup_by_name_len (ifname_tmp,
-			       strnlen(ifname_tmp, INTERFACE_NAMSIZ));
+  ifp = if_lookup_by_name_len_vrf (ifname_tmp,
+                                   strnlen (ifname_tmp, INTERFACE_NAMSIZ),
+                                   vrf_id);
 
   /* If such interface does not exist, indicate an error */
   if (! ifp)
@@ -754,7 +783,7 @@ memconstant(const void *s, int c, size_t n)
 }
 
 struct connected *
-zebra_interface_address_read (int type, struct stream *s)
+zebra_interface_address_read (int type, struct stream *s, vrf_id_t vrf_id)
 {
   unsigned int ifindex;
   struct interface *ifp;
@@ -771,7 +800,7 @@ zebra_interface_address_read (int type, struct stream *s)
   ifindex = stream_getl (s);
 
   /* Lookup index. */
-  ifp = if_lookup_by_index (ifindex);
+  ifp = if_lookup_by_index_vrf (ifindex, vrf_id);
   if (ifp == NULL)
     {
       zlog_warn ("zebra_interface_address_read(%s): "
@@ -834,6 +863,7 @@ zclient_read (struct thread *thread)
   size_t already;
   uint16_t length, command;
   uint8_t marker, version;
+  vrf_id_t vrf_id;
   struct zclient *zclient;
 
   /* Get socket to zebra. */
@@ -868,6 +898,7 @@ zclient_read (struct thread *thread)
   length = stream_getw (zclient->ibuf);
   marker = stream_getc (zclient->ibuf);
   version = stream_getc (zclient->ibuf);
+  vrf_id = stream_getw (zclient->ibuf);
   command = stream_getw (zclient->ibuf);
   
   if (marker != ZEBRA_HEADER_MARKER || version != ZSERV_VERSION)
@@ -919,53 +950,53 @@ zclient_read (struct thread *thread)
   length -= ZEBRA_HEADER_SIZE;
 
   if (zclient_debug)
-    zlog_debug("zclient 0x%p command 0x%x \n", (void *)zclient, command);
+    zlog_debug("zclient 0x%p command 0x%x VRF %u\n", (void *)zclient, command, vrf_id);
 
   switch (command)
     {
     case ZEBRA_ROUTER_ID_UPDATE:
       if (zclient->router_id_update)
-	(*zclient->router_id_update) (command, zclient, length);
+	(*zclient->router_id_update) (command, zclient, length, vrf_id);
       break;
     case ZEBRA_INTERFACE_ADD:
       if (zclient->interface_add)
-	(*zclient->interface_add) (command, zclient, length);
+	(*zclient->interface_add) (command, zclient, length, vrf_id);
       break;
     case ZEBRA_INTERFACE_DELETE:
       if (zclient->interface_delete)
-	(*zclient->interface_delete) (command, zclient, length);
+	(*zclient->interface_delete) (command, zclient, length, vrf_id);
       break;
     case ZEBRA_INTERFACE_ADDRESS_ADD:
       if (zclient->interface_address_add)
-	(*zclient->interface_address_add) (command, zclient, length);
+	(*zclient->interface_address_add) (command, zclient, length, vrf_id);
       break;
     case ZEBRA_INTERFACE_ADDRESS_DELETE:
       if (zclient->interface_address_delete)
-	(*zclient->interface_address_delete) (command, zclient, length);
+	(*zclient->interface_address_delete) (command, zclient, length, vrf_id);
       break;
     case ZEBRA_INTERFACE_UP:
       if (zclient->interface_up)
-	(*zclient->interface_up) (command, zclient, length);
+	(*zclient->interface_up) (command, zclient, length, vrf_id);
       break;
     case ZEBRA_INTERFACE_DOWN:
       if (zclient->interface_down)
-	(*zclient->interface_down) (command, zclient, length);
+	(*zclient->interface_down) (command, zclient, length, vrf_id);
       break;
     case ZEBRA_IPV4_ROUTE_ADD:
       if (zclient->ipv4_route_add)
-	(*zclient->ipv4_route_add) (command, zclient, length);
+	(*zclient->ipv4_route_add) (command, zclient, length, vrf_id);
       break;
     case ZEBRA_IPV4_ROUTE_DELETE:
       if (zclient->ipv4_route_delete)
-	(*zclient->ipv4_route_delete) (command, zclient, length);
+	(*zclient->ipv4_route_delete) (command, zclient, length, vrf_id);
       break;
     case ZEBRA_IPV6_ROUTE_ADD:
       if (zclient->ipv6_route_add)
-	(*zclient->ipv6_route_add) (command, zclient, length);
+	(*zclient->ipv6_route_add) (command, zclient, length, vrf_id);
       break;
     case ZEBRA_IPV6_ROUTE_DELETE:
       if (zclient->ipv6_route_delete)
-	(*zclient->ipv6_route_delete) (command, zclient, length);
+	(*zclient->ipv6_route_delete) (command, zclient, length, vrf_id);
       break;
     default:
       break;
@@ -983,46 +1014,48 @@ zclient_read (struct thread *thread)
 }
 
 void
-zclient_redistribute (int command, struct zclient *zclient, int type)
+zclient_redistribute (int command, struct zclient *zclient, int type,
+    vrf_id_t vrf_id)
 {
 
   if (command == ZEBRA_REDISTRIBUTE_ADD) 
     {
-      if (zclient->redist[type])
+      if (vrf_bitmap_check (zclient->redist[type], vrf_id))
          return;
-      zclient->redist[type] = 1;
+      vrf_bitmap_set (zclient->redist[type], vrf_id);
     }
   else
     {
-      if (!zclient->redist[type])
+      if (!vrf_bitmap_check (zclient->redist[type], vrf_id))
          return;
-      zclient->redist[type] = 0;
+      vrf_bitmap_unset (zclient->redist[type], vrf_id);
     }
 
   if (zclient->sock > 0)
-    zebra_redistribute_send (command, zclient, type);
+    zebra_redistribute_send (command, zclient, type, vrf_id);
 }
 
 
 void
-zclient_redistribute_default (int command, struct zclient *zclient)
+zclient_redistribute_default (int command, struct zclient *zclient,
+    vrf_id_t vrf_id)
 {
 
   if (command == ZEBRA_REDISTRIBUTE_DEFAULT_ADD)
     {
-      if (zclient->default_information)
+      if (vrf_bitmap_check (zclient->default_information, vrf_id))
         return;
-      zclient->default_information = 1;
+      vrf_bitmap_set (zclient->default_information, vrf_id);
     }
   else 
     {
-      if (!zclient->default_information)
+      if (!vrf_bitmap_check (zclient->default_information, vrf_id))
         return;
-      zclient->default_information = 0;
+      vrf_bitmap_unset (zclient->default_information, vrf_id);
     }
 
   if (zclient->sock > 0)
-    zebra_message_send (zclient, command);
+    zebra_message_send (zclient, command, vrf_id);
 }
 
 static void
diff --git a/lib/zclient.h b/lib/zclient.h
index a51b3def..19b4f0ea 100644
--- a/lib/zclient.h
+++ b/lib/zclient.h
@@ -28,11 +28,14 @@
 /* For struct interface and struct connected. */
 #include "if.h"
 
+/* For vrf_bitmap_t. */
+#include "vrf.h"
+
 /* For input/output buffer to zebra. */
 #define ZEBRA_MAX_PACKET_SIZ          4096
 
 /* Zebra header size. */
-#define ZEBRA_HEADER_SIZE             6
+#define ZEBRA_HEADER_SIZE             8
 
 /* Structure for the zebra client. */
 struct zclient
@@ -65,23 +68,24 @@ struct zclient
 
   /* Redistribute information. */
   u_char redist_default;
-  u_char redist[ZEBRA_ROUTE_MAX];
+  vrf_bitmap_t redist[ZEBRA_ROUTE_MAX];
 
   /* Redistribute defauilt. */
-  u_char default_information;
+  vrf_bitmap_t default_information;
 
   /* Pointer to the callback functions. */
-  int (*router_id_update) (int, struct zclient *, uint16_t);
-  int (*interface_add) (int, struct zclient *, uint16_t);
-  int (*interface_delete) (int, struct zclient *, uint16_t);
-  int (*interface_up) (int, struct zclient *, uint16_t);
-  int (*interface_down) (int, struct zclient *, uint16_t);
-  int (*interface_address_add) (int, struct zclient *, uint16_t);
-  int (*interface_address_delete) (int, struct zclient *, uint16_t);
-  int (*ipv4_route_add) (int, struct zclient *, uint16_t);
-  int (*ipv4_route_delete) (int, struct zclient *, uint16_t);
-  int (*ipv6_route_add) (int, struct zclient *, uint16_t);
-  int (*ipv6_route_delete) (int, struct zclient *, uint16_t);
+  void (*zebra_connected) (struct zclient *);
+  int (*router_id_update) (int, struct zclient *, uint16_t, vrf_id_t);
+  int (*interface_add) (int, struct zclient *, uint16_t, vrf_id_t);
+  int (*interface_delete) (int, struct zclient *, uint16_t, vrf_id_t);
+  int (*interface_up) (int, struct zclient *, uint16_t, vrf_id_t);
+  int (*interface_down) (int, struct zclient *, uint16_t, vrf_id_t);
+  int (*interface_address_add) (int, struct zclient *, uint16_t, vrf_id_t);
+  int (*interface_address_delete) (int, struct zclient *, uint16_t, vrf_id_t);
+  int (*ipv4_route_add) (int, struct zclient *, uint16_t, vrf_id_t);
+  int (*ipv4_route_delete) (int, struct zclient *, uint16_t, vrf_id_t);
+  int (*ipv6_route_add) (int, struct zclient *, uint16_t, vrf_id_t);
+  int (*ipv6_route_delete) (int, struct zclient *, uint16_t, vrf_id_t);
 };
 
 /* Zebra API message flag. */
@@ -98,7 +102,8 @@ struct zserv_header
                          * always set to 255 in new zserv.
                          */
   uint8_t version;
-#define ZSERV_VERSION	2
+#define ZSERV_VERSION	3
+  vrf_id_t vrf_id;
   uint16_t command;
 };
 
@@ -122,6 +127,8 @@ struct zapi_ipv4
   u_char distance;
 
   u_int32_t metric;
+
+  vrf_id_t vrf_id;
 };
 
 /* Prototypes of zebra client service functions. */
@@ -136,25 +143,33 @@ extern int  zclient_socket_connect (struct zclient *);
 extern void zclient_serv_path_set  (char *path);
 extern const char *zclient_serv_path_get (void);
 
+extern void zclient_send_requests (struct zclient *, vrf_id_t);
+
 /* Send redistribute command to zebra daemon. Do not update zclient state. */
-extern int zebra_redistribute_send (int command, struct zclient *, int type);
+extern int zebra_redistribute_send (int command, struct zclient *, int type,
+    vrf_id_t vrf_id);
 
 /* If state has changed, update state and call zebra_redistribute_send. */
-extern void zclient_redistribute (int command, struct zclient *, int type);
+extern void zclient_redistribute (int command, struct zclient *, int type,
+    vrf_id_t vrf_id);
 
 /* If state has changed, update state and send the command to zebra. */
-extern void zclient_redistribute_default (int command, struct zclient *);
+extern void zclient_redistribute_default (int command, struct zclient *,
+    vrf_id_t vrf_id);
 
 /* Send the message in zclient->obuf to the zebra daemon (or enqueue it).
    Returns 0 for success or -1 on an I/O error. */
 extern int zclient_send_message(struct zclient *);
 
 /* create header for command, length to be filled in by user later */
-extern void zclient_create_header (struct stream *, uint16_t);
-
-extern struct interface *zebra_interface_add_read (struct stream *);
-extern struct interface *zebra_interface_state_read (struct stream *s);
-extern struct connected *zebra_interface_address_read (int, struct stream *);
+extern void zclient_create_header (struct stream *, uint16_t, vrf_id_t);
+
+extern struct interface *zebra_interface_add_read (struct stream *,
+    vrf_id_t);
+extern struct interface *zebra_interface_state_read (struct stream *,
+    vrf_id_t);
+extern struct connected *zebra_interface_address_read (int, struct stream *,
+    vrf_id_t);
 extern void zebra_interface_if_set_value (struct stream *, struct interface *);
 extern void zebra_router_id_update_read (struct stream *s, struct prefix *rid);
 extern int zapi_ipv4_route (u_char, struct zclient *, struct prefix_ipv4 *, 
@@ -182,6 +197,8 @@ struct zapi_ipv6
   u_char distance;
 
   u_int32_t metric;
+
+  vrf_id_t vrf_id;
 };
 
 extern int zapi_ipv6_route (u_char cmd, struct zclient *zclient, 
diff --git a/lib/zebra.h b/lib/zebra.h
index e88a6293..85864377 100644
--- a/lib/zebra.h
+++ b/lib/zebra.h
@@ -412,7 +412,8 @@ struct in_pktinfo
 #define ZEBRA_ROUTER_ID_UPDATE            22
 #define ZEBRA_HELLO                       23
 #define ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB    24
-#define ZEBRA_MESSAGE_MAX                 25
+#define ZEBRA_VRF_UNREGISTER              25
+#define ZEBRA_MESSAGE_MAX                 26
 
 /* Marker value used in new Zserv, in the byte location corresponding
  * the command value in the old zserv header. To allow old and new