ospfclient/ospf_apiclient.c

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