1 /*
2 * Zebra connect library for EIGRP.
3 * Copyright (C) 2013-2014
4 * Authors:
5 * Donnie Savage
6 * Jan Janovic
7 * Matej Perina
8 * Peter Orsag
9 * Peter Paluch
10 *
11 * This file is part of GNU Zebra.
12 *
13 * GNU Zebra is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU General Public License as published by the
15 * Free Software Foundation; either version 2, or (at your option) any
16 * later version.
17 *
18 * GNU Zebra is distributed in the hope that it will be useful, but
19 * WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License along
24 * with this program; see the file COPYING; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
26 */
27
28 #include <zebra.h>
29
30 #include "thread.h"
31 #include "command.h"
32 #include "network.h"
33 #include "prefix.h"
34 #include "routemap.h"
35 #include "table.h"
36 #include "stream.h"
37 #include "memory.h"
38 #include "zclient.h"
39 #include "filter.h"
40 #include "plist.h"
41 #include "log.h"
42 #include "nexthop.h"
43
44 #include "eigrpd/eigrp_structs.h"
45 #include "eigrpd/eigrpd.h"
46 #include "eigrpd/eigrp_interface.h"
47 #include "eigrpd/eigrp_neighbor.h"
48 #include "eigrpd/eigrp_packet.h"
49 #include "eigrpd/eigrp_zebra.h"
50 #include "eigrpd/eigrp_vty.h"
51 #include "eigrpd/eigrp_dump.h"
52 #include "eigrpd/eigrp_network.h"
53 #include "eigrpd/eigrp_topology.h"
54 #include "eigrpd/eigrp_fsm.h"
55
56 static int eigrp_interface_address_add(ZAPI_CALLBACK_ARGS);
57 static int eigrp_interface_address_delete(ZAPI_CALLBACK_ARGS);
58
59 static int eigrp_zebra_read_route(ZAPI_CALLBACK_ARGS);
60
61 /* Zebra structure to hold current status. */
62 struct zclient *zclient = NULL;
63
64 /* For registering threads. */
65 extern struct thread_master *master;
66 struct in_addr router_id_zebra;
67
68 /* Router-id update message from zebra. */
eigrp_router_id_update_zebra(ZAPI_CALLBACK_ARGS)69 static int eigrp_router_id_update_zebra(ZAPI_CALLBACK_ARGS)
70 {
71 struct eigrp *eigrp;
72 struct prefix router_id;
73 zebra_router_id_update_read(zclient->ibuf, &router_id);
74
75 router_id_zebra = router_id.u.prefix4;
76
77 eigrp = eigrp_lookup(vrf_id);
78
79 if (eigrp != NULL)
80 eigrp_router_id_update(eigrp);
81
82 return 0;
83 }
84
eigrp_zebra_route_notify_owner(ZAPI_CALLBACK_ARGS)85 static int eigrp_zebra_route_notify_owner(ZAPI_CALLBACK_ARGS)
86 {
87 struct prefix p;
88 enum zapi_route_notify_owner note;
89 uint32_t table;
90
91 if (!zapi_route_notify_decode(zclient->ibuf, &p, &table, ¬e))
92 return -1;
93
94 return 0;
95 }
96
eigrp_zebra_connected(struct zclient * zclient)97 static void eigrp_zebra_connected(struct zclient *zclient)
98 {
99 zclient_send_reg_requests(zclient, VRF_DEFAULT);
100 }
101
eigrp_zebra_init(void)102 void eigrp_zebra_init(void)
103 {
104 struct zclient_options opt = {.receive_notify = false};
105
106 zclient = zclient_new(master, &opt);
107
108 zclient_init(zclient, ZEBRA_ROUTE_EIGRP, 0, &eigrpd_privs);
109 zclient->zebra_connected = eigrp_zebra_connected;
110 zclient->router_id_update = eigrp_router_id_update_zebra;
111 zclient->interface_address_add = eigrp_interface_address_add;
112 zclient->interface_address_delete = eigrp_interface_address_delete;
113 zclient->redistribute_route_add = eigrp_zebra_read_route;
114 zclient->redistribute_route_del = eigrp_zebra_read_route;
115 zclient->route_notify_owner = eigrp_zebra_route_notify_owner;
116 }
117
118
119 /* Zebra route add and delete treatment. */
eigrp_zebra_read_route(ZAPI_CALLBACK_ARGS)120 static int eigrp_zebra_read_route(ZAPI_CALLBACK_ARGS)
121 {
122 struct zapi_route api;
123 struct eigrp *eigrp;
124
125 if (zapi_route_decode(zclient->ibuf, &api) < 0)
126 return -1;
127
128 if (IPV4_NET127(ntohl(api.prefix.u.prefix4.s_addr)))
129 return 0;
130
131 eigrp = eigrp_lookup(vrf_id);
132 if (eigrp == NULL)
133 return 0;
134
135 if (cmd == ZEBRA_REDISTRIBUTE_ROUTE_ADD) {
136
137 } else /* if (cmd == ZEBRA_REDISTRIBUTE_ROUTE_DEL) */
138 {
139 }
140
141 return 0;
142 }
143
eigrp_interface_address_add(ZAPI_CALLBACK_ARGS)144 static int eigrp_interface_address_add(ZAPI_CALLBACK_ARGS)
145 {
146 struct connected *c;
147
148 c = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
149
150 if (c == NULL)
151 return 0;
152
153 if (IS_DEBUG_EIGRP(zebra, ZEBRA_INTERFACE)) {
154 char buf[128];
155 prefix2str(c->address, buf, sizeof(buf));
156 zlog_debug("Zebra: interface %s address add %s", c->ifp->name,
157 buf);
158 }
159
160 eigrp_if_update(c->ifp);
161
162 return 0;
163 }
164
eigrp_interface_address_delete(ZAPI_CALLBACK_ARGS)165 static int eigrp_interface_address_delete(ZAPI_CALLBACK_ARGS)
166 {
167 struct connected *c;
168 struct interface *ifp;
169 struct eigrp_interface *ei;
170
171 c = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
172
173 if (c == NULL)
174 return 0;
175
176 if (IS_DEBUG_EIGRP(zebra, ZEBRA_INTERFACE)) {
177 char buf[128];
178 prefix2str(c->address, buf, sizeof(buf));
179 zlog_debug("Zebra: interface %s address delete %s",
180 c->ifp->name, buf);
181 }
182
183 ifp = c->ifp;
184 ei = ifp->info;
185 if (!ei)
186 return 0;
187
188 /* Call interface hook functions to clean up */
189 if (prefix_cmp(&ei->address, c->address) == 0)
190 eigrp_if_free(ei, INTERFACE_DOWN_BY_ZEBRA);
191
192 connected_free(&c);
193
194 return 0;
195 }
196
eigrp_zebra_route_add(struct eigrp * eigrp,struct prefix * p,struct list * successors,uint32_t distance)197 void eigrp_zebra_route_add(struct eigrp *eigrp, struct prefix *p,
198 struct list *successors, uint32_t distance)
199 {
200 struct zapi_route api;
201 struct zapi_nexthop *api_nh;
202 struct eigrp_nexthop_entry *te;
203 struct listnode *node;
204 int count = 0;
205
206 if (!zclient->redist[AFI_IP][ZEBRA_ROUTE_EIGRP])
207 return;
208
209 memset(&api, 0, sizeof(api));
210 api.vrf_id = eigrp->vrf_id;
211 api.type = ZEBRA_ROUTE_EIGRP;
212 api.safi = SAFI_UNICAST;
213 api.metric = distance;
214 memcpy(&api.prefix, p, sizeof(*p));
215
216 SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
217 SET_FLAG(api.message, ZAPI_MESSAGE_METRIC);
218
219 /* Nexthop, ifindex, distance and metric information. */
220 for (ALL_LIST_ELEMENTS_RO(successors, node, te)) {
221 if (count >= MULTIPATH_NUM)
222 break;
223 api_nh = &api.nexthops[count];
224 api_nh->vrf_id = eigrp->vrf_id;
225 if (te->adv_router->src.s_addr) {
226 api_nh->gate.ipv4 = te->adv_router->src;
227 api_nh->type = NEXTHOP_TYPE_IPV4_IFINDEX;
228 } else
229 api_nh->type = NEXTHOP_TYPE_IFINDEX;
230 api_nh->ifindex = te->ei->ifp->ifindex;
231
232 count++;
233 }
234 api.nexthop_num = count;
235
236 if (IS_DEBUG_EIGRP(zebra, ZEBRA_REDISTRIBUTE)) {
237 char buf[2][PREFIX_STRLEN];
238 zlog_debug("Zebra: Route add %s nexthop %s",
239 prefix2str(p, buf[0], PREFIX_STRLEN),
240 inet_ntop(AF_INET, 0, buf[1], PREFIX_STRLEN));
241 }
242
243 zclient_route_send(ZEBRA_ROUTE_ADD, zclient, &api);
244 }
245
eigrp_zebra_route_delete(struct eigrp * eigrp,struct prefix * p)246 void eigrp_zebra_route_delete(struct eigrp *eigrp, struct prefix *p)
247 {
248 struct zapi_route api;
249
250 if (!zclient->redist[AFI_IP][ZEBRA_ROUTE_EIGRP])
251 return;
252
253 memset(&api, 0, sizeof(api));
254 api.vrf_id = eigrp->vrf_id;
255 api.type = ZEBRA_ROUTE_EIGRP;
256 api.safi = SAFI_UNICAST;
257 memcpy(&api.prefix, p, sizeof(*p));
258 zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
259
260 if (IS_DEBUG_EIGRP(zebra, ZEBRA_REDISTRIBUTE)) {
261 char buf[PREFIX_STRLEN];
262 zlog_debug("Zebra: Route del %s",
263 prefix2str(p, buf, PREFIX_STRLEN));
264 }
265
266 return;
267 }
268
eigrp_is_type_redistributed(int type,vrf_id_t vrf_id)269 static int eigrp_is_type_redistributed(int type, vrf_id_t vrf_id)
270 {
271 return ((DEFAULT_ROUTE_TYPE(type))
272 ? vrf_bitmap_check(zclient->default_information[AFI_IP],
273 vrf_id)
274 : vrf_bitmap_check(zclient->redist[AFI_IP][type],
275 vrf_id));
276 }
277
eigrp_redistribute_set(struct eigrp * eigrp,int type,struct eigrp_metrics metric)278 int eigrp_redistribute_set(struct eigrp *eigrp, int type,
279 struct eigrp_metrics metric)
280 {
281
282 if (eigrp_is_type_redistributed(type, eigrp->vrf_id)) {
283 if (eigrp_metrics_is_same(metric, eigrp->dmetric[type])) {
284 eigrp->dmetric[type] = metric;
285 }
286
287 eigrp_external_routes_refresh(eigrp, type);
288
289 // if (IS_DEBUG_EIGRP(zebra, ZEBRA_REDISTRIBUTE))
290 // zlog_debug ("Redistribute[%s]: Refresh Type[%d],
291 // Metric[%d]",
292 // eigrp_redist_string(type),
293 // metric_type (eigrp, type), metric_value
294 // (eigrp, type));
295 return CMD_SUCCESS;
296 }
297
298 eigrp->dmetric[type] = metric;
299
300 zclient_redistribute(ZEBRA_REDISTRIBUTE_ADD, zclient, AFI_IP, type, 0,
301 eigrp->vrf_id);
302
303 ++eigrp->redistribute;
304
305 return CMD_SUCCESS;
306 }
307
eigrp_redistribute_unset(struct eigrp * eigrp,int type)308 int eigrp_redistribute_unset(struct eigrp *eigrp, int type)
309 {
310
311 if (eigrp_is_type_redistributed(type, eigrp->vrf_id)) {
312 memset(&eigrp->dmetric[type], 0, sizeof(struct eigrp_metrics));
313 zclient_redistribute(ZEBRA_REDISTRIBUTE_DELETE, zclient, AFI_IP,
314 type, 0, eigrp->vrf_id);
315 --eigrp->redistribute;
316 }
317
318 return CMD_SUCCESS;
319 }
320