开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 网络 > 查看源码
ospfd.c
资源名称：zebra-0.95a.tar.gz　[点击查看]
上传用户：xiaozhuqw
上传日期：2009-11-15
资源大小：1338k
文件大小：37k
源码类别：

网络

开发平台：

Unix_Linux

ospfd.c：源码内容
  1. /* OSPF version 2 daemon program.
  2.    Copyright (C) 1999, 2000 Toshiaki Takada
  4. This file is part of GNU Zebra.
  6. GNU Zebra is free software; you can redistribute it and/or modify it
  7. under the terms of the GNU General Public License as published by the
  8. Free Software Foundation; either version 2, or (at your option) any
  9. later version.
  11. GNU Zebra is distributed in the hope that it will be useful, but
  12. WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14. General Public License for more details.
  16. You should have received a copy of the GNU General Public License
  17. along with GNU Zebra; see the file COPYING.  If not, write to the Free
  18. Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19. 02111-1307, USA.  */
  21. #include <zebra.h>
  23. #include "thread.h"
  24. #include "vty.h"
  25. #include "command.h"
  26. #include "linklist.h"
  27. #include "prefix.h"
  28. #include "table.h"
  29. #include "if.h"
  30. #include "memory.h"
  31. #include "stream.h"
  32. #include "log.h"
  33. #include "sockunion.h"          /* for inet_aton () */
  34. #include "zclient.h"
  35. #include "plist.h"
  37. #include "ospfd/ospfd.h"
  38. #include "ospfd/ospf_network.h"
  39. #include "ospfd/ospf_interface.h"
  40. #include "ospfd/ospf_ism.h"
  41. #include "ospfd/ospf_asbr.h"
  42. #include "ospfd/ospf_lsa.h"
  43. #include "ospfd/ospf_lsdb.h"
  44. #include "ospfd/ospf_neighbor.h"
  45. #include "ospfd/ospf_nsm.h"
  46. #include "ospfd/ospf_spf.h"
  47. #include "ospfd/ospf_packet.h"
  48. #include "ospfd/ospf_dump.h"
  49. #include "ospfd/ospf_zebra.h"
  50. #include "ospfd/ospf_abr.h"
  51. #include "ospfd/ospf_flood.h"
  52. #include "ospfd/ospf_route.h"
  53. #include "ospfd/ospf_ase.h"
  56. /* OSPF process wide configuration. */
  57. static struct ospf_master ospf_master;
  59. /* OSPF process wide configuration pointer to export. */
  60. struct ospf_master *om;
  62. extern struct zclient *zclient;
  65. void ospf_remove_vls_through_area (struct ospf *, struct ospf_area *);
  66. void ospf_network_free (struct ospf *, struct ospf_network *);
  67. void ospf_area_free (struct ospf_area *);
  68. void ospf_network_run (struct ospf *, struct prefix *, struct ospf_area *);
  70. /* Get Router ID from ospf interface list. */
  71. struct in_addr
  72. ospf_router_id_get (list if_list)
  73. {
  74.   listnode node;
  75.   struct in_addr router_id;
  77.   memset (&router_id, 0, sizeof (struct in_addr));
  79.   for (node = listhead (if_list); node; nextnode (node))
  80.     {
  81.       struct ospf_interface *oi = getdata (node);
  83.       if (!if_is_up (oi->ifp) ||
  84.   OSPF_IF_PARAM (oi, passive_interface) == OSPF_IF_PASSIVE)
  85. continue;
  86.       
  87.       /* Ignore virtual link interface. */
  88.       if (oi->type != OSPF_IFTYPE_VIRTUALLINK &&
  89.   oi->type != OSPF_IFTYPE_LOOPBACK) 
  90. if (IPV4_ADDR_CMP (&router_id, &oi->address->u.prefix4) < 0)
  91.   router_id = oi->address->u.prefix4;
  92.     }
  94.   return router_id;
  95. }
  97. #define OSPF_EXTERNAL_LSA_ORIGINATE_DELAY 1
  99. void
  100. ospf_router_id_update (struct ospf *ospf)
  101. {
  102.   struct in_addr router_id, router_id_old;
  103.   listnode node;
  105.   if (IS_DEBUG_OSPF_EVENT)
  106.     zlog_info ("Router-ID[OLD:%s]: Update", inet_ntoa (ospf->router_id));
  108.   router_id_old = ospf->router_id;
  110.   if (ospf->router_id_static.s_addr != 0)
  111.     router_id = ospf->router_id_static;
  112.   else
  113.     router_id = ospf_router_id_get (ospf->oiflist);
  115.   ospf->router_id = router_id;
  116.   
  117.   if (IS_DEBUG_OSPF_EVENT)
  118.     zlog_info ("Router-ID[NEW:%s]: Update", inet_ntoa (ospf->router_id));
  120.   if (!IPV4_ADDR_SAME (&router_id_old, &router_id))
  121.     {
  122.       for (node = listhead (ospf->oiflist); node; nextnode (node))
  123.         {
  124.   struct ospf_interface *oi = getdata (node);
  126.           /* Update self-neighbor's router_id. */
  127.           oi->nbr_self->router_id = router_id;
  128.         }
  130.       /* If AS-external-LSA is queued, then flush those LSAs. */
  131.       if (router_id_old.s_addr == 0 && ospf->external_origin)
  132. {
  133.   int type;
  134.   /* Originate each redistributed external route. */
  135.   for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
  136.     if (ospf->external_origin & (1 << type))
  137.       thread_add_event (master, ospf_external_lsa_originate_timer,
  138. ospf, type);
  139.   /* Originate Deafult. */
  140.   if (ospf->external_origin & (1 << ZEBRA_ROUTE_MAX))
  141.     thread_add_event (master, ospf_default_originate_timer,
  142.       &ospf->default_originate, 0);
  144.   ospf->external_origin = 0;
  145. }
  147.       OSPF_TIMER_ON (ospf->t_router_lsa_update,
  148.      ospf_router_lsa_update_timer, OSPF_LSA_UPDATE_DELAY);
  149.     }
  150. }
  152. int
  153. ospf_router_id_update_timer (struct thread *thread)
  154. {
  155.   struct ospf *ospf = THREAD_ARG (thread);
  157.   if (IS_DEBUG_OSPF_EVENT)
  158.     zlog_info ("Router-ID: Update timer fired!");
  160.   ospf->t_router_id_update = NULL;
  161.   ospf_router_id_update (ospf);
  163.   return 0;
  164. }
  166. /* For OSPF area sort by area id. */
  167. int
  168. ospf_area_id_cmp (struct ospf_area *a1, struct ospf_area *a2)
  169. {
  170.   if (ntohl (a1->area_id.s_addr) > ntohl (a2->area_id.s_addr))
  171.     return 1;
  172.   if (ntohl (a1->area_id.s_addr) < ntohl (a2->area_id.s_addr))
  173.     return -1;
  174.   return 0;
  175. }
  177. /* Allocate new ospf structure. */
  178. struct ospf *
  179. ospf_new ()
  180. {
  181.   int i;
  183.   struct ospf *new = XCALLOC (MTYPE_OSPF_TOP, sizeof (struct ospf));
  185.   new->router_id.s_addr = htonl (0);
  186.   new->router_id_static.s_addr = htonl (0);
  188.   new->abr_type = OSPF_ABR_STAND;
  189.   new->oiflist = list_new ();
  190.   new->vlinks = list_new ();
  191.   new->areas = list_new ();
  192.   new->areas->cmp = (int (*)(void *, void *)) ospf_area_id_cmp;
  193.   new->networks = route_table_init ();
  194.   new->nbr_nbma = route_table_init ();
  196.   new->lsdb = ospf_lsdb_new ();
  198.   new->default_originate = DEFAULT_ORIGINATE_NONE;
  200.   new->new_external_route = route_table_init ();
  201.   new->old_external_route = route_table_init ();
  202.   new->external_lsas = route_table_init ();
  204.   /* Distribute parameter init. */
  205.   for (i = 0; i <= ZEBRA_ROUTE_MAX; i++)
  206.     {
  207.       new->dmetric[i].type = -1;
  208.       new->dmetric[i].value = -1;
  209.     }
  210.   new->default_metric = -1;
  211.   new->ref_bandwidth = OSPF_DEFAULT_REF_BANDWIDTH;
  213.   /* SPF timer value init. */
  214.   new->spf_delay = OSPF_SPF_DELAY_DEFAULT;
  215.   new->spf_holdtime = OSPF_SPF_HOLDTIME_DEFAULT;
  217.   /* MaxAge init. */
  218.   new->maxage_lsa = list_new ();
  219.   new->t_maxage_walker =
  220.     thread_add_timer (master, ospf_lsa_maxage_walker,
  221.                       new, OSPF_LSA_MAXAGE_CHECK_INTERVAL);
  223.   /* Distance table init. */
  224.   new->distance_table = route_table_init ();
  226.   new->lsa_refresh_queue.index = 0;
  227.   new->lsa_refresh_interval = OSPF_LSA_REFRESH_INTERVAL_DEFAULT;
  228.   new->t_lsa_refresher = thread_add_timer (master, ospf_lsa_refresh_walker,
  229.    new, new->lsa_refresh_interval);
  230.   new->lsa_refresher_started = time (NULL);
  232.   new->fd = ospf_sock_init ();
  233.   if (new->fd >= 0)
  234.     new->t_read = thread_add_read (master, ospf_read, new, new->fd);
  235.   new->oi_write_q = list_new ();
  236.   
  237.   return new;
  238. }
  240. struct ospf *
  241. ospf_lookup ()
  242. {
  243.   if (listcount (om->ospf) == 0)
  244.     return NULL;
  246.   return getdata (listhead (om->ospf));
  247. }
  249. void
  250. ospf_add (struct ospf *ospf)
  251. {
  252.   listnode_add (om->ospf, ospf);
  253. }
  255. void
  256. ospf_delete (struct ospf *ospf)
  257. {
  258.   listnode_delete (om->ospf, ospf);
  259. }
  261. struct ospf *
  262. ospf_get ()
  263. {
  264.   struct ospf *ospf;
  266.   ospf = ospf_lookup ();
  267.   if (ospf == NULL)
  268.     {
  269.       ospf = ospf_new ();
  270.       ospf_add (ospf);
  272.       if (ospf->router_id_static.s_addr == 0)
  273. ospf_router_id_update (ospf);
  275. #ifdef HAVE_OPAQUE_LSA
  276.       ospf_opaque_type11_lsa_init (ospf);
  277. #endif /* HAVE_OPAQUE_LSA */
  278.     }
  280.   return ospf;
  281. }
  283. void
  284. ospf_finish (struct ospf *ospf)
  285. {
  286.   struct route_node *rn;
  287.   struct ospf_nbr_nbma *nbr_nbma;
  288.   struct ospf_lsa *lsa;
  289.   listnode node;
  290.   int i;
  292. #ifdef HAVE_OPAQUE_LSA
  293.   ospf_opaque_type11_lsa_term (ospf);
  294. #endif /* HAVE_OPAQUE_LSA */
  296.   /* Unredister redistribution */
  297.   for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
  298.     ospf_redistribute_unset (ospf, i);
  300.   for (node = listhead (ospf->areas); node;)
  301.     {
  302.       struct ospf_area *area = getdata (node);
  303.       nextnode (node);
  304.       
  305.       ospf_remove_vls_through_area (ospf, area);
  306.     }
  307.   
  308.   for (node = listhead (ospf->vlinks); node; )
  309.     {
  310.       struct ospf_vl_data *vl_data = node->data;
  311.       nextnode (node);
  312.       
  313.       ospf_vl_delete (ospf, vl_data);
  314.     }
  315.   
  316.   list_delete (ospf->vlinks);
  318.   /* Reset interface. */
  319.   for (node = listhead (ospf->oiflist); node;)
  320.     {
  321.       struct ospf_interface *oi = getdata (node);
  322.       nextnode (node);
  323.       
  324.       if (oi)
  325. ospf_if_free (oi);
  326.     }
  328.   /* Clear static neighbors */
  329.   for (rn = route_top (ospf->nbr_nbma); rn; rn = route_next (rn))
  330.     if ((nbr_nbma = rn->info))
  331.       {
  332. OSPF_POLL_TIMER_OFF (nbr_nbma->t_poll);
  334. if (nbr_nbma->nbr)
  335.   {
  336.     nbr_nbma->nbr->nbr_nbma = NULL;
  337.     nbr_nbma->nbr = NULL;
  338.   }
  340. if (nbr_nbma->oi)
  341.   {
  342.     listnode_delete (nbr_nbma->oi->nbr_nbma, nbr_nbma);
  343.     nbr_nbma->oi = NULL;
  344.   }
  346. XFREE (MTYPE_OSPF_NEIGHBOR_STATIC, nbr_nbma);
  347.       }
  349.   route_table_finish (ospf->nbr_nbma);
  351.   /* Clear networks and Areas. */
  352.   for (rn = route_top (ospf->networks); rn; rn = route_next (rn))
  353.     {
  354.       struct ospf_network *network;
  356.       if ((network = rn->info) != NULL)
  357. {
  358.   ospf_network_free (ospf, network);
  359.   rn->info = NULL;
  360.   route_unlock_node (rn);
  361. }
  362.     }
  364.   for (node = listhead (ospf->areas); node;)
  365.     {
  366.       struct ospf_area *area = getdata (node);
  367.       nextnode (node);
  368.       
  369.       listnode_delete (ospf->areas, area);
  370.       ospf_area_free (area);
  371.     }
  373.   /* Cancel all timers. */
  374.   OSPF_TIMER_OFF (ospf->t_external_lsa);
  375.   OSPF_TIMER_OFF (ospf->t_router_id_update);
  376.   OSPF_TIMER_OFF (ospf->t_router_lsa_update);
  377.   OSPF_TIMER_OFF (ospf->t_spf_calc);
  378.   OSPF_TIMER_OFF (ospf->t_ase_calc);
  379.   OSPF_TIMER_OFF (ospf->t_maxage);
  380.   OSPF_TIMER_OFF (ospf->t_maxage_walker);
  381.   OSPF_TIMER_OFF (ospf->t_abr_task);
  382.   OSPF_TIMER_OFF (ospf->t_distribute_update);
  383.   OSPF_TIMER_OFF (ospf->t_lsa_refresher);
  384.   OSPF_TIMER_OFF (ospf->t_read);
  385.   OSPF_TIMER_OFF (ospf->t_write);
  387.   close (ospf->fd);
  388.    
  389. #ifdef HAVE_OPAQUE_LSA
  390.   LSDB_LOOP (OPAQUE_AS_LSDB (ospf), rn, lsa)
  391.     ospf_discard_from_db (ospf, ospf->lsdb, lsa);
  392. #endif /* HAVE_OPAQUE_LSA */
  393.   LSDB_LOOP (EXTERNAL_LSDB (ospf), rn, lsa)
  394.     ospf_discard_from_db (ospf, ospf->lsdb, lsa);
  396.   ospf_lsdb_delete_all (ospf->lsdb);
  397.   ospf_lsdb_free (ospf->lsdb);
  399.   for (node = listhead (ospf->maxage_lsa); node; nextnode (node))
  400.     ospf_lsa_unlock (getdata (node));
  402.   list_delete (ospf->maxage_lsa);
  404.   if (ospf->old_table)
  405.     ospf_route_table_free (ospf->old_table);
  406.   if (ospf->new_table)
  407.     {
  408.       ospf_route_delete (ospf->new_table);
  409.       ospf_route_table_free (ospf->new_table);
  410.     }
  411.   if (ospf->old_rtrs)
  412.     ospf_rtrs_free (ospf->old_rtrs);
  413.   if (ospf->new_rtrs)
  414.     ospf_rtrs_free (ospf->new_rtrs);
  415.   if (ospf->new_external_route)
  416.     {
  417.       ospf_route_delete (ospf->new_external_route);
  418.       ospf_route_table_free (ospf->new_external_route);
  419.     }
  420.   if (ospf->old_external_route)
  421.     {
  422.       ospf_route_delete (ospf->old_external_route);
  423.       ospf_route_table_free (ospf->old_external_route);
  424.     }
  425.   if (ospf->external_lsas)
  426.     {
  427.       ospf_ase_external_lsas_finish (ospf->external_lsas);
  428.     }
  430.   list_delete (ospf->areas);
  431.   
  432.   for (i = ZEBRA_ROUTE_SYSTEM; i <= ZEBRA_ROUTE_MAX; i++)
  433.     if (EXTERNAL_INFO (i) != NULL)
  434.       for (rn = route_top (EXTERNAL_INFO (i)); rn; rn = route_next (rn))
  435. {
  436.   if (rn->info == NULL)
  437.     continue;
  438.   
  439.   XFREE (MTYPE_OSPF_EXTERNAL_INFO, rn->info);
  440.   rn->info = NULL;
  441.   route_unlock_node (rn);
  442. }
  444.   ospf_distance_reset (ospf);
  445.   route_table_finish (ospf->distance_table);
  447.   ospf_delete (ospf);
  449.   XFREE (MTYPE_OSPF_TOP, ospf);
  450. }
  453. /* allocate new OSPF Area object */
  454. struct ospf_area *
  455. ospf_area_new (struct ospf *ospf, struct in_addr area_id)
  456. {
  457.   struct ospf_area *new;
  459.   /* Allocate new config_network. */
  460.   new = XCALLOC (MTYPE_OSPF_AREA, sizeof (struct ospf_area));
  462.   new->ospf = ospf;
  464.   new->area_id = area_id;
  466.   new->external_routing = OSPF_AREA_DEFAULT;
  467.   new->default_cost = 1;
  468.   new->auth_type = OSPF_AUTH_NULL;
  470.   /* New LSDB init. */
  471.   new->lsdb = ospf_lsdb_new ();
  473.   /* Self-originated LSAs initialize. */
  474.   new->router_lsa_self = NULL;
  476. #ifdef HAVE_OPAQUE_LSA
  477.   ospf_opaque_type10_lsa_init (new);
  478. #endif /* HAVE_OPAQUE_LSA */
  480.   new->oiflist = list_new ();
  481.   new->ranges = route_table_init ();
  483.   if (area_id.s_addr == OSPF_AREA_BACKBONE)
  484.     ospf->backbone = new;
  486.   return new;
  487. }
  489. void
  490. ospf_area_free (struct ospf_area *area)
  491. {
  492.   struct route_node *rn;
  493.   struct ospf_lsa *lsa;
  495.   /* Free LSDBs. */
  496.   LSDB_LOOP (ROUTER_LSDB (area), rn, lsa)
  497.     ospf_discard_from_db (area->ospf, area->lsdb, lsa);
  498.   LSDB_LOOP (NETWORK_LSDB (area), rn, lsa)
  499.     ospf_discard_from_db (area->ospf, area->lsdb, lsa);
  500.   LSDB_LOOP (SUMMARY_LSDB (area), rn, lsa)
  501.     ospf_discard_from_db (area->ospf, area->lsdb, lsa);
  502.   LSDB_LOOP (ASBR_SUMMARY_LSDB (area), rn, lsa)
  503.     ospf_discard_from_db (area->ospf, area->lsdb, lsa);
  505. #ifdef HAVE_NSSA
  506.   LSDB_LOOP (NSSA_LSDB (area), rn, lsa)
  507.     ospf_discard_from_db (area->ospf, area->lsdb, lsa);
  508. #endif /* HAVE_NSSA */
  509. #ifdef HAVE_OPAQUE_LSA
  510.   LSDB_LOOP (OPAQUE_AREA_LSDB (area), rn, lsa)
  511.     ospf_discard_from_db (area->ospf, area->lsdb, lsa);
  512.   LSDB_LOOP (OPAQUE_LINK_LSDB (area), rn, lsa)
  513.     ospf_discard_from_db (area->ospf, area->lsdb, lsa);
  514. #endif /* HAVE_OPAQUE_LSA */
  516.   ospf_lsdb_delete_all (area->lsdb);
  517.   ospf_lsdb_free (area->lsdb);
  519. #ifdef HAVE_OPAQUE_LSA
  520.   ospf_opaque_type10_lsa_term (area);
  521. #endif /* HAVE_OPAQUE_LSA */
  522.   ospf_lsa_unlock (area->router_lsa_self);
  523.   
  524.   route_table_finish (area->ranges);
  525.   list_delete (area->oiflist);
  527.   if (EXPORT_NAME (area))
  528.     free (EXPORT_NAME (area));
  530.   if (IMPORT_NAME (area))
  531.     free (IMPORT_NAME (area));
  533.   /* Cancel timer. */
  534.   OSPF_TIMER_OFF (area->t_router_lsa_self);
  536.   if (OSPF_IS_AREA_BACKBONE (area))
  537.     area->ospf->backbone = NULL;
  539.   XFREE (MTYPE_OSPF_AREA, area);
  540. }
  542. void
  543. ospf_area_check_free (struct ospf *ospf, struct in_addr area_id)
  544. {
  545.   struct ospf_area *area;
  547.   area = ospf_area_lookup_by_area_id (ospf, area_id);
  548.   if (area &&
  549.       listcount (area->oiflist) == 0 &&
  550.       area->ranges->top == NULL &&
  551.       area->shortcut_configured == OSPF_SHORTCUT_DEFAULT &&
  552.       area->external_routing == OSPF_AREA_DEFAULT &&
  553.       area->no_summary == 0 &&
  554.       area->default_cost == 1 &&
  555.       EXPORT_NAME (area) == NULL &&
  556.       IMPORT_NAME (area) == NULL &&
  557.       area->auth_type == OSPF_AUTH_NULL)
  558.     {
  559.       listnode_delete (ospf->areas, area);
  560.       ospf_area_free (area);
  561.     }
  562. }
  564. struct ospf_area *
  565. ospf_area_get (struct ospf *ospf, struct in_addr area_id, int format)
  566. {
  567.   struct ospf_area *area;
  568.   
  569.   area = ospf_area_lookup_by_area_id (ospf, area_id);
  570.   if (!area)
  571.     {
  572.       area = ospf_area_new (ospf, area_id);
  573.       area->format = format;
  574.       listnode_add_sort (ospf->areas, area);
  575.       ospf_check_abr_status (ospf);  
  576.     }
  578.   return area;
  579. }
  581. struct ospf_area *
  582. ospf_area_lookup_by_area_id (struct ospf *ospf, struct in_addr area_id)
  583. {
  584.   struct ospf_area *area;
  585.   listnode node;
  587.   for (node = listhead (ospf->areas); node; nextnode (node))
  588.     {
  589.       area = getdata (node);
  591.       if (IPV4_ADDR_SAME (&area->area_id, &area_id))
  592.         return area;
  593.     }
  595.   return NULL;
  596. }
  598. void
  599. ospf_area_add_if (struct ospf_area *area, struct ospf_interface *oi)
  600. {
  601.   listnode_add (area->oiflist, oi);
  602. }
  604. void
  605. ospf_area_del_if (struct ospf_area *area, struct ospf_interface *oi)
  606. {
  607.   listnode_delete (area->oiflist, oi);
  608. }
  611. /* Config network statement related functions. */
  612. struct ospf_network *
  613. ospf_network_new (struct in_addr area_id, int format)
  614. {
  615.   struct ospf_network *new;
  616.   new = XCALLOC (MTYPE_OSPF_NETWORK, sizeof (struct ospf_network));
  618.   new->area_id = area_id;
  619.   new->format = format;
  620.   
  621.   return new;
  622. }
  624. void
  625. ospf_network_free (struct ospf *ospf, struct ospf_network *network)
  626. {
  627.   ospf_area_check_free (ospf, network->area_id);
  628.   ospf_schedule_abr_task (ospf);
  629.   XFREE (MTYPE_OSPF_NETWORK, network);
  630. }
  632. int
  633. ospf_network_set (struct ospf *ospf, struct prefix_ipv4 *p,
  634.   struct in_addr area_id)
  635. {
  636.   struct ospf_network *network;
  637.   struct ospf_area *area;
  638.   struct route_node *rn;
  639.   struct external_info *ei;
  640.   int ret = OSPF_AREA_ID_FORMAT_ADDRESS;
  642.   rn = route_node_get (ospf->networks, (struct prefix *)p);
  643.   if (rn->info)
  644.     {
  645.       /* There is already same network statement. */
  646.       route_unlock_node (rn);
  647.       return 0;
  648.     }
  650.   rn->info = network = ospf_network_new (area_id, ret);
  651.   area = ospf_area_get (ospf, area_id, ret);
  653.   /* Run network config now. */
  654.   ospf_network_run (ospf, (struct prefix *)p, area);
  656.   /* Update connected redistribute. */
  657.   if (ospf_is_type_redistributed (ZEBRA_ROUTE_CONNECT))
  658.     if (EXTERNAL_INFO (ZEBRA_ROUTE_CONNECT))
  659.       for (rn = route_top (EXTERNAL_INFO (ZEBRA_ROUTE_CONNECT));
  660.    rn; rn = route_next (rn))
  661. if ((ei = rn->info) != NULL)
  662.   if (ospf_external_info_find_lsa (ospf, &ei->p))
  663.     if (!ospf_distribute_check_connected (ospf, ei))
  664.       ospf_external_lsa_flush (ospf, ei->type, &ei->p,
  665.        ei->ifindex, ei->nexthop);
  667.   ospf_area_check_free (ospf, area_id);
  669.   return 1;
  670. }
  672. int
  673. ospf_network_unset (struct ospf *ospf, struct prefix_ipv4 *p,
  674.     struct in_addr area_id)
  675. {
  676.   struct route_node *rn;
  677.   struct ospf_network *network;
  678.   struct external_info *ei;
  680.   rn = route_node_lookup (ospf->networks, (struct prefix *)p);
  681.   if (rn == NULL)
  682.     return 0;
  684.   network = rn->info;
  685.   if (!IPV4_ADDR_SAME (&area_id, &network->area_id))
  686.     return 0;
  688.   ospf_network_free (ospf, rn->info);
  689.   rn->info = NULL;
  690.   route_unlock_node (rn);
  692.   ospf_if_update (ospf);
  693.   
  694.   /* Update connected redistribute. */
  695.   if (ospf_is_type_redistributed (ZEBRA_ROUTE_CONNECT))
  696.     if (EXTERNAL_INFO (ZEBRA_ROUTE_CONNECT))
  697.       for (rn = route_top (EXTERNAL_INFO (ZEBRA_ROUTE_CONNECT));
  698.    rn; rn = route_next (rn))
  699. if ((ei = rn->info) != NULL)
  700.   if (!ospf_external_info_find_lsa (ospf, &ei->p))
  701.     if (ospf_distribute_check_connected (ospf, ei))
  702.       ospf_external_lsa_originate (ospf, ei);
  704.   return 1;
  705. }
  708. void
  709. ospf_network_run (struct ospf *ospf, struct prefix *p, struct ospf_area *area)
  710. {
  711.   struct interface *ifp;
  712.   listnode node;
  714.   /* Schedule Router ID Update. */
  715.   if (ospf->router_id_static.s_addr == 0)
  716.     if (ospf->t_router_id_update == NULL)
  717.       {
  718. OSPF_TIMER_ON (ospf->t_router_id_update, ospf_router_id_update_timer,
  719.        OSPF_ROUTER_ID_UPDATE_DELAY);
  720.       }
  722.   /* Get target interface. */
  723.   for (node = listhead (om->iflist); node; nextnode (node))
  724.     {
  725.       listnode cn;
  726.       
  727.       if ((ifp = getdata (node)) == NULL)
  728. continue;
  730.       if (memcmp (ifp->name, "VLINK", 5) == 0)
  731. continue;
  733.       /* if interface prefix is match specified prefix,
  734.  then create socket and join multicast group. */
  735.       for (cn = listhead (ifp->connected); cn; nextnode (cn))
  736. {
  737.   struct connected *co = getdata (cn);
  738.   struct prefix *addr;
  740.   if (if_is_pointopoint (ifp))
  741.     addr = co->destination;
  742.   else 
  743.     addr = co->address;
  745.   if (p->family == co->address->family &&
  746.       ! ospf_if_is_configured (ospf, &(addr->u.prefix4)))
  747.     if ((if_is_pointopoint (ifp) &&
  748.  IPV4_ADDR_SAME (&(addr->u.prefix4), &(p->u.prefix4))) ||
  749. prefix_match (p, addr)) 
  750.     {
  751.         struct ospf_interface *oi;
  753. oi = ospf_if_new (ospf, ifp, co->address);
  754. oi->connected = co;
  756. oi->nbr_self->address = *oi->address;
  758. area->act_ints++;
  759. oi->area = area;
  761. oi->params = ospf_lookup_if_params (ifp, oi->address->u.prefix4);
  762. oi->output_cost = ospf_if_get_output_cost (oi);
  764. if (area->external_routing != OSPF_AREA_DEFAULT)
  765.   UNSET_FLAG (oi->nbr_self->options, OSPF_OPTION_E);
  766. oi->nbr_self->priority = OSPF_IF_PARAM (oi, priority);
  768. /* Add pseudo neighbor. */
  769. ospf_nbr_add_self (oi);
  771. /* Make sure pseudo neighbor's router_id. */
  772. oi->nbr_self->router_id = ospf->router_id;
  773. oi->nbr_self->src = oi->address->u.prefix4;
  775. /* Relate ospf interface to ospf instance. */
  776. oi->ospf = ospf;
  778. /* update network type as interface flag */
  779. /* If network type is specified previously,
  780.    skip network type setting. */
  781. oi->type = IF_DEF_PARAMS (ifp)->type;
  783. /* Set area flag. */
  784. switch (area->external_routing)
  785.   {
  786.   case OSPF_AREA_DEFAULT:
  787.     SET_FLAG (oi->nbr_self->options, OSPF_OPTION_E);
  788.     break;
  789.   case OSPF_AREA_STUB:
  790.     UNSET_FLAG (oi->nbr_self->options, OSPF_OPTION_E);
  791.     break;
  792. #ifdef HAVE_NSSA
  793.   case OSPF_AREA_NSSA:
  794.     UNSET_FLAG (oi->nbr_self->options, OSPF_OPTION_E);
  795.     SET_FLAG (oi->nbr_self->options, OSPF_OPTION_NP);
  796.     break;
  797. #endif /* HAVE_NSSA */
  798.   }
  800. ospf_area_add_if (oi->area, oi);
  802. if (if_is_up (ifp)) 
  803.   ospf_if_up (oi);
  805. break;
  806.       }
  807. }
  808.     }
  809. }
  811. void
  812. ospf_ls_upd_queue_empty (struct ospf_interface *oi)
  813. {
  814.   struct route_node *rn;
  815.   listnode node;
  816.   list lst;
  817.   struct ospf_lsa *lsa;
  819.   /* empty ls update queue */
  820.   for (rn = route_top (oi->ls_upd_queue); rn;
  821.        rn = route_next (rn))
  822.     if ((lst = (list) rn->info))
  823.       {
  824. for (node = listhead (lst); node; nextnode (node))
  825.   if ((lsa = getdata (node)))
  826.     ospf_lsa_unlock (lsa);
  827. list_free (lst);
  828. rn->info = NULL;
  829.       }
  830.   
  831.   /* remove update event */
  832.   if (oi->t_ls_upd_event)
  833.     {
  834.       thread_cancel (oi->t_ls_upd_event);
  835.       oi->t_ls_upd_event = NULL;
  836.     }
  837. }
  839. void
  840. ospf_if_update (struct ospf *ospf)
  841. {
  842.   struct route_node *rn;
  843.   listnode node;
  844.   listnode next;
  845.   struct ospf_network *network;
  846.   struct ospf_area *area;
  848.   if (ospf != NULL)
  849.     {
  850.       /* Update Router ID scheduled. */
  851.       if (ospf->router_id_static.s_addr == 0)
  852.         if (ospf->t_router_id_update == NULL)
  853.           {
  854.     OSPF_TIMER_ON (ospf->t_router_id_update,
  855.    ospf_router_id_update_timer,
  856.    OSPF_ROUTER_ID_UPDATE_DELAY);
  857.           }
  859.       /* Find interfaces that not configured already.  */
  860.       for (node = listhead (ospf->oiflist); node; node = next)
  861. {
  862.   int found = 0;
  863.   struct ospf_interface *oi = getdata (node);
  864.   struct connected *co = oi->connected;
  865.   
  866.   next = nextnode (node);
  868.   if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
  869.     continue;
  870.   
  871.   for (rn = route_top (ospf->networks); rn; rn = route_next (rn))
  872.     {
  873.       if (rn->info == NULL)
  874. continue;
  875.       
  876.       if ((oi->type == OSPF_IFTYPE_POINTOPOINT
  877.    && IPV4_ADDR_SAME (&(co->destination->u.prefix4),
  878.       &(rn->p.u.prefix4)))
  879.   || prefix_match (&(rn->p), co->address))
  880. {
  881.   found = 1;
  882.   route_unlock_node (rn);
  883.   break;
  884. }
  885.     }
  887.   if (found == 0)
  888.     ospf_if_free (oi);
  889. }
  891.       /* Run each interface. */
  892.       for (rn = route_top (ospf->networks); rn; rn = route_next (rn))
  893. if (rn->info != NULL)
  894.   {
  895.     network = (struct ospf_network *) rn->info;
  896.     area = ospf_area_get (ospf, network->area_id, network->format);
  897.     ospf_network_run (ospf, &rn->p, area);
  898.   }
  899.     }
  900. }
  902. void
  903. ospf_remove_vls_through_area (struct ospf *ospf, struct ospf_area *area)
  904. {
  905.   listnode node, next;
  906.   struct ospf_vl_data *vl_data;
  908.   for (node = listhead (ospf->vlinks); node; node = next)
  909.     {
  910.       next = node->next;
  911.       if ((vl_data = getdata (node)) != NULL)
  912. if (IPV4_ADDR_SAME (&vl_data->vl_area_id, &area->area_id))
  913.   ospf_vl_delete (ospf, vl_data);
  914.     }
  915. }
  918. struct message ospf_area_type_msg[] =
  919. {
  920.   { OSPF_AREA_DEFAULT, "Default" },
  921.   { OSPF_AREA_STUB,     "Stub" },
  922.   { OSPF_AREA_NSSA,     "NSSA" },
  923. };
  924. int ospf_area_type_msg_max = OSPF_AREA_TYPE_MAX;
  926. void
  927. ospf_area_type_set (struct ospf_area *area, int type)
  928. {
  929.   listnode node;
  930.   struct ospf_interface *oi;
  932.   if (area->external_routing == type)
  933.     {
  934.       if (IS_DEBUG_OSPF_EVENT)
  935. zlog_info ("Area[%s]: Types are the same, ignored.",
  936.    inet_ntoa (area->area_id));
  937.       return;
  938.     }
  940.   area->external_routing = type;
  942.   if (IS_DEBUG_OSPF_EVENT)
  943.     zlog_info ("Area[%s]: Configured as %s", inet_ntoa (area->area_id),
  944.        LOOKUP (ospf_area_type_msg, type));
  946.   switch (area->external_routing)
  947.     {
  948.     case OSPF_AREA_DEFAULT:
  949.       for (node = listhead (area->oiflist); node; nextnode (node))
  950. if ((oi = getdata (node)) != NULL)
  951.   if (oi->nbr_self != NULL)
  952.     SET_FLAG (oi->nbr_self->options, OSPF_OPTION_E);
  953.       break;
  954.     case OSPF_AREA_STUB:
  955.       for (node = listhead (area->oiflist); node; nextnode (node))
  956. if ((oi = getdata (node)) != NULL)
  957.   if (oi->nbr_self != NULL)
  958.     {
  959.       if (IS_DEBUG_OSPF_EVENT)
  960. zlog_info ("setting options on %s accordingly", IF_NAME (oi));
  961.       UNSET_FLAG (oi->nbr_self->options, OSPF_OPTION_E);
  962.       if (IS_DEBUG_OSPF_EVENT)
  963. zlog_info ("options set on %s: %x",
  964.    IF_NAME (oi), OPTIONS (oi));
  965.     }
  966.       break;
  967.     case OSPF_AREA_NSSA:
  968. #ifdef HAVE_NSSA
  969.       for (node = listhead (area->oiflist); node; nextnode (node))
  970. if ((oi = getdata (node)) != NULL)
  971.   if (oi->nbr_self != NULL)
  972.     {
  973.       zlog_info ("setting nssa options on %s accordingly", IF_NAME (oi));
  974.       UNSET_FLAG (oi->nbr_self->options, OSPF_OPTION_E);
  975.       SET_FLAG (oi->nbr_self->options, OSPF_OPTION_NP);
  976.       zlog_info ("options set on %s: %x", IF_NAME (oi), OPTIONS (oi));
  977.     }
  978. #endif /* HAVE_NSSA */
  979.       break;
  980.     default:
  981.       break;
  982.     }
  984.   ospf_router_lsa_timer_add (area);
  985.   ospf_schedule_abr_task (area->ospf);
  986. }
  988. int
  989. ospf_area_shortcut_set (struct ospf *ospf, struct ospf_area *area, int mode)
  990. {
  991.   if (area->shortcut_configured == mode)
  992.     return 0;
  994.   area->shortcut_configured = mode;
  995.   ospf_router_lsa_timer_add (area);
  996.   ospf_schedule_abr_task (ospf);
  998.   ospf_area_check_free (ospf, area->area_id);
  1000.   return 1;
  1001. }
  1003. int
  1004. ospf_area_shortcut_unset (struct ospf *ospf, struct ospf_area *area)
  1005. {
  1006.   area->shortcut_configured = OSPF_SHORTCUT_DEFAULT;
  1007.   ospf_router_lsa_timer_add (area);
  1008.   ospf_area_check_free (ospf, area->area_id);
  1009.   ospf_schedule_abr_task (ospf);
  1011.   return 1;
  1012. }
  1014. int
  1015. ospf_area_vlink_count (struct ospf *ospf, struct ospf_area *area)
  1016. {
  1017.   struct ospf_vl_data *vl;
  1018.   listnode node;
  1019.   int count = 0;
  1021.   for (node = listhead (ospf->vlinks); node; nextnode (node))
  1022.     {
  1023.       vl = getdata (node);
  1024.       if (IPV4_ADDR_SAME (&vl->vl_area_id, &area->area_id))
  1025. count++;
  1026.     }
  1028.   return count;
  1029. }
  1031. int
  1032. ospf_area_stub_set (struct ospf *ospf, struct in_addr area_id)
  1033. {
  1034.   struct ospf_area *area;
  1035.   int format = OSPF_AREA_ID_FORMAT_ADDRESS;
  1037.   area = ospf_area_get (ospf, area_id, format);
  1038.   if (ospf_area_vlink_count (ospf, area))
  1039.     return 0;
  1041.   if (area->external_routing != OSPF_AREA_STUB)
  1042.     ospf_area_type_set (area, OSPF_AREA_STUB);
  1044.   return 1;
  1045. }
  1047. int
  1048. ospf_area_stub_unset (struct ospf *ospf, struct in_addr area_id)
  1049. {
  1050.   struct ospf_area *area;
  1052.   area = ospf_area_lookup_by_area_id (ospf, area_id);
  1053.   if (area == NULL)
  1054.     return 1;
  1056.   if (area->external_routing == OSPF_AREA_STUB)
  1057.     ospf_area_type_set (area, OSPF_AREA_DEFAULT);
  1059.   ospf_area_check_free (ospf, area_id);
  1061.   return 1;
  1062. }
  1064. int
  1065. ospf_area_no_summary_set (struct ospf *ospf, struct in_addr area_id)
  1066. {
  1067.   struct ospf_area *area;
  1068.   int format = OSPF_AREA_ID_FORMAT_ADDRESS;
  1070.   area = ospf_area_get (ospf, area_id, format);
  1071.   area->no_summary = 1;
  1073.   return 1;
  1074. }
  1076. int
  1077. ospf_area_no_summary_unset (struct ospf *ospf, struct in_addr area_id)
  1078. {
  1079.   struct ospf_area *area;
  1081.   area = ospf_area_lookup_by_area_id (ospf, area_id);
  1082.   if (area == NULL)
  1083.     return 0;
  1085.   area->no_summary = 0;
  1086.   ospf_area_check_free (ospf, area_id);
  1088.   return 1;
  1089. }
  1091. int
  1092. ospf_area_nssa_set (struct ospf *ospf, struct in_addr area_id)
  1093. {
  1094.   struct ospf_area *area;
  1095.   int format = OSPF_AREA_ID_FORMAT_ADDRESS;
  1097.   area = ospf_area_get (ospf, area_id, format);
  1098.   if (ospf_area_vlink_count (ospf, area))
  1099.     return 0;
  1101.   if (area->external_routing != OSPF_AREA_NSSA)
  1102.     {
  1103.       ospf_area_type_set (area, OSPF_AREA_NSSA);
  1104.       ospf->anyNSSA++;
  1105.     }
  1107.   return 1;
  1108. }
  1110. int
  1111. ospf_area_nssa_unset (struct ospf *ospf, struct in_addr area_id)
  1112. {
  1113.   struct ospf_area *area;
  1115.   area = ospf_area_lookup_by_area_id (ospf, area_id);
  1116.   if (area == NULL)
  1117.     return 0;
  1119.   if (area->external_routing == OSPF_AREA_NSSA)
  1120.     {
  1121.       ospf->anyNSSA--;
  1122.       ospf_area_type_set (area, OSPF_AREA_DEFAULT);
  1123.     }
  1125.   ospf_area_check_free (ospf, area_id);
  1127.   return 1;
  1128. }
  1130. int
  1131. ospf_area_nssa_translator_role_set (struct ospf *ospf, struct in_addr area_id,
  1132.     int role)
  1133. {
  1134.   struct ospf_area *area;
  1136.   area = ospf_area_lookup_by_area_id (ospf, area_id);
  1137.   if (area == NULL)
  1138.     return 0;
  1140.   area->NSSATranslator = role;
  1142.   return 1;
  1143. }
  1145. int
  1146. ospf_area_nssa_translator_role_unset (struct ospf *ospf,
  1147.       struct in_addr area_id)
  1148. {
  1149.   struct ospf_area *area;
  1151.   area = ospf_area_lookup_by_area_id (ospf, area_id);
  1152.   if (area == NULL)
  1153.     return 0;
  1155.   area->NSSATranslator = OSPF_NSSA_ROLE_CANDIDATE;
  1157.   ospf_area_check_free (ospf, area_id);
  1159.   return 1;
  1160. }
  1162. int
  1163. ospf_area_export_list_set (struct ospf *ospf,
  1164.    struct ospf_area *area, char *list_name)
  1165. {
  1166.   struct access_list *list;
  1167.   list = access_list_lookup (AFI_IP, list_name);
  1169.   EXPORT_LIST (area) = list;
  1171.   if (EXPORT_NAME (area))
  1172.     free (EXPORT_NAME (area));
  1174.   EXPORT_NAME (area) = strdup (list_name);
  1175.   ospf_schedule_abr_task (ospf);
  1177.   return 1;
  1178. }
  1180. int
  1181. ospf_area_export_list_unset (struct ospf *ospf, struct ospf_area * area)
  1182. {
  1184.   EXPORT_LIST (area) = 0;
  1186.   if (EXPORT_NAME (area))
  1187.     free (EXPORT_NAME (area));
  1189.   EXPORT_NAME (area) = NULL;
  1191.   ospf_area_check_free (ospf, area->area_id);
  1192.   
  1193.   ospf_schedule_abr_task (ospf);
  1195.   return 1;
  1196. }
  1198. int
  1199. ospf_area_import_list_set (struct ospf *ospf,
  1200.    struct ospf_area *area, char *name)
  1201. {
  1202.   struct access_list *list;
  1203.   list = access_list_lookup (AFI_IP, name);
  1205.   IMPORT_LIST (area) = list;
  1207.   if (IMPORT_NAME (area))
  1208.     free (IMPORT_NAME (area));
  1210.   IMPORT_NAME (area) = strdup (name);
  1211.   ospf_schedule_abr_task (ospf);
  1213.   return 1;
  1214. }
  1216. int
  1217. ospf_area_import_list_unset (struct ospf *ospf, struct ospf_area * area)
  1218. {
  1219.   IMPORT_LIST (area) = 0;
  1221.   if (IMPORT_NAME (area))
  1222.     free (IMPORT_NAME (area));
  1224.   IMPORT_NAME (area) = NULL;
  1225.   ospf_area_check_free (ospf, area->area_id);
  1227.   ospf_schedule_abr_task (ospf);
  1229.   return 1;
  1230. }
  1232. int
  1233. ospf_timers_spf_set (struct ospf *ospf, u_int32_t delay, u_int32_t hold)
  1234. {
  1235.   ospf->spf_delay = delay;
  1236.   ospf->spf_holdtime = hold;
  1238.   return 1;
  1239. }
  1241. int
  1242. ospf_timers_spf_unset (struct ospf *ospf)
  1243. {
  1244.   ospf->spf_delay = OSPF_SPF_DELAY_DEFAULT;
  1245.   ospf->spf_holdtime = OSPF_SPF_HOLDTIME_DEFAULT;
  1247.   return 1;
  1248. }
  1250. int
  1251. ospf_timers_refresh_set (struct ospf *ospf, int interval)
  1252. {
  1253.   int time_left;
  1255.   if (ospf->lsa_refresh_interval == interval)
  1256.     return 1;
  1258.   time_left = ospf->lsa_refresh_interval -
  1259.     (time (NULL) - ospf->lsa_refresher_started);
  1260.   
  1261.   if (time_left > interval)
  1262.     {
  1263.       OSPF_TIMER_OFF (ospf->t_lsa_refresher);
  1264.       ospf->t_lsa_refresher =
  1265. thread_add_timer (master, ospf_lsa_refresh_walker, ospf, interval);
  1266.     }
  1267.   ospf->lsa_refresh_interval = interval;
  1269.   return 1;
  1270. }
  1272. int
  1273. ospf_timers_refresh_unset (struct ospf *ospf)
  1274. {
  1275.   int time_left;
  1277.   time_left = ospf->lsa_refresh_interval -
  1278.     (time (NULL) - ospf->lsa_refresher_started);
  1280.   if (time_left > OSPF_LSA_REFRESH_INTERVAL_DEFAULT)
  1281.     {
  1282.       OSPF_TIMER_OFF (ospf->t_lsa_refresher);
  1283.       ospf->t_lsa_refresher =
  1284. thread_add_timer (master, ospf_lsa_refresh_walker, ospf,
  1285.   OSPF_LSA_REFRESH_INTERVAL_DEFAULT);
  1286.     }
  1288.   ospf->lsa_refresh_interval = OSPF_LSA_REFRESH_INTERVAL_DEFAULT;
  1290.   return 1;
  1291. }
  1294. struct ospf_nbr_nbma *
  1295. ospf_nbr_nbma_new ()
  1296. {
  1297.   struct ospf_nbr_nbma *nbr_nbma;
  1299.   nbr_nbma = XMALLOC (MTYPE_OSPF_NEIGHBOR_STATIC,
  1300.       sizeof (struct ospf_nbr_nbma));
  1301.   memset (nbr_nbma, 0, sizeof (struct ospf_nbr_nbma));
  1303.   nbr_nbma->priority = OSPF_NEIGHBOR_PRIORITY_DEFAULT;
  1304.   nbr_nbma->v_poll = OSPF_POLL_INTERVAL_DEFAULT;
  1306.   return nbr_nbma;
  1307. }
  1309. void
  1310. ospf_nbr_nbma_free (struct ospf_nbr_nbma *nbr_nbma)
  1311. {
  1312.   XFREE (MTYPE_OSPF_NEIGHBOR_STATIC, nbr_nbma);
  1313. }
  1315. void
  1316. ospf_nbr_nbma_delete (struct ospf *ospf, struct ospf_nbr_nbma *nbr_nbma)
  1317. {
  1318.   struct route_node *rn;
  1319.   struct prefix_ipv4 p;
  1321.   p.family = AF_INET;
  1322.   p.prefix = nbr_nbma->addr;
  1323.   p.prefixlen = IPV4_MAX_BITLEN;
  1325.   rn = route_node_lookup (ospf->nbr_nbma, (struct prefix *)&p);
  1326.   if (rn)
  1327.     {
  1328.       ospf_nbr_nbma_free (rn->info);
  1329.       rn->info = NULL;
  1330.       route_unlock_node (rn);
  1331.       route_unlock_node (rn);
  1332.     }
  1333. }
  1335. void
  1336. ospf_nbr_nbma_down (struct ospf_nbr_nbma *nbr_nbma)
  1337. {
  1338.   OSPF_TIMER_OFF (nbr_nbma->t_poll);
  1340.   if (nbr_nbma->nbr)
  1341.     {
  1342.       nbr_nbma->nbr->nbr_nbma = NULL;
  1343.       OSPF_NSM_EVENT_EXECUTE (nbr_nbma->nbr, NSM_KillNbr);
  1344.     }
  1346.   if (nbr_nbma->oi)
  1347.     listnode_delete (nbr_nbma->oi->nbr_nbma, nbr_nbma);
  1348. }
  1350. void
  1351. ospf_nbr_nbma_add (struct ospf_nbr_nbma *nbr_nbma,
  1352.    struct ospf_interface *oi)
  1353. {
  1354.   struct ospf_neighbor *nbr;
  1355.   struct route_node *rn;
  1356.   struct prefix p;
  1358.   if (oi->type != OSPF_IFTYPE_NBMA)
  1359.     return;
  1361.   if (nbr_nbma->nbr != NULL)
  1362.     return;
  1364.   if (IPV4_ADDR_SAME (&oi->nbr_self->address.u.prefix4, &nbr_nbma->addr))
  1365.     return;
  1366.       
  1367.   nbr_nbma->oi = oi;
  1368.   listnode_add (oi->nbr_nbma, nbr_nbma);
  1370.   /* Get neighbor information from table. */
  1371.   p.family = AF_INET;
  1372.   p.prefixlen = IPV4_MAX_BITLEN;
  1373.   p.u.prefix4 = nbr_nbma->addr;
  1375.   rn = route_node_get (oi->nbrs, (struct prefix *)&p);
  1376.   if (rn->info)
  1377.     {
  1378.       nbr = rn->info;
  1379.       nbr->nbr_nbma = nbr_nbma;
  1380.       nbr_nbma->nbr = nbr;
  1382.       route_unlock_node (rn);
  1383.     }
  1384.   else
  1385.     {
  1386.       nbr = rn->info = ospf_nbr_new (oi);
  1387.       nbr->state = NSM_Down;
  1388.       nbr->src = nbr_nbma->addr;
  1389.       nbr->nbr_nbma = nbr_nbma;
  1390.       nbr->priority = nbr_nbma->priority;
  1391.       nbr->address = p;
  1393.       nbr_nbma->nbr = nbr;
  1395.       OSPF_NSM_EVENT_EXECUTE (nbr, NSM_Start);
  1396.     }
  1397. }
  1399. void
  1400. ospf_nbr_nbma_if_update (struct ospf *ospf, struct ospf_interface *oi)
  1401. {
  1402.   struct ospf_nbr_nbma *nbr_nbma;
  1403.   struct route_node *rn;
  1404.   struct prefix_ipv4 p;
  1406.   if (oi->type != OSPF_IFTYPE_NBMA)
  1407.     return;
  1409.   for (rn = route_top (ospf->nbr_nbma); rn; rn = route_next (rn))
  1410.     if ((nbr_nbma = rn->info))
  1411.       if (nbr_nbma->oi == NULL && nbr_nbma->nbr == NULL)
  1412. {
  1413.   p.family = AF_INET;
  1414.   p.prefix = nbr_nbma->addr;
  1415.   p.prefixlen = IPV4_MAX_BITLEN;
  1417.   if (prefix_match (oi->address, (struct prefix *)&p))
  1418.     ospf_nbr_nbma_add (nbr_nbma, oi);
  1419. }
  1420. }
  1422. struct ospf_nbr_nbma *
  1423. ospf_nbr_nbma_lookup (struct ospf *ospf, struct in_addr nbr_addr)
  1424. {
  1425.   struct route_node *rn;
  1426.   struct prefix_ipv4 p;
  1428.   p.family = AF_INET;
  1429.   p.prefix = nbr_addr;
  1430.   p.prefixlen = IPV4_MAX_BITLEN;
  1432.   rn = route_node_lookup (ospf->nbr_nbma, (struct prefix *)&p);
  1433.   if (rn)
  1434.     {
  1435.       route_unlock_node (rn);
  1436.       return rn->info;
  1437.     }
  1438.   return NULL;
  1439. }
  1441. int
  1442. ospf_nbr_nbma_set (struct ospf *ospf, struct in_addr nbr_addr)
  1443. {
  1444.   struct ospf_nbr_nbma *nbr_nbma;
  1445.   struct ospf_interface *oi;
  1446.   struct prefix_ipv4 p;
  1447.   struct route_node *rn;
  1448.   listnode node;
  1450.   nbr_nbma = ospf_nbr_nbma_lookup (ospf, nbr_addr);
  1451.   if (nbr_nbma)
  1452.     return 0;
  1454.   nbr_nbma = ospf_nbr_nbma_new ();
  1455.   nbr_nbma->addr = nbr_addr;
  1457.   p.family = AF_INET;
  1458.   p.prefix = nbr_addr;
  1459.   p.prefixlen = IPV4_MAX_BITLEN;
  1461.   rn = route_node_get (ospf->nbr_nbma, (struct prefix *)&p);
  1462.   rn->info = nbr_nbma;
  1464.   for (node = listhead (ospf->oiflist); node; nextnode (node))
  1465.     {
  1466.       oi = getdata (node);
  1467.       if (oi->type == OSPF_IFTYPE_NBMA)
  1468. if (prefix_match (oi->address, (struct prefix *)&p))
  1469.   {
  1470.     ospf_nbr_nbma_add (nbr_nbma, oi);
  1471.     break;
  1472.   }
  1473.     }
  1475.   return 1;
  1476. }
  1478. int
  1479. ospf_nbr_nbma_unset (struct ospf *ospf, struct in_addr nbr_addr)
  1480. {
  1481.   struct ospf_nbr_nbma *nbr_nbma;
  1483.   nbr_nbma = ospf_nbr_nbma_lookup (ospf, nbr_addr);
  1484.   if (nbr_nbma == NULL)
  1485.     return 0;
  1487.   ospf_nbr_nbma_down (nbr_nbma);
  1488.   ospf_nbr_nbma_delete (ospf, nbr_nbma);
  1490.   return 1;
  1491. }
  1493. int
  1494. ospf_nbr_nbma_priority_set (struct ospf *ospf, struct in_addr nbr_addr,
  1495.     u_char priority)
  1496. {
  1497.   struct ospf_nbr_nbma *nbr_nbma;
  1499.   nbr_nbma = ospf_nbr_nbma_lookup (ospf, nbr_addr);
  1500.   if (nbr_nbma == NULL)
  1501.     return 0;
  1503.   if (nbr_nbma->priority != priority)
  1504.     nbr_nbma->priority = priority;
  1506.   return 1;
  1507. }
  1509. int
  1510. ospf_nbr_nbma_priority_unset (struct ospf *ospf, struct in_addr nbr_addr)
  1511. {
  1512.   struct ospf_nbr_nbma *nbr_nbma;
  1514.   nbr_nbma = ospf_nbr_nbma_lookup (ospf, nbr_addr);
  1515.   if (nbr_nbma == NULL)
  1516.     return 0;
  1518.   if (nbr_nbma != OSPF_NEIGHBOR_PRIORITY_DEFAULT)
  1519.     nbr_nbma->priority = OSPF_NEIGHBOR_PRIORITY_DEFAULT;
  1521.   return 1;
  1522. }
  1524. int
  1525. ospf_nbr_nbma_poll_interval_set (struct ospf *ospf, struct in_addr nbr_addr,
  1526.  int interval)
  1527. {
  1528.   struct ospf_nbr_nbma *nbr_nbma;
  1530.   nbr_nbma = ospf_nbr_nbma_lookup (ospf, nbr_addr);
  1531.   if (nbr_nbma == NULL)
  1532.     return 0;
  1534.   if (nbr_nbma->v_poll != interval)
  1535.     {
  1536.       nbr_nbma->v_poll = interval;
  1537.       if (nbr_nbma->oi && ospf_if_is_up (nbr_nbma->oi))
  1538. {
  1539.   OSPF_TIMER_OFF (nbr_nbma->t_poll);
  1540.   OSPF_POLL_TIMER_ON (nbr_nbma->t_poll, ospf_poll_timer,
  1541.       nbr_nbma->v_poll);
  1542. }
  1543.     }
  1545.   return 1;
  1546. }
  1548. int
  1549. ospf_nbr_nbma_poll_interval_unset (struct ospf *ospf, struct in_addr addr)
  1550. {
  1551.   struct ospf_nbr_nbma *nbr_nbma;
  1553.   nbr_nbma = ospf_nbr_nbma_lookup (ospf, addr);
  1554.   if (nbr_nbma == NULL)
  1555.     return 0;
  1557.   if (nbr_nbma->v_poll != OSPF_POLL_INTERVAL_DEFAULT)
  1558.     nbr_nbma->v_poll = OSPF_POLL_INTERVAL_DEFAULT;
  1560.   return 1;
  1561. }
  1564. void
  1565. ospf_prefix_list_update (struct prefix_list *plist)
  1566. {
  1567.   struct ospf *ospf;
  1568.   struct ospf_area *area;
  1569.   listnode node;
  1570.   int abr_inv = 0;
  1572.   /* If OSPF instatnce does not exist, return right now. */
  1573.   ospf = ospf_lookup ();
  1574.   if (ospf == NULL)
  1575.     return;
  1577.   /* Update Area prefix-list. */
  1578.   for (node = listhead (ospf->areas); node; nextnode (node))
  1579.     {
  1580.       area = getdata (node);
  1582.       /* Update filter-list in. */
  1583.       if (PREFIX_NAME_IN (area))
  1584. if (strcmp (PREFIX_NAME_IN (area), plist->name) == 0)
  1585.   {
  1586.     PREFIX_LIST_IN (area) = 
  1587.       prefix_list_lookup (AFI_IP, PREFIX_NAME_IN (area));
  1588.     abr_inv++;
  1589.   }
  1591.       /* Update filter-list out. */
  1592.       if (PREFIX_NAME_OUT (area))
  1593. if (strcmp (PREFIX_NAME_OUT (area), plist->name) == 0)
  1594.   {
  1595.     PREFIX_LIST_IN (area) = 
  1596.       prefix_list_lookup (AFI_IP, PREFIX_NAME_OUT (area));
  1597.     abr_inv++;
  1598.   }
  1599.     }
  1601.   /* Schedule ABR tasks. */
  1602.   if (IS_OSPF_ABR (ospf) && abr_inv)
  1603.     ospf_schedule_abr_task (ospf);
  1604. }
  1606. void
  1607. ospf_master_init ()
  1608. {
  1609.   memset (&ospf_master, 0, sizeof (struct ospf_master));
  1611.   om = &ospf_master;
  1612.   om->ospf = list_new ();
  1613.   om->master = thread_master_create ();
  1614.   om->start_time = time (NULL);
  1615. }
  1617. void
  1618. ospf_init ()
  1619. {
  1620.   prefix_list_add_hook (ospf_prefix_list_update);
  1621.   prefix_list_delete_hook (ospf_prefix_list_update);
  1622. }