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", opaquelen);
  78
  79         for (i = 0; i < opaquelen; i++) {
  80                 zlog_debug("0x%x ", olsa->mydata[i]);
  81         }
  82         zlog_debug(" ");
  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!");
 246                 return;
 247         }
 248
 249         /* API message common header part. */
 250         zlog_debug("API-msg [%s]: type(%d),len(%d),seq(%lu),data(%p),size(%zd)",
 251                    ospf_api_typename(msg->hdr.msgtype), msg->hdr.msgtype,
 252                    ntohs(msg->hdr.msglen),
 253                    (unsigned long)ntohl(msg->hdr.msgseq), STREAM_DATA(msg->s),
 254                    STREAM_SIZE(msg->s));
 255
 256         return;
 257 }
 258
 259 void msg_free(struct msg *msg)
 260 {
 261         if (msg->s)
 262                 stream_free(msg->s);
 263
 264         XFREE(MTYPE_OSPF_API_MSG, msg);
 265 }
 266
 267
 268 /* Set sequence number of message */
 269 void msg_set_seq(struct msg *msg, uint32_t seqnr)
 270 {
 271         assert(msg);
 272         msg->hdr.msgseq = htonl(seqnr);
 273 }
 274
 275 /* Get sequence number of message */
 276 uint32_t msg_get_seq(struct msg *msg)
 277 {
 278         assert(msg);
 279         return ntohl(msg->hdr.msgseq);
 280 }
 281
 282 /* -----------------------------------------------------------
 283  * Message fifo queues
 284  * -----------------------------------------------------------
 285  */
 286
 287 struct msg_fifo *msg_fifo_new(void)
 288 {
 289         return XCALLOC(MTYPE_OSPF_API_FIFO, sizeof(struct msg_fifo));
 290 }
 291
 292 /* Add new message to fifo. */
 293 void msg_fifo_push(struct msg_fifo *fifo, struct msg *msg)
 294 {
 295         if (fifo->tail)
 296                 fifo->tail->next = msg;
 297         else
 298                 fifo->head = msg;
 299
 300         fifo->tail = msg;
 301         fifo->count++;
 302 }
 303
 304
 305 /* Remove first message from fifo. */
 306 struct msg *msg_fifo_pop(struct msg_fifo *fifo)
 307 {
 308         struct msg *msg;
 309
 310         msg = fifo->head;
 311         if (msg) {
 312                 fifo->head = msg->next;
 313
 314                 if (fifo->head == NULL)
 315                         fifo->tail = NULL;
 316
 317                 fifo->count--;
 318         }
 319         return msg;
 320 }
 321
 322 /* Return first fifo entry but do not remove it. */
 323 struct msg *msg_fifo_head(struct msg_fifo *fifo)
 324 {
 325         return fifo->head;
 326 }
 327
 328 /* Flush message fifo. */
 329 void msg_fifo_flush(struct msg_fifo *fifo)
 330 {
 331         struct msg *op;
 332         struct msg *next;
 333
 334         for (op = fifo->head; op; op = next) {
 335                 next = op->next;
 336                 msg_free(op);
 337         }
 338
 339         fifo->head = fifo->tail = NULL;
 340         fifo->count = 0;
 341 }
 342
 343 /* Free API message fifo. */
 344 void msg_fifo_free(struct msg_fifo *fifo)
 345 {
 346         msg_fifo_flush(fifo);
 347
 348         XFREE(MTYPE_OSPF_API_FIFO, fifo);
 349 }
 350
 351 struct msg *msg_read(int fd)
 352 {
 353         struct msg *msg;
 354         struct apimsghdr hdr;
 355         uint8_t buf[OSPF_API_MAX_MSG_SIZE];
 356         int bodylen;
 357         int rlen;
 358
 359         /* Read message header */
 360         rlen = readn(fd, (uint8_t *)&hdr, sizeof(struct apimsghdr));
 361
 362         if (rlen < 0) {
 363                 zlog_warn("msg_read: readn %s", safe_strerror(errno));
 364                 return NULL;
 365         } else if (rlen == 0) {
 366                 zlog_warn("msg_read: Connection closed by peer");
 367                 return NULL;
 368         } else if (rlen != sizeof(struct apimsghdr)) {
 369                 zlog_warn("msg_read: Cannot read message header!");
 370                 return NULL;
 371         }
 372
 373         /* Check version of API protocol */
 374         if (hdr.version != OSPF_API_VERSION) {
 375                 zlog_warn("msg_read: OSPF API protocol version mismatch");
 376                 return NULL;
 377         }
 378
 379         /* Determine body length. */
 380         bodylen = ntohs(hdr.msglen);
 381         if (bodylen > 0) {
 382
 383                 /* Read message body */
 384                 rlen = readn(fd, buf, bodylen);
 385                 if (rlen < 0) {
 386                         zlog_warn("msg_read: readn %s", safe_strerror(errno));
 387                         return NULL;
 388                 } else if (rlen == 0) {
 389                         zlog_warn("msg_read: Connection closed by peer");
 390                         return NULL;
 391                 } else if (rlen != bodylen) {
 392                         zlog_warn("msg_read: Cannot read message body!");
 393                         return NULL;
 394                 }
 395         }
 396
 397         /* Allocate new message */
 398         msg = msg_new(hdr.msgtype, buf, ntohl(hdr.msgseq), ntohs(hdr.msglen));
 399
 400         return msg;
 401 }
 402
 403 int msg_write(int fd, struct msg *msg)
 404 {
 405         uint8_t buf[OSPF_API_MAX_MSG_SIZE];
 406         int l;
 407         int wlen;
 408
 409         assert(msg);
 410         assert(msg->s);
 411
 412         /* Length of message including header */
 413         l = sizeof(struct apimsghdr) + ntohs(msg->hdr.msglen);
 414
 415         /* Make contiguous memory buffer for message */
 416         memcpy(buf, &msg->hdr, sizeof(struct apimsghdr));
 417         memcpy(buf + sizeof(struct apimsghdr), STREAM_DATA(msg->s),
 418                ntohs(msg->hdr.msglen));
 419
 420         wlen = writen(fd, buf, l);
 421         if (wlen < 0) {
 422                 zlog_warn("msg_write: writen %s", safe_strerror(errno));
 423                 return -1;
 424         } else if (wlen == 0) {
 425                 zlog_warn("msg_write: Connection closed by peer");
 426                 return -1;
 427         } else if (wlen != l) {
 428                 zlog_warn("msg_write: Cannot write API message");
 429                 return -1;
 430         }
 431         return 0;
 432 }
 433
 434 /* -----------------------------------------------------------
 435  * Specific messages
 436  * -----------------------------------------------------------
 437  */
 438
 439 struct msg *new_msg_register_opaque_type(uint32_t seqnum, uint8_t ltype,
 440                                          uint8_t otype)
 441 {
 442         struct msg_register_opaque_type rmsg;
 443
 444         rmsg.lsatype = ltype;
 445         rmsg.opaquetype = otype;
 446         memset(&rmsg.pad, 0, sizeof(rmsg.pad));
 447
 448         return msg_new(MSG_REGISTER_OPAQUETYPE, &rmsg, seqnum,
 449                        sizeof(struct msg_register_opaque_type));
 450 }
 451
 452 struct msg *new_msg_register_event(uint32_t seqnum,
 453                                    struct lsa_filter_type *filter)
 454 {
 455         uint8_t buf[OSPF_API_MAX_MSG_SIZE];
 456         struct msg_register_event *emsg;
 457         unsigned int len;
 458
 459         emsg = (struct msg_register_event *)buf;
 460         len = sizeof(struct msg_register_event)
 461               + filter->num_areas * sizeof(struct in_addr);
 462         emsg->filter.typemask = htons(filter->typemask);
 463         emsg->filter.origin = filter->origin;
 464         emsg->filter.num_areas = filter->num_areas;
 465         if (len > sizeof(buf))
 466                 len = sizeof(buf);
 467         /* API broken - missing memcpy to fill data */
 468         return msg_new(MSG_REGISTER_EVENT, emsg, seqnum, len);
 469 }
 470
 471 struct msg *new_msg_sync_lsdb(uint32_t seqnum, struct lsa_filter_type *filter)
 472 {
 473         uint8_t buf[OSPF_API_MAX_MSG_SIZE];
 474         struct msg_sync_lsdb *smsg;
 475         unsigned int len;
 476
 477         smsg = (struct msg_sync_lsdb *)buf;
 478         len = sizeof(struct msg_sync_lsdb)
 479               + filter->num_areas * sizeof(struct in_addr);
 480         smsg->filter.typemask = htons(filter->typemask);
 481         smsg->filter.origin = filter->origin;
 482         smsg->filter.num_areas = filter->num_areas;
 483         if (len > sizeof(buf))
 484                 len = sizeof(buf);
 485         /* API broken - missing memcpy to fill data */
 486         return msg_new(MSG_SYNC_LSDB, smsg, seqnum, len);
 487 }
 488
 489
 490 struct msg *new_msg_originate_request(uint32_t seqnum, struct in_addr ifaddr,
 491                                       struct in_addr area_id,
 492                                       struct lsa_header *data)
 493 {
 494         struct msg_originate_request *omsg;
 495         unsigned int omsglen;
 496         char buf[OSPF_API_MAX_MSG_SIZE];
 497         size_t off_data = offsetof(struct msg_originate_request, data);
 498         size_t data_maxs = sizeof(buf) - off_data;
 499         struct lsa_header *omsg_data = (struct lsa_header *)&buf[off_data];
 500
 501         omsg = (struct msg_originate_request *)buf;
 502         omsg->ifaddr = ifaddr;
 503         omsg->area_id = area_id;
 504
 505         omsglen = ntohs(data->length);
 506         if (omsglen > data_maxs)
 507                 omsglen = data_maxs;
 508         memcpy(omsg_data, data, omsglen);
 509         omsglen += sizeof(struct msg_originate_request)
 510                    - sizeof(struct lsa_header);
 511
 512         return msg_new(MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
 513 }
 514
 515 struct msg *new_msg_delete_request(uint32_t seqnum, struct in_addr area_id,
 516                                    uint8_t lsa_type, uint8_t opaque_type,
 517                                    uint32_t opaque_id)
 518 {
 519         struct msg_delete_request dmsg;
 520         dmsg.area_id = area_id;
 521         dmsg.lsa_type = lsa_type;
 522         dmsg.opaque_type = opaque_type;
 523         dmsg.opaque_id = htonl(opaque_id);
 524         memset(&dmsg.pad, 0, sizeof(dmsg.pad));
 525
 526         return msg_new(MSG_DELETE_REQUEST, &dmsg, seqnum,
 527                        sizeof(struct msg_delete_request));
 528 }
 529
 530
 531 struct msg *new_msg_reply(uint32_t seqnr, uint8_t rc)
 532 {
 533         struct msg *msg;
 534         struct msg_reply rmsg;
 535
 536         /* Set return code */
 537         rmsg.errcode = rc;
 538         memset(&rmsg.pad, 0, sizeof(rmsg.pad));
 539
 540         msg = msg_new(MSG_REPLY, &rmsg, seqnr, sizeof(struct msg_reply));
 541
 542         return msg;
 543 }
 544
 545 struct msg *new_msg_ready_notify(uint32_t seqnr, uint8_t lsa_type,
 546                                  uint8_t opaque_type, struct in_addr addr)
 547 {
 548         struct msg_ready_notify rmsg;
 549
 550         rmsg.lsa_type = lsa_type;
 551         rmsg.opaque_type = opaque_type;
 552         memset(&rmsg.pad, 0, sizeof(rmsg.pad));
 553         rmsg.addr = addr;
 554
 555         return msg_new(MSG_READY_NOTIFY, &rmsg, seqnr,
 556                        sizeof(struct msg_ready_notify));
 557 }
 558
 559 struct msg *new_msg_new_if(uint32_t seqnr, struct in_addr ifaddr,
 560                            struct in_addr area_id)
 561 {
 562         struct msg_new_if nmsg;
 563
 564         nmsg.ifaddr = ifaddr;
 565         nmsg.area_id = area_id;
 566
 567         return msg_new(MSG_NEW_IF, &nmsg, seqnr, sizeof(struct msg_new_if));
 568 }
 569
 570 struct msg *new_msg_del_if(uint32_t seqnr, struct in_addr ifaddr)
 571 {
 572         struct msg_del_if dmsg;
 573
 574         dmsg.ifaddr = ifaddr;
 575
 576         return msg_new(MSG_DEL_IF, &dmsg, seqnr, sizeof(struct msg_del_if));
 577 }
 578
 579 struct msg *new_msg_ism_change(uint32_t seqnr, struct in_addr ifaddr,
 580                                struct in_addr area_id, uint8_t status)
 581 {
 582         struct msg_ism_change imsg;
 583
 584         imsg.ifaddr = ifaddr;
 585         imsg.area_id = area_id;
 586         imsg.status = status;
 587         memset(&imsg.pad, 0, sizeof(imsg.pad));
 588
 589         return msg_new(MSG_ISM_CHANGE, &imsg, seqnr,
 590                        sizeof(struct msg_ism_change));
 591 }
 592
 593 struct msg *new_msg_nsm_change(uint32_t seqnr, struct in_addr ifaddr,
 594                                struct in_addr nbraddr, struct in_addr router_id,
 595                                uint8_t status)
 596 {
 597         struct msg_nsm_change nmsg;
 598
 599         nmsg.ifaddr = ifaddr;
 600         nmsg.nbraddr = nbraddr;
 601         nmsg.router_id = router_id;
 602         nmsg.status = status;
 603         memset(&nmsg.pad, 0, sizeof(nmsg.pad));
 604
 605         return msg_new(MSG_NSM_CHANGE, &nmsg, seqnr,
 606                        sizeof(struct msg_nsm_change));
 607 }
 608
 609 struct msg *new_msg_lsa_change_notify(uint8_t msgtype, uint32_t seqnum,
 610                                       struct in_addr ifaddr,
 611                                       struct in_addr area_id,
 612                                       uint8_t is_self_originated,
 613                                       struct lsa_header *data)
 614 {
 615         uint8_t buf[OSPF_API_MAX_MSG_SIZE];
 616         struct msg_lsa_change_notify *nmsg;
 617         unsigned int len;
 618         size_t off_data = offsetof(struct msg_lsa_change_notify, data);
 619         size_t data_maxs = sizeof(buf) - off_data;
 620         struct lsa_header *nmsg_data = (struct lsa_header *)&buf[off_data];
 621
 622         assert(data);
 623
 624         nmsg = (struct msg_lsa_change_notify *)buf;
 625         nmsg->ifaddr = ifaddr;
 626         nmsg->area_id = area_id;
 627         nmsg->is_self_originated = is_self_originated;
 628         memset(&nmsg->pad, 0, sizeof(nmsg->pad));
 629
 630         len = ntohs(data->length);
 631         if (len > data_maxs)
 632                 len = data_maxs;
 633         memcpy(nmsg_data, data, len);
 634         len += sizeof(struct msg_lsa_change_notify) - sizeof(struct lsa_header);
 635
 636         return msg_new(msgtype, nmsg, seqnum, len);
 637 }
 638
 639 #endif /* SUPPORT_OSPF_API */