diff --git a/ospf6d/ospf6_dbex.c b/ospf6d/ospf6_dbex.c
new file mode 100644
index 0000000..b10d9ae
--- /dev/null
+++ b/ospf6d/ospf6_dbex.c
@@ -0,0 +1,704 @@
+/*
+ * Copyright (C) 1999 Yasuhiro Ohara
+ *
+ * This file is part of GNU Zebra.
+ *
+ * GNU Zebra is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * GNU Zebra is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Zebra; see the file COPYING.  If not, write to the 
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 
+ * Boston, MA 02111-1307, USA.  
+ */
+
+#include "ospf6d.h"
+
+/* check validity and put lsa in reqestlist if needed. */
+/* returns -1 if SeqNumMismatch required. */
+int
+ospf6_dbex_check_dbdesc_lsa_header (struct ospf6_lsa_header *lsa_header,
+                                    struct ospf6_neighbor *from)
+{
+  struct ospf6_lsa *received = NULL;
+  struct ospf6_lsa *have = NULL;
+
+  received = ospf6_lsa_summary_create
+    ((struct ospf6_lsa_header__ *) lsa_header);
+
+  /* case when received is AS-External though neighbor belongs stub area */
+  if (lsa_header->type == htons (OSPF6_LSA_TYPE_AS_EXTERNAL) &&
+      ospf6_area_is_stub (from->ospf6_interface->area))
+    {
+      zlog_err ("DbDesc %s receive from %s", from->str, received->str);
+      zlog_err ("    E-bit mismatch: %s", received->str);
+      ospf6_lsa_delete (received);
+      return -1;
+    }
+
+  /* if already have newer database copy, check next LSA */
+  have = ospf6_lsdb_lookup (lsa_header->type, lsa_header->ls_id,
+                            lsa_header->advrtr,
+                            ospf6_lsa_get_scope (lsa_header->type,
+                                                 from->ospf6_interface));
+  if (! have)
+    {
+      /* if we don't have database copy, add request */
+      if (IS_OSPF6_DUMP_DBEX)
+        zlog_info ("Have no database copy, Request");
+      ospf6_neighbor_request_add (received, from);
+    }
+  else if (have)
+    {
+      /* if database copy is less recent, add request */
+      if (ospf6_lsa_check_recent (received, have) < 0)
+        {
+          if (IS_OSPF6_DUMP_DBEX)
+            zlog_info ("Database copy less recent, Request");
+          ospf6_neighbor_request_add (received, from);
+        }
+    }
+
+  return 0;
+}
+
+/* Direct acknowledgement */
+static void
+ospf6_dbex_acknowledge_direct (struct ospf6_lsa *lsa,
+                               struct ospf6_neighbor *o6n)
+{
+  struct iovec directack[MAXIOVLIST];
+  assert (lsa);
+
+  if (IS_OSPF6_DUMP_DBEX)
+    zlog_info ("DBEX: [%s:%s] direct ack %s ",
+               o6n->str, o6n->ospf6_interface->interface->name,
+               lsa->str);
+
+  /* clear pointers to fragments of packet for direct acknowledgement */
+  iov_clear (directack, MAXIOVLIST);
+
+  /* set pointer of LSA to send */
+  OSPF6_MESSAGE_ATTACH (directack, lsa->header,
+                        sizeof (struct ospf6_lsa_header));
+
+  /* age update and add InfTransDelay */
+  ospf6_lsa_age_update_to_send (lsa, o6n->ospf6_interface->transdelay);
+
+  /* send unicast packet to neighbor's ipaddress */
+  ospf6_message_send (OSPF6_MESSAGE_TYPE_LSACK, directack, &o6n->hisaddr,
+                      o6n->ospf6_interface->if_id);
+}
+
+/* Delayed  acknowledgement */
+void
+ospf6_dbex_acknowledge_delayed (struct ospf6_lsa *lsa,
+                                struct ospf6_interface *o6i)
+{
+  assert (o6i);
+
+  if (IS_OSPF6_DUMP_DBEX)
+    zlog_info ("DBEX: [%s] delayed ack %s", o6i->interface->name, lsa->str);
+
+  /* attach delayed acknowledge list */
+  ospf6_lsa_age_current (lsa);
+  ospf6_interface_delayed_ack_add (lsa, o6i);
+
+  /* if not yet, schedule delayed acknowledge RxmtInterval later.
+     timers should be *less than* RxmtInterval
+     or needless retrans will ensue */
+  if (o6i->thread_send_lsack_delayed == NULL)
+    o6i->thread_send_lsack_delayed
+      = thread_add_timer (master, ospf6_send_lsack_delayed,
+                          o6i, o6i->rxmt_interval - 1);
+
+  return;
+}
+
+/* RFC2328 section 13 (4):
+   if MaxAge LSA and if we have no instance, and no neighbor
+   is in states Exchange or Loading */
+/* returns 1 if match this case, else returns 0 */
+static int
+ospf6_dbex_is_maxage_to_be_dropped (struct ospf6_lsa *received,
+                                    struct ospf6_neighbor *from)
+{
+  int count;
+
+  if (! IS_LSA_MAXAGE (received))
+    return 0;
+
+  if (ospf6_lsdb_lookup (received->header->type, received->header->id,
+                         received->header->adv_router,
+                         ospf6_lsa_get_scope (received->header->type,
+                                              from->ospf6_interface)))
+    return 0;
+
+  if (OSPF6_LSA_IS_SCOPE_LINKLOCAL (ntohs (received->header->type)))
+    {
+      count = 0;
+      (*from->ospf6_interface->foreach_nei)
+        (from->ospf6_interface, &count, NBS_EXCHANGE, ospf6_count_state);
+      (*from->ospf6_interface->foreach_nei)
+        (from->ospf6_interface, &count, NBS_LOADING, ospf6_count_state);
+      if (count)
+        return 0;
+    }
+  else if (OSPF6_LSA_IS_SCOPE_AREA (ntohs (received->header->type)))
+    {
+      count = 0;
+      (*from->ospf6_interface->area->foreach_nei)
+         (from->ospf6_interface->area, &count, NBS_EXCHANGE, ospf6_count_state);
+      (*from->ospf6_interface->area->foreach_nei)
+         (from->ospf6_interface->area, &count, NBS_LOADING, ospf6_count_state);
+      if (count)
+        return 0;
+    }
+  else if (OSPF6_LSA_IS_SCOPE_AS (ntohs (received->header->type)))
+    {
+      count = 0;
+      (*from->ospf6_interface->area->ospf6->foreach_nei)
+         (from->ospf6_interface->area->ospf6, &count, NBS_EXCHANGE,
+          ospf6_count_state);
+      (*from->ospf6_interface->area->ospf6->foreach_nei)
+         (from->ospf6_interface->area->ospf6, &count, NBS_LOADING,
+          ospf6_count_state);
+      if (count)
+        return 0;
+    }
+
+  return 1;
+}
+
+static void
+ospf6_dbex_remove_retrans (void *arg, int val, void *obj)
+{
+  struct ospf6_lsa *rem;
+  struct ospf6_neighbor *nei = (struct ospf6_neighbor *) obj;
+  struct ospf6_lsa *lsa = (struct ospf6_lsa *) arg;
+
+  rem = ospf6_lsdb_lookup_lsdb (lsa->header->type, lsa->header->id,
+                                lsa->header->adv_router, nei->retrans_list);
+  if (rem)
+    {
+      ospf6_neighbor_retrans_remove (rem, nei);
+      ospf6_maxage_remover ();
+    }
+}
+
+void
+ospf6_dbex_remove_from_all_retrans_list (struct ospf6_lsa *lsa)
+{
+  struct ospf6_interface *o6i;
+  struct ospf6_area *o6a;
+
+  if (OSPF6_LSA_IS_SCOPE_LINKLOCAL (htons (lsa->header->type)))
+    {
+      o6i = lsa->scope;
+      (*o6i->foreach_nei) (o6i, lsa, 0, ospf6_dbex_remove_retrans);
+    }
+  else if (OSPF6_LSA_IS_SCOPE_AREA (htons (lsa->header->type)))
+    {
+      o6a = lsa->scope;
+      (*o6a->foreach_nei) (o6a, lsa, 0, ospf6_dbex_remove_retrans);
+    }
+  else if (OSPF6_LSA_IS_SCOPE_AS (htons (lsa->header->type)))
+    {
+      (*ospf6->foreach_nei) (ospf6, lsa, 0, ospf6_dbex_remove_retrans);
+    }
+}
+
+/* RFC2328 section 13 */
+void
+ospf6_dbex_receive_lsa (struct ospf6_lsa_header *lsa_header,
+                        struct ospf6_neighbor *from)
+{
+  struct ospf6_lsa *received, *have, *rem;
+  struct timeval now;
+  int ismore_recent, acktype;
+  unsigned short cksum;
+  struct ospf6_lsa_slot *slot;
+
+  received = have = (struct ospf6_lsa *)NULL;
+  ismore_recent = -1;
+  recent_reason = "no instance";
+
+  zlog_info ("Receive LSA (header -> %p)", lsa_header);
+
+  /* make lsa structure for received lsa */
+  received = ospf6_lsa_create (lsa_header);
+
+  /* set LSA scope */
+  if (OSPF6_LSA_IS_SCOPE_LINKLOCAL (htons (lsa_header->type)))
+    received->scope = from->ospf6_interface;
+  else if (OSPF6_LSA_IS_SCOPE_AREA (htons (lsa_header->type)))
+    received->scope = from->ospf6_interface->area;
+  else if (OSPF6_LSA_IS_SCOPE_AS (htons (lsa_header->type)))
+    received->scope = from->ospf6_interface->area->ospf6;
+
+  /* (1) LSA Checksum */
+  cksum = ntohs (lsa_header->checksum);
+  if (ntohs (ospf6_lsa_checksum (lsa_header)) != cksum)
+    {
+      if (IS_OSPF6_DUMP_DBEX)
+        zlog_info ("DBEX: received %s from %s%%%s"
+                   ": wrong checksum, drop",
+                   received->str, from->str,
+                   from->ospf6_interface->interface->name);
+      ospf6_lsa_delete (received);
+      return;
+    }
+
+  /* (3) Ebit Missmatch: AS-External-LSA */
+  if (lsa_header->type == htons (OSPF6_LSA_TYPE_AS_EXTERNAL) &&
+      ospf6_area_is_stub (from->ospf6_interface->area))
+    {
+      if (IS_OSPF6_DUMP_DBEX)
+        zlog_info ("DBEX: received %s from %s%%%s"
+                   ": E-bit mismatch, drop",
+                   received->str, from->str,
+                   from->ospf6_interface->interface->name);
+      ospf6_lsa_delete (received);
+      return;
+    }
+
+  /* (4) if MaxAge LSA and if we have no instance, and no neighbor
+         is in states Exchange or Loading */
+  if (ospf6_dbex_is_maxage_to_be_dropped (received, from))
+    {
+      /* log */
+      if (IS_OSPF6_DUMP_DBEX)
+        zlog_info ("DBEX: received %s from %s%%%s"
+                   ": MaxAge, no instance, no neighbor exchange, drop",
+                   received->str, from->str,
+                   from->ospf6_interface->interface->name);
+
+      /* a) Acknowledge back to neighbor (13.5) */
+        /* Direct Acknowledgement */
+      ospf6_dbex_acknowledge_direct (received, from);
+
+      /* b) Discard */
+      ospf6_lsa_delete (received);
+      return;
+    }
+
+  /* (5) */
+  /* lookup the same database copy in lsdb */
+  have = ospf6_lsdb_lookup (lsa_header->type, lsa_header->ls_id,
+                            lsa_header->advrtr,
+                            ospf6_lsa_get_scope (lsa_header->type,
+                                                 from->ospf6_interface));
+  if (have)
+    {
+      ismore_recent = ospf6_lsa_check_recent (received, have);
+      if (ntohl (received->header->seqnum) == ntohl (have->header->seqnum))
+        SET_FLAG (received->flag, OSPF6_LSA_FLAG_DUPLICATE);
+    }
+
+  /* if no database copy or received is more recent */
+  if (!have || ismore_recent < 0)
+    {
+      /* in case we have no database copy */
+      ismore_recent = -1;
+
+      /* (a) MinLSArrival check */
+      gettimeofday (&now, (struct timezone *)NULL);
+      if (have && SEC_TVDIFF (&now, &have->installed) < OSPF6_MIN_LS_ARRIVAL)
+        {
+          //if (IS_OSPF6_DUMP_DBEX)
+            zlog_info ("DBEX: Receive new LSA from %s: %s seq: %#x age: %d "
+                       "within MinLSArrival, drop: %ld.%06ld",
+                       from->str, received->str,
+                       ntohl (received->header->seqnum),
+                       ntohs (received->header->age),
+                       now.tv_sec, now.tv_usec);
+
+          /* this will do free this lsa */
+          ospf6_lsa_delete (received);
+          return;   /* examin next lsa */
+        }
+
+      //if (IS_OSPF6_DUMP_DBEX)
+        zlog_info ("DBEX: Receive new LSA from %s: %s seq: %#x age: %d: "
+                   "%ld.%06ld",
+                   from->str, received->str,
+                   ntohl (received->header->seqnum),
+                   ntohs (received->header->age),
+                   now.tv_sec, now.tv_usec);
+
+      /* (b) immediately flood */
+      ospf6_dbex_flood (received, from);
+
+#if 0
+      /* Because New LSDB do not permit two LSA having the same identifier
+         exist in a LSDB list, above ospf6_dbex_flood() will remove
+         the old instance automatically. thus bellow is not needed. */
+      /* (c) remove database copy from all neighbor's retranslist */
+      if (have)
+        ospf6_dbex_remove_from_all_retrans_list (have);
+#endif
+
+      /* (d), installing lsdb, which may cause routing
+              table calculation (replacing database copy) */
+      ospf6_lsdb_install (received);
+
+      /* (e) possibly acknowledge */
+      acktype = ack_type (received, ismore_recent, from);
+      if (acktype == DIRECT_ACK)
+        {
+          if (IS_OSPF6_DUMP_DBEX)
+            zlog_info ("DBEX: Direct Ack to %s", from->str);
+          ospf6_dbex_acknowledge_direct (received, from);
+        }
+      else if (acktype == DELAYED_ACK)
+        {
+          if (IS_OSPF6_DUMP_DBEX)
+            zlog_info ("DBEX: Delayed Ack to %s", from->str);
+          ospf6_dbex_acknowledge_delayed (received, from->ospf6_interface);
+        }
+      else
+        {
+          if (IS_OSPF6_DUMP_DBEX)
+            zlog_info ("DBEX: No Ack to %s", from->str);
+        }
+
+      /* (f) */
+      /* Self Originated LSA, section 13.4 */
+      if (received->lsa_hdr->lsh_advrtr == ospf6->router_id
+          && (! have || ismore_recent < 0))
+        {
+          /* we're going to make new lsa or to flush this LSA. */
+          if (IS_OSPF6_DUMP_DBEX)
+            zlog_info ("DBEX: Self-originated LSA %s from %s:%s",
+                       received->str, from->str,
+                       from->ospf6_interface->interface->name);
+          if (IS_OSPF6_DUMP_DBEX)
+            zlog_info ("DBEX: %s: Make new one/Flush", received->str);
+
+          SET_FLAG (received->flag, OSPF6_LSA_FLAG_REFRESH);
+          slot = ospf6_lsa_slot_get (received->header->type);
+          if (slot && slot->func_refresh)
+            {
+              (*slot->func_refresh) (received);
+              return;
+            }
+
+          zlog_warn ("Can't Refresh LSA: Unknown type: %#x, Flush",
+                     ntohs (received->header->type));
+          ospf6_lsa_premature_aging (received);
+          return;
+        }
+    }
+  else if (ospf6_lsdb_lookup_lsdb (received->header->type,
+                                   received->header->id,
+                                   received->header->adv_router,
+                                   from->request_list))
+    /* (6) if there is instance on sending neighbor's request list */
+    {
+      /* if no database copy, should go above state (5) */
+      assert (have);
+
+      zlog_warn ("DBEX: [%s:%s] received LSA %s is not newer,"
+                 " and is on his requestlist: Generate BadLSReq",
+                 from->str, from->ospf6_interface->interface->name,
+                 received->str);
+
+      /* BadLSReq */
+      thread_add_event (master, bad_lsreq, from, 0);
+
+      ospf6_lsa_delete (received);
+    }
+  else if (ismore_recent == 0) /* (7) if neither is more recent */
+    {
+      /* (a) if on retranslist, Treat this LSA as an Ack: Implied Ack */
+      rem = ospf6_lsdb_lookup_lsdb (received->header->type,
+                                    received->header->id,
+                                    received->header->adv_router,
+                                    from->retrans_list);
+      if (rem)
+        {
+          if (IS_OSPF6_DUMP_DBEX)
+            zlog_info ("DBEX: Implied Ack from %s, (remove retrans)",
+                       from->str);
+          SET_FLAG (received->flag, OSPF6_LSA_FLAG_IMPLIEDACK);
+          ospf6_neighbor_retrans_remove (rem, from);
+        }
+
+      /* (b) possibly acknowledge */
+      acktype = ack_type (received, ismore_recent, from);
+      if (acktype == DIRECT_ACK)
+        {
+          if (IS_OSPF6_DUMP_DBEX)
+            zlog_info ("DBEX: Direct Ack to %s", from->str);
+          ospf6_dbex_acknowledge_direct (received, from);
+        }
+      else if (acktype == DELAYED_ACK)
+        {
+          if (IS_OSPF6_DUMP_DBEX)
+            zlog_info ("DBEX: Delayed Ack to %s", from->str);
+          ospf6_dbex_acknowledge_delayed (received, from->ospf6_interface);
+        }
+      else
+        {
+          if (IS_OSPF6_DUMP_DBEX)
+            zlog_info ("DBEX: No Ack to %s", from->str);
+        }
+      ospf6_lsa_delete (received);
+    }
+  else /* (8) previous database copy is more recent */
+    {
+      /* If Seqnumber Wrapping, simply discard
+         Otherwise, Send database copy of this LSA to this neighbor */
+      if (! IS_LSA_MAXAGE (received) ||
+          received->lsa_hdr->lsh_seqnum != MAX_SEQUENCE_NUMBER)
+        {
+          if (IS_OSPF6_DUMP_DBEX)
+            zlog_info ("DBEX: database is more recent: send back to %s",
+                       from->str);
+          ospf6_send_lsupdate_direct (have, from);
+        }
+      ospf6_lsa_delete (received);
+    }
+}
+
+/* RFC2328: Table 19: Sending link state acknowledgements. */
+int 
+ack_type (struct ospf6_lsa *newp, int ismore_recent,
+          struct ospf6_neighbor *from)
+{
+  struct ospf6_interface *ospf6_interface;
+  struct ospf6_lsa *have;
+  int count;
+
+  assert (from && from->ospf6_interface);
+  ospf6_interface = from->ospf6_interface;
+
+  if (CHECK_FLAG (newp->flag, OSPF6_LSA_FLAG_FLOODBACK))
+    return NO_ACK;
+
+  if (ismore_recent < 0)
+    {
+      if (ospf6_interface->state != IFS_BDR)
+        return DELAYED_ACK;
+
+      if (ospf6_interface->dr == from->router_id)
+        return DELAYED_ACK;
+      return NO_ACK;
+    }
+
+  if (CHECK_FLAG (newp->flag, OSPF6_LSA_FLAG_DUPLICATE) &&
+      CHECK_FLAG (newp->flag, OSPF6_LSA_FLAG_IMPLIEDACK))
+    {
+      if (ospf6_interface->state != IFS_BDR)
+        return NO_ACK;
+
+      if (ospf6_interface->dr == from->router_id)
+        return DELAYED_ACK;
+
+      return NO_ACK;
+    }
+
+  if (CHECK_FLAG (newp->flag, OSPF6_LSA_FLAG_DUPLICATE) &&
+      ! CHECK_FLAG (newp->flag, OSPF6_LSA_FLAG_IMPLIEDACK))
+    return DIRECT_ACK;
+
+  have = ospf6_lsdb_lookup (newp->header->type, newp->header->id,
+                            newp->header->adv_router,
+                            ospf6_lsa_get_scope (newp->header->type,
+                                                 from->ospf6_interface));
+
+  count = 0;
+  ospf6->foreach_nei (ospf6, &count, NBS_EXCHANGE, ospf6_count_state);
+  ospf6->foreach_nei (ospf6, &count, NBS_LOADING, ospf6_count_state);
+
+  if (IS_LSA_MAXAGE (newp) && have == NULL && count == 0)
+    return DIRECT_ACK;
+ 
+  return NO_ACK;
+}
+
+static void
+ospf6_dbex_flood_linklocal (struct ospf6_lsa *lsa, struct ospf6_interface *o6i,
+                            struct ospf6_neighbor *from)
+{
+  struct ospf6_neighbor *o6n = (struct ospf6_neighbor *) NULL;
+  int ismore_recent, addretrans = 0;
+  listnode n;
+  struct ospf6_lsa *req;
+
+  /* (1) for each neighbor */
+  for (n = listhead (o6i->neighbor_list); n; nextnode (n))
+    {
+      o6n = (struct ospf6_neighbor *) getdata (n);
+
+      /* (a) */
+      if (o6n->state < NBS_EXCHANGE)
+        continue;  /* examin next neighbor */
+
+      /* (b) */
+      if (o6n->state == NBS_EXCHANGE
+          || o6n->state == NBS_LOADING)
+        {
+          req = ospf6_lsdb_lookup_lsdb (lsa->header->type,
+                                        lsa->header->id,
+                                        lsa->header->adv_router,
+                                        o6n->request_list);
+          if (req)
+            {
+              ismore_recent = ospf6_lsa_check_recent (lsa, req);
+              if (ismore_recent > 0)
+                {
+                  continue; /* examin next neighbor */
+                }
+              else if (ismore_recent == 0)
+                {
+                  ospf6_neighbor_request_remove (req, o6n);
+                  continue; /* examin next neighbor */
+                }
+              else /* ismore_recent < 0 (the new LSA is more recent) */
+                {
+                  ospf6_neighbor_request_remove (req, o6n);
+                }
+            }
+        }
+
+      /* (c) */
+      if (from && from->router_id == o6n->router_id)
+        continue; /* examin next neighbor */
+
+      /* (d) add retranslist */
+      if (IS_OSPF6_DUMP_DBEX)
+        zlog_info ("DBEX: schedule flooding [%s:%s]: %s",
+                   o6n->str, o6n->ospf6_interface->interface->name,
+                   lsa->str);
+      ospf6_neighbor_retrans_add (lsa, o6n);
+      addretrans++;
+      if (o6n->send_update == (struct thread *) NULL)
+        o6n->send_update =
+          thread_add_timer (master, ospf6_send_lsupdate_rxmt, o6n,
+                            o6n->ospf6_interface->rxmt_interval);
+    }
+
+  /* (2) */
+  if (addretrans == 0)
+    return; /* examin next interface */
+
+  if (from && from->ospf6_interface == o6i)
+    {
+      if (IS_OSPF6_DUMP_DBEX)
+        zlog_info ("DBEX: flood back %s to %s",
+                   lsa->str, o6i->interface->name);
+      /* note occurence of floodback */
+      SET_FLAG (lsa->flag, OSPF6_LSA_FLAG_FLOODBACK);
+    }
+
+  /* (3) */
+  if (from && from->ospf6_interface == o6i)
+    {
+      /* if from DR or BDR, don't need to flood this interface */
+      if (from->router_id == from->ospf6_interface->dr ||
+          from->router_id == from->ospf6_interface->bdr)
+        return; /* examin next interface */
+    }
+
+  /* (4) if I'm BDR, DR will flood this interface */
+  if (from && from->ospf6_interface == o6i
+      && o6i->state == IFS_BDR)
+    return; /* examin next interface */
+
+  if (IS_OSPF6_DUMP_DBEX)
+    zlog_info ("Flood to interface %s", o6i->interface->name);
+
+  /* (5) send LinkState Update */
+  ospf6_send_lsupdate_flood (lsa, o6i);
+
+  return;
+}
+
+/* RFC2328 section 13.3 */
+static void
+ospf6_dbex_flood_area (struct ospf6_lsa *lsa, struct ospf6_area *area,
+                       struct ospf6_neighbor *from)
+{
+  listnode n;
+  struct ospf6_interface *ospf6_interface;
+
+  assert (lsa && lsa->lsa_hdr && area);
+
+  /* for each eligible ospf_ifs */
+  for (n = listhead (area->if_list); n; nextnode (n))
+    {
+      ospf6_interface = (struct ospf6_interface *) getdata (n);
+      ospf6_dbex_flood_linklocal (lsa, ospf6_interface, from);
+    }
+}
+
+static void
+ospf6_dbex_flood_as (struct ospf6_lsa *lsa, struct ospf6 *ospf6,
+                     struct ospf6_neighbor *from)
+{
+  listnode n;
+  struct ospf6_area *o6a;
+
+  assert (lsa && lsa->lsa_hdr && ospf6);
+
+  /* for each attached area */
+  for (n = listhead (ospf6->area_list); n; nextnode (n))
+    {
+      o6a = (struct ospf6_area *) getdata (n);
+      ospf6_dbex_flood_area (lsa, o6a, from);
+    }
+}
+
+/* flood ospf6_lsa within appropriate scope */
+void
+ospf6_dbex_flood (struct ospf6_lsa *lsa, struct ospf6_neighbor *from)
+{
+  struct ospf6_area *o6a;
+  struct ospf6_interface *o6i;
+  struct ospf6 *o6;
+  struct ospf6_lsa_header *lsa_header;
+
+  lsa_header = (struct ospf6_lsa_header *) lsa->lsa_hdr;
+
+  if (OSPF6_LSA_IS_SCOPE_LINKLOCAL (ntohs (lsa_header->type)))
+    {
+      o6i = (struct ospf6_interface *) lsa->scope;
+      assert (o6i);
+
+      if (IS_OSPF6_DUMP_DBEX)
+        zlog_info ("Flood Linklocal: %s", o6i->interface->name);
+      ospf6_dbex_flood_linklocal (lsa, o6i, from);
+    }
+  else if (OSPF6_LSA_IS_SCOPE_AREA (ntohs (lsa_header->type)))
+    {
+      o6a = (struct ospf6_area *) lsa->scope;
+      assert (o6a);
+
+      if (IS_OSPF6_DUMP_DBEX)
+        zlog_info ("Flood Area: %s", o6a->str);
+      ospf6_dbex_flood_area (lsa, o6a, from);
+    }
+  else if (OSPF6_LSA_IS_SCOPE_AS (ntohs (lsa_header->type)))
+    {
+      o6 = (struct ospf6 *) lsa->scope;
+      assert (o6);
+
+      if (IS_OSPF6_DUMP_DBEX)
+        zlog_info ("Flood AS");
+      ospf6_dbex_flood_as (lsa, o6, from);
+    }
+  else
+    {
+      zlog_warn ("Can't Flood %s: scope unknown", lsa->str);
+    }
+}
+
+