Annotation of embedaddon/quagga/ospfclient/ospf_apiclient.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Client side of OSPF API.
! 3: * Copyright (C) 2001, 2002, 2003 Ralph Keller
! 4: *
! 5: * This file is part of GNU Zebra.
! 6: *
! 7: * GNU Zebra is free software; you can redistribute it and/or modify
! 8: * it under the terms of the GNU General Public License as published
! 9: * by the Free Software Foundation; either version 2, or (at your
! 10: * option) any 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: */
! 22:
! 23: #include <zebra.h>
! 24:
! 25: #include <lib/version.h>
! 26: #include "getopt.h"
! 27: #include "thread.h"
! 28: #include "prefix.h"
! 29: #include "linklist.h"
! 30: #include "if.h"
! 31: #include "vector.h"
! 32: #include "vty.h"
! 33: #include "command.h"
! 34: #include "filter.h"
! 35: #include "stream.h"
! 36: #include "log.h"
! 37: #include "memory.h"
! 38:
! 39: #include "ospfd/ospfd.h"
! 40: #include "ospfd/ospf_interface.h"
! 41: #include "ospfd/ospf_asbr.h"
! 42: #include "ospfd/ospf_lsa.h"
! 43: #include "ospfd/ospf_opaque.h"
! 44: #include "ospfd/ospf_lsdb.h"
! 45: #include "ospfd/ospf_neighbor.h"
! 46: #include "ospfd/ospf_dump.h"
! 47: #include "ospfd/ospf_zebra.h"
! 48: #include "ospfd/ospf_api.h"
! 49:
! 50: #include "ospf_apiclient.h"
! 51:
! 52: /* Backlog for listen */
! 53: #define BACKLOG 5
! 54:
! 55: /* -----------------------------------------------------------
! 56: * Forward declarations
! 57: * -----------------------------------------------------------
! 58: */
! 59:
! 60: void ospf_apiclient_handle_reply (struct ospf_apiclient *oclient,
! 61: struct msg *msg);
! 62: void ospf_apiclient_handle_update_notify (struct ospf_apiclient *oclient,
! 63: struct msg *msg);
! 64: void ospf_apiclient_handle_delete_notify (struct ospf_apiclient *oclient,
! 65: struct msg *msg);
! 66:
! 67: /* -----------------------------------------------------------
! 68: * Initialization
! 69: * -----------------------------------------------------------
! 70: */
! 71:
! 72: static unsigned short
! 73: ospf_apiclient_getport (void)
! 74: {
! 75: struct servent *sp = getservbyname ("ospfapi", "tcp");
! 76:
! 77: return sp ? ntohs (sp->s_port) : OSPF_API_SYNC_PORT;
! 78: }
! 79:
! 80: /* -----------------------------------------------------------
! 81: * Followings are functions for connection management
! 82: * -----------------------------------------------------------
! 83: */
! 84:
! 85: struct ospf_apiclient *
! 86: ospf_apiclient_connect (char *host, int syncport)
! 87: {
! 88: struct sockaddr_in myaddr_sync;
! 89: struct sockaddr_in myaddr_async;
! 90: struct sockaddr_in peeraddr;
! 91: struct hostent *hp;
! 92: struct ospf_apiclient *new;
! 93: int size = 0;
! 94: unsigned int peeraddrlen;
! 95: int async_server_sock;
! 96: int fd1, fd2;
! 97: int ret;
! 98: int on = 1;
! 99:
! 100: /* There are two connections between the client and the server.
! 101: First the client opens a connection for synchronous requests/replies
! 102: to the server. The server will accept this connection and
! 103: as a reaction open a reverse connection channel for
! 104: asynchronous messages. */
! 105:
! 106: async_server_sock = socket (AF_INET, SOCK_STREAM, 0);
! 107: if (async_server_sock < 0)
! 108: {
! 109: fprintf (stderr,
! 110: "ospf_apiclient_connect: creating async socket failed\n");
! 111: return NULL;
! 112: }
! 113:
! 114: /* Prepare socket for asynchronous messages */
! 115: /* Initialize async address structure */
! 116: memset (&myaddr_async, 0, sizeof (struct sockaddr_in));
! 117: myaddr_async.sin_family = AF_INET;
! 118: myaddr_async.sin_addr.s_addr = htonl (INADDR_ANY);
! 119: myaddr_async.sin_port = htons (syncport+1);
! 120: size = sizeof (struct sockaddr_in);
! 121: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
! 122: myaddr_async.sin_len = size;
! 123: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
! 124:
! 125: /* This is a server socket, reuse addr and port */
! 126: ret = setsockopt (async_server_sock, SOL_SOCKET,
! 127: SO_REUSEADDR, (void *) &on, sizeof (on));
! 128: if (ret < 0)
! 129: {
! 130: fprintf (stderr, "ospf_apiclient_connect: SO_REUSEADDR failed\n");
! 131: close (async_server_sock);
! 132: return NULL;
! 133: }
! 134:
! 135: #ifdef SO_REUSEPORT
! 136: ret = setsockopt (async_server_sock, SOL_SOCKET, SO_REUSEPORT,
! 137: (void *) &on, sizeof (on));
! 138: if (ret < 0)
! 139: {
! 140: fprintf (stderr, "ospf_apiclient_connect: SO_REUSEPORT failed\n");
! 141: close (async_server_sock);
! 142: return NULL;
! 143: }
! 144: #endif /* SO_REUSEPORT */
! 145:
! 146: /* Bind socket to address structure */
! 147: ret = bind (async_server_sock, (struct sockaddr *) &myaddr_async, size);
! 148: if (ret < 0)
! 149: {
! 150: fprintf (stderr, "ospf_apiclient_connect: bind async socket failed\n");
! 151: close (async_server_sock);
! 152: return NULL;
! 153: }
! 154:
! 155: /* Wait for reverse channel connection establishment from server */
! 156: ret = listen (async_server_sock, BACKLOG);
! 157: if (ret < 0)
! 158: {
! 159: fprintf (stderr, "ospf_apiclient_connect: listen: %s\n", safe_strerror (errno));
! 160: close (async_server_sock);
! 161: return NULL;
! 162: }
! 163:
! 164: /* Make connection for synchronous requests and connect to server */
! 165: /* Resolve address of server */
! 166: hp = gethostbyname (host);
! 167: if (!hp)
! 168: {
! 169: fprintf (stderr, "ospf_apiclient_connect: no such host %s\n", host);
! 170: close (async_server_sock);
! 171: return NULL;
! 172: }
! 173:
! 174: fd1 = socket (AF_INET, SOCK_STREAM, 0);
! 175: if (fd1 < 0)
! 176: {
! 177: fprintf (stderr,
! 178: "ospf_apiclient_connect: creating sync socket failed\n");
! 179: return NULL;
! 180: }
! 181:
! 182:
! 183: /* Reuse addr and port */
! 184: ret = setsockopt (fd1, SOL_SOCKET,
! 185: SO_REUSEADDR, (void *) &on, sizeof (on));
! 186: if (ret < 0)
! 187: {
! 188: fprintf (stderr, "ospf_apiclient_connect: SO_REUSEADDR failed\n");
! 189: close (fd1);
! 190: return NULL;
! 191: }
! 192:
! 193: #ifdef SO_REUSEPORT
! 194: ret = setsockopt (fd1, SOL_SOCKET, SO_REUSEPORT,
! 195: (void *) &on, sizeof (on));
! 196: if (ret < 0)
! 197: {
! 198: fprintf (stderr, "ospf_apiclient_connect: SO_REUSEPORT failed\n");
! 199: close (fd1);
! 200: return NULL;
! 201: }
! 202: #endif /* SO_REUSEPORT */
! 203:
! 204:
! 205: /* Bind sync socket to address structure. This is needed since we
! 206: want the sync port number on a fixed port number. The reverse
! 207: async channel will be at this port+1 */
! 208:
! 209: memset (&myaddr_sync, 0, sizeof (struct sockaddr_in));
! 210: myaddr_sync.sin_family = AF_INET;
! 211: myaddr_sync.sin_port = htons (syncport);
! 212: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
! 213: myaddr_sync.sin_len = sizeof (struct sockaddr_in);
! 214: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
! 215:
! 216: ret = bind (fd1, (struct sockaddr *) &myaddr_sync, size);
! 217: if (ret < 0)
! 218: {
! 219: fprintf (stderr, "ospf_apiclient_connect: bind sync socket failed\n");
! 220: close (fd1);
! 221: return NULL;
! 222: }
! 223:
! 224: /* Prepare address structure for connect */
! 225: memcpy (&myaddr_sync.sin_addr, hp->h_addr, hp->h_length);
! 226: myaddr_sync.sin_family = AF_INET;
! 227: myaddr_sync.sin_port = htons(ospf_apiclient_getport ());
! 228: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
! 229: myaddr_sync.sin_len = sizeof (struct sockaddr_in);
! 230: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
! 231:
! 232: /* Now establish synchronous channel with OSPF daemon */
! 233: ret = connect (fd1, (struct sockaddr *) &myaddr_sync,
! 234: sizeof (struct sockaddr_in));
! 235: if (ret < 0)
! 236: {
! 237: fprintf (stderr, "ospf_apiclient_connect: sync connect failed\n");
! 238: close (async_server_sock);
! 239: close (fd1);
! 240: return NULL;
! 241: }
! 242:
! 243: /* Accept reverse connection */
! 244: peeraddrlen = sizeof (struct sockaddr_in);
! 245: memset (&peeraddr, 0, peeraddrlen);
! 246:
! 247: fd2 =
! 248: accept (async_server_sock, (struct sockaddr *) &peeraddr, &peeraddrlen);
! 249: if (fd2 < 0)
! 250: {
! 251: fprintf (stderr, "ospf_apiclient_connect: accept async failed\n");
! 252: close (async_server_sock);
! 253: close (fd1);
! 254: return NULL;
! 255: }
! 256:
! 257: /* Server socket is not needed anymore since we are not accepting more
! 258: connections */
! 259: close (async_server_sock);
! 260:
! 261: /* Create new client-side instance */
! 262: new = XCALLOC (MTYPE_OSPF_APICLIENT, sizeof (struct ospf_apiclient));
! 263:
! 264: /* Initialize socket descriptors for sync and async channels */
! 265: new->fd_sync = fd1;
! 266: new->fd_async = fd2;
! 267:
! 268: return new;
! 269: }
! 270:
! 271: int
! 272: ospf_apiclient_close (struct ospf_apiclient *oclient)
! 273: {
! 274:
! 275: if (oclient->fd_sync >= 0)
! 276: {
! 277: close (oclient->fd_sync);
! 278: }
! 279:
! 280: if (oclient->fd_async >= 0)
! 281: {
! 282: close (oclient->fd_async);
! 283: }
! 284:
! 285: /* Free client structure */
! 286: XFREE (MTYPE_OSPF_APICLIENT, oclient);
! 287: return 0;
! 288: }
! 289:
! 290: /* -----------------------------------------------------------
! 291: * Followings are functions to send a request to OSPFd
! 292: * -----------------------------------------------------------
! 293: */
! 294:
! 295: /* Send synchronous request, wait for reply */
! 296: static int
! 297: ospf_apiclient_send_request (struct ospf_apiclient *oclient, struct msg *msg)
! 298: {
! 299: u_int32_t reqseq;
! 300: struct msg_reply *msgreply;
! 301: int rc;
! 302:
! 303: /* NB: Given "msg" is freed inside this function. */
! 304:
! 305: /* Remember the sequence number of the request */
! 306: reqseq = ntohl (msg->hdr.msgseq);
! 307:
! 308: /* Write message to OSPFd */
! 309: rc = msg_write (oclient->fd_sync, msg);
! 310: msg_free (msg);
! 311:
! 312: if (rc < 0)
! 313: {
! 314: return -1;
! 315: }
! 316:
! 317: /* Wait for reply *//* NB: New "msg" is allocated by "msg_read()". */
! 318: msg = msg_read (oclient->fd_sync);
! 319: if (!msg)
! 320: return -1;
! 321:
! 322: assert (msg->hdr.msgtype == MSG_REPLY);
! 323: assert (ntohl (msg->hdr.msgseq) == reqseq);
! 324:
! 325: msgreply = (struct msg_reply *) STREAM_DATA (msg->s);
! 326: rc = msgreply->errcode;
! 327: msg_free (msg);
! 328:
! 329: return rc;
! 330: }
! 331:
! 332:
! 333: /* -----------------------------------------------------------
! 334: * Helper functions
! 335: * -----------------------------------------------------------
! 336: */
! 337:
! 338: static u_int32_t
! 339: ospf_apiclient_get_seqnr (void)
! 340: {
! 341: static u_int32_t seqnr = MIN_SEQ;
! 342: u_int32_t tmp;
! 343:
! 344: tmp = seqnr;
! 345: /* Increment sequence number */
! 346: if (seqnr < MAX_SEQ)
! 347: {
! 348: seqnr++;
! 349: }
! 350: else
! 351: {
! 352: seqnr = MIN_SEQ;
! 353: }
! 354: return tmp;
! 355: }
! 356:
! 357: /* -----------------------------------------------------------
! 358: * API to access OSPF daemon by client applications.
! 359: * -----------------------------------------------------------
! 360: */
! 361:
! 362: /*
! 363: * Synchronous request to register opaque type.
! 364: */
! 365: int
! 366: ospf_apiclient_register_opaque_type (struct ospf_apiclient *cl,
! 367: u_char ltype, u_char otype)
! 368: {
! 369: struct msg *msg;
! 370: int rc;
! 371:
! 372: /* just put 1 as a sequence number. */
! 373: msg = new_msg_register_opaque_type (ospf_apiclient_get_seqnr (),
! 374: ltype, otype);
! 375: if (!msg)
! 376: {
! 377: fprintf (stderr, "new_msg_register_opaque_type failed\n");
! 378: return -1;
! 379: }
! 380:
! 381: rc = ospf_apiclient_send_request (cl, msg);
! 382: return rc;
! 383: }
! 384:
! 385: /*
! 386: * Synchronous request to synchronize with OSPF's LSDB.
! 387: * Two steps required: register_event in order to get
! 388: * dynamic updates and LSDB_Sync.
! 389: */
! 390: int
! 391: ospf_apiclient_sync_lsdb (struct ospf_apiclient *oclient)
! 392: {
! 393: struct msg *msg;
! 394: int rc;
! 395: struct lsa_filter_type filter;
! 396:
! 397: filter.typemask = 0xFFFF; /* all LSAs */
! 398: filter.origin = ANY_ORIGIN;
! 399: filter.num_areas = 0; /* all Areas. */
! 400:
! 401: msg = new_msg_register_event (ospf_apiclient_get_seqnr (), &filter);
! 402: if (!msg)
! 403: {
! 404: fprintf (stderr, "new_msg_register_event failed\n");
! 405: return -1;
! 406: }
! 407: rc = ospf_apiclient_send_request (oclient, msg);
! 408:
! 409: if (rc != 0)
! 410: goto out;
! 411:
! 412: msg = new_msg_sync_lsdb (ospf_apiclient_get_seqnr (), &filter);
! 413: if (!msg)
! 414: {
! 415: fprintf (stderr, "new_msg_sync_lsdb failed\n");
! 416: return -1;
! 417: }
! 418: rc = ospf_apiclient_send_request (oclient, msg);
! 419:
! 420: out:
! 421: return rc;
! 422: }
! 423:
! 424: /*
! 425: * Synchronous request to originate or update an LSA.
! 426: */
! 427:
! 428: int
! 429: ospf_apiclient_lsa_originate (struct ospf_apiclient *oclient,
! 430: struct in_addr ifaddr,
! 431: struct in_addr area_id,
! 432: u_char lsa_type,
! 433: u_char opaque_type, u_int32_t opaque_id,
! 434: void *opaquedata, int opaquelen)
! 435: {
! 436: struct msg *msg;
! 437: int rc;
! 438: u_char buf[OSPF_MAX_LSA_SIZE];
! 439: struct lsa_header *lsah;
! 440: u_int32_t tmp;
! 441:
! 442:
! 443: /* We can only originate opaque LSAs */
! 444: if (!IS_OPAQUE_LSA (lsa_type))
! 445: {
! 446: fprintf (stderr, "Cannot originate non-opaque LSA type %d\n", lsa_type);
! 447: return OSPF_API_ILLEGALLSATYPE;
! 448: }
! 449:
! 450: /* Make a new LSA from parameters */
! 451: lsah = (struct lsa_header *) buf;
! 452: lsah->ls_age = 0;
! 453: lsah->options = 0;
! 454: lsah->type = lsa_type;
! 455:
! 456: tmp = SET_OPAQUE_LSID (opaque_type, opaque_id);
! 457: lsah->id.s_addr = htonl (tmp);
! 458: lsah->adv_router.s_addr = 0;
! 459: lsah->ls_seqnum = 0;
! 460: lsah->checksum = 0;
! 461: lsah->length = htons (sizeof (struct lsa_header) + opaquelen);
! 462:
! 463: memcpy (((u_char *) lsah) + sizeof (struct lsa_header), opaquedata,
! 464: opaquelen);
! 465:
! 466: msg = new_msg_originate_request (ospf_apiclient_get_seqnr (),
! 467: ifaddr, area_id, lsah);
! 468: if (!msg)
! 469: {
! 470: fprintf (stderr, "new_msg_originate_request failed\n");
! 471: return OSPF_API_NOMEMORY;
! 472: }
! 473:
! 474: rc = ospf_apiclient_send_request (oclient, msg);
! 475: return rc;
! 476: }
! 477:
! 478: int
! 479: ospf_apiclient_lsa_delete (struct ospf_apiclient *oclient,
! 480: struct in_addr area_id, u_char lsa_type,
! 481: u_char opaque_type, u_int32_t opaque_id)
! 482: {
! 483: struct msg *msg;
! 484: int rc;
! 485:
! 486: /* Only opaque LSA can be deleted */
! 487: if (!IS_OPAQUE_LSA (lsa_type))
! 488: {
! 489: fprintf (stderr, "Cannot delete non-opaque LSA type %d\n", lsa_type);
! 490: return OSPF_API_ILLEGALLSATYPE;
! 491: }
! 492:
! 493: /* opaque_id is in host byte order and will be converted
! 494: * to network byte order by new_msg_delete_request */
! 495: msg = new_msg_delete_request (ospf_apiclient_get_seqnr (),
! 496: area_id, lsa_type, opaque_type, opaque_id);
! 497:
! 498: rc = ospf_apiclient_send_request (oclient, msg);
! 499: return rc;
! 500: }
! 501:
! 502: /* -----------------------------------------------------------
! 503: * Followings are handlers for messages from OSPF daemon
! 504: * -----------------------------------------------------------
! 505: */
! 506:
! 507: static void
! 508: ospf_apiclient_handle_ready (struct ospf_apiclient *oclient, struct msg *msg)
! 509: {
! 510: struct msg_ready_notify *r;
! 511: r = (struct msg_ready_notify *) STREAM_DATA (msg->s);
! 512:
! 513: /* Invoke registered callback function. */
! 514: if (oclient->ready_notify)
! 515: {
! 516: (oclient->ready_notify) (r->lsa_type, r->opaque_type, r->addr);
! 517: }
! 518: }
! 519:
! 520: static void
! 521: ospf_apiclient_handle_new_if (struct ospf_apiclient *oclient, struct msg *msg)
! 522: {
! 523: struct msg_new_if *n;
! 524: n = (struct msg_new_if *) STREAM_DATA (msg->s);
! 525:
! 526: /* Invoke registered callback function. */
! 527: if (oclient->new_if)
! 528: {
! 529: (oclient->new_if) (n->ifaddr, n->area_id);
! 530: }
! 531: }
! 532:
! 533: static void
! 534: ospf_apiclient_handle_del_if (struct ospf_apiclient *oclient, struct msg *msg)
! 535: {
! 536: struct msg_del_if *d;
! 537: d = (struct msg_del_if *) STREAM_DATA (msg->s);
! 538:
! 539: /* Invoke registered callback function. */
! 540: if (oclient->del_if)
! 541: {
! 542: (oclient->del_if) (d->ifaddr);
! 543: }
! 544: }
! 545:
! 546: static void
! 547: ospf_apiclient_handle_ism_change (struct ospf_apiclient *oclient,
! 548: struct msg *msg)
! 549: {
! 550: struct msg_ism_change *m;
! 551: m = (struct msg_ism_change *) STREAM_DATA (msg->s);
! 552:
! 553: /* Invoke registered callback function. */
! 554: if (oclient->ism_change)
! 555: {
! 556: (oclient->ism_change) (m->ifaddr, m->area_id, m->status);
! 557: }
! 558:
! 559: }
! 560:
! 561: static void
! 562: ospf_apiclient_handle_nsm_change (struct ospf_apiclient *oclient,
! 563: struct msg *msg)
! 564: {
! 565: struct msg_nsm_change *m;
! 566: m = (struct msg_nsm_change *) STREAM_DATA (msg->s);
! 567:
! 568: /* Invoke registered callback function. */
! 569: if (oclient->nsm_change)
! 570: {
! 571: (oclient->nsm_change) (m->ifaddr, m->nbraddr, m->router_id, m->status);
! 572: }
! 573: }
! 574:
! 575: static void
! 576: ospf_apiclient_handle_lsa_update (struct ospf_apiclient *oclient,
! 577: struct msg *msg)
! 578: {
! 579: struct msg_lsa_change_notify *cn;
! 580: struct lsa_header *lsa;
! 581: int lsalen;
! 582:
! 583: cn = (struct msg_lsa_change_notify *) STREAM_DATA (msg->s);
! 584:
! 585: /* Extract LSA from message */
! 586: lsalen = ntohs (cn->data.length);
! 587: lsa = XMALLOC (MTYPE_OSPF_APICLIENT, lsalen);
! 588: if (!lsa)
! 589: {
! 590: fprintf (stderr, "LSA update: Cannot allocate memory for LSA\n");
! 591: return;
! 592: }
! 593: memcpy (lsa, &(cn->data), lsalen);
! 594:
! 595: /* Invoke registered update callback function */
! 596: if (oclient->update_notify)
! 597: {
! 598: (oclient->update_notify) (cn->ifaddr, cn->area_id,
! 599: cn->is_self_originated, lsa);
! 600: }
! 601:
! 602: /* free memory allocated by ospf apiclient library */
! 603: XFREE (MTYPE_OSPF_APICLIENT, lsa);
! 604: }
! 605:
! 606: static void
! 607: ospf_apiclient_handle_lsa_delete (struct ospf_apiclient *oclient,
! 608: struct msg *msg)
! 609: {
! 610: struct msg_lsa_change_notify *cn;
! 611: struct lsa_header *lsa;
! 612: int lsalen;
! 613:
! 614: cn = (struct msg_lsa_change_notify *) STREAM_DATA (msg->s);
! 615:
! 616: /* Extract LSA from message */
! 617: lsalen = ntohs (cn->data.length);
! 618: lsa = XMALLOC (MTYPE_OSPF_APICLIENT, lsalen);
! 619: if (!lsa)
! 620: {
! 621: fprintf (stderr, "LSA delete: Cannot allocate memory for LSA\n");
! 622: return;
! 623: }
! 624: memcpy (lsa, &(cn->data), lsalen);
! 625:
! 626: /* Invoke registered update callback function */
! 627: if (oclient->delete_notify)
! 628: {
! 629: (oclient->delete_notify) (cn->ifaddr, cn->area_id,
! 630: cn->is_self_originated, lsa);
! 631: }
! 632:
! 633: /* free memory allocated by ospf apiclient library */
! 634: XFREE (MTYPE_OSPF_APICLIENT, lsa);
! 635: }
! 636:
! 637: static void
! 638: ospf_apiclient_msghandle (struct ospf_apiclient *oclient, struct msg *msg)
! 639: {
! 640: /* Call message handler function. */
! 641: switch (msg->hdr.msgtype)
! 642: {
! 643: case MSG_READY_NOTIFY:
! 644: ospf_apiclient_handle_ready (oclient, msg);
! 645: break;
! 646: case MSG_NEW_IF:
! 647: ospf_apiclient_handle_new_if (oclient, msg);
! 648: break;
! 649: case MSG_DEL_IF:
! 650: ospf_apiclient_handle_del_if (oclient, msg);
! 651: break;
! 652: case MSG_ISM_CHANGE:
! 653: ospf_apiclient_handle_ism_change (oclient, msg);
! 654: break;
! 655: case MSG_NSM_CHANGE:
! 656: ospf_apiclient_handle_nsm_change (oclient, msg);
! 657: break;
! 658: case MSG_LSA_UPDATE_NOTIFY:
! 659: ospf_apiclient_handle_lsa_update (oclient, msg);
! 660: break;
! 661: case MSG_LSA_DELETE_NOTIFY:
! 662: ospf_apiclient_handle_lsa_delete (oclient, msg);
! 663: break;
! 664: default:
! 665: fprintf (stderr, "ospf_apiclient_read: Unknown message type: %d\n",
! 666: msg->hdr.msgtype);
! 667: break;
! 668: }
! 669: }
! 670:
! 671: /* -----------------------------------------------------------
! 672: * Callback handler registration
! 673: * -----------------------------------------------------------
! 674: */
! 675:
! 676: void
! 677: ospf_apiclient_register_callback (struct ospf_apiclient *oclient,
! 678: void (*ready_notify) (u_char lsa_type,
! 679: u_char opaque_type,
! 680: struct in_addr addr),
! 681: void (*new_if) (struct in_addr ifaddr,
! 682: struct in_addr area_id),
! 683: void (*del_if) (struct in_addr ifaddr),
! 684: void (*ism_change) (struct in_addr ifaddr,
! 685: struct in_addr area_id,
! 686: u_char status),
! 687: void (*nsm_change) (struct in_addr ifaddr,
! 688: struct in_addr nbraddr,
! 689: struct in_addr
! 690: router_id,
! 691: u_char status),
! 692: void (*update_notify) (struct in_addr
! 693: ifaddr,
! 694: struct in_addr
! 695: area_id,
! 696: u_char self_origin,
! 697: struct lsa_header *
! 698: lsa),
! 699: void (*delete_notify) (struct in_addr
! 700: ifaddr,
! 701: struct in_addr
! 702: area_id,
! 703: u_char self_origin,
! 704: struct lsa_header *
! 705: lsa))
! 706: {
! 707: assert (oclient);
! 708: assert (update_notify);
! 709:
! 710: /* Register callback function */
! 711: oclient->ready_notify = ready_notify;
! 712: oclient->new_if = new_if;
! 713: oclient->del_if = del_if;
! 714: oclient->ism_change = ism_change;
! 715: oclient->nsm_change = nsm_change;
! 716: oclient->update_notify = update_notify;
! 717: oclient->delete_notify = delete_notify;
! 718: }
! 719:
! 720: /* -----------------------------------------------------------
! 721: * Asynchronous message handling
! 722: * -----------------------------------------------------------
! 723: */
! 724:
! 725: int
! 726: ospf_apiclient_handle_async (struct ospf_apiclient *oclient)
! 727: {
! 728: struct msg *msg;
! 729:
! 730: /* Get a message */
! 731: msg = msg_read (oclient->fd_async);
! 732:
! 733: if (!msg)
! 734: {
! 735: /* Connection broke down */
! 736: return -1;
! 737: }
! 738:
! 739: /* Handle message */
! 740: ospf_apiclient_msghandle (oclient, msg);
! 741:
! 742: /* Don't forget to free this message */
! 743: msg_free (msg);
! 744:
! 745: return 0;
! 746: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ospf_apiclient.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 / ospfclient