Annotation of embedaddon/quagga/pimd/pim_zlookup.c, revision 1.1
1.1 ! misho 1: /*
! 2: PIM for Quagga
! 3: Copyright (C) 2008 Everton da Silva Marques
! 4:
! 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.
! 9:
! 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.
! 14:
! 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,
! 18: MA 02110-1301 USA
! 19:
! 20: $QuaggaId: $Format:%an, %ai, %h$ $
! 21: */
! 22:
! 23: #include <zebra.h>
! 24: #include "zebra/rib.h"
! 25:
! 26: #include "log.h"
! 27: #include "prefix.h"
! 28: #include "zclient.h"
! 29: #include "stream.h"
! 30: #include "network.h"
! 31: #include "thread.h"
! 32:
! 33: #include "pimd.h"
! 34: #include "pim_pim.h"
! 35: #include "pim_str.h"
! 36: #include "pim_zlookup.h"
! 37:
! 38: extern int zclient_debug;
! 39:
! 40: static void zclient_lookup_sched(struct zclient *zlookup, int delay);
! 41:
! 42: /* Connect to zebra for nexthop lookup. */
! 43: static int zclient_lookup_connect(struct thread *t)
! 44: {
! 45: struct zclient *zlookup;
! 46:
! 47: zlookup = THREAD_ARG(t);
! 48: zlookup->t_connect = NULL;
! 49:
! 50: if (zlookup->sock >= 0) {
! 51: return 0;
! 52: }
! 53:
! 54: if (zclient_socket_connect(zlookup) < 0) {
! 55: ++zlookup->fail;
! 56: zlog_warn("%s: failure connecting zclient socket: failures=%d",
! 57: __PRETTY_FUNCTION__, zlookup->fail);
! 58: }
! 59: else {
! 60: zlookup->fail = 0; /* reset counter on connection */
! 61: }
! 62:
! 63: zassert(!zlookup->t_connect);
! 64: if (zlookup->sock < 0) {
! 65: /* Since last connect failed, retry within 10 secs */
! 66: zclient_lookup_sched(zlookup, 10);
! 67: return -1;
! 68: }
! 69:
! 70: return 0;
! 71: }
! 72:
! 73: /* Schedule connection with delay. */
! 74: static void zclient_lookup_sched(struct zclient *zlookup, int delay)
! 75: {
! 76: zassert(!zlookup->t_connect);
! 77:
! 78: THREAD_TIMER_ON(master, zlookup->t_connect,
! 79: zclient_lookup_connect,
! 80: zlookup, delay);
! 81:
! 82: zlog_notice("%s: zclient lookup connection scheduled for %d seconds",
! 83: __PRETTY_FUNCTION__, delay);
! 84: }
! 85:
! 86: /* Schedule connection for now. */
! 87: static void zclient_lookup_sched_now(struct zclient *zlookup)
! 88: {
! 89: zassert(!zlookup->t_connect);
! 90:
! 91: zlookup->t_connect = thread_add_event(master, zclient_lookup_connect,
! 92: zlookup, 0);
! 93:
! 94: zlog_notice("%s: zclient lookup immediate connection scheduled",
! 95: __PRETTY_FUNCTION__);
! 96: }
! 97:
! 98: /* Schedule reconnection, if needed. */
! 99: static void zclient_lookup_reconnect(struct zclient *zlookup)
! 100: {
! 101: if (zlookup->t_connect) {
! 102: return;
! 103: }
! 104:
! 105: zclient_lookup_sched_now(zlookup);
! 106: }
! 107:
! 108: static void zclient_lookup_failed(struct zclient *zlookup)
! 109: {
! 110: if (zlookup->sock >= 0) {
! 111: if (close(zlookup->sock)) {
! 112: zlog_warn("%s: closing fd=%d: errno=%d %s", __func__, zlookup->sock,
! 113: errno, safe_strerror(errno));
! 114: }
! 115: zlookup->sock = -1;
! 116: }
! 117:
! 118: zclient_lookup_reconnect(zlookup);
! 119: }
! 120:
! 121: struct zclient *zclient_lookup_new()
! 122: {
! 123: struct zclient *zlookup;
! 124:
! 125: zlookup = zclient_new (master);
! 126: if (!zlookup) {
! 127: zlog_err("%s: zclient_new() failure",
! 128: __PRETTY_FUNCTION__);
! 129: return 0;
! 130: }
! 131:
! 132: zlookup->sock = -1;
! 133: zlookup->ibuf = stream_new(ZEBRA_MAX_PACKET_SIZ);
! 134: zlookup->obuf = stream_new(ZEBRA_MAX_PACKET_SIZ);
! 135: zlookup->t_connect = 0;
! 136:
! 137: zclient_lookup_sched_now(zlookup);
! 138:
! 139: zlog_notice("%s: zclient lookup socket initialized",
! 140: __PRETTY_FUNCTION__);
! 141:
! 142: return zlookup;
! 143: }
! 144:
! 145: static int zclient_read_nexthop(struct zclient *zlookup,
! 146: struct pim_zlookup_nexthop nexthop_tab[],
! 147: const int tab_size,
! 148: struct in_addr addr)
! 149: {
! 150: int num_ifindex = 0;
! 151: struct stream *s;
! 152: const uint16_t MIN_LEN = 10; /* getipv4=4 getc=1 getl=4 getc=1 */
! 153: uint16_t length;
! 154: u_char marker;
! 155: u_char version;
! 156: uint16_t vrf_id;
! 157: uint16_t command;
! 158: int nbytes;
! 159: struct in_addr raddr;
! 160: uint8_t distance;
! 161: uint32_t metric;
! 162: int nexthop_num;
! 163: int i, err;
! 164:
! 165: if (PIM_DEBUG_ZEBRA) {
! 166: char addr_str[100];
! 167: pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
! 168: zlog_debug("%s: addr=%s",
! 169: __PRETTY_FUNCTION__,
! 170: addr_str);
! 171: }
! 172:
! 173: s = zlookup->ibuf;
! 174: stream_reset(s);
! 175:
! 176: err = zclient_read_header (s, zlookup->sock, &length, &marker, &version,
! 177: &vrf_id, &command);
! 178: if (err < 0) {
! 179: zlog_err("%s %s: zclient_read_header() failed",
! 180: __FILE__, __PRETTY_FUNCTION__);
! 181: zclient_lookup_failed(zlookup);
! 182: return -1;
! 183: }
! 184:
! 185: if (length < MIN_LEN) {
! 186: zlog_err("%s %s: failure reading zclient lookup socket: len=%d < MIN_LEN=%d",
! 187: __FILE__, __PRETTY_FUNCTION__, length, MIN_LEN);
! 188: zclient_lookup_failed(zlookup);
! 189: return -2;
! 190: }
! 191:
! 192: nbytes = stream_read(s, zlookup->sock, length);
! 193: if (nbytes < length) {
! 194: zlog_err("%s %s: failure reading zclient lookup socket: nbytes=%d < len=%d",
! 195: __FILE__, __PRETTY_FUNCTION__, nbytes, length);
! 196: zclient_lookup_failed(zlookup);
! 197: return -3;
! 198: }
! 199:
! 200: if (command != ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB) {
! 201: zlog_err("%s: socket %d command mismatch: %d",
! 202: __func__, zlookup->sock, command);
! 203: return -5;
! 204: }
! 205:
! 206: raddr.s_addr = stream_get_ipv4(s);
! 207:
! 208: if (raddr.s_addr != addr.s_addr) {
! 209: char addr_str[100];
! 210: char raddr_str[100];
! 211: pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
! 212: pim_inet4_dump("<raddr?>", raddr, raddr_str, sizeof(raddr_str));
! 213: zlog_warn("%s: address mismatch: addr=%s raddr=%s",
! 214: __PRETTY_FUNCTION__,
! 215: addr_str, raddr_str);
! 216: /* warning only */
! 217: }
! 218:
! 219: distance = stream_getc(s);
! 220: metric = stream_getl(s);
! 221: nexthop_num = stream_getc(s);
! 222:
! 223: if (nexthop_num < 1) {
! 224: zlog_err("%s: socket %d bad nexthop_num=%d",
! 225: __func__, zlookup->sock, nexthop_num);
! 226: return -6;
! 227: }
! 228:
! 229: length -= MIN_LEN;
! 230:
! 231: for (i = 0; i < nexthop_num; ++i) {
! 232: enum nexthop_types_t nexthop_type;
! 233:
! 234: if (length < 1) {
! 235: zlog_err("%s: socket %d empty input expecting nexthop_type: len=%d",
! 236: __func__, zlookup->sock, length);
! 237: return -7;
! 238: }
! 239:
! 240: nexthop_type = stream_getc(s);
! 241: --length;
! 242:
! 243: switch (nexthop_type) {
! 244: case ZEBRA_NEXTHOP_IFINDEX:
! 245: case ZEBRA_NEXTHOP_IFNAME:
! 246: case ZEBRA_NEXTHOP_IPV4_IFINDEX:
! 247: if (num_ifindex >= tab_size) {
! 248: char addr_str[100];
! 249: pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
! 250: zlog_warn("%s %s: found too many nexthop ifindexes (%d > %d) for address %s",
! 251: __FILE__, __PRETTY_FUNCTION__,
! 252: (num_ifindex + 1), tab_size, addr_str);
! 253: return num_ifindex;
! 254: }
! 255: if (nexthop_type == ZEBRA_NEXTHOP_IPV4_IFINDEX) {
! 256: if (length < 4) {
! 257: zlog_err("%s: socket %d short input expecting nexthop IPv4-addr: len=%d",
! 258: __func__, zlookup->sock, length);
! 259: return -8;
! 260: }
! 261: nexthop_tab[num_ifindex].nexthop_addr.s_addr = stream_get_ipv4(s);
! 262: length -= 4;
! 263: }
! 264: else {
! 265: nexthop_tab[num_ifindex].nexthop_addr.s_addr = PIM_NET_INADDR_ANY;
! 266: }
! 267: nexthop_tab[num_ifindex].ifindex = stream_getl(s);
! 268: nexthop_tab[num_ifindex].protocol_distance = distance;
! 269: nexthop_tab[num_ifindex].route_metric = metric;
! 270: ++num_ifindex;
! 271: break;
! 272: case ZEBRA_NEXTHOP_IPV4:
! 273: if (num_ifindex >= tab_size) {
! 274: char addr_str[100];
! 275: pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
! 276: zlog_warn("%s %s: found too many nexthop ifindexes (%d > %d) for address %s",
! 277: __FILE__, __PRETTY_FUNCTION__,
! 278: (num_ifindex + 1), tab_size, addr_str);
! 279: return num_ifindex;
! 280: }
! 281: nexthop_tab[num_ifindex].nexthop_addr.s_addr = stream_get_ipv4(s);
! 282: length -= 4;
! 283: nexthop_tab[num_ifindex].ifindex = 0;
! 284: nexthop_tab[num_ifindex].protocol_distance = distance;
! 285: nexthop_tab[num_ifindex].route_metric = metric;
! 286: if (PIM_DEBUG_ZEBRA) {
! 287: char addr_str[100];
! 288: char nexthop_str[100];
! 289: pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
! 290: pim_inet4_dump("<nexthop?>", nexthop_tab[num_ifindex].nexthop_addr, nexthop_str, sizeof(nexthop_str));
! 291: zlog_debug("%s %s: zebra returned recursive nexthop %s for address %s",
! 292: __FILE__, __PRETTY_FUNCTION__,
! 293: nexthop_str, addr_str);
! 294: }
! 295: ++num_ifindex;
! 296: break;
! 297: default:
! 298: /* do nothing */
! 299: {
! 300: char addr_str[100];
! 301: pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
! 302: zlog_warn("%s %s: found non-ifindex nexthop type=%d for address %s",
! 303: __FILE__, __PRETTY_FUNCTION__,
! 304: nexthop_type, addr_str);
! 305: }
! 306: break;
! 307: }
! 308: }
! 309:
! 310: return num_ifindex;
! 311: }
! 312:
! 313: static int zclient_lookup_nexthop_once(struct zclient *zlookup,
! 314: struct pim_zlookup_nexthop nexthop_tab[],
! 315: const int tab_size,
! 316: struct in_addr addr)
! 317: {
! 318: struct stream *s;
! 319: int ret;
! 320:
! 321: if (PIM_DEBUG_ZEBRA) {
! 322: char addr_str[100];
! 323: pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
! 324: zlog_debug("%s: addr=%s",
! 325: __PRETTY_FUNCTION__,
! 326: addr_str);
! 327: }
! 328:
! 329: /* Check socket. */
! 330: if (zlookup->sock < 0) {
! 331: zlog_err("%s %s: zclient lookup socket is not connected",
! 332: __FILE__, __PRETTY_FUNCTION__);
! 333: zclient_lookup_failed(zlookup);
! 334: return -1;
! 335: }
! 336:
! 337: s = zlookup->obuf;
! 338: stream_reset(s);
! 339: zclient_create_header(s, ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB, VRF_DEFAULT);
! 340: stream_put_in_addr(s, &addr);
! 341: stream_putw_at(s, 0, stream_get_endp(s));
! 342:
! 343: ret = writen(zlookup->sock, s->data, stream_get_endp(s));
! 344: if (ret < 0) {
! 345: zlog_err("%s %s: writen() failure writing to zclient lookup socket",
! 346: __FILE__, __PRETTY_FUNCTION__);
! 347: zclient_lookup_failed(zlookup);
! 348: return -2;
! 349: }
! 350: if (ret == 0) {
! 351: zlog_err("%s %s: connection closed on zclient lookup socket",
! 352: __FILE__, __PRETTY_FUNCTION__);
! 353: zclient_lookup_failed(zlookup);
! 354: return -3;
! 355: }
! 356:
! 357: return zclient_read_nexthop(zlookup, nexthop_tab,
! 358: tab_size, addr);
! 359: }
! 360:
! 361: int zclient_lookup_nexthop(struct zclient *zlookup,
! 362: struct pim_zlookup_nexthop nexthop_tab[],
! 363: const int tab_size,
! 364: struct in_addr addr,
! 365: int max_lookup)
! 366: {
! 367: int lookup;
! 368: uint32_t route_metric = 0xFFFFFFFF;
! 369: uint8_t protocol_distance = 0xFF;
! 370:
! 371: for (lookup = 0; lookup < max_lookup; ++lookup) {
! 372: int num_ifindex;
! 373: int first_ifindex;
! 374: struct in_addr nexthop_addr;
! 375:
! 376: num_ifindex = zclient_lookup_nexthop_once(qpim_zclient_lookup, nexthop_tab,
! 377: PIM_NEXTHOP_IFINDEX_TAB_SIZE, addr);
! 378: if ((num_ifindex < 1) && PIM_DEBUG_ZEBRA) {
! 379: char addr_str[100];
! 380: pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
! 381: zlog_warn("%s %s: lookup=%d/%d: could not find nexthop ifindex for address %s",
! 382: __FILE__, __PRETTY_FUNCTION__,
! 383: lookup, max_lookup, addr_str);
! 384: return -1;
! 385: }
! 386:
! 387: if (lookup < 1) {
! 388: /* this is the non-recursive lookup - save original metric/distance */
! 389: route_metric = nexthop_tab[0].route_metric;
! 390: protocol_distance = nexthop_tab[0].protocol_distance;
! 391: }
! 392:
! 393: /*
! 394: FIXME: Non-recursive nexthop ensured only for first ifindex.
! 395: However, recursive route lookup should really be fixed in zebra daemon.
! 396: See also TODO T24.
! 397: */
! 398: first_ifindex = nexthop_tab[0].ifindex;
! 399: nexthop_addr = nexthop_tab[0].nexthop_addr;
! 400: if (first_ifindex > 0) {
! 401: /* found: first ifindex is non-recursive nexthop */
! 402:
! 403: if ((lookup > 0) && PIM_DEBUG_ZEBRA) {
! 404: /* Report non-recursive success after first lookup */
! 405: char addr_str[100];
! 406: pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
! 407: zlog_debug("%s %s: lookup=%d/%d: found non-recursive ifindex=%d for address %s dist=%d met=%d",
! 408: __FILE__, __PRETTY_FUNCTION__,
! 409: lookup, max_lookup, first_ifindex, addr_str,
! 410: nexthop_tab[0].protocol_distance,
! 411: nexthop_tab[0].route_metric);
! 412:
! 413: /* use last address as nexthop address */
! 414: nexthop_tab[0].nexthop_addr = addr;
! 415:
! 416: /* report original route metric/distance */
! 417: nexthop_tab[0].route_metric = route_metric;
! 418: nexthop_tab[0].protocol_distance = protocol_distance;
! 419: }
! 420:
! 421: return num_ifindex;
! 422: }
! 423:
! 424: if (PIM_DEBUG_ZEBRA) {
! 425: char addr_str[100];
! 426: char nexthop_str[100];
! 427: pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
! 428: pim_inet4_dump("<nexthop?>", nexthop_addr, nexthop_str, sizeof(nexthop_str));
! 429: zlog_debug("%s %s: lookup=%d/%d: zebra returned recursive nexthop %s for address %s dist=%d met=%d",
! 430: __FILE__, __PRETTY_FUNCTION__,
! 431: lookup, max_lookup, nexthop_str, addr_str,
! 432: nexthop_tab[0].protocol_distance,
! 433: nexthop_tab[0].route_metric);
! 434: }
! 435:
! 436: addr = nexthop_addr; /* use nexthop addr for recursive lookup */
! 437:
! 438: } /* for (max_lookup) */
! 439:
! 440: if (PIM_DEBUG_ZEBRA) {
! 441: char addr_str[100];
! 442: pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
! 443: zlog_warn("%s %s: lookup=%d/%d: failure searching recursive nexthop ifindex for address %s",
! 444: __FILE__, __PRETTY_FUNCTION__,
! 445: lookup, max_lookup, addr_str);
! 446: }
! 447:
! 448: return -2;
! 449: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pim_zlookup.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / pimd