3 Copyright (C) 2008 Everton da Silva Marques
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; see the file COPYING; if not, write to the
17 Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
23 #include "zebra/rib.h"
35 #include "pim_iface.h"
39 #include "pim_zlookup.h"
41 extern int zclient_debug
;
43 static struct zclient
*zlookup
= NULL
;
45 static void zclient_lookup_sched(struct zclient
*zlookup
, int delay
);
47 /* Connect to zebra for nexthop lookup. */
48 static int zclient_lookup_connect(struct thread
*t
)
50 struct zclient
*zlookup
;
52 zlookup
= THREAD_ARG(t
);
53 zlookup
->t_connect
= NULL
;
55 if (zlookup
->sock
>= 0) {
59 if (zclient_socket_connect(zlookup
) < 0) {
61 zlog_warn("%s: failure connecting zclient socket: failures=%d",
62 __PRETTY_FUNCTION__
, zlookup
->fail
);
65 zlookup
->fail
= 0; /* reset counter on connection */
68 zassert(!zlookup
->t_connect
);
69 if (zlookup
->sock
< 0) {
70 /* Since last connect failed, retry within 10 secs */
71 zclient_lookup_sched(zlookup
, 10);
78 /* Schedule connection with delay. */
79 static void zclient_lookup_sched(struct zclient
*zlookup
, int delay
)
81 zassert(!zlookup
->t_connect
);
83 THREAD_TIMER_ON(master
, zlookup
->t_connect
,
84 zclient_lookup_connect
,
87 zlog_notice("%s: zclient lookup connection scheduled for %d seconds",
88 __PRETTY_FUNCTION__
, delay
);
91 /* Schedule connection for now. */
92 static void zclient_lookup_sched_now(struct zclient
*zlookup
)
94 zassert(!zlookup
->t_connect
);
96 zlookup
->t_connect
= thread_add_event(master
, zclient_lookup_connect
,
99 zlog_notice("%s: zclient lookup immediate connection scheduled",
100 __PRETTY_FUNCTION__
);
103 /* Schedule reconnection, if needed. */
104 static void zclient_lookup_reconnect(struct zclient
*zlookup
)
106 if (zlookup
->t_connect
) {
110 zclient_lookup_sched_now(zlookup
);
113 static void zclient_lookup_failed(struct zclient
*zlookup
)
115 if (zlookup
->sock
>= 0) {
116 if (close(zlookup
->sock
)) {
117 zlog_warn("%s: closing fd=%d: errno=%d %s", __func__
, zlookup
->sock
,
118 errno
, safe_strerror(errno
));
123 zclient_lookup_reconnect(zlookup
);
127 zclient_lookup_new (void)
129 zlookup
= zclient_new (master
);
131 zlog_err("%s: zclient_new() failure",
132 __PRETTY_FUNCTION__
);
137 zlookup
->ibuf
= stream_new(ZEBRA_MAX_PACKET_SIZ
);
138 zlookup
->obuf
= stream_new(ZEBRA_MAX_PACKET_SIZ
);
139 zlookup
->t_connect
= 0;
141 zclient_lookup_sched_now(zlookup
);
143 zlog_notice("%s: zclient lookup socket initialized",
144 __PRETTY_FUNCTION__
);
148 static int zclient_read_nexthop(struct zclient
*zlookup
,
149 struct pim_zlookup_nexthop nexthop_tab
[],
155 const uint16_t MIN_LEN
= 10; /* getipv4=4 getc=1 getl=4 getc=1 */
160 uint16_t command
= 0;
161 struct in_addr raddr
;
167 if (PIM_DEBUG_ZEBRA
) {
169 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
170 zlog_debug("%s: addr=%s",
177 while (command
!= ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB
)
180 err
= zclient_read_header (s
, zlookup
->sock
, &length
, &marker
, &version
,
183 zlog_err("%s %s: zclient_read_header() failed",
184 __FILE__
, __PRETTY_FUNCTION__
);
185 zclient_lookup_failed(zlookup
);
189 if (length
< MIN_LEN
) {
190 zlog_err("%s %s: failure reading zclient lookup socket: len=%d < MIN_LEN=%d",
191 __FILE__
, __PRETTY_FUNCTION__
, length
, MIN_LEN
);
192 zclient_lookup_failed(zlookup
);
197 raddr
.s_addr
= stream_get_ipv4(s
);
199 if (raddr
.s_addr
!= addr
.s_addr
) {
202 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
203 pim_inet4_dump("<raddr?>", raddr
, raddr_str
, sizeof(raddr_str
));
204 zlog_warn("%s: address mismatch: addr=%s raddr=%s",
206 addr_str
, raddr_str
);
210 distance
= stream_getc(s
);
211 metric
= stream_getl(s
);
212 nexthop_num
= stream_getc(s
);
214 if (nexthop_num
< 1) {
215 zlog_err("%s: socket %d bad nexthop_num=%d",
216 __func__
, zlookup
->sock
, nexthop_num
);
222 for (i
= 0; i
< nexthop_num
; ++i
) {
223 enum nexthop_types_t nexthop_type
;
226 zlog_err("%s: socket %d empty input expecting nexthop_type: len=%d",
227 __func__
, zlookup
->sock
, length
);
231 nexthop_type
= stream_getc(s
);
233 if (num_ifindex
>= tab_size
) {
235 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
236 zlog_warn("%s %s: found too many nexthop ifindexes (%d > %d) for address %s",
237 __FILE__
, __PRETTY_FUNCTION__
,
238 (num_ifindex
+ 1), tab_size
, addr_str
);
241 switch (nexthop_type
) {
242 case NEXTHOP_TYPE_IFINDEX
:
243 case NEXTHOP_TYPE_IPV4_IFINDEX
:
244 nexthop_tab
[num_ifindex
].nexthop_addr
.family
= AF_INET
;
245 if (nexthop_type
== NEXTHOP_TYPE_IPV4_IFINDEX
) {
247 zlog_err("%s: socket %d short input expecting nexthop IPv4-addr: len=%d",
248 __func__
, zlookup
->sock
, length
);
251 nexthop_tab
[num_ifindex
].nexthop_addr
.u
.prefix4
.s_addr
= stream_get_ipv4(s
);
255 nexthop_tab
[num_ifindex
].nexthop_addr
.u
.prefix4
.s_addr
= PIM_NET_INADDR_ANY
;
257 nexthop_tab
[num_ifindex
].ifindex
= stream_getl(s
);
258 nexthop_tab
[num_ifindex
].protocol_distance
= distance
;
259 nexthop_tab
[num_ifindex
].route_metric
= metric
;
262 case NEXTHOP_TYPE_IPV4
:
263 nexthop_tab
[num_ifindex
].nexthop_addr
.family
= AF_INET
;
264 nexthop_tab
[num_ifindex
].nexthop_addr
.u
.prefix4
.s_addr
= stream_get_ipv4(s
);
266 nexthop_tab
[num_ifindex
].ifindex
= 0;
267 nexthop_tab
[num_ifindex
].protocol_distance
= distance
;
268 nexthop_tab
[num_ifindex
].route_metric
= metric
;
269 if (PIM_DEBUG_ZEBRA
) {
271 char nexthop_str
[100];
272 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
273 pim_addr_dump("<nexthop?>", &nexthop_tab
[num_ifindex
].nexthop_addr
, nexthop_str
, sizeof(nexthop_str
));
274 zlog_debug("%s %s: zebra returned recursive nexthop %s for address %s",
275 __FILE__
, __PRETTY_FUNCTION__
,
276 nexthop_str
, addr_str
);
284 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
285 zlog_warn("%s %s: found non-ifindex nexthop type=%d for address %s",
286 __FILE__
, __PRETTY_FUNCTION__
,
287 nexthop_type
, addr_str
);
297 zclient_lookup_nexthop_once (struct pim_zlookup_nexthop nexthop_tab
[],
304 if (PIM_DEBUG_ZEBRA
) {
306 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
307 zlog_debug("%s: addr=%s",
313 if (zlookup
->sock
< 0) {
314 zlog_err("%s %s: zclient lookup socket is not connected",
315 __FILE__
, __PRETTY_FUNCTION__
);
316 zclient_lookup_failed(zlookup
);
322 zclient_create_header(s
, ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB
, VRF_DEFAULT
);
323 stream_put_in_addr(s
, &addr
);
324 stream_putw_at(s
, 0, stream_get_endp(s
));
326 ret
= writen(zlookup
->sock
, s
->data
, stream_get_endp(s
));
328 zlog_err("%s %s: writen() failure writing to zclient lookup socket",
329 __FILE__
, __PRETTY_FUNCTION__
);
330 zclient_lookup_failed(zlookup
);
334 zlog_err("%s %s: connection closed on zclient lookup socket",
335 __FILE__
, __PRETTY_FUNCTION__
);
336 zclient_lookup_failed(zlookup
);
340 return zclient_read_nexthop(zlookup
, nexthop_tab
,
345 zclient_lookup_nexthop (struct pim_zlookup_nexthop nexthop_tab
[],
351 uint32_t route_metric
= 0xFFFFFFFF;
352 uint8_t protocol_distance
= 0xFF;
354 qpim_nexthop_lookups
++;
356 for (lookup
= 0; lookup
< max_lookup
; ++lookup
) {
359 struct prefix nexthop_addr
;
361 num_ifindex
= zclient_lookup_nexthop_once(nexthop_tab
,
362 PIM_NEXTHOP_IFINDEX_TAB_SIZE
, addr
);
363 if (num_ifindex
< 1) {
364 if (PIM_DEBUG_ZEBRA
) {
366 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
367 zlog_debug("%s %s: lookup=%d/%d: could not find nexthop ifindex for address %s",
368 __FILE__
, __PRETTY_FUNCTION__
,
369 lookup
, max_lookup
, addr_str
);
375 /* this is the non-recursive lookup - save original metric/distance */
376 route_metric
= nexthop_tab
[0].route_metric
;
377 protocol_distance
= nexthop_tab
[0].protocol_distance
;
381 FIXME: Non-recursive nexthop ensured only for first ifindex.
382 However, recursive route lookup should really be fixed in zebra daemon.
385 first_ifindex
= nexthop_tab
[0].ifindex
;
386 nexthop_addr
= nexthop_tab
[0].nexthop_addr
;
387 if (first_ifindex
> 0) {
388 /* found: first ifindex is non-recursive nexthop */
391 /* Report non-recursive success after first lookup */
392 if (PIM_DEBUG_ZEBRA
) {
394 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
395 zlog_debug("%s %s: lookup=%d/%d: found non-recursive ifindex=%d for address %s dist=%d met=%d",
396 __FILE__
, __PRETTY_FUNCTION__
,
397 lookup
, max_lookup
, first_ifindex
, addr_str
,
398 nexthop_tab
[0].protocol_distance
,
399 nexthop_tab
[0].route_metric
);
402 /* use last address as nexthop address */
403 nexthop_tab
[0].nexthop_addr
.u
.prefix4
= addr
;
405 /* report original route metric/distance */
406 nexthop_tab
[0].route_metric
= route_metric
;
407 nexthop_tab
[0].protocol_distance
= protocol_distance
;
413 if (PIM_DEBUG_ZEBRA
) {
415 char nexthop_str
[100];
416 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
417 pim_addr_dump("<nexthop?>", &nexthop_addr
, nexthop_str
, sizeof(nexthop_str
));
418 zlog_debug("%s %s: lookup=%d/%d: zebra returned recursive nexthop %s for address %s dist=%d met=%d",
419 __FILE__
, __PRETTY_FUNCTION__
,
420 lookup
, max_lookup
, nexthop_str
, addr_str
,
421 nexthop_tab
[0].protocol_distance
,
422 nexthop_tab
[0].route_metric
);
425 addr
= nexthop_addr
.u
.prefix4
; /* use nexthop addr for recursive lookup */
427 } /* for (max_lookup) */
429 if (PIM_DEBUG_ZEBRA
) {
431 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
432 zlog_warn("%s %s: lookup=%d/%d: failure searching recursive nexthop ifindex for address %s",
433 __FILE__
, __PRETTY_FUNCTION__
,
434 lookup
, max_lookup
, addr_str
);
441 pim_zlookup_show_ip_multicast (struct vty
*vty
)
443 vty_out(vty
, "Zclient lookup socket: ");
445 vty_out(vty
, "%d failures=%d%s", zlookup
->sock
,
446 zlookup
->fail
, VTY_NEWLINE
);
449 vty_out(vty
, "<null zclient>%s", VTY_NEWLINE
);
454 pim_zlookup_sg_statistics (struct channel_oil
*c_oil
)
456 struct stream
*s
= zlookup
->obuf
;
457 uint16_t command
= 0;
458 unsigned long long lastused
;
462 struct interface
*ifp
= pim_if_find_by_vif_index (c_oil
->oil
.mfcc_parent
);
465 zlog_debug ("Sending Request for New Channel Oil Information");
468 zclient_create_header (s
, ZEBRA_IPMR_ROUTE_STATS
, VRF_DEFAULT
);
469 stream_put_in_addr (s
, &c_oil
->oil
.mfcc_origin
);
470 stream_put_in_addr (s
, &c_oil
->oil
.mfcc_mcastgrp
);
471 stream_putl (s
, ifp
->ifindex
);
472 stream_putw_at(s
, 0, stream_get_endp(s
));
474 count
= stream_get_endp (s
);
475 ret
= writen (zlookup
->sock
, s
->data
, count
);
478 zlog_err("%s %s: writen() failure writing to zclient lookup socket",
479 __FILE__
, __PRETTY_FUNCTION__
);
485 while (command
!= ZEBRA_IPMR_ROUTE_STATS
)
494 err
= zclient_read_header (s
, zlookup
->sock
, &length
, &marker
, &version
,
498 zlog_err ("%s %s: zclient_read_header() failed",
499 __FILE__
, __PRETTY_FUNCTION__
);
500 zclient_lookup_failed(zlookup
);
505 sg
.src
.s_addr
= stream_get_ipv4 (s
);
506 sg
.grp
.s_addr
= stream_get_ipv4 (s
);
507 if (sg
.src
.s_addr
!= c_oil
->oil
.mfcc_origin
.s_addr
||
508 sg
.grp
.s_addr
!= c_oil
->oil
.mfcc_mcastgrp
.s_addr
)
510 zlog_err ("%s: Received wrong %s information",
511 __PRETTY_FUNCTION__
, pim_str_sg_dump (&sg
));
512 zclient_lookup_failed (zlookup
);
516 stream_get (&lastused
, s
, sizeof (lastused
));
519 zlog_debug ("Received %lld for %s", lastused
, pim_str_sg_dump (&sg
));
521 c_oil
->cc
.lastused
= lastused
;