Annotation of embedaddon/bird2/proto/ospf/lsupd.c, revision 1.1
1.1 ! misho 1: /*
! 2: * BIRD -- OSPF
! 3: *
! 4: * (c) 2000--2004 Ondrej Filip <feela@network.cz>
! 5: * (c) 2009--2014 Ondrej Zajicek <santiago@crfreenet.org>
! 6: * (c) 2009--2014 CZ.NIC z.s.p.o.
! 7: *
! 8: * Can be freely distributed and used under the terms of the GNU GPL.
! 9: */
! 10:
! 11: #include "ospf.h"
! 12:
! 13:
! 14: /*
! 15: struct ospf_lsupd_packet
! 16: {
! 17: struct ospf_packet hdr;
! 18: // union ospf_auth auth;
! 19:
! 20: u32 lsa_count;
! 21: void lsas[];
! 22: };
! 23: */
! 24:
! 25:
! 26: void
! 27: ospf_dump_lsahdr(struct ospf_proto *p, struct ospf_lsa_header *lsa_n)
! 28: {
! 29: struct ospf_lsa_header lsa;
! 30: u32 lsa_etype;
! 31:
! 32: lsa_ntoh_hdr(lsa_n, &lsa);
! 33: lsa_etype = lsa_get_etype(&lsa, p);
! 34:
! 35: log(L_TRACE "%s: LSA Type: %04x, Id: %R, Rt: %R, Seq: %08x, Age: %u, Sum: %04x",
! 36: p->p.name, lsa_etype, lsa.id, lsa.rt, lsa.sn, lsa.age, lsa.checksum);
! 37: }
! 38:
! 39: void
! 40: ospf_dump_common(struct ospf_proto *p, struct ospf_packet *pkt)
! 41: {
! 42: log(L_TRACE "%s: length %d", p->p.name, ntohs(pkt->length));
! 43: log(L_TRACE "%s: router %R", p->p.name, ntohl(pkt->routerid));
! 44: }
! 45:
! 46: static inline uint
! 47: ospf_lsupd_hdrlen(struct ospf_proto *p)
! 48: {
! 49: return ospf_pkt_hdrlen(p) + 4; /* + u32 lsa count field */
! 50: }
! 51:
! 52: static inline u32
! 53: ospf_lsupd_get_lsa_count(struct ospf_packet *pkt, uint hdrlen)
! 54: {
! 55: u32 *c = ((void *) pkt) + hdrlen - 4;
! 56: return ntohl(*c);
! 57: }
! 58:
! 59: static inline void
! 60: ospf_lsupd_set_lsa_count(struct ospf_packet *pkt, uint hdrlen, u32 val)
! 61: {
! 62: u32 *c = ((void *) pkt) + hdrlen - 4;
! 63: *c = htonl(val);
! 64: }
! 65:
! 66: static inline void
! 67: ospf_lsupd_body(struct ospf_proto *p, struct ospf_packet *pkt,
! 68: uint *offset, uint *lsa_count)
! 69: {
! 70: uint hlen = ospf_lsupd_hdrlen(p);
! 71: *offset = hlen;
! 72: *lsa_count = ospf_lsupd_get_lsa_count(pkt, hlen);
! 73: }
! 74:
! 75: static void
! 76: ospf_dump_lsupd(struct ospf_proto *p, struct ospf_packet *pkt)
! 77: {
! 78: uint offset, plen, i, lsa_count, lsa_len;
! 79:
! 80: ASSERT(pkt->type == LSUPD_P);
! 81: ospf_dump_common(p, pkt);
! 82:
! 83: plen = ntohs(pkt->length);
! 84: ospf_lsupd_body(p, pkt, &offset, &lsa_count);
! 85: for (i = 0; i < lsa_count; i++)
! 86: {
! 87: if ((offset + sizeof(struct ospf_lsa_header)) > plen)
! 88: goto invalid;
! 89:
! 90: struct ospf_lsa_header *lsa = ((void *) pkt) + offset;
! 91: lsa_len = ntohs(lsa->length);
! 92:
! 93: if (((lsa_len % 4) != 0) || (lsa_len <= sizeof(struct ospf_lsa_header)))
! 94: goto invalid;
! 95:
! 96: ospf_dump_lsahdr(p, lsa);
! 97: offset += lsa_len;
! 98: }
! 99: return;
! 100:
! 101: invalid:
! 102: log(L_TRACE "%s: LSA invalid", p->p.name);
! 103: return;
! 104: }
! 105:
! 106:
! 107: static inline void
! 108: ospf_lsa_lsrq_down(struct top_hash_entry *req, struct ospf_neighbor *n)
! 109: {
! 110: if (req == n->lsrqi)
! 111: n->lsrqi = SNODE_NEXT(req);
! 112:
! 113: s_rem_node(SNODE req);
! 114: ospf_hash_delete(n->lsrqh, req);
! 115:
! 116: if (EMPTY_SLIST(n->lsrql))
! 117: {
! 118: tm_stop(n->lsrq_timer);
! 119:
! 120: if (n->state == NEIGHBOR_LOADING)
! 121: ospf_neigh_sm(n, INM_LOADDONE);
! 122: }
! 123: }
! 124:
! 125: static inline void
! 126: ospf_lsa_lsrt_up(struct top_hash_entry *en, struct ospf_neighbor *n)
! 127: {
! 128: struct top_hash_entry *ret = ospf_hash_get_entry(n->lsrth, en);
! 129:
! 130: if (!SNODE_VALID(ret))
! 131: {
! 132: en->ret_count++;
! 133: s_add_tail(&n->lsrtl, SNODE ret);
! 134: }
! 135:
! 136: ret->lsa = en->lsa;
! 137: ret->lsa_body = LSA_BODY_DUMMY;
! 138:
! 139: if (!tm_active(n->lsrt_timer))
! 140: tm_start(n->lsrt_timer, n->ifa->rxmtint S);
! 141: }
! 142:
! 143: void
! 144: ospf_lsa_lsrt_down_(struct top_hash_entry *en, struct ospf_neighbor *n, struct top_hash_entry *ret)
! 145: {
! 146: if (en)
! 147: en->ret_count--;
! 148:
! 149: s_rem_node(SNODE ret);
! 150: ospf_hash_delete(n->lsrth, ret);
! 151:
! 152: if (EMPTY_SLIST(n->lsrtl))
! 153: tm_stop(n->lsrt_timer);
! 154: }
! 155:
! 156: static inline int
! 157: ospf_lsa_lsrt_down(struct top_hash_entry *en, struct ospf_neighbor *n)
! 158: {
! 159: struct top_hash_entry *ret = ospf_hash_find_entry(n->lsrth, en);
! 160:
! 161: if (ret)
! 162: ospf_lsa_lsrt_down_(en, n, ret);
! 163:
! 164: return ret != NULL;
! 165: }
! 166:
! 167: void
! 168: ospf_add_flushed_to_lsrt(struct ospf_proto *p, struct ospf_neighbor *n)
! 169: {
! 170: struct top_hash_entry *en;
! 171:
! 172: WALK_SLIST(en, p->lsal)
! 173: if ((en->lsa.age == LSA_MAXAGE) && (en->lsa_body != NULL) &&
! 174: lsa_flooding_allowed(en->lsa_type, en->domain, n->ifa) &&
! 175: lsa_is_acceptable(en->lsa_type, n, p))
! 176: ospf_lsa_lsrt_up(en, n);
! 177:
! 178: /* If we found any flushed LSA, we send them ASAP */
! 179: if (tm_active(n->lsrt_timer))
! 180: tm_start(n->lsrt_timer, 0);
! 181: }
! 182:
! 183: static int ospf_flood_lsupd(struct ospf_proto *p, struct top_hash_entry **lsa_list, uint lsa_count, uint lsa_min_count, struct ospf_iface *ifa);
! 184:
! 185: static void
! 186: ospf_enqueue_lsa(struct ospf_proto *p, struct top_hash_entry *en, struct ospf_iface *ifa)
! 187: {
! 188: /* Exception for local Grace-LSA, they are flooded synchronously */
! 189: if ((en->lsa_type == LSA_T_GR) && (en->lsa.rt == p->router_id))
! 190: {
! 191: ospf_flood_lsupd(p, &en, 1, 1, ifa);
! 192: return;
! 193: }
! 194:
! 195: if (ifa->flood_queue_used == ifa->flood_queue_size)
! 196: {
! 197: /* If we already have full queue, we send some packets */
! 198: uint sent = ospf_flood_lsupd(p, ifa->flood_queue, ifa->flood_queue_used, ifa->flood_queue_used / 2, ifa);
! 199: uint i;
! 200:
! 201: for (i = 0; i < sent; i++)
! 202: ifa->flood_queue[i]->ret_count--;
! 203:
! 204: ifa->flood_queue_used -= sent;
! 205: memmove(ifa->flood_queue, ifa->flood_queue + sent, ifa->flood_queue_used * sizeof(void *));
! 206: bzero(ifa->flood_queue + ifa->flood_queue_used, sent * sizeof(void *));
! 207: }
! 208:
! 209: en->ret_count++;
! 210: ifa->flood_queue[ifa->flood_queue_used] = en;
! 211: ifa->flood_queue_used++;
! 212:
! 213: if (!ev_active(p->flood_event))
! 214: ev_schedule(p->flood_event);
! 215: }
! 216:
! 217: void
! 218: ospf_flood_event(void *ptr)
! 219: {
! 220: struct ospf_proto *p = ptr;
! 221: struct ospf_iface *ifa;
! 222: int i, count;
! 223:
! 224: WALK_LIST(ifa, p->iface_list)
! 225: {
! 226: if (ifa->flood_queue_used == 0)
! 227: continue;
! 228:
! 229: count = ifa->flood_queue_used;
! 230: ospf_flood_lsupd(p, ifa->flood_queue, count, count, ifa);
! 231:
! 232: for (i = 0; i < count; i++)
! 233: ifa->flood_queue[i]->ret_count--;
! 234:
! 235: ifa->flood_queue_used = 0;
! 236: bzero(ifa->flood_queue, count * sizeof(void *));
! 237: }
! 238: }
! 239:
! 240:
! 241: /**
! 242: * ospf_flood_lsa - send LSA to the neighbors
! 243: * @p: OSPF protocol instance
! 244: * @en: LSA entry
! 245: * @from: neighbor than sent this LSA (or NULL if LSA is local)
! 246: *
! 247: * return value - was the LSA flooded back?
! 248: */
! 249: int
! 250: ospf_flood_lsa(struct ospf_proto *p, struct top_hash_entry *en, struct ospf_neighbor *from)
! 251: {
! 252: struct ospf_iface *ifa;
! 253: struct ospf_neighbor *n;
! 254:
! 255: /* RFC 2328 13.3 */
! 256:
! 257: int back = 0;
! 258: WALK_LIST(ifa, p->iface_list)
! 259: {
! 260: if (ifa->stub)
! 261: continue;
! 262:
! 263: if (! lsa_flooding_allowed(en->lsa_type, en->domain, ifa))
! 264: continue;
! 265:
! 266: DBG("Wanted to flood LSA: Type: %u, ID: %R, RT: %R, SN: 0x%x, Age %u\n",
! 267: hh->type, hh->id, hh->rt, hh->sn, hh->age);
! 268:
! 269: int used = 0;
! 270: WALK_LIST(n, ifa->neigh_list)
! 271: {
! 272: /* 13.3 (1a) */
! 273: if (n->state < NEIGHBOR_EXCHANGE)
! 274: continue;
! 275:
! 276: /* 13.3 (1b) */
! 277: if (n->state < NEIGHBOR_FULL)
! 278: {
! 279: struct top_hash_entry *req = ospf_hash_find_entry(n->lsrqh, en);
! 280: if (req != NULL)
! 281: {
! 282: int cmp = lsa_comp(&en->lsa, &req->lsa);
! 283:
! 284: /* If same or newer, remove LSA from the link state request list */
! 285: if (cmp > CMP_OLDER)
! 286: ospf_lsa_lsrq_down(req, n);
! 287:
! 288: /* If older or same, skip processing of this neighbor */
! 289: if (cmp < CMP_NEWER)
! 290: continue;
! 291: }
! 292: }
! 293:
! 294: /* 13.3 (1c) */
! 295: if (n == from)
! 296: continue;
! 297:
! 298: /* Check whether optional LSAs are supported by neighbor */
! 299: if (!lsa_is_acceptable(en->lsa_type, n, p))
! 300: continue;
! 301:
! 302: /* 13.3 (1d) - add LSA to the link state retransmission list */
! 303: ospf_lsa_lsrt_up(en, n);
! 304:
! 305: used = 1;
! 306: }
! 307:
! 308: /* 13.3 (2) */
! 309: if (!used)
! 310: continue;
! 311:
! 312: if (from && (from->ifa == ifa))
! 313: {
! 314: /* 13.3 (3) */
! 315: if ((from->rid == ifa->drid) || (from->rid == ifa->bdrid))
! 316: continue;
! 317:
! 318: /* 13.3 (4) */
! 319: if (ifa->state == OSPF_IS_BACKUP)
! 320: continue;
! 321:
! 322: back = 1;
! 323: }
! 324:
! 325: /* 13.3 (5) - finally flood the packet */
! 326: ospf_enqueue_lsa(p, en, ifa);
! 327: }
! 328:
! 329: return back;
! 330: }
! 331:
! 332: static uint
! 333: ospf_prepare_lsupd(struct ospf_proto *p, struct ospf_iface *ifa,
! 334: struct top_hash_entry **lsa_list, uint lsa_count)
! 335: {
! 336: struct ospf_packet *pkt;
! 337: uint hlen, pos, i, maxsize;
! 338:
! 339: pkt = ospf_tx_buffer(ifa);
! 340: hlen = ospf_lsupd_hdrlen(p);
! 341: maxsize = ospf_pkt_maxsize(ifa);
! 342:
! 343: ospf_pkt_fill_hdr(ifa, pkt, LSUPD_P);
! 344: pos = hlen;
! 345:
! 346: for (i = 0; i < lsa_count; i++)
! 347: {
! 348: struct top_hash_entry *en = lsa_list[i];
! 349: uint len = en->lsa.length;
! 350:
! 351: if ((pos + len) > maxsize)
! 352: {
! 353: /* The packet if full, stop adding LSAs and sent it */
! 354: if (i > 0)
! 355: break;
! 356:
! 357: /* LSA is larger than MTU, check buffer size */
! 358: if (ospf_iface_assure_bufsize(ifa, pos + len) < 0)
! 359: {
! 360: /* Cannot fit in a tx buffer, skip that */
! 361: log(L_ERR "%s: LSA too large to send on %s (Type: %04x, Id: %R, Rt: %R)",
! 362: p->p.name, ifa->ifname, en->lsa_type, en->lsa.id, en->lsa.rt);
! 363: break;
! 364: }
! 365:
! 366: /* TX buffer could be reallocated */
! 367: pkt = ospf_tx_buffer(ifa);
! 368: }
! 369:
! 370: struct ospf_lsa_header *buf = ((void *) pkt) + pos;
! 371: lsa_hton_hdr(&en->lsa, buf);
! 372: lsa_hton_body(en->lsa_body, ((void *) buf) + sizeof(struct ospf_lsa_header),
! 373: len - sizeof(struct ospf_lsa_header));
! 374: buf->age = htons(MIN(en->lsa.age + ifa->inftransdelay, LSA_MAXAGE));
! 375:
! 376: pos += len;
! 377: }
! 378:
! 379: ospf_lsupd_set_lsa_count(pkt, hlen, i);
! 380: pkt->length = htons(pos);
! 381:
! 382: return i;
! 383: }
! 384:
! 385:
! 386: static int
! 387: ospf_flood_lsupd(struct ospf_proto *p, struct top_hash_entry **lsa_list, uint lsa_count, uint lsa_min_count, struct ospf_iface *ifa)
! 388: {
! 389: uint i, c;
! 390:
! 391: for (i = 0; i < lsa_min_count; i += c)
! 392: {
! 393: c = ospf_prepare_lsupd(p, ifa, lsa_list + i, lsa_count - i);
! 394:
! 395: if (!c) /* Too large LSA */
! 396: { i++; continue; }
! 397:
! 398: OSPF_PACKET(ospf_dump_lsupd, ospf_tx_buffer(ifa),
! 399: "LSUPD packet flooded via %s", ifa->ifname);
! 400:
! 401: if (ifa->type == OSPF_IT_BCAST)
! 402: {
! 403: if ((ifa->state == OSPF_IS_DR) || (ifa->state == OSPF_IS_BACKUP))
! 404: ospf_send_to_all(ifa);
! 405: else
! 406: ospf_send_to_des(ifa);
! 407: }
! 408: else
! 409: ospf_send_to_agt(ifa, NEIGHBOR_EXCHANGE);
! 410: }
! 411:
! 412: return i;
! 413: }
! 414:
! 415: int
! 416: ospf_send_lsupd(struct ospf_proto *p, struct top_hash_entry **lsa_list, uint lsa_count, struct ospf_neighbor *n)
! 417: {
! 418: struct ospf_iface *ifa = n->ifa;
! 419: uint i, c;
! 420:
! 421: for (i = 0; i < lsa_count; i += c)
! 422: {
! 423: c = ospf_prepare_lsupd(p, ifa, lsa_list + i, lsa_count - i);
! 424:
! 425: if (!c) /* Too large LSA */
! 426: { i++; continue; }
! 427:
! 428: OSPF_PACKET(ospf_dump_lsupd, ospf_tx_buffer(ifa),
! 429: "LSUPD packet sent to nbr %R on %s", n->rid, ifa->ifname);
! 430:
! 431: ospf_send_to(ifa, n->ip);
! 432: }
! 433:
! 434: return i;
! 435: }
! 436:
! 437: void
! 438: ospf_rxmt_lsupd(struct ospf_proto *p, struct ospf_neighbor *n)
! 439: {
! 440: uint max = 2 * n->ifa->flood_queue_size;
! 441: struct top_hash_entry *entries[max];
! 442: struct top_hash_entry *ret, *nxt, *en;
! 443: uint i = 0;
! 444:
! 445: /* ASSERT((n->state >= NEIGHBOR_EXCHANGE) && !EMPTY_SLIST(n->lsrtl)); */
! 446:
! 447: WALK_SLIST_DELSAFE(ret, nxt, n->lsrtl)
! 448: {
! 449: if (i == max)
! 450: break;
! 451:
! 452: en = ospf_hash_find_entry(p->gr, ret);
! 453: if (!en)
! 454: {
! 455: /* Probably flushed LSA, this should not happen */
! 456: log(L_WARN "%s: LSA disappeared (Type: %04x, Id: %R, Rt: %R)",
! 457: p->p.name, ret->lsa_type, ret->lsa.id, ret->lsa.rt);
! 458:
! 459: s_rem_node(SNODE ret);
! 460: ospf_hash_delete(n->lsrth, ret);
! 461:
! 462: continue;
! 463: }
! 464:
! 465: entries[i] = en;
! 466: i++;
! 467: }
! 468:
! 469: ospf_send_lsupd(p, entries, i, n);
! 470: }
! 471:
! 472:
! 473: static inline int
! 474: ospf_addr_is_local(struct ospf_proto *p, struct ospf_area *oa, ip_addr ip)
! 475: {
! 476: struct ospf_iface *ifa;
! 477: WALK_LIST(ifa, p->iface_list)
! 478: if ((ifa->oa == oa) && ifa->addr && ipa_equal(ifa->addr->ip, ip))
! 479: return 1;
! 480:
! 481: return 0;
! 482: }
! 483:
! 484: void
! 485: ospf_receive_lsupd(struct ospf_packet *pkt, struct ospf_iface *ifa,
! 486: struct ospf_neighbor *n)
! 487: {
! 488: struct ospf_proto *p = ifa->oa->po;
! 489: const char *err_dsc = NULL;
! 490: uint plen, err_val = 0;
! 491:
! 492: /* RFC 2328 13. */
! 493:
! 494: plen = ntohs(pkt->length);
! 495: if (plen < ospf_lsupd_hdrlen(p))
! 496: {
! 497: LOG_PKT("Bad LSUPD packet from nbr %R on %s - %s (%u)", n->rid, ifa->ifname, "too short", plen);
! 498: return;
! 499: }
! 500:
! 501: OSPF_PACKET(ospf_dump_lsupd, pkt, "LSUPD packet received from nbr %R on %s", n->rid, ifa->ifname);
! 502:
! 503: if (n->state < NEIGHBOR_EXCHANGE)
! 504: {
! 505: OSPF_TRACE(D_PACKETS, "LSUPD packet ignored - lesser state than Exchange");
! 506: return;
! 507: }
! 508:
! 509: ospf_neigh_sm(n, INM_HELLOREC); /* Questionable */
! 510:
! 511: uint offset, i, lsa_count;
! 512: ospf_lsupd_body(p, pkt, &offset, &lsa_count);
! 513:
! 514: for (i = 0; i < lsa_count; i++)
! 515: {
! 516: struct ospf_lsa_header lsa, *lsa_n;
! 517: struct top_hash_entry *en;
! 518: u32 lsa_len, lsa_type, lsa_domain;
! 519:
! 520: if ((offset + sizeof(struct ospf_lsa_header)) > plen)
! 521: DROP("too short", plen);
! 522:
! 523: /* LSA header in network order */
! 524: lsa_n = ((void *) pkt) + offset;
! 525: lsa_len = ntohs(lsa_n->length);
! 526: offset += lsa_len;
! 527:
! 528: if (offset > plen)
! 529: DROP("too short", plen);
! 530:
! 531: if (((lsa_len % 4) != 0) || (lsa_len <= sizeof(struct ospf_lsa_header)))
! 532: DROP("invalid LSA length", lsa_len);
! 533:
! 534: /* LSA header in host order */
! 535: lsa_ntoh_hdr(lsa_n, &lsa);
! 536: lsa_get_type_domain(&lsa, ifa, &lsa_type, &lsa_domain);
! 537:
! 538: DBG("Update Type: %04x, Id: %R, Rt: %R, Sn: 0x%08x, Age: %u, Sum: %u\n",
! 539: lsa_type, lsa.id, lsa.rt, lsa.sn, lsa.age, lsa.checksum);
! 540:
! 541: /* RFC 2328 13. (1) - verify LSA checksum */
! 542: if ((lsa_n->checksum == 0) || !lsa_verify_checksum(lsa_n, lsa_len))
! 543: SKIP("invalid checksum");
! 544:
! 545: /* RFC 2328 13. (2) */
! 546: if (!lsa_type)
! 547: SKIP("unknown type");
! 548:
! 549: /* RFC 5340 4.5.1 (2) and RFC 2328 13. (3) */
! 550: if (!oa_is_ext(ifa->oa) && (LSA_SCOPE(lsa_type) == LSA_SCOPE_AS))
! 551: SKIP("AS scope in stub area");
! 552:
! 553: /* Errata 3746 to RFC 2328 - rt-summary-LSAs forbidden in stub areas */
! 554: if (!oa_is_ext(ifa->oa) && (lsa_type == LSA_T_SUM_RT))
! 555: SKIP("rt-summary-LSA in stub area");
! 556:
! 557: /* RFC 5340 4.5.1 (3) */
! 558: if (LSA_SCOPE(lsa_type) == LSA_SCOPE_RES)
! 559: SKIP("invalid scope");
! 560:
! 561: /* Find local copy of LSA in link state database */
! 562: en = ospf_hash_find(p->gr, lsa_domain, lsa.id, lsa.rt, lsa_type);
! 563:
! 564: #ifdef LOCAL_DEBUG
! 565: if (en)
! 566: DBG("I have Type: %04x, Id: %R, Rt: %R, Sn: 0x%08x, Age: %u, Sum: %u\n",
! 567: en->lsa_type, en->lsa.id, en->lsa.rt, en->lsa.sn, en->lsa.age, en->lsa.checksum);
! 568: #endif
! 569:
! 570: /* 13. (4) - ignore maxage LSA if i have no local copy */
! 571: if ((lsa.age == LSA_MAXAGE) && !en && (p->padj == 0))
! 572: {
! 573: /* 13.5. - schedule ACKs (tbl 19, case 5) */
! 574: ospf_enqueue_lsack(n, lsa_n, ACKL_DIRECT);
! 575: continue;
! 576: }
! 577:
! 578: /* 13. (5) - received LSA is newer (or no local copy) */
! 579: if (!en || (lsa_comp(&lsa, &en->lsa) == CMP_NEWER))
! 580: {
! 581: /* 13. (5a) - enforce minimum time between updates for received LSAs */
! 582: /* We also use this to ratelimit reactions to received self-originated LSAs */
! 583: if (en && (lsa_inst_age(en) < MINLSARRIVAL))
! 584: {
! 585: OSPF_TRACE(D_EVENTS, "Skipping LSA received in less that MinLSArrival");
! 586: continue;
! 587: }
! 588:
! 589: /* Copy and validate LSA body */
! 590: int blen = lsa.length - sizeof(struct ospf_lsa_header);
! 591: void *body = mb_alloc(p->p.pool, blen);
! 592: lsa_ntoh_body(lsa_n + 1, body, blen);
! 593:
! 594: if (lsa_validate(&lsa, lsa_type, ospf_is_v2(p), body) == 0)
! 595: {
! 596: mb_free(body);
! 597: SKIP("invalid body");
! 598: }
! 599:
! 600: /* 13. (5f) - handle self-originated LSAs, see also 13.4. */
! 601: if (!p->gr_recovery &&
! 602: ((lsa.rt == p->router_id) ||
! 603: (ospf_is_v2(p) && (lsa_type == LSA_T_NET) && ospf_addr_is_local(p, ifa->oa, ipa_from_u32(lsa.id)))))
! 604: {
! 605: OSPF_TRACE(D_EVENTS, "Received unexpected self-originated LSA");
! 606: ospf_advance_lsa(p, en, &lsa, lsa_type, lsa_domain, body);
! 607: continue;
! 608: }
! 609:
! 610: /* 13. (5c) - remove old LSA from all retransmission lists
! 611: *
! 612: * We only need to remove it from the retransmission list of the neighbor
! 613: * that send us the new LSA. The old LSA is automatically replaced in
! 614: * retransmission lists by the new LSA.
! 615: */
! 616: if (en)
! 617: ospf_lsa_lsrt_down(en, n);
! 618:
! 619: #if 0
! 620: /*
! 621: * Old code for removing LSA from all retransmission lists. Must be done
! 622: * before (5b), otherwise it also removes the new entries from (5b).
! 623: */
! 624: struct ospf_iface *ifi;
! 625: struct ospf_neighbor *ni;
! 626:
! 627: WALK_LIST(ifi, p->iface_list)
! 628: WALK_LIST(ni, ifi->neigh_list)
! 629: if (ni->state > NEIGHBOR_EXSTART)
! 630: ospf_lsa_lsrt_down(en, ni);
! 631: #endif
! 632:
! 633: /* 13. (5d) - install new LSA into database */
! 634: en = ospf_install_lsa(p, &lsa, lsa_type, lsa_domain, body);
! 635:
! 636: /* RFC 5340 4.4.3 Events 6+7 - new Link LSA received */
! 637: if (lsa_type == LSA_T_LINK)
! 638: ospf_notify_net_lsa(ifa);
! 639:
! 640: /* RFC 3623 3.1 - entering graceful restart helper mode */
! 641: if (lsa_type == LSA_T_GR)
! 642: ospf_neigh_notify_grace_lsa(n, en);
! 643:
! 644: /* Link received pre-restart router LSA */
! 645: if (p->gr_recovery && (lsa_type == LSA_T_RT) && (lsa.rt == p->router_id))
! 646: ifa->oa->rt = en;
! 647:
! 648: /* 13. (5b) - flood new LSA */
! 649: int flood_back = ospf_flood_lsa(p, en, n);
! 650:
! 651: /* 13.5. - schedule ACKs (tbl 19, cases 1+2) */
! 652: if (! flood_back)
! 653: if ((ifa->state != OSPF_IS_BACKUP) || (n->rid == ifa->drid))
! 654: ospf_enqueue_lsack(n, lsa_n, ACKL_DELAY);
! 655:
! 656: /* FIXME: remove LSA entry if it is LSA_MAXAGE and it is possible? */
! 657:
! 658: continue;
! 659: }
! 660:
! 661: /* 13. (6) - received LSA is in Link state request list (but not newer) */
! 662: if (ospf_hash_find_entry(n->lsrqh, en) != NULL)
! 663: DROP1("error in LSA database exchange");
! 664:
! 665: /* 13. (7) - received LSA is same */
! 666: if (lsa_comp(&lsa, &en->lsa) == CMP_SAME)
! 667: {
! 668: /* Duplicate LSA, treat as implicit ACK */
! 669: int implicit_ack = ospf_lsa_lsrt_down(en, n);
! 670:
! 671: /* 13.5. - schedule ACKs (tbl 19, cases 3+4) */
! 672: if (implicit_ack)
! 673: {
! 674: if ((ifa->state == OSPF_IS_BACKUP) && (n->rid == ifa->drid))
! 675: ospf_enqueue_lsack(n, lsa_n, ACKL_DELAY);
! 676: }
! 677: else
! 678: ospf_enqueue_lsack(n, lsa_n, ACKL_DIRECT);
! 679:
! 680: continue;
! 681: }
! 682:
! 683: /* 13. (8) - received LSA is older */
! 684: {
! 685: /* Seqnum is wrapping, wait until it is flushed */
! 686: if ((en->lsa.age == LSA_MAXAGE) && (en->lsa.sn == LSA_MAXSEQNO))
! 687: continue;
! 688:
! 689: /* Send newer local copy back to neighbor */
! 690: /* FIXME - check for MinLSArrival ? */
! 691: ospf_send_lsupd(p, &en, 1, n);
! 692:
! 693: continue;
! 694: }
! 695:
! 696: skip:
! 697: LOG_LSA1("Bad LSA (Type: %04x, Id: %R, Rt: %R) in LSUPD", lsa_type, lsa.id, lsa.rt);
! 698: LOG_LSA2(" received from nbr %R on %s - %s", n->rid, ifa->ifname, err_dsc);
! 699: }
! 700:
! 701: /* Send direct LSACKs */
! 702: ospf_send_lsack(p, n, ACKL_DIRECT);
! 703:
! 704: /* Send enqueued LSAs immediately, do not wait for flood_event */
! 705: if (ev_active(p->flood_event))
! 706: {
! 707: ev_postpone(p->flood_event);
! 708: ospf_flood_event(p);
! 709: }
! 710:
! 711: /*
! 712: * During loading, we should ask for another batch of LSAs. This is only
! 713: * vaguely mentioned in RFC 2328. We send a new LSREQ if all requests sent in
! 714: * the last packet were already answered and/or removed from the LS request
! 715: * list and therefore lsrqi is pointing to the first node of the list.
! 716: */
! 717: if (!EMPTY_SLIST(n->lsrql) && (n->lsrqi == SHEAD(n->lsrql)))
! 718: {
! 719: ospf_send_lsreq(p, n);
! 720: tm_start(n->lsrq_timer, n->ifa->rxmtint S);
! 721: }
! 722:
! 723: return;
! 724:
! 725: drop:
! 726: LOG_PKT("Bad LSUPD packet from nbr %R on %s - %s (%u)",
! 727: n->rid, ifa->ifname, err_dsc, err_val);
! 728:
! 729: /* Malformed LSUPD - there is no defined error event, we abuse BadLSReq */
! 730: ospf_neigh_sm(n, INM_BADLSREQ);
! 731: return;
! 732: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to lsupd.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / proto / ospf