Annotation of embedaddon/quagga/ripd/rip_zebra.c, revision 1.1
1.1 ! misho 1: /* RIPd and zebra interface.
! 2: * Copyright (C) 1997, 1999 Kunihiro Ishiguro <kunihiro@zebra.org>
! 3: *
! 4: * This file is part of GNU Zebra.
! 5: *
! 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.
! 10: *
! 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.
! 15: *
! 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.
! 20: */
! 21:
! 22: #include <zebra.h>
! 23:
! 24: #include "command.h"
! 25: #include "prefix.h"
! 26: #include "stream.h"
! 27: #include "routemap.h"
! 28: #include "zclient.h"
! 29: #include "log.h"
! 30: #include "ripd/ripd.h"
! 31: #include "ripd/rip_debug.h"
! 32: #include "ripd/rip_interface.h"
! 33:
! 34: /* All information about zebra. */
! 35: struct zclient *zclient = NULL;
! 36:
! 37: /* RIPd to zebra command interface. */
! 38: void
! 39: rip_zebra_ipv4_add (struct prefix_ipv4 *p, struct in_addr *nexthop,
! 40: u_int32_t metric, u_char distance)
! 41: {
! 42: struct zapi_ipv4 api;
! 43:
! 44: if (zclient->redist[ZEBRA_ROUTE_RIP])
! 45: {
! 46: api.type = ZEBRA_ROUTE_RIP;
! 47: api.flags = 0;
! 48: api.message = 0;
! 49: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
! 50: api.nexthop_num = 1;
! 51: api.nexthop = &nexthop;
! 52: api.ifindex_num = 0;
! 53: SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
! 54: api.metric = metric;
! 55:
! 56: if (distance && distance != ZEBRA_RIP_DISTANCE_DEFAULT)
! 57: {
! 58: SET_FLAG (api.message, ZAPI_MESSAGE_DISTANCE);
! 59: api.distance = distance;
! 60: }
! 61:
! 62: zapi_ipv4_route (ZEBRA_IPV4_ROUTE_ADD, zclient, p, &api);
! 63:
! 64: rip_global_route_changes++;
! 65: }
! 66: }
! 67:
! 68: void
! 69: rip_zebra_ipv4_delete (struct prefix_ipv4 *p, struct in_addr *nexthop,
! 70: u_int32_t metric)
! 71: {
! 72: struct zapi_ipv4 api;
! 73:
! 74: if (zclient->redist[ZEBRA_ROUTE_RIP])
! 75: {
! 76: api.type = ZEBRA_ROUTE_RIP;
! 77: api.flags = 0;
! 78: api.message = 0;
! 79: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
! 80: api.nexthop_num = 1;
! 81: api.nexthop = &nexthop;
! 82: api.ifindex_num = 0;
! 83: SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
! 84: api.metric = metric;
! 85:
! 86: zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE, zclient, p, &api);
! 87:
! 88: rip_global_route_changes++;
! 89: }
! 90: }
! 91:
! 92: /* Zebra route add and delete treatment. */
! 93: static int
! 94: rip_zebra_read_ipv4 (int command, struct zclient *zclient, zebra_size_t length)
! 95: {
! 96: struct stream *s;
! 97: struct zapi_ipv4 api;
! 98: unsigned long ifindex;
! 99: struct in_addr nexthop;
! 100: struct prefix_ipv4 p;
! 101:
! 102: s = zclient->ibuf;
! 103: ifindex = 0;
! 104: nexthop.s_addr = 0;
! 105:
! 106: /* Type, flags, message. */
! 107: api.type = stream_getc (s);
! 108: api.flags = stream_getc (s);
! 109: api.message = stream_getc (s);
! 110:
! 111: /* IPv4 prefix. */
! 112: memset (&p, 0, sizeof (struct prefix_ipv4));
! 113: p.family = AF_INET;
! 114: p.prefixlen = stream_getc (s);
! 115: stream_get (&p.prefix, s, PSIZE (p.prefixlen));
! 116:
! 117: /* Nexthop, ifindex, distance, metric. */
! 118: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
! 119: {
! 120: api.nexthop_num = stream_getc (s);
! 121: nexthop.s_addr = stream_get_ipv4 (s);
! 122: }
! 123: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
! 124: {
! 125: api.ifindex_num = stream_getc (s);
! 126: ifindex = stream_getl (s);
! 127: }
! 128: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
! 129: api.distance = stream_getc (s);
! 130: else
! 131: api.distance = 255;
! 132: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
! 133: api.metric = stream_getl (s);
! 134: else
! 135: api.metric = 0;
! 136:
! 137: /* Then fetch IPv4 prefixes. */
! 138: if (command == ZEBRA_IPV4_ROUTE_ADD)
! 139: rip_redistribute_add (api.type, RIP_ROUTE_REDISTRIBUTE, &p, ifindex,
! 140: &nexthop, api.metric, api.distance);
! 141: else
! 142: rip_redistribute_delete (api.type, RIP_ROUTE_REDISTRIBUTE, &p, ifindex);
! 143:
! 144: return 0;
! 145: }
! 146:
! 147: void
! 148: rip_zclient_reset (void)
! 149: {
! 150: zclient_reset (zclient);
! 151: }
! 152:
! 153: /* RIP route-map set for redistribution */
! 154: static void
! 155: rip_routemap_set (int type, const char *name)
! 156: {
! 157: if (rip->route_map[type].name)
! 158: free(rip->route_map[type].name);
! 159:
! 160: rip->route_map[type].name = strdup (name);
! 161: rip->route_map[type].map = route_map_lookup_by_name (name);
! 162: }
! 163:
! 164: static void
! 165: rip_redistribute_metric_set (int type, unsigned int metric)
! 166: {
! 167: rip->route_map[type].metric_config = 1;
! 168: rip->route_map[type].metric = metric;
! 169: }
! 170:
! 171: static int
! 172: rip_metric_unset (int type, unsigned int metric)
! 173: {
! 174: #define DONT_CARE_METRIC_RIP 17
! 175: if (metric != DONT_CARE_METRIC_RIP &&
! 176: rip->route_map[type].metric != metric)
! 177: return 1;
! 178: rip->route_map[type].metric_config = 0;
! 179: rip->route_map[type].metric = 0;
! 180: return 0;
! 181: }
! 182:
! 183: /* RIP route-map unset for redistribution */
! 184: static int
! 185: rip_routemap_unset (int type, const char *name)
! 186: {
! 187: if (! rip->route_map[type].name ||
! 188: (name != NULL && strcmp(rip->route_map[type].name,name)))
! 189: return 1;
! 190:
! 191: free (rip->route_map[type].name);
! 192: rip->route_map[type].name = NULL;
! 193: rip->route_map[type].map = NULL;
! 194:
! 195: return 0;
! 196: }
! 197:
! 198: /* Redistribution types */
! 199: static struct {
! 200: int type;
! 201: int str_min_len;
! 202: const char *str;
! 203: } redist_type[] = {
! 204: {ZEBRA_ROUTE_KERNEL, 1, "kernel"},
! 205: {ZEBRA_ROUTE_CONNECT, 1, "connected"},
! 206: {ZEBRA_ROUTE_STATIC, 1, "static"},
! 207: {ZEBRA_ROUTE_OSPF, 1, "ospf"},
! 208: {ZEBRA_ROUTE_BGP, 1, "bgp"},
! 209: {0, 0, NULL}
! 210: };
! 211:
! 212: DEFUN (router_zebra,
! 213: router_zebra_cmd,
! 214: "router zebra",
! 215: "Enable a routing process\n"
! 216: "Make connection to zebra daemon\n")
! 217: {
! 218: vty->node = ZEBRA_NODE;
! 219: zclient->enable = 1;
! 220: zclient_start (zclient);
! 221: return CMD_SUCCESS;
! 222: }
! 223:
! 224: DEFUN (no_router_zebra,
! 225: no_router_zebra_cmd,
! 226: "no router zebra",
! 227: NO_STR
! 228: "Enable a routing process\n"
! 229: "Make connection to zebra daemon\n")
! 230: {
! 231: zclient->enable = 0;
! 232: zclient_stop (zclient);
! 233: return CMD_SUCCESS;
! 234: }
! 235:
! 236: #if 0
! 237: static int
! 238: rip_redistribute_set (int type)
! 239: {
! 240: if (zclient->redist[type])
! 241: return CMD_SUCCESS;
! 242:
! 243: zclient->redist[type] = 1;
! 244:
! 245: if (zclient->sock > 0)
! 246: zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD, zclient, type);
! 247:
! 248: return CMD_SUCCESS;
! 249: }
! 250: #endif
! 251:
! 252: static int
! 253: rip_redistribute_unset (int type)
! 254: {
! 255: if (! zclient->redist[type])
! 256: return CMD_SUCCESS;
! 257:
! 258: zclient->redist[type] = 0;
! 259:
! 260: if (zclient->sock > 0)
! 261: zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE, zclient, type);
! 262:
! 263: /* Remove the routes from RIP table. */
! 264: rip_redistribute_withdraw (type);
! 265:
! 266: return CMD_SUCCESS;
! 267: }
! 268:
! 269: int
! 270: rip_redistribute_check (int type)
! 271: {
! 272: return (zclient->redist[type]);
! 273: }
! 274:
! 275: void
! 276: rip_redistribute_clean (void)
! 277: {
! 278: int i;
! 279:
! 280: for (i = 0; redist_type[i].str; i++)
! 281: {
! 282: if (zclient->redist[redist_type[i].type])
! 283: {
! 284: if (zclient->sock > 0)
! 285: zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE,
! 286: zclient, redist_type[i].type);
! 287:
! 288: zclient->redist[redist_type[i].type] = 0;
! 289:
! 290: /* Remove the routes from RIP table. */
! 291: rip_redistribute_withdraw (redist_type[i].type);
! 292: }
! 293: }
! 294: }
! 295:
! 296: DEFUN (rip_redistribute_rip,
! 297: rip_redistribute_rip_cmd,
! 298: "redistribute rip",
! 299: "Redistribute information from another routing protocol\n"
! 300: "Routing Information Protocol (RIP)\n")
! 301: {
! 302: zclient->redist[ZEBRA_ROUTE_RIP] = 1;
! 303: return CMD_SUCCESS;
! 304: }
! 305:
! 306: DEFUN (no_rip_redistribute_rip,
! 307: no_rip_redistribute_rip_cmd,
! 308: "no redistribute rip",
! 309: NO_STR
! 310: "Redistribute information from another routing protocol\n"
! 311: "Routing Information Protocol (RIP)\n")
! 312: {
! 313: zclient->redist[ZEBRA_ROUTE_RIP] = 0;
! 314: return CMD_SUCCESS;
! 315: }
! 316:
! 317: DEFUN (rip_redistribute_type,
! 318: rip_redistribute_type_cmd,
! 319: "redistribute " QUAGGA_REDIST_STR_RIPD,
! 320: REDIST_STR
! 321: QUAGGA_REDIST_HELP_STR_RIPD)
! 322: {
! 323: int i;
! 324:
! 325: for(i = 0; redist_type[i].str; i++)
! 326: {
! 327: if (strncmp (redist_type[i].str, argv[0],
! 328: redist_type[i].str_min_len) == 0)
! 329: {
! 330: zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient,
! 331: redist_type[i].type);
! 332: return CMD_SUCCESS;
! 333: }
! 334: }
! 335:
! 336: vty_out(vty, "Invalid type %s%s", argv[0],
! 337: VTY_NEWLINE);
! 338:
! 339: return CMD_WARNING;
! 340: }
! 341:
! 342: DEFUN (no_rip_redistribute_type,
! 343: no_rip_redistribute_type_cmd,
! 344: "no redistribute " QUAGGA_REDIST_STR_RIPD,
! 345: NO_STR
! 346: REDIST_STR
! 347: QUAGGA_REDIST_HELP_STR_RIPD)
! 348: {
! 349: int i;
! 350:
! 351: for (i = 0; redist_type[i].str; i++)
! 352: {
! 353: if (strncmp(redist_type[i].str, argv[0],
! 354: redist_type[i].str_min_len) == 0)
! 355: {
! 356: rip_metric_unset (redist_type[i].type, DONT_CARE_METRIC_RIP);
! 357: rip_routemap_unset (redist_type[i].type,NULL);
! 358: rip_redistribute_unset (redist_type[i].type);
! 359: return CMD_SUCCESS;
! 360: }
! 361: }
! 362:
! 363: vty_out(vty, "Invalid type %s%s", argv[0],
! 364: VTY_NEWLINE);
! 365:
! 366: return CMD_WARNING;
! 367: }
! 368:
! 369: DEFUN (rip_redistribute_type_routemap,
! 370: rip_redistribute_type_routemap_cmd,
! 371: "redistribute " QUAGGA_REDIST_STR_RIPD " route-map WORD",
! 372: REDIST_STR
! 373: QUAGGA_REDIST_HELP_STR_RIPD
! 374: "Route map reference\n"
! 375: "Pointer to route-map entries\n")
! 376: {
! 377: int i;
! 378:
! 379: for (i = 0; redist_type[i].str; i++) {
! 380: if (strncmp(redist_type[i].str, argv[0],
! 381: redist_type[i].str_min_len) == 0)
! 382: {
! 383: rip_routemap_set (redist_type[i].type, argv[1]);
! 384: zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type);
! 385: return CMD_SUCCESS;
! 386: }
! 387: }
! 388:
! 389: vty_out(vty, "Invalid type %s%s", argv[0],
! 390: VTY_NEWLINE);
! 391:
! 392: return CMD_WARNING;
! 393: }
! 394:
! 395: DEFUN (no_rip_redistribute_type_routemap,
! 396: no_rip_redistribute_type_routemap_cmd,
! 397: "no redistribute " QUAGGA_REDIST_STR_RIPD " route-map WORD",
! 398: NO_STR
! 399: REDIST_STR
! 400: QUAGGA_REDIST_HELP_STR_RIPD
! 401: "Route map reference\n"
! 402: "Pointer to route-map entries\n")
! 403: {
! 404: int i;
! 405:
! 406: for (i = 0; redist_type[i].str; i++)
! 407: {
! 408: if (strncmp(redist_type[i].str, argv[0],
! 409: redist_type[i].str_min_len) == 0)
! 410: {
! 411: if (rip_routemap_unset (redist_type[i].type,argv[1]))
! 412: return CMD_WARNING;
! 413: rip_redistribute_unset (redist_type[i].type);
! 414: return CMD_SUCCESS;
! 415: }
! 416: }
! 417:
! 418: vty_out(vty, "Invalid type %s%s", argv[0],
! 419: VTY_NEWLINE);
! 420:
! 421: return CMD_WARNING;
! 422: }
! 423:
! 424: DEFUN (rip_redistribute_type_metric,
! 425: rip_redistribute_type_metric_cmd,
! 426: "redistribute " QUAGGA_REDIST_STR_RIPD " metric <0-16>",
! 427: REDIST_STR
! 428: QUAGGA_REDIST_HELP_STR_RIPD
! 429: "Metric\n"
! 430: "Metric value\n")
! 431: {
! 432: int i;
! 433: int metric;
! 434:
! 435: metric = atoi (argv[1]);
! 436:
! 437: for (i = 0; redist_type[i].str; i++) {
! 438: if (strncmp(redist_type[i].str, argv[0],
! 439: redist_type[i].str_min_len) == 0)
! 440: {
! 441: rip_redistribute_metric_set (redist_type[i].type, metric);
! 442: zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type);
! 443: return CMD_SUCCESS;
! 444: }
! 445: }
! 446:
! 447: vty_out(vty, "Invalid type %s%s", argv[0],
! 448: VTY_NEWLINE);
! 449:
! 450: return CMD_WARNING;
! 451: }
! 452:
! 453: DEFUN (no_rip_redistribute_type_metric,
! 454: no_rip_redistribute_type_metric_cmd,
! 455: "no redistribute " QUAGGA_REDIST_STR_RIPD " metric <0-16>",
! 456: NO_STR
! 457: REDIST_STR
! 458: QUAGGA_REDIST_HELP_STR_RIPD
! 459: "Metric\n"
! 460: "Metric value\n")
! 461: {
! 462: int i;
! 463:
! 464: for (i = 0; redist_type[i].str; i++)
! 465: {
! 466: if (strncmp(redist_type[i].str, argv[0],
! 467: redist_type[i].str_min_len) == 0)
! 468: {
! 469: if (rip_metric_unset (redist_type[i].type, atoi(argv[1])))
! 470: return CMD_WARNING;
! 471: rip_redistribute_unset (redist_type[i].type);
! 472: return CMD_SUCCESS;
! 473: }
! 474: }
! 475:
! 476: vty_out(vty, "Invalid type %s%s", argv[0],
! 477: VTY_NEWLINE);
! 478:
! 479: return CMD_WARNING;
! 480: }
! 481:
! 482: DEFUN (rip_redistribute_type_metric_routemap,
! 483: rip_redistribute_type_metric_routemap_cmd,
! 484: "redistribute " QUAGGA_REDIST_STR_RIPD " metric <0-16> route-map WORD",
! 485: REDIST_STR
! 486: QUAGGA_REDIST_HELP_STR_RIPD
! 487: "Metric\n"
! 488: "Metric value\n"
! 489: "Route map reference\n"
! 490: "Pointer to route-map entries\n")
! 491: {
! 492: int i;
! 493: int metric;
! 494:
! 495: metric = atoi (argv[1]);
! 496:
! 497: for (i = 0; redist_type[i].str; i++) {
! 498: if (strncmp(redist_type[i].str, argv[0],
! 499: redist_type[i].str_min_len) == 0)
! 500: {
! 501: rip_redistribute_metric_set (redist_type[i].type, metric);
! 502: rip_routemap_set (redist_type[i].type, argv[2]);
! 503: zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type);
! 504: return CMD_SUCCESS;
! 505: }
! 506: }
! 507:
! 508: vty_out(vty, "Invalid type %s%s", argv[0],
! 509: VTY_NEWLINE);
! 510:
! 511: return CMD_WARNING;
! 512: }
! 513:
! 514:
! 515: DEFUN (no_rip_redistribute_type_metric_routemap,
! 516: no_rip_redistribute_type_metric_routemap_cmd,
! 517: "no redistribute " QUAGGA_REDIST_STR_RIPD
! 518: " metric <0-16> route-map WORD",
! 519: NO_STR
! 520: REDIST_STR
! 521: QUAGGA_REDIST_HELP_STR_RIPD
! 522: "Metric\n"
! 523: "Metric value\n"
! 524: "Route map reference\n"
! 525: "Pointer to route-map entries\n")
! 526: {
! 527: int i;
! 528:
! 529: for (i = 0; redist_type[i].str; i++)
! 530: {
! 531: if (strncmp(redist_type[i].str, argv[0],
! 532: redist_type[i].str_min_len) == 0)
! 533: {
! 534: if (rip_metric_unset (redist_type[i].type, atoi(argv[1])))
! 535: return CMD_WARNING;
! 536: if (rip_routemap_unset (redist_type[i].type, argv[2]))
! 537: {
! 538: rip_redistribute_metric_set(redist_type[i].type, atoi(argv[1]));
! 539: return CMD_WARNING;
! 540: }
! 541: rip_redistribute_unset (redist_type[i].type);
! 542: return CMD_SUCCESS;
! 543: }
! 544: }
! 545:
! 546: vty_out(vty, "Invalid type %s%s", argv[0],
! 547: VTY_NEWLINE);
! 548:
! 549: return CMD_WARNING;
! 550: }
! 551:
! 552: /* Default information originate. */
! 553:
! 554: DEFUN (rip_default_information_originate,
! 555: rip_default_information_originate_cmd,
! 556: "default-information originate",
! 557: "Control distribution of default route\n"
! 558: "Distribute a default route\n")
! 559: {
! 560: struct prefix_ipv4 p;
! 561:
! 562: if (! rip->default_information)
! 563: {
! 564: memset (&p, 0, sizeof (struct prefix_ipv4));
! 565: p.family = AF_INET;
! 566:
! 567: rip->default_information = 1;
! 568:
! 569: rip_redistribute_add (ZEBRA_ROUTE_RIP, RIP_ROUTE_DEFAULT, &p, 0,
! 570: NULL, 0, 0);
! 571: }
! 572:
! 573: return CMD_SUCCESS;
! 574: }
! 575:
! 576: DEFUN (no_rip_default_information_originate,
! 577: no_rip_default_information_originate_cmd,
! 578: "no default-information originate",
! 579: NO_STR
! 580: "Control distribution of default route\n"
! 581: "Distribute a default route\n")
! 582: {
! 583: struct prefix_ipv4 p;
! 584:
! 585: if (rip->default_information)
! 586: {
! 587: memset (&p, 0, sizeof (struct prefix_ipv4));
! 588: p.family = AF_INET;
! 589:
! 590: rip->default_information = 0;
! 591:
! 592: rip_redistribute_delete (ZEBRA_ROUTE_RIP, RIP_ROUTE_DEFAULT, &p, 0);
! 593: }
! 594:
! 595: return CMD_SUCCESS;
! 596: }
! 597:
! 598: /* RIP configuration write function. */
! 599: static int
! 600: config_write_zebra (struct vty *vty)
! 601: {
! 602: if (! zclient->enable)
! 603: {
! 604: vty_out (vty, "no router zebra%s", VTY_NEWLINE);
! 605: return 1;
! 606: }
! 607: else if (! zclient->redist[ZEBRA_ROUTE_RIP])
! 608: {
! 609: vty_out (vty, "router zebra%s", VTY_NEWLINE);
! 610: vty_out (vty, " no redistribute rip%s", VTY_NEWLINE);
! 611: return 1;
! 612: }
! 613: return 0;
! 614: }
! 615:
! 616: int
! 617: config_write_rip_redistribute (struct vty *vty, int config_mode)
! 618: {
! 619: int i;
! 620:
! 621: for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
! 622: if (i != zclient->redist_default && zclient->redist[i])
! 623: {
! 624: if (config_mode)
! 625: {
! 626: if (rip->route_map[i].metric_config)
! 627: {
! 628: if (rip->route_map[i].name)
! 629: vty_out (vty, " redistribute %s metric %d route-map %s%s",
! 630: zebra_route_string(i), rip->route_map[i].metric,
! 631: rip->route_map[i].name,
! 632: VTY_NEWLINE);
! 633: else
! 634: vty_out (vty, " redistribute %s metric %d%s",
! 635: zebra_route_string(i), rip->route_map[i].metric,
! 636: VTY_NEWLINE);
! 637: }
! 638: else
! 639: {
! 640: if (rip->route_map[i].name)
! 641: vty_out (vty, " redistribute %s route-map %s%s",
! 642: zebra_route_string(i), rip->route_map[i].name,
! 643: VTY_NEWLINE);
! 644: else
! 645: vty_out (vty, " redistribute %s%s", zebra_route_string(i),
! 646: VTY_NEWLINE);
! 647: }
! 648: }
! 649: else
! 650: vty_out (vty, " %s", zebra_route_string(i));
! 651: }
! 652: return 0;
! 653: }
! 654:
! 655: /* Zebra node structure. */
! 656: static struct cmd_node zebra_node =
! 657: {
! 658: ZEBRA_NODE,
! 659: "%s(config-router)# ",
! 660: };
! 661:
! 662: void
! 663: rip_zclient_init ()
! 664: {
! 665: /* Set default value to the zebra client structure. */
! 666: zclient = zclient_new ();
! 667: zclient_init (zclient, ZEBRA_ROUTE_RIP);
! 668: zclient->interface_add = rip_interface_add;
! 669: zclient->interface_delete = rip_interface_delete;
! 670: zclient->interface_address_add = rip_interface_address_add;
! 671: zclient->interface_address_delete = rip_interface_address_delete;
! 672: zclient->ipv4_route_add = rip_zebra_read_ipv4;
! 673: zclient->ipv4_route_delete = rip_zebra_read_ipv4;
! 674: zclient->interface_up = rip_interface_up;
! 675: zclient->interface_down = rip_interface_down;
! 676:
! 677: /* Install zebra node. */
! 678: install_node (&zebra_node, config_write_zebra);
! 679:
! 680: /* Install command elements to zebra node. */
! 681: install_element (CONFIG_NODE, &router_zebra_cmd);
! 682: install_element (CONFIG_NODE, &no_router_zebra_cmd);
! 683: install_default (ZEBRA_NODE);
! 684: install_element (ZEBRA_NODE, &rip_redistribute_rip_cmd);
! 685: install_element (ZEBRA_NODE, &no_rip_redistribute_rip_cmd);
! 686:
! 687: /* Install command elements to rip node. */
! 688: install_element (RIP_NODE, &rip_redistribute_type_cmd);
! 689: install_element (RIP_NODE, &rip_redistribute_type_routemap_cmd);
! 690: install_element (RIP_NODE, &rip_redistribute_type_metric_cmd);
! 691: install_element (RIP_NODE, &rip_redistribute_type_metric_routemap_cmd);
! 692: install_element (RIP_NODE, &no_rip_redistribute_type_cmd);
! 693: install_element (RIP_NODE, &no_rip_redistribute_type_routemap_cmd);
! 694: install_element (RIP_NODE, &no_rip_redistribute_type_metric_cmd);
! 695: install_element (RIP_NODE, &no_rip_redistribute_type_metric_routemap_cmd);
! 696: install_element (RIP_NODE, &rip_default_information_originate_cmd);
! 697: install_element (RIP_NODE, &no_rip_default_information_originate_cmd);
! 698: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rip_zebra.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 / ripd