ospfd/ospf_api.c

   1 /*
   2  * API message handling module for OSPF daemon and client.
   3  * Copyright (C) 2001, 2002 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 #ifdef SUPPORT_OSPF_API
  25
  26 #include "linklist.h"
  27 #include "prefix.h"
  28 #include "if.h"
  29 #include "table.h"
  30 #include "memory.h"
  31 #include "command.h"
  32 #include "vty.h"
  33 #include "stream.h"
  34 #include "log.h"
  35 #include "thread.h"
  36 #include "hash.h"
  37 #include "sockunion.h" /* for inet_aton() */
  38 #include "buffer.h"
  39 #include "network.h"
  40
  41 #include "ospfd/ospfd.h"
  42 #include "ospfd/ospf_interface.h"
  43 #include "ospfd/ospf_ism.h"
  44 #include "ospfd/ospf_asbr.h"
  45 #include "ospfd/ospf_lsa.h"
  46 #include "ospfd/ospf_lsdb.h"
  47 #include "ospfd/ospf_neighbor.h"
  48 #include "ospfd/ospf_nsm.h"
  49 #include "ospfd/ospf_flood.h"
  50 #include "ospfd/ospf_packet.h"
  51 #include "ospfd/ospf_spf.h"
  52 #include "ospfd/ospf_dump.h"
  53 #include "ospfd/ospf_route.h"
  54 #include "ospfd/ospf_ase.h"
  55 #include "ospfd/ospf_zebra.h"
  56
  57 #include "ospfd/ospf_api.h"
  58
  59
  60 /* For debugging only, will be removed */
  61 void api_opaque_lsa_print(struct lsa_header *data)
  62 {
  63         struct opaque_lsa {
  64                 struct lsa_header header;
  65                 uint8_t mydata[];
  66         };
  67
  68         struct opaque_lsa *olsa;
  69         int opaquelen;
  70         int i;
  71
  72         ospf_lsa_header_dump(data);
  73
  74         olsa = (struct opaque_lsa *)data;
  75
  76         opaquelen = ntohs(data->length) - OSPF_LSA_HEADER_SIZE;
  77         zlog_debug("apiserver_lsa_print: opaquelen=%d\n", opaquelen);
  78
  79         for (i = 0; i < opaquelen; i++) {
  80                 zlog_debug("0x%x ", olsa->mydata[i]);
  81         }
  82         zlog_debug("\n");
  83 }
  84
  85 /* -----------------------------------------------------------
  86  * Generic messages
  87  * -----------------------------------------------------------
  88  */
  89
  90 struct msg *msg_new(uint8_t msgtype, void *msgbody, uint32_t seqnum,
  91                     uint16_t msglen)
  92 {
  93         struct msg *new;
  94
  95         new = XCALLOC(MTYPE_OSPF_API_MSG, sizeof(struct msg));
  96
  97         new->hdr.version = OSPF_API_VERSION;
  98         new->hdr.msgtype = msgtype;
  99         new->hdr.msglen = htons(msglen);
 100         new->hdr.msgseq = htonl(seqnum);
 101
 102         new->s = stream_new(msglen);
 103         assert(new->s);
 104         stream_put(new->s, msgbody, msglen);
 105
 106         return new;
 107 }
 108
 109
 110 /* Duplicate a message by copying content. */
 111 struct msg *msg_dup(struct msg *msg)
 112 {
 113         struct msg *new;
 114
 115         assert(msg);
 116
 117         new = msg_new(msg->hdr.msgtype, STREAM_DATA(msg->s),
 118                       ntohl(msg->hdr.msgseq), ntohs(msg->hdr.msglen));
 119         return new;
 120 }
 121
 122
 123 /* XXX only for testing, will be removed */
 124
 125 struct nametab {
 126         int value;
 127         const char *name;
 128 };
 129
 130 const char *ospf_api_typename(int msgtype)
 131 {
 132         struct nametab NameTab[] = {
 133                 {
 134                         MSG_REGISTER_OPAQUETYPE, "Register opaque-type",
 135                 },
 136                 {
 137                         MSG_UNREGISTER_OPAQUETYPE, "Unregister opaque-type",
 138                 },
 139                 {
 140                         MSG_REGISTER_EVENT, "Register event",
 141                 },
 142                 {
 143                         MSG_SYNC_LSDB, "Sync LSDB",
 144                 },
 145                 {
 146                         MSG_ORIGINATE_REQUEST, "Originate request",
 147                 },
 148                 {
 149                         MSG_DELETE_REQUEST, "Delete request",
 150                 },
 151                 {
 152                         MSG_REPLY, "Reply",
 153                 },
 154                 {
 155                         MSG_READY_NOTIFY, "Ready notify",
 156                 },
 157                 {
 158                         MSG_LSA_UPDATE_NOTIFY, "LSA update notify",
 159                 },
 160                 {
 161                         MSG_LSA_DELETE_NOTIFY, "LSA delete notify",
 162                 },
 163                 {
 164                         MSG_NEW_IF, "New interface",
 165                 },
 166                 {
 167                         MSG_DEL_IF, "Del interface",
 168                 },
 169                 {
 170                         MSG_ISM_CHANGE, "ISM change",
 171                 },
 172                 {
 173                         MSG_NSM_CHANGE, "NSM change",
 174                 },
 175         };
 176
 177         int i, n = array_size(NameTab);
 178         const char *name = NULL;
 179
 180         for (i = 0; i < n; i++) {
 181                 if (NameTab[i].value == msgtype) {
 182                         name = NameTab[i].name;
 183                         break;
 184                 }
 185         }
 186
 187         return name ? name : "?";
 188 }
 189
 190 const char *ospf_api_errname(int errcode)
 191 {
 192         struct nametab NameTab[] = {
 193                 {
 194                         OSPF_API_OK, "OK",
 195                 },
 196                 {
 197                         OSPF_API_NOSUCHINTERFACE, "No such interface",
 198                 },
 199                 {
 200                         OSPF_API_NOSUCHAREA, "No such area",
 201                 },
 202                 {
 203                         OSPF_API_NOSUCHLSA, "No such LSA",
 204                 },
 205                 {
 206                         OSPF_API_ILLEGALLSATYPE, "Illegal LSA type",
 207                 },
 208                 {
 209                         OSPF_API_OPAQUETYPEINUSE, "Opaque type in use",
 210                 },
 211                 {
 212                         OSPF_API_OPAQUETYPENOTREGISTERED,
 213                         "Opaque type not registered",
 214                 },
 215                 {
 216                         OSPF_API_NOTREADY, "Not ready",
 217                 },
 218                 {
 219                         OSPF_API_NOMEMORY, "No memory",
 220                 },
 221                 {
 222                         OSPF_API_ERROR, "Other error",
 223                 },
 224                 {
 225                         OSPF_API_UNDEF, "Undefined",
 226                 },
 227         };
 228
 229         int i, n = array_size(NameTab);
 230         const char *name = NULL;
 231
 232         for (i = 0; i < n; i++) {
 233                 if (NameTab[i].value == errcode) {
 234                         name = NameTab[i].name;
 235                         break;
 236                 }
 237         }
 238
 239         return name ? name : "?";
 240 }
 241
 242 void msg_print(struct msg *msg)
 243 {
 244         if (!msg) {
 245                 zlog_debug("msg_print msg=NULL!\n");
 246                 return;
 247         }
 248
 249 #ifdef ORIGINAL_CODING
 250         zlog_debug(
 251                 "msg=%p msgtype=%d msglen=%d msgseq=%d streamdata=%p streamsize=%lu\n",
 252                 msg, msg->hdr.msgtype, ntohs(msg->hdr.msglen),
 253                 ntohl(msg->hdr.msgseq), STREAM_DATA(msg->s),
 254                 STREAM_SIZE(msg->s));
 255 #else /* ORIGINAL_CODING */
 256         /* API message common header part. */
 257         zlog_debug("API-msg [%s]: type(%d),len(%d),seq(%lu),data(%p),size(%zd)",
 258                    ospf_api_typename(msg->hdr.msgtype), msg->hdr.msgtype,
 259                    ntohs(msg->hdr.msglen),
 260                    (unsigned long)ntohl(msg->hdr.msgseq), STREAM_DATA(msg->s),
 261                    STREAM_SIZE(msg->s));
 262
 263 /* API message body part. */
 264 #ifdef ndef
 265         /* Generic Hex/Ascii dump */
 266         DumpBuf(STREAM_DATA(msg->s), STREAM_SIZE(msg->s)); /* Sorry, deleted! */
 267 #else  /* ndef */
 268 /* Message-type dependent dump function. */
 269 #endif /* ndef */
 270
 271         return;
 272 #endif /* ORIGINAL_CODING */
 273 }
 274
 275 void msg_free(struct msg *msg)
 276 {
 277         if (msg->s)
 278                 stream_free(msg->s);
 279
 280         XFREE(MTYPE_OSPF_API_MSG, msg);
 281 }
 282
 283
 284 /* Set sequence number of message */
 285 void msg_set_seq(struct msg *msg, uint32_t seqnr)
 286 {
 287         assert(msg);
 288         msg->hdr.msgseq = htonl(seqnr);
 289 }
 290
 291 /* Get sequence number of message */
 292 uint32_t msg_get_seq(struct msg *msg)
 293 {
 294         assert(msg);
 295         return ntohl(msg->hdr.msgseq);
 296 }
 297
 298 /* -----------------------------------------------------------
 299  * Message fifo queues
 300  * -----------------------------------------------------------
 301  */
 302
 303 struct msg_fifo *msg_fifo_new()
 304 {
 305         return XCALLOC(MTYPE_OSPF_API_FIFO, sizeof(struct msg_fifo));
 306 }
 307
 308 /* Add new message to fifo. */
 309 void msg_fifo_push(struct msg_fifo *fifo, struct msg *msg)
 310 {
 311         if (fifo->tail)
 312                 fifo->tail->next = msg;
 313         else
 314                 fifo->head = msg;
 315
 316         fifo->tail = msg;
 317         fifo->count++;
 318 }
 319
 320
 321 /* Remove first message from fifo. */
 322 struct msg *msg_fifo_pop(struct msg_fifo *fifo)
 323 {
 324         struct msg *msg;
 325
 326         msg = fifo->head;
 327         if (msg) {
 328                 fifo->head = msg->next;
 329
 330                 if (fifo->head == NULL)
 331                         fifo->tail = NULL;
 332
 333                 fifo->count--;
 334         }
 335         return msg;
 336 }
 337
 338 /* Return first fifo entry but do not remove it. */
 339 struct msg *msg_fifo_head(struct msg_fifo *fifo)
 340 {
 341         return fifo->head;
 342 }
 343
 344 /* Flush message fifo. */
 345 void msg_fifo_flush(struct msg_fifo *fifo)
 346 {
 347         struct msg *op;
 348         struct msg *next;
 349
 350         for (op = fifo->head; op; op = next) {
 351                 next = op->next;
 352                 msg_free(op);
 353         }
 354
 355         fifo->head = fifo->tail = NULL;
 356         fifo->count = 0;
 357 }
 358
 359 /* Free API message fifo. */
 360 void msg_fifo_free(struct msg_fifo *fifo)
 361 {
 362         msg_fifo_flush(fifo);
 363
 364         XFREE(MTYPE_OSPF_API_FIFO, fifo);
 365 }
 366
 367 struct msg *msg_read(int fd)
 368 {
 369         struct msg *msg;
 370         struct apimsghdr hdr;
 371         uint8_t buf[OSPF_API_MAX_MSG_SIZE];
 372         int bodylen;
 373         int rlen;
 374
 375         /* Read message header */
 376         rlen = readn(fd, (uint8_t *)&hdr, sizeof(struct apimsghdr));
 377
 378         if (rlen < 0) {
 379                 zlog_warn("msg_read: readn %s", safe_strerror(errno));
 380                 return NULL;
 381         } else if (rlen == 0) {
 382                 zlog_warn("msg_read: Connection closed by peer");
 383                 return NULL;
 384         } else if (rlen != sizeof(struct apimsghdr)) {
 385                 zlog_warn("msg_read: Cannot read message header!");
 386                 return NULL;
 387         }
 388
 389         /* Check version of API protocol */
 390         if (hdr.version != OSPF_API_VERSION) {
 391                 zlog_warn("msg_read: OSPF API protocol version mismatch");
 392                 return NULL;
 393         }
 394
 395         /* Determine body length. */
 396         bodylen = ntohs(hdr.msglen);
 397         if (bodylen > 0) {
 398
 399                 /* Read message body */
 400                 rlen = readn(fd, buf, bodylen);
 401                 if (rlen < 0) {
 402                         zlog_warn("msg_read: readn %s", safe_strerror(errno));
 403                         return NULL;
 404                 } else if (rlen == 0) {
 405                         zlog_warn("msg_read: Connection closed by peer");
 406                         return NULL;
 407                 } else if (rlen != bodylen) {
 408                         zlog_warn("msg_read: Cannot read message body!");
 409                         return NULL;
 410                 }
 411         }
 412
 413         /* Allocate new message */
 414         msg = msg_new(hdr.msgtype, buf, ntohl(hdr.msgseq), ntohs(hdr.msglen));
 415
 416         return msg;
 417 }
 418
 419 int msg_write(int fd, struct msg *msg)
 420 {
 421         uint8_t buf[OSPF_API_MAX_MSG_SIZE];
 422         int l;
 423         int wlen;
 424
 425         assert(msg);
 426         assert(msg->s);
 427
 428         /* Length of message including header */
 429         l = sizeof(struct apimsghdr) + ntohs(msg->hdr.msglen);
 430
 431         /* Make contiguous memory buffer for message */
 432         memcpy(buf, &msg->hdr, sizeof(struct apimsghdr));
 433         memcpy(buf + sizeof(struct apimsghdr), STREAM_DATA(msg->s),
 434                ntohs(msg->hdr.msglen));
 435
 436         wlen = writen(fd, buf, l);
 437         if (wlen < 0) {
 438                 zlog_warn("msg_write: writen %s", safe_strerror(errno));
 439                 return -1;
 440         } else if (wlen == 0) {
 441                 zlog_warn("msg_write: Connection closed by peer");
 442                 return -1;
 443         } else if (wlen != l) {
 444                 zlog_warn("msg_write: Cannot write API message");
 445                 return -1;
 446         }
 447         return 0;
 448 }
 449
 450 /* -----------------------------------------------------------
 451  * Specific messages
 452  * -----------------------------------------------------------
 453  */
 454
 455 struct msg *new_msg_register_opaque_type(uint32_t seqnum, uint8_t ltype,
 456                                          uint8_t otype)
 457 {
 458         struct msg_register_opaque_type rmsg;
 459
 460         rmsg.lsatype = ltype;
 461         rmsg.opaquetype = otype;
 462         memset(&rmsg.pad, 0, sizeof(rmsg.pad));
 463
 464         return msg_new(MSG_REGISTER_OPAQUETYPE, &rmsg, seqnum,
 465                        sizeof(struct msg_register_opaque_type));
 466 }
 467
 468 struct msg *new_msg_register_event(uint32_t seqnum,
 469                                    struct lsa_filter_type *filter)
 470 {
 471         uint8_t buf[OSPF_API_MAX_MSG_SIZE];
 472         struct msg_register_event *emsg;
 473         unsigned int len;
 474
 475         emsg = (struct msg_register_event *)buf;
 476         len = sizeof(struct msg_register_event)
 477               + filter->num_areas * sizeof(struct in_addr);
 478         emsg->filter.typemask = htons(filter->typemask);
 479         emsg->filter.origin = filter->origin;
 480         emsg->filter.num_areas = filter->num_areas;
 481         if (len > sizeof(buf))
 482                 len = sizeof(buf);
 483         /* API broken - missing memcpy to fill data */
 484         return msg_new(MSG_REGISTER_EVENT, emsg, seqnum, len);
 485 }
 486
 487 struct msg *new_msg_sync_lsdb(uint32_t seqnum, struct lsa_filter_type *filter)
 488 {
 489         uint8_t buf[OSPF_API_MAX_MSG_SIZE];
 490         struct msg_sync_lsdb *smsg;
 491         unsigned int len;
 492
 493         smsg = (struct msg_sync_lsdb *)buf;
 494         len = sizeof(struct msg_sync_lsdb)
 495               + filter->num_areas * sizeof(struct in_addr);
 496         smsg->filter.typemask = htons(filter->typemask);
 497         smsg->filter.origin = filter->origin;
 498         smsg->filter.num_areas = filter->num_areas;
 499         if (len > sizeof(buf))
 500                 len = sizeof(buf);
 501         /* API broken - missing memcpy to fill data */
 502         return msg_new(MSG_SYNC_LSDB, smsg, seqnum, len);
 503 }
 504
 505
 506 struct msg *new_msg_originate_request(uint32_t seqnum, struct in_addr ifaddr,
 507                                       struct in_addr area_id,
 508                                       struct lsa_header *data)
 509 {
 510         struct msg_originate_request *omsg;
 511         unsigned int omsglen;
 512         char buf[OSPF_API_MAX_MSG_SIZE];
 513         size_t off_data = offsetof(struct msg_originate_request, data);
 514         size_t data_maxs = sizeof(buf) - off_data;
 515         struct lsa_header *omsg_data = (struct lsa_header *)&buf[off_data];
 516
 517         omsg = (struct msg_originate_request *)buf;
 518         omsg->ifaddr = ifaddr;
 519         omsg->area_id = area_id;
 520
 521         omsglen = ntohs(data->length);
 522         if (omsglen > data_maxs)
 523                 omsglen = data_maxs;
 524         memcpy(omsg_data, data, omsglen);
 525         omsglen += sizeof(struct msg_originate_request)
 526                    - sizeof(struct lsa_header);
 527
 528         return msg_new(MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
 529 }
 530
 531 struct msg *new_msg_delete_request(uint32_t seqnum, struct in_addr area_id,
 532                                    uint8_t lsa_type, uint8_t opaque_type,
 533                                    uint32_t opaque_id)
 534 {
 535         struct msg_delete_request dmsg;
 536         dmsg.area_id = area_id;
 537         dmsg.lsa_type = lsa_type;
 538         dmsg.opaque_type = opaque_type;
 539         dmsg.opaque_id = htonl(opaque_id);
 540         memset(&dmsg.pad, 0, sizeof(dmsg.pad));
 541
 542         return msg_new(MSG_DELETE_REQUEST, &dmsg, seqnum,
 543                        sizeof(struct msg_delete_request));
 544 }
 545
 546
 547 struct msg *new_msg_reply(uint32_t seqnr, uint8_t rc)
 548 {
 549         struct msg *msg;
 550         struct msg_reply rmsg;
 551
 552         /* Set return code */
 553         rmsg.errcode = rc;
 554         memset(&rmsg.pad, 0, sizeof(rmsg.pad));
 555
 556         msg = msg_new(MSG_REPLY, &rmsg, seqnr, sizeof(struct msg_reply));
 557
 558         return msg;
 559 }
 560
 561 struct msg *new_msg_ready_notify(uint32_t seqnr, uint8_t lsa_type,
 562                                  uint8_t opaque_type, struct in_addr addr)
 563 {
 564         struct msg_ready_notify rmsg;
 565
 566         rmsg.lsa_type = lsa_type;
 567         rmsg.opaque_type = opaque_type;
 568         memset(&rmsg.pad, 0, sizeof(rmsg.pad));
 569         rmsg.addr = addr;
 570
 571         return msg_new(MSG_READY_NOTIFY, &rmsg, seqnr,
 572                        sizeof(struct msg_ready_notify));
 573 }
 574
 575 struct msg *new_msg_new_if(uint32_t seqnr, struct in_addr ifaddr,
 576                            struct in_addr area_id)
 577 {
 578         struct msg_new_if nmsg;
 579
 580         nmsg.ifaddr = ifaddr;
 581         nmsg.area_id = area_id;
 582
 583         return msg_new(MSG_NEW_IF, &nmsg, seqnr, sizeof(struct msg_new_if));
 584 }
 585
 586 struct msg *new_msg_del_if(uint32_t seqnr, struct in_addr ifaddr)
 587 {
 588         struct msg_del_if dmsg;
 589
 590         dmsg.ifaddr = ifaddr;
 591
 592         return msg_new(MSG_DEL_IF, &dmsg, seqnr, sizeof(struct msg_del_if));
 593 }
 594
 595 struct msg *new_msg_ism_change(uint32_t seqnr, struct in_addr ifaddr,
 596                                struct in_addr area_id, uint8_t status)
 597 {
 598         struct msg_ism_change imsg;
 599
 600         imsg.ifaddr = ifaddr;
 601         imsg.area_id = area_id;
 602         imsg.status = status;
 603         memset(&imsg.pad, 0, sizeof(imsg.pad));
 604
 605         return msg_new(MSG_ISM_CHANGE, &imsg, seqnr,
 606                        sizeof(struct msg_ism_change));
 607 }
 608
 609 struct msg *new_msg_nsm_change(uint32_t seqnr, struct in_addr ifaddr,
 610                                struct in_addr nbraddr, struct in_addr router_id,
 611                                uint8_t status)
 612 {
 613         struct msg_nsm_change nmsg;
 614
 615         nmsg.ifaddr = ifaddr;
 616         nmsg.nbraddr = nbraddr;
 617         nmsg.router_id = router_id;
 618         nmsg.status = status;
 619         memset(&nmsg.pad, 0, sizeof(nmsg.pad));
 620
 621         return msg_new(MSG_NSM_CHANGE, &nmsg, seqnr,
 622                        sizeof(struct msg_nsm_change));
 623 }
 624
 625 struct msg *new_msg_lsa_change_notify(uint8_t msgtype, uint32_t seqnum,
 626                                       struct in_addr ifaddr,
 627                                       struct in_addr area_id,
 628                                       uint8_t is_self_originated,
 629                                       struct lsa_header *data)
 630 {
 631         uint8_t buf[OSPF_API_MAX_MSG_SIZE];
 632         struct msg_lsa_change_notify *nmsg;
 633         unsigned int len;
 634         size_t off_data = offsetof(struct msg_lsa_change_notify, data);
 635         size_t data_maxs = sizeof(buf) - off_data;
 636         struct lsa_header *nmsg_data = (struct lsa_header *)&buf[off_data];
 637
 638         assert(data);
 639
 640         nmsg = (struct msg_lsa_change_notify *)buf;
 641         nmsg->ifaddr = ifaddr;
 642         nmsg->area_id = area_id;
 643         nmsg->is_self_originated = is_self_originated;
 644         memset(&nmsg->pad, 0, sizeof(nmsg->pad));
 645
 646         len = ntohs(data->length);
 647         if (len > data_maxs)
 648                 len = data_maxs;
 649         memcpy(nmsg_data, data, len);
 650         len += sizeof(struct msg_lsa_change_notify) - sizeof(struct lsa_header);
 651
 652         return msg_new(msgtype, nmsg, seqnum, len);
 653 }
 654
 655 #endif /* SUPPORT_OSPF_API */