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

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

网络

开发平台：

Unix_Linux

ospf_zebra.c：源码内容
  1. /*
  2.  * Zebra connect library for OSPFd
  3.  * Copyright (C) 1997, 98, 99, 2000 Kunihiro Ishiguro, Toshiaki Takada
  4.  *
  5.  * This file is part of GNU Zebra.
  6.  *
  7.  * GNU Zebra is free software; you can redistribute it and/or modify it
  8.  * under the terms of the GNU General Public License as published by the
  9.  * Free Software Foundation; either version 2, or (at your option) any
  10.  * later version.
  11.  *
  12.  * GNU Zebra is distributed in the hope that it will be useful, but
  13.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU General Public License
  18.  * along with GNU Zebra; see the file COPYING.  If not, write to the
  19.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20.  * Boston, MA 02111-1307, USA. 
  21.  */
  23. #include <zebra.h>
  25. #include "thread.h"
  26. #include "command.h"
  27. #include "network.h"
  28. #include "prefix.h"
  29. #include "routemap.h"
  30. #include "table.h"
  31. #include "stream.h"
  32. #include "memory.h"
  33. #include "zclient.h"
  34. #include "filter.h"
  35. #include "log.h"
  37. #include "ospfd/ospfd.h"
  38. #include "ospfd/ospf_interface.h"
  39. #include "ospfd/ospf_ism.h"
  40. #include "ospfd/ospf_asbr.h"
  41. #include "ospfd/ospf_asbr.h"
  42. #include "ospfd/ospf_abr.h"
  43. #include "ospfd/ospf_lsa.h"
  44. #include "ospfd/ospf_dump.h"
  45. #include "ospfd/ospf_route.h"
  46. #include "ospfd/ospf_zebra.h"
  47. #ifdef HAVE_SNMP
  48. #include "ospfd/ospf_snmp.h"
  49. #endif /* HAVE_SNMP */
  51. /* Zebra structure to hold current status. */
  52. struct zclient *zclient = NULL;
  54. /* For registering threads. */
  55. extern struct thread_master *master;
  57. /* Inteface addition message from zebra. */
  58. int
  59. ospf_interface_add (int command, struct zclient *zclient, zebra_size_t length)
  60. {
  61.   struct interface *ifp;
  62.   struct ospf *ospf;
  64.   ifp = zebra_interface_add_read (zclient->ibuf);
  66.   if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
  67.     zlog_info ("Zebra: interface add %s index %d flags %ld metric %d mtu %d",
  68.        ifp->name, ifp->ifindex, ifp->flags, ifp->metric, ifp->mtu);
  70.   if (!OSPF_IF_PARAM_CONFIGURED (IF_DEF_PARAMS (ifp), type))
  71.     {
  72.       SET_IF_PARAM (IF_DEF_PARAMS (ifp), type);
  73.       IF_DEF_PARAMS (ifp)->type = OSPF_IFTYPE_BROADCAST;
  74.       
  75.       if (if_is_broadcast (ifp))
  76. IF_DEF_PARAMS (ifp)->type = OSPF_IFTYPE_BROADCAST;
  77.       else if (if_is_pointopoint (ifp))
  78. IF_DEF_PARAMS (ifp)->type = OSPF_IFTYPE_POINTOPOINT;
  79.       else if (if_is_loopback (ifp))
  80. IF_DEF_PARAMS (ifp)->type = OSPF_IFTYPE_LOOPBACK;
  81.     }
  83.   ospf = ospf_lookup ();
  84.   if (ospf != NULL)
  85.     ospf_if_update (ospf);
  87. #ifdef HAVE_SNMP
  88.   ospf_snmp_if_update (ifp);
  89. #endif /* HAVE_SNMP */
  91.   return 0;
  92. }
  94. int
  95. ospf_interface_delete (int command, struct zclient *zclient,
  96.        zebra_size_t length)
  97. {
  98.   struct interface *ifp;
  99.   struct stream *s;
  100.   struct route_node *rn;
  102.   s = zclient->ibuf;  
  103.   /* zebra_interface_state_read() updates interface structure in iflist */
  104.   ifp = zebra_interface_state_read (s);
  106.   if (ifp == NULL)
  107.     return 0;
  109.   if (if_is_up (ifp))
  110.     zlog_warn ("Zebra: got delete of %s, but interface is still up",
  111.        ifp->name);
  112.   
  113.   if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
  114.     zlog_info ("Zebra: interface delete %s index %d flags %ld metric %d mtu %d",
  115.        ifp->name, ifp->ifindex, ifp->flags, ifp->metric, ifp->mtu);  
  117. #ifdef HAVE_SNMP
  118.   ospf_snmp_if_delete (ifp);
  119. #endif /* HAVE_SNMP */
  121.   for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn))
  122.     if (rn->info)
  123.       ospf_if_free ((struct ospf_interface *) rn->info);
  125.   for (rn = route_top (IF_OIFS_PARAMS (ifp)); rn; rn = route_next (rn))
  126.     if (rn->info)
  127.       ospf_del_if_params (rn->info);
  128.   
  129.   if_delete (ifp);
  131.   return 0;
  132. }
  134. struct interface *
  135. zebra_interface_if_lookup (struct stream *s)
  136. {
  137.   struct interface *ifp;
  138.   u_char ifname_tmp[INTERFACE_NAMSIZ];
  140.   /* Read interface name. */
  141.   stream_get (ifname_tmp, s, INTERFACE_NAMSIZ);
  143.   /* Lookup this by interface index. */
  144.   ifp = if_lookup_by_name (ifname_tmp);
  146.   /* If such interface does not exist, indicate an error */
  147.   if (!ifp)
  148.     return NULL;
  150.   return ifp;
  151. }
  153. void
  154. zebra_interface_if_set_value (struct stream *s, struct interface *ifp)
  155. {
  156.   /* Read interface's index. */
  157.   ifp->ifindex = stream_getl (s);
  159.   /* Read interface's value. */
  160.   ifp->flags = stream_getl (s);
  161.   ifp->metric = stream_getl (s);
  162.   ifp->mtu = stream_getl (s);
  163.   ifp->bandwidth = stream_getl (s);
  164. }
  166. int
  167. ospf_interface_state_up (int command, struct zclient *zclient,
  168.  zebra_size_t length)
  169. {
  170.   struct interface *ifp;
  171.   struct interface if_tmp;
  172.   struct ospf_interface *oi;
  173.   struct route_node *rn;
  174.   
  175.   ifp = zebra_interface_if_lookup (zclient->ibuf);
  177.   if (ifp == NULL)
  178.     return 0;
  180.   /* Interface is already up. */
  181.   if (if_is_up (ifp))
  182.     {
  183.       /* Temporarily keep ifp values. */
  184.       memcpy (&if_tmp, ifp, sizeof (struct interface));
  186.       zebra_interface_if_set_value (zclient->ibuf, ifp);
  188.       if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
  189. zlog_info ("Zebra: Interface[%s] state update.", ifp->name);
  191.       if (if_tmp.bandwidth != ifp->bandwidth)
  192. {
  193.   if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
  194.     zlog_info ("Zebra: Interface[%s] bandwidth change %d -> %d.",
  195.        ifp->name, if_tmp.bandwidth, ifp->bandwidth);
  197.   ospf_if_recalculate_output_cost (ifp);
  198. }
  199.       return 0;
  200.     }
  201.   
  202.   zebra_interface_if_set_value (zclient->ibuf, ifp);
  203.   
  204.   if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
  205.     zlog_info ("Zebra: Interface[%s] state change to up.", ifp->name);
  206.   
  207.   for (rn = route_top (IF_OIFS (ifp));rn; rn = route_next (rn))
  208.     {
  209.       if ( (oi = rn->info) == NULL)
  210. continue;
  211.       
  212.       ospf_if_up (oi);
  213.     }
  214.   
  215.   return 0;
  216. }
  218. int
  219. ospf_interface_state_down (int command, struct zclient *zclient,
  220.    zebra_size_t length)
  221. {
  222.   struct interface *ifp;
  223.   struct ospf_interface *oi;
  224.   struct route_node *node;
  226.   ifp = zebra_interface_state_read (zclient->ibuf);
  228.   if (ifp == NULL)
  229.     return 0;
  231.   if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
  232.     zlog_info ("Zebra: Interface[%s] state change to down.", ifp->name);
  234.   for (node = route_top (IF_OIFS (ifp));node; node = route_next (node))
  235.     {
  236.       if ( (oi = node->info) == NULL)
  237. continue;
  238.       ospf_if_down (oi);
  239.     }
  241.   return 0;
  242. }
  244. int
  245. ospf_interface_address_add (int command, struct zclient *zclient,
  246.     zebra_size_t length)
  247. {
  248.   struct ospf *ospf;
  249.   struct connected *c;
  251.   c = zebra_interface_address_add_read (zclient->ibuf);
  253.   if (c == NULL)
  254.     return 0;
  256.   ospf = ospf_lookup ();
  257.   if (ospf != NULL)
  258.     ospf_if_update (ospf);
  260. #ifdef HAVE_SNMP
  261.   ospf_snmp_if_update (c->ifp);
  262. #endif /* HAVE_SNMP */
  264.   return 0;
  265. }
  267. int
  268. ospf_interface_address_delete (int command, struct zclient *zclient,
  269.        zebra_size_t length)
  270. {
  271.   struct ospf *ospf;
  272.   struct connected *c;
  273.   struct interface *ifp;
  274.   struct ospf_interface *oi;
  275.   struct route_node *rn;
  276.   struct prefix p;
  278.   c = zebra_interface_address_delete_read (zclient->ibuf);
  280.   if (c == NULL)
  281.     return 0;
  283.   ifp = c->ifp;
  284.   p = *c->address;
  285.   p.prefixlen = IPV4_MAX_PREFIXLEN;
  287.   rn = route_node_lookup (IF_OIFS (ifp), &p);
  288.   if (! rn)
  289.     return 0;
  291.   assert (rn->info);
  292.   oi = rn->info;
  293.   
  294.   /* Call interface hook functions to clean up */
  295.   ospf_if_free (oi);
  296.   
  297. #ifdef HAVE_SNMP
  298.   ospf_snmp_if_update (c->ifp);
  299. #endif /* HAVE_SNMP */
  301.   connected_free (c);
  303.   ospf = ospf_lookup ();
  304.   if (ospf != NULL)
  305.     ospf_if_update (ospf);
  307.   return 0;
  308. }
  310. void
  311. ospf_zebra_add (struct prefix_ipv4 *p, struct ospf_route *or)
  312. {
  313.   u_char message;
  314.   u_char distance;
  315.   u_char flags;
  316.   int psize;
  317.   struct stream *s;
  318.   struct ospf_path *path;
  319.   listnode node;
  321.   if (zclient->redist[ZEBRA_ROUTE_OSPF])
  322.     {
  323.       message = 0;
  324.       flags = 0;
  326.       /* OSPF pass nexthop and metric */
  327.       SET_FLAG (message, ZAPI_MESSAGE_NEXTHOP);
  328.       SET_FLAG (message, ZAPI_MESSAGE_METRIC);
  330.       /* Distance value. */
  331.       distance = ospf_distance_apply (p, or);
  332.       if (distance)
  333. SET_FLAG (message, ZAPI_MESSAGE_DISTANCE);
  335.       /* Make packet. */
  336.       s = zclient->obuf;
  337.       stream_reset (s);
  339.       /* Length place holder. */
  340.       stream_putw (s, 0);
  342.       /* Put command, type, flags, message. */
  343.       stream_putc (s, ZEBRA_IPV4_ROUTE_ADD);
  344.       stream_putc (s, ZEBRA_ROUTE_OSPF);
  345.       stream_putc (s, flags);
  346.       stream_putc (s, message);
  347.   
  348.       /* Put prefix information. */
  349.       psize = PSIZE (p->prefixlen);
  350.       stream_putc (s, p->prefixlen);
  351.       stream_write (s, (u_char *)&p->prefix, psize);
  353.       /* Nexthop count. */
  354.       stream_putc (s, or->path->count);
  356.       /* Nexthop, ifindex, distance and metric information. */
  357.       for (node = listhead (or->path); node; nextnode (node))
  358. {
  359.   path = getdata (node);
  361.   if (path->nexthop.s_addr != INADDR_ANY)
  362.     {
  363.       stream_putc (s, ZEBRA_NEXTHOP_IPV4);
  364.       stream_put_in_addr (s, &path->nexthop);
  365.     }
  366.   else
  367.     {
  368.       stream_putc (s, ZEBRA_NEXTHOP_IFINDEX);
  369.       if (path->oi)
  370. stream_putl (s, path->oi->ifp->ifindex);
  371.       else
  372. stream_putl (s, 0);
  373.     }
  374. }
  376.       if (CHECK_FLAG (message, ZAPI_MESSAGE_DISTANCE))
  377. stream_putc (s, distance);
  378.       if (CHECK_FLAG (message, ZAPI_MESSAGE_METRIC))
  379. {
  380.   if (or->path_type == OSPF_PATH_TYPE1_EXTERNAL)
  381.     stream_putl (s, or->cost + or->u.ext.type2_cost);
  382.   else if (or->path_type == OSPF_PATH_TYPE2_EXTERNAL)
  383.     stream_putl (s, or->u.ext.type2_cost);
  384.   else
  385.     stream_putl (s, or->cost);
  386. }
  388.       stream_putw_at (s, 0, stream_get_endp (s));
  390.       writen (zclient->sock, s->data, stream_get_endp (s));
  391.     }
  392. }
  394. void
  395. ospf_zebra_delete (struct prefix_ipv4 *p, struct ospf_route *or)
  396. {
  397.   struct zapi_ipv4 api;
  399.   if (zclient->redist[ZEBRA_ROUTE_OSPF])
  400.     {
  401.       api.type = ZEBRA_ROUTE_OSPF;
  402.       api.flags = 0;
  403.       api.message = 0;
  404.       zapi_ipv4_delete (zclient, p, &api);
  405.     }
  406. }
  408. void
  409. ospf_zebra_add_discard (struct prefix_ipv4 *p)
  410. {
  411.   struct zapi_ipv4 api;
  413.   if (zclient->redist[ZEBRA_ROUTE_OSPF])
  414.     {
  415.       api.type = ZEBRA_ROUTE_OSPF;
  416.       api.flags = ZEBRA_FLAG_BLACKHOLE;
  417.       api.message = 0;
  418.       SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
  419.       api.nexthop_num = 0;
  420.       api.ifindex_num = 0;
  422.       zapi_ipv4_add (zclient, p, &api);
  423.     }
  424. }
  426. void
  427. ospf_zebra_delete_discard (struct prefix_ipv4 *p)
  428. {
  429.   struct zapi_ipv4 api;
  431.   if (zclient->redist[ZEBRA_ROUTE_OSPF])
  432.     {
  433.       api.type = ZEBRA_ROUTE_OSPF;
  434.       api.flags = ZEBRA_FLAG_BLACKHOLE;
  435.       api.message = 0;
  436.       SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
  437.       api.nexthop_num = 0;
  438.       api.ifindex_num = 0;
  440.       zapi_ipv4_delete (zclient, p, &api);
  441.     }
  442. }
  444. int
  445. ospf_is_type_redistributed (int type)
  446. {
  447.   return (DEFAULT_ROUTE_TYPE (type)) ?
  448.     zclient->default_information : zclient->redist[type];
  449. }
  451. int
  452. ospf_redistribute_set (struct ospf *ospf, int type, int mtype, int mvalue)
  453. {
  454.   int force = 0;
  455.   
  456.   if (ospf_is_type_redistributed (type))
  457.     {
  458.       if (mtype != ospf->dmetric[type].type)
  459. {
  460.   ospf->dmetric[type].type = mtype;
  461.   force = LSA_REFRESH_FORCE;
  462. }
  463.       if (mvalue != ospf->dmetric[type].value)
  464. {
  465.   ospf->dmetric[type].value = mvalue;
  466.   force = LSA_REFRESH_FORCE;
  467. }
  468.   
  469.       ospf_external_lsa_refresh_type (ospf, type, force);
  470.       
  471.       if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
  472. zlog_info ("Redistribute[%s]: Refresh  Type[%d], Metric[%d]",
  473.    LOOKUP (ospf_redistributed_proto, type),
  474.    metric_type (ospf, type), metric_value (ospf, type));
  475.       
  476.       return CMD_SUCCESS;
  477.     }
  479.   ospf->dmetric[type].type = mtype;
  480.   ospf->dmetric[type].value = mvalue;
  482.   zclient_redistribute_set (zclient, type);
  484.   if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
  485.     zlog_info ("Redistribute[%s]: Start  Type[%d], Metric[%d]",
  486.        LOOKUP (ospf_redistributed_proto, type),
  487.        metric_type (ospf, type), metric_value (ospf, type));
  488.   
  489.   ospf_asbr_status_update (ospf, ++ospf->redistribute);
  491.   return CMD_SUCCESS;
  492. }
  494. int
  495. ospf_redistribute_unset (struct ospf *ospf, int type)
  496. {
  497.   if (type == zclient->redist_default)
  498.     return CMD_SUCCESS;
  500.   if (! ospf_is_type_redistributed (type))
  501.     return CMD_SUCCESS;
  503.   zclient_redistribute_unset (zclient, type);
  504.   
  505.   if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
  506.     zlog_info ("Redistribute[%s]: Stop",
  507.        LOOKUP (ospf_redistributed_proto, type));
  509.   ospf->dmetric[type].type = -1;
  510.   ospf->dmetric[type].value = -1;
  512.   /* Remove the routes from OSPF table. */
  513.   ospf_redistribute_withdraw (type);
  515.   ospf_asbr_status_update (ospf, --ospf->redistribute);
  517.   return CMD_SUCCESS;
  518. }
  520. int
  521. ospf_redistribute_default_set (struct ospf *ospf, int originate,
  522.        int mtype, int mvalue)
  523. {
  524.   int force = 0;
  526.   if (ospf_is_type_redistributed (DEFAULT_ROUTE))
  527.     {
  528.       if (mtype != ospf->dmetric[DEFAULT_ROUTE].type)
  529. {
  530.   ospf->dmetric[DEFAULT_ROUTE].type = mtype;
  531.   force = 1;
  532. }
  533.       if (mvalue != ospf->dmetric[DEFAULT_ROUTE].value)
  534. {
  535.   force = 1;
  536.   ospf->dmetric[DEFAULT_ROUTE].value = mvalue;
  537. }
  538.       
  539.       ospf_external_lsa_refresh_default (ospf);
  540.       
  541.       if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
  542. zlog_info ("Redistribute[%s]: Refresh  Type[%d], Metric[%d]",
  543.    LOOKUP (ospf_redistributed_proto, DEFAULT_ROUTE),
  544.    metric_type (ospf, DEFAULT_ROUTE),
  545.    metric_value (ospf, DEFAULT_ROUTE));
  546.       return CMD_SUCCESS;
  547.     }
  549.   ospf->default_originate = originate;
  550.   ospf->dmetric[DEFAULT_ROUTE].type = mtype;
  551.   ospf->dmetric[DEFAULT_ROUTE].value = mvalue;
  553.   zclient_redistribute_default_set (zclient);
  554.   
  555.   if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
  556.     zlog_info ("Redistribute[DEFAULT]: Start  Type[%d], Metric[%d]",
  557.        metric_type (ospf, DEFAULT_ROUTE),
  558.        metric_value (ospf, DEFAULT_ROUTE));
  560.   if (ospf->router_id.s_addr == 0)
  561.     ospf->external_origin |= (1 << DEFAULT_ROUTE);
  562.   else
  563.     thread_add_timer (master, ospf_default_originate_timer,
  564.       &ospf->default_originate, 1);
  566.   ospf_asbr_status_update (ospf, ++ospf->redistribute);
  568.   return CMD_SUCCESS;
  569. }
  571. int
  572. ospf_redistribute_default_unset (struct ospf *ospf)
  573. {
  574.   if (!ospf_is_type_redistributed (DEFAULT_ROUTE))
  575.     return CMD_SUCCESS;
  577.   ospf->default_originate = DEFAULT_ORIGINATE_NONE;
  578.   ospf->dmetric[DEFAULT_ROUTE].type = -1;
  579.   ospf->dmetric[DEFAULT_ROUTE].value = -1;
  581.   zclient_redistribute_default_unset (zclient);
  583.   if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
  584.     zlog_info ("Redistribute[DEFAULT]: Stop");
  585.   
  586.   ospf_asbr_status_update (ospf, --ospf->redistribute);
  588.   return CMD_SUCCESS;
  589. }
  591. int
  592. ospf_external_lsa_originate_check (struct ospf *ospf,
  593.    struct external_info *ei)
  594. {
  595.   /* If prefix is multicast, then do not originate LSA. */
  596.   if (IN_MULTICAST (htonl (ei->p.prefix.s_addr)))
  597.     {
  598.       zlog_info ("LSA[Type5:%s]: Not originate AS-external-LSA, "
  599.  "Prefix belongs multicast", inet_ntoa (ei->p.prefix));
  600.       return 0;
  601.     }
  603.   /* Take care of default-originate. */
  604.   if (is_prefix_default (&ei->p))
  605.     if (ospf->default_originate == DEFAULT_ORIGINATE_NONE)
  606.       {
  607. zlog_info ("LSA[Type5:0.0.0.0]: Not originate AS-exntenal-LSA "
  608.    "for default");
  609. return 0;
  610.       }
  612.   return 1;
  613. }
  615. /* If connected prefix is OSPF enable interface, then do not announce. */
  616. int
  617. ospf_distribute_check_connected (struct ospf *ospf,
  618.  struct external_info *ei)
  619. {
  620.   struct route_node *rn;
  622.   for (rn = route_top (ospf->networks); rn; rn = route_next (rn))
  623.     if (rn->info != NULL)
  624.       if (prefix_match (&rn->p, (struct prefix *)&ei->p))
  625. {
  626.   route_unlock_node (rn);
  627.   return 0;
  628. }
  630.   return 1;
  631. }
  633. /* return 1 if external LSA must be originated, 0 otherwise */
  634. int
  635. ospf_redistribute_check (struct ospf *ospf,
  636.  struct external_info *ei, int *changed)
  637. {
  638.   struct route_map_set_values save_values;
  639.   struct prefix_ipv4 *p = &ei->p;
  640.   u_char type = is_prefix_default (&ei->p) ? DEFAULT_ROUTE : ei->type;
  641.   
  642.   if (changed)
  643.     *changed = 0;
  645.   if (!ospf_external_lsa_originate_check (ospf, ei))
  646.     return 0;
  648.   /* Take care connected route. */
  649.   if (type == ZEBRA_ROUTE_CONNECT &&
  650.       !ospf_distribute_check_connected (ospf, ei))
  651.     return 0;
  653.   if (!DEFAULT_ROUTE_TYPE (type) && DISTRIBUTE_NAME (ospf, type))
  654.     /* distirbute-list exists, but access-list may not? */
  655.     if (DISTRIBUTE_LIST (ospf, type))
  656.       if (access_list_apply (DISTRIBUTE_LIST (ospf, type), p) == FILTER_DENY)
  657. {
  658.   if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
  659.     zlog_info ("Redistribute[%s]: %s/%d filtered by ditribute-list.",
  660.        LOOKUP (ospf_redistributed_proto, type),
  661.        inet_ntoa (p->prefix), p->prefixlen);
  662.   return 0;
  663. }
  665.   save_values = ei->route_map_set;
  666.   ospf_reset_route_map_set_values (&ei->route_map_set);
  667.   
  668.   /* apply route-map if needed */
  669.   if (ROUTEMAP_NAME (ospf, type))
  670.     {
  671.       int ret;
  673.       ret = route_map_apply (ROUTEMAP (ospf, type), (struct prefix *)p,
  674.      RMAP_OSPF, ei);
  676.       if (ret == RMAP_DENYMATCH)
  677. {
  678.   ei->route_map_set = save_values;
  679.   if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
  680.     zlog_info ("Redistribute[%s]: %s/%d filtered by route-map.",
  681.        LOOKUP (ospf_redistributed_proto, type),
  682.        inet_ntoa (p->prefix), p->prefixlen);
  683.   return 0;
  684. }
  685.       
  686.       /* check if 'route-map set' changed something */
  687.       if (changed)
  688. *changed = !ospf_route_map_set_compare (&ei->route_map_set,
  689. &save_values);
  690.     }
  692.   return 1;
  693. }
  695. /* OSPF route-map set for redistribution */
  696. void
  697. ospf_routemap_set (struct ospf *ospf, int type, char *name)
  698. {
  699.   if (ROUTEMAP_NAME (ospf, type))
  700.     free (ROUTEMAP_NAME (ospf, type));
  702.   ROUTEMAP_NAME (ospf, type) = strdup (name);
  703.   ROUTEMAP (ospf, type) = route_map_lookup_by_name (name);
  704. }
  706. void
  707. ospf_routemap_unset (struct ospf *ospf, int type)
  708. {
  709.   if (ROUTEMAP_NAME (ospf, type))
  710.     free (ROUTEMAP_NAME (ospf, type));
  712.   ROUTEMAP_NAME (ospf, type) = NULL;
  713.   ROUTEMAP (ospf, type) = NULL;
  714. }
  716. /* Zebra route add and delete treatment. */
  717. int
  718. ospf_zebra_read_ipv4 (int command, struct zclient *zclient,
  719.       zebra_size_t length)
  720. {
  721.   struct stream *s;
  722.   struct zapi_ipv4 api;
  723.   unsigned long ifindex;
  724.   struct in_addr nexthop;
  725.   struct prefix_ipv4 p;
  726.   struct external_info *ei;
  727.   struct ospf *ospf;
  729.   s = zclient->ibuf;
  730.   ifindex = 0;
  731.   nexthop.s_addr = 0;
  733.   /* Type, flags, message. */
  734.   api.type = stream_getc (s);
  735.   api.flags = stream_getc (s);
  736.   api.message = stream_getc (s);
  738.   /* IPv4 prefix. */
  739.   memset (&p, 0, sizeof (struct prefix_ipv4));
  740.   p.family = AF_INET;
  741.   p.prefixlen = stream_getc (s);
  742.   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
  744.   /* Nexthop, ifindex, distance, metric. */
  745.   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
  746.     {
  747.       api.nexthop_num = stream_getc (s);
  748.       nexthop.s_addr = stream_get_ipv4 (s);
  749.     }
  750.   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
  751.     {
  752.       api.ifindex_num = stream_getc (s);
  753.       ifindex = stream_getl (s);
  754.     }
  755.   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
  756.     api.distance = stream_getc (s);
  757.   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
  758.     api.metric = stream_getl (s);
  760.   ospf = ospf_lookup ();
  761.   if (ospf == NULL)
  762.     return 0;
  764.   if (command == ZEBRA_IPV4_ROUTE_ADD)
  765.     {
  766.       ei = ospf_external_info_add (api.type, p, ifindex, nexthop);
  768.       if (ospf->router_id.s_addr == 0)
  769. /* Set flags to generate AS-external-LSA originate event
  770.    for each redistributed protocols later. */
  771. ospf->external_origin |= (1 << api.type);
  772.       else
  773. {
  774.   if (ei)
  775.     {
  776.       if (is_prefix_default (&p))
  777. ospf_external_lsa_refresh_default (ospf);
  778.       else
  779. {
  780.   struct ospf_lsa *current;
  782.   current = ospf_external_info_find_lsa (ospf, &ei->p);
  783.   if (!current)
  784.     ospf_external_lsa_originate (ospf, ei);
  785.   else if (IS_LSA_MAXAGE (current))
  786.     ospf_external_lsa_refresh (ospf, current,
  787.        ei, LSA_REFRESH_FORCE);
  788.   else
  789.     zlog_warn ("ospf_zebra_read_ipv4() : %s already exists",
  790.        inet_ntoa (p.prefix));
  791. }
  792.     }
  793. }
  794.     }
  795.   else /* if (command == ZEBRA_IPV4_ROUTE_DELETE) */
  796.     {
  797.       ospf_external_info_delete (api.type, p);
  798.       if ( !is_prefix_default (&p))
  799. ospf_external_lsa_flush (ospf, api.type, &p, ifindex, nexthop);
  800.       else
  801. ospf_external_lsa_refresh_default (ospf);
  802.     }
  804.   return 0;
  805. }
  808. int
  809. ospf_distribute_list_out_set (struct ospf *ospf, int type, char *name)
  810. {
  811.   /* Lookup access-list for distribute-list. */
  812.   DISTRIBUTE_LIST (ospf, type) = access_list_lookup (AFI_IP, name);
  814.   /* Clear previous distribute-name. */
  815.   if (DISTRIBUTE_NAME (ospf, type))
  816.     free (DISTRIBUTE_NAME (ospf, type));
  818.   /* Set distribute-name. */
  819.   DISTRIBUTE_NAME (ospf, type) = strdup (name);
  821.   /* If access-list have been set, schedule update timer. */
  822.   if (DISTRIBUTE_LIST (ospf, type))
  823.     ospf_distribute_list_update (ospf, type);
  825.   return CMD_SUCCESS;
  826. }
  828. int
  829. ospf_distribute_list_out_unset (struct ospf *ospf, int type, char *name)
  830. {
  831.   /* Schedule update timer. */
  832.   if (DISTRIBUTE_LIST (ospf, type))
  833.     ospf_distribute_list_update (ospf, type);
  835.   /* Unset distribute-list. */
  836.   DISTRIBUTE_LIST (ospf, type) = NULL;
  838.   /* Clear distribute-name. */
  839.   if (DISTRIBUTE_NAME (ospf, type))
  840.     free (DISTRIBUTE_NAME (ospf, type));
  841.   
  842.   DISTRIBUTE_NAME (ospf, type) = NULL;
  844.   return CMD_SUCCESS;
  845. }
  847. /* distribute-list update timer. */
  848. int
  849. ospf_distribute_list_update_timer (struct thread *thread)
  850. {
  851.   struct route_node *rn;
  852.   struct external_info *ei;
  853.   struct route_table *rt;
  854.   struct ospf_lsa *lsa;
  855.   u_char type;
  856.   struct ospf *ospf;
  858.   type = (int) THREAD_ARG (thread);
  859.   rt = EXTERNAL_INFO (type);
  861.   ospf = ospf_lookup ();
  862.   if (ospf == NULL)
  863.     return 0;
  865.   ospf->t_distribute_update = NULL;
  867.   zlog_info ("Zebra[Redistribute]: distribute-list update timer fired!");
  869.   /* foreach all external info. */
  870.   if (rt)
  871.     for (rn = route_top (rt); rn; rn = route_next (rn))
  872.       if ((ei = rn->info) != NULL)
  873. {
  874.   if (is_prefix_default (&ei->p))
  875.     ospf_external_lsa_refresh_default (ospf);
  876.   else if ((lsa = ospf_external_info_find_lsa (ospf, &ei->p)))
  877.     ospf_external_lsa_refresh (ospf, lsa, ei, LSA_REFRESH_IF_CHANGED);
  878.   else
  879.     ospf_external_lsa_originate (ospf, ei);
  880. }
  881.   return 0;
  882. }
  884. #define OSPF_DISTRIBUTE_UPDATE_DELAY 5
  886. /* Update distribute-list and set timer to apply access-list. */
  887. void
  888. ospf_distribute_list_update (struct ospf *ospf, int type)
  889. {
  890.   struct route_table *rt;
  891.   
  892.   /* External info does not exist. */
  893.   if (!(rt = EXTERNAL_INFO (type)))
  894.     return;
  896.   /* If exists previously invoked thread, then cancel it. */
  897.   if (ospf->t_distribute_update)
  898.     OSPF_TIMER_OFF (ospf->t_distribute_update);
  900.   /* Set timer. */
  901.   ospf->t_distribute_update =
  902.     thread_add_timer (master, ospf_distribute_list_update_timer,
  903.       (void *) type, OSPF_DISTRIBUTE_UPDATE_DELAY);
  904. }
  906. /* If access-list is updated, apply some check. */
  907. void
  908. ospf_filter_update (struct access_list *access)
  909. {
  910.   struct ospf *ospf;
  911.   int type;
  912.   int abr_inv = 0;
  913.   struct ospf_area *area;
  914.   listnode node;
  916.   /* If OSPF instatnce does not exist, return right now. */
  917.   ospf = ospf_lookup ();
  918.   if (ospf == NULL)
  919.     return;
  921.   /* Update distribute-list, and apply filter. */
  922.   for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
  923.     {
  924.       if (ROUTEMAP (ospf, type) != NULL)
  925. {
  926.   /* if route-map is not NULL it may be using this access list */
  927.   ospf_distribute_list_update (ospf, type);
  928.   continue;
  929. }
  930.       
  932.       if (DISTRIBUTE_NAME (ospf, type))
  933. {
  934.   /* Keep old access-list for distribute-list. */
  935.   struct access_list *old = DISTRIBUTE_LIST (ospf, type);
  936.   
  937.   /* Update access-list for distribute-list. */
  938.   DISTRIBUTE_LIST (ospf, type) =
  939.     access_list_lookup (AFI_IP, DISTRIBUTE_NAME (ospf, type));
  940.   
  941.   /* No update for this distribute type. */
  942.   if (old == NULL && DISTRIBUTE_LIST (ospf, type) == NULL)
  943.     continue;
  944.   
  945.   /* Schedule distribute-list update timer. */
  946.   if (DISTRIBUTE_LIST (ospf, type) == NULL ||
  947.       strcmp (DISTRIBUTE_NAME (ospf, type), access->name) == 0)
  948.     ospf_distribute_list_update (ospf, type);
  949. }
  950.     }
  952.   /* Update Area access-list. */
  953.   for (node = listhead (ospf->areas); node; nextnode (node))
  954.     if ((area = getdata (node)) != NULL)
  955.       {
  956. if (EXPORT_NAME (area))
  957.   {
  958.     EXPORT_LIST (area) = NULL;
  959.     abr_inv++;
  960.   }
  962. if (IMPORT_NAME (area))
  963.   {
  964.     IMPORT_LIST (area) = NULL;
  965.     abr_inv++;
  966.   }
  967.       }
  969.   /* Schedule ABR tasks -- this will be changed -- takada. */
  970.   if (IS_OSPF_ABR (ospf) && abr_inv)
  971.     ospf_schedule_abr_task (ospf);
  972. }
  975. struct ospf_distance *
  976. ospf_distance_new ()
  977. {
  978.   struct ospf_distance *new;
  979.   new = XMALLOC (MTYPE_OSPF_DISTANCE, sizeof (struct ospf_distance));
  980.   memset (new, 0, sizeof (struct ospf_distance));
  981.   return new;
  982. }
  984. void
  985. ospf_distance_free (struct ospf_distance *odistance)
  986. {
  987.   XFREE (MTYPE_OSPF_DISTANCE, odistance);
  988. }
  990. int
  991. ospf_distance_set (struct vty *vty, struct ospf *ospf, char *distance_str,
  992.    char *ip_str, char *access_list_str)
  993. {
  994.   int ret;
  995.   struct prefix_ipv4 p;
  996.   u_char distance;
  997.   struct route_node *rn;
  998.   struct ospf_distance *odistance;
  1000.   ret = str2prefix_ipv4 (ip_str, &p);
  1001.   if (ret == 0)
  1002.     {
  1003.       vty_out (vty, "Malformed prefix%s", VTY_NEWLINE);
  1004.       return CMD_WARNING;
  1005.     }
  1007.   distance = atoi (distance_str);
  1009.   /* Get OSPF distance node. */
  1010.   rn = route_node_get (ospf->distance_table, (struct prefix *) &p);
  1011.   if (rn->info)
  1012.     {
  1013.       odistance = rn->info;
  1014.       route_unlock_node (rn);
  1015.     }
  1016.   else
  1017.     {
  1018.       odistance = ospf_distance_new ();
  1019.       rn->info = odistance;
  1020.     }
  1022.   /* Set distance value. */
  1023.   odistance->distance = distance;
  1025.   /* Reset access-list configuration. */
  1026.   if (odistance->access_list)
  1027.     {
  1028.       free (odistance->access_list);
  1029.       odistance->access_list = NULL;
  1030.     }
  1031.   if (access_list_str)
  1032.     odistance->access_list = strdup (access_list_str);
  1034.   return CMD_SUCCESS;
  1035. }
  1037. int
  1038. ospf_distance_unset (struct vty *vty, struct ospf *ospf, char *distance_str,
  1039.      char *ip_str, char *access_list_str)
  1040. {
  1041.   int ret;
  1042.   struct prefix_ipv4 p;
  1043.   u_char distance;
  1044.   struct route_node *rn;
  1045.   struct ospf_distance *odistance;
  1047.   ret = str2prefix_ipv4 (ip_str, &p);
  1048.   if (ret == 0)
  1049.     {
  1050.       vty_out (vty, "Malformed prefix%s", VTY_NEWLINE);
  1051.       return CMD_WARNING;
  1052.     }
  1054.   distance = atoi (distance_str);
  1056.   rn = route_node_lookup (ospf->distance_table, (struct prefix *)&p);
  1057.   if (! rn)
  1058.     {
  1059.       vty_out (vty, "Can't find specified prefix%s", VTY_NEWLINE);
  1060.       return CMD_WARNING;
  1061.     }
  1063.   odistance = rn->info;
  1065.   if (odistance->access_list)
  1066.     free (odistance->access_list);
  1067.   ospf_distance_free (odistance);
  1069.   rn->info = NULL;
  1070.   route_unlock_node (rn);
  1071.   route_unlock_node (rn);
  1073.   return CMD_SUCCESS;
  1074. }
  1076. void
  1077. ospf_distance_reset (struct ospf *ospf)
  1078. {
  1079.   struct route_node *rn;
  1080.   struct ospf_distance *odistance;
  1082.   for (rn = route_top (ospf->distance_table); rn; rn = route_next (rn))
  1083.     if ((odistance = rn->info) != NULL)
  1084.       {
  1085. if (odistance->access_list)
  1086.   free (odistance->access_list);
  1087. ospf_distance_free (odistance);
  1088. rn->info = NULL;
  1089. route_unlock_node (rn);
  1090.       }
  1091. }
  1093. u_char
  1094. ospf_distance_apply (struct prefix_ipv4 *p, struct ospf_route *or)
  1095. {
  1096.   struct ospf *ospf;
  1098.   ospf = ospf_lookup ();
  1099.   if (ospf == NULL)
  1100.     return 0;
  1102.   if (ospf->distance_intra)
  1103.     if (or->path_type == OSPF_PATH_INTRA_AREA)
  1104.       return ospf->distance_intra;
  1106.   if (ospf->distance_inter)
  1107.     if (or->path_type == OSPF_PATH_INTER_AREA)
  1108.       return ospf->distance_inter;
  1110.   if (ospf->distance_external)
  1111.     if (or->path_type == OSPF_PATH_TYPE1_EXTERNAL
  1112. || or->path_type == OSPF_PATH_TYPE2_EXTERNAL)
  1113.       return ospf->distance_external;
  1114.   
  1115.   if (ospf->distance_all)
  1116.     return ospf->distance_all;
  1118.   return 0;
  1119. }
  1121. void
  1122. ospf_zebra_init ()
  1123. {
  1124.   /* Allocate zebra structure. */
  1125.   zclient = zclient_new ();
  1126.   zclient_init (zclient, ZEBRA_ROUTE_OSPF);
  1127.   zclient->interface_add = ospf_interface_add;
  1128.   zclient->interface_delete = ospf_interface_delete;
  1129.   zclient->interface_up = ospf_interface_state_up;
  1130.   zclient->interface_down = ospf_interface_state_down;
  1131.   zclient->interface_address_add = ospf_interface_address_add;
  1132.   zclient->interface_address_delete = ospf_interface_address_delete;
  1133.   zclient->ipv4_route_add = ospf_zebra_read_ipv4;
  1134.   zclient->ipv4_route_delete = ospf_zebra_read_ipv4;
  1136.   access_list_add_hook (ospf_filter_update);
  1137.   access_list_delete_hook (ospf_filter_update);
  1138. }