Annotation of embedaddon/bird2/proto/ospf/lsalib.c, revision 1.1
1.1 ! misho 1: /*
! 2: * BIRD -- OSPF
! 3: *
! 4: * (c) 1999--2004 Ondrej Filip <feela@network.cz>
! 5: * (c) 2009--2015 Ondrej Zajicek <santiago@crfreenet.org>
! 6: * (c) 2009--2015 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: #include "lib/fletcher16.h"
! 14:
! 15: #define HDRLEN sizeof(struct ospf_lsa_header)
! 16:
! 17:
! 18: #ifndef CPU_BIG_ENDIAN
! 19: void
! 20: lsa_hton_hdr(struct ospf_lsa_header *h, struct ospf_lsa_header *n)
! 21: {
! 22: n->age = htons(h->age);
! 23: n->type_raw = htons(h->type_raw);
! 24: n->id = htonl(h->id);
! 25: n->rt = htonl(h->rt);
! 26: n->sn = htonl(h->sn);
! 27: n->checksum = htons(h->checksum);
! 28: n->length = htons(h->length);
! 29: }
! 30:
! 31: void
! 32: lsa_ntoh_hdr(struct ospf_lsa_header *n, struct ospf_lsa_header *h)
! 33: {
! 34: h->age = ntohs(n->age);
! 35: h->type_raw = ntohs(n->type_raw);
! 36: h->id = ntohl(n->id);
! 37: h->rt = ntohl(n->rt);
! 38: h->sn = ntohl(n->sn);
! 39: h->checksum = ntohs(n->checksum);
! 40: h->length = ntohs(n->length);
! 41: }
! 42:
! 43: void
! 44: lsa_hton_body(void *h, void *n, u16 len)
! 45: {
! 46: u32 *hid = h;
! 47: u32 *nid = n;
! 48: uint i;
! 49:
! 50: for (i = 0; i < (len / sizeof(u32)); i++)
! 51: nid[i] = htonl(hid[i]);
! 52: }
! 53:
! 54: void
! 55: lsa_ntoh_body(void *n, void *h, u16 len)
! 56: {
! 57: u32 *nid = n;
! 58: u32 *hid = h;
! 59: uint i;
! 60:
! 61: for (i = 0; i < (len / sizeof(u32)); i++)
! 62: hid[i] = ntohl(nid[i]);
! 63: }
! 64: #endif /* little endian */
! 65:
! 66:
! 67: int
! 68: lsa_flooding_allowed(u32 type, u32 domain, struct ospf_iface *ifa)
! 69: {
! 70: /* Handle inactive vlinks */
! 71: if (ifa->state == OSPF_IS_DOWN)
! 72: return 0;
! 73:
! 74: /* 4.5.2 (Case 2) */
! 75: switch (LSA_SCOPE(type))
! 76: {
! 77: case LSA_SCOPE_LINK:
! 78: return ifa->iface_id == domain;
! 79:
! 80: case LSA_SCOPE_AREA:
! 81: return ifa->oa->areaid == domain;
! 82:
! 83: case LSA_SCOPE_AS:
! 84: if (ifa->type == OSPF_IT_VLINK)
! 85: return 0;
! 86: if (!oa_is_ext(ifa->oa))
! 87: return 0;
! 88: return 1;
! 89:
! 90: default:
! 91: log(L_ERR "OSPF: LSA with invalid scope");
! 92: return 0;
! 93: }
! 94: }
! 95:
! 96: int
! 97: lsa_is_acceptable(u32 type, struct ospf_neighbor *n, struct ospf_proto *p)
! 98: {
! 99: if (ospf_is_v2(p))
! 100: {
! 101: /* Do not check NSSA-LSA here, as OPT_N is only in HELLO packets */
! 102:
! 103: if (lsa_is_opaque(type))
! 104: return !!(n->options & OPT_O);
! 105:
! 106: return 1;
! 107: }
! 108: else
! 109: {
! 110: /*
! 111: * There should be check whether receiving router understands that type
! 112: * of LSA (for LSA types with U-bit == 0). But as we do not support any
! 113: * optional LSA types, this is not needed yet.
! 114: */
! 115:
! 116: return 1;
! 117: }
! 118: }
! 119:
! 120: static int
! 121: unknown_lsa_type(u32 type)
! 122: {
! 123: switch (type)
! 124: {
! 125: case LSA_T_RT:
! 126: case LSA_T_NET:
! 127: case LSA_T_SUM_NET:
! 128: case LSA_T_SUM_RT:
! 129: case LSA_T_EXT:
! 130: case LSA_T_NSSA:
! 131: case LSA_T_LINK:
! 132: case LSA_T_PREFIX:
! 133: case LSA_T_RI_LINK:
! 134: case LSA_T_RI_AREA:
! 135: case LSA_T_RI_AS:
! 136: return 0;
! 137:
! 138: default:
! 139: return 1;
! 140: }
! 141: }
! 142:
! 143: /* Maps OSPFv2 types to OSPFv3 types */
! 144: static const u16 lsa_v2_types[] = {
! 145: 0, LSA_T_RT, LSA_T_NET, LSA_T_SUM_NET, LSA_T_SUM_RT, LSA_T_EXT, 0, LSA_T_NSSA,
! 146: 0, LSA_T_OPAQUE_LINK, LSA_T_OPAQUE_AREA, LSA_T_OPAQUE_AS
! 147: };
! 148:
! 149: /* Maps OSPFv2 opaque types to OSPFv3 function codes */
! 150: static const u16 opaque_lsa_types[] = {
! 151: [LSA_OT_GR] = LSA_T_GR,
! 152: [LSA_OT_RI] = LSA_T_RI_,
! 153: };
! 154:
! 155: /* Maps (subset of) OSPFv3 function codes to OSPFv2 opaque types */
! 156: static const u8 opaque_lsa_types_inv[] = {
! 157: [LSA_T_GR] = LSA_OT_GR,
! 158: [LSA_T_RI_] = LSA_OT_RI,
! 159: };
! 160:
! 161: #define LOOKUP(a, i) ({ uint _i = (i); (_i < ARRAY_SIZE(a)) ? a[_i] : 0; })
! 162:
! 163: void
! 164: lsa_get_type_domain_(u32 type, u32 id, struct ospf_iface *ifa, u32 *otype, u32 *domain)
! 165: {
! 166: if (ospf_is_v2(ifa->oa->po))
! 167: {
! 168: type = type & LSA_T_V2_MASK;
! 169: type = LOOKUP(lsa_v2_types, type);
! 170:
! 171: uint code;
! 172: if (LSA_FUNCTION(type) == LSA_T_OPAQUE_)
! 173: if (code = LOOKUP(opaque_lsa_types, id >> 24))
! 174: {
! 175: type = code | LSA_UBIT | LSA_SCOPE(type);
! 176:
! 177: /* Hack for Grace-LSA: It does not use U-bit for link-scoped LSAs */
! 178: if (type == (LSA_T_GR | LSA_UBIT))
! 179: type = LSA_T_GR;
! 180: }
! 181: }
! 182: else
! 183: {
! 184: /* For unkown LSAs without U-bit change scope to LSA_SCOPE_LINK */
! 185: if (unknown_lsa_type(type) && !(type & LSA_UBIT))
! 186: type = type & ~LSA_SCOPE_MASK;
! 187: }
! 188:
! 189: *otype = type;
! 190:
! 191: switch (LSA_SCOPE(type))
! 192: {
! 193: case LSA_SCOPE_LINK:
! 194: *domain = ifa->iface_id;
! 195: return;
! 196:
! 197: case LSA_SCOPE_AREA:
! 198: *domain = ifa->oa->areaid;
! 199: return;
! 200:
! 201: case LSA_SCOPE_AS:
! 202: default:
! 203: *domain = 0;
! 204: return;
! 205: }
! 206: }
! 207:
! 208: int
! 209: lsa_is_opaque(u32 type)
! 210: {
! 211: u32 fn = LSA_FUNCTION(type);
! 212: return LOOKUP(opaque_lsa_types_inv, fn) || (fn == LSA_T_OPAQUE_);
! 213: }
! 214:
! 215: u32
! 216: lsa_get_opaque_type(u32 type)
! 217: {
! 218: return LOOKUP(opaque_lsa_types_inv, LSA_FUNCTION(type));
! 219: }
! 220:
! 221:
! 222: void
! 223: lsa_generate_checksum(struct ospf_lsa_header *lsa, const u8 *body)
! 224: {
! 225: struct fletcher16_context ctx;
! 226: struct ospf_lsa_header hdr;
! 227: u16 len = lsa->length;
! 228:
! 229: /*
! 230: * lsa and body are in the host order, we need to compute Fletcher-16 checksum
! 231: * for data in the network order. We also skip the initial age field.
! 232: */
! 233:
! 234: lsa_hton_hdr(lsa, &hdr);
! 235: hdr.checksum = 0;
! 236:
! 237: fletcher16_init(&ctx);
! 238: fletcher16_update(&ctx, (u8 *) &hdr + 2, sizeof(struct ospf_lsa_header) - 2);
! 239: fletcher16_update_n32(&ctx, body, len - sizeof(struct ospf_lsa_header));
! 240: lsa->checksum = fletcher16_final(&ctx, len, OFFSETOF(struct ospf_lsa_header, checksum));
! 241: }
! 242:
! 243: u16
! 244: lsa_verify_checksum(const void *lsa_n, int lsa_len)
! 245: {
! 246: struct fletcher16_context ctx;
! 247:
! 248: /* The whole LSA is at lsa_n in net order, we just skip initial age field */
! 249:
! 250: fletcher16_init(&ctx);
! 251: fletcher16_update(&ctx, (u8 *) lsa_n + 2, lsa_len - 2);
! 252:
! 253: return fletcher16_compute(&ctx) == 0;
! 254: }
! 255:
! 256:
! 257: int
! 258: lsa_comp(struct ospf_lsa_header *l1, struct ospf_lsa_header *l2)
! 259: /* Return codes from point of view of l1 */
! 260: {
! 261: u32 sn1, sn2;
! 262:
! 263: sn1 = l1->sn - LSA_INITSEQNO + 1;
! 264: sn2 = l2->sn - LSA_INITSEQNO + 1;
! 265:
! 266: if (sn1 > sn2)
! 267: return CMP_NEWER;
! 268: if (sn1 < sn2)
! 269: return CMP_OLDER;
! 270:
! 271: if (l1->checksum != l2->checksum)
! 272: return l1->checksum < l2->checksum ? CMP_OLDER : CMP_NEWER;
! 273:
! 274: if ((l1->age == LSA_MAXAGE) && (l2->age != LSA_MAXAGE))
! 275: return CMP_NEWER;
! 276: if ((l2->age == LSA_MAXAGE) && (l1->age != LSA_MAXAGE))
! 277: return CMP_OLDER;
! 278:
! 279: if (ABS(l1->age - l2->age) > LSA_MAXAGEDIFF)
! 280: return l1->age < l2->age ? CMP_NEWER : CMP_OLDER;
! 281:
! 282: return CMP_SAME;
! 283: }
! 284:
! 285:
! 286: #define LSA_TLV_LENGTH(tlv) \
! 287: (sizeof(struct ospf_tlv) + BIRD_ALIGN((tlv)->length, 4))
! 288:
! 289: #define LSA_NEXT_TLV(tlv) \
! 290: ((struct ospf_tlv *) ((byte *) (tlv) + LSA_TLV_LENGTH(tlv)))
! 291:
! 292: #define LSA_WALK_TLVS(tlv,buf,len) \
! 293: for(struct ospf_tlv *tlv = (void *) (buf); \
! 294: (byte *) tlv < (byte *) (buf) + (len); \
! 295: tlv = LSA_NEXT_TLV(tlv))
! 296:
! 297: struct ospf_tlv *
! 298: lsa_get_tlv(struct top_hash_entry *en, uint type)
! 299: {
! 300: LSA_WALK_TLVS(tlv, en->lsa_body, en->lsa.length - HDRLEN)
! 301: if (tlv->type == type)
! 302: return tlv;
! 303:
! 304: return NULL;
! 305: }
! 306:
! 307: int
! 308: lsa_validate_tlvs(byte *buf, uint len)
! 309: {
! 310: byte *pos = buf;
! 311: byte *end = buf + len;
! 312:
! 313: while (pos < end)
! 314: {
! 315: if ((pos + sizeof(struct ospf_tlv)) > end)
! 316: return 0;
! 317:
! 318: struct ospf_tlv *tlv = (void *) pos;
! 319: uint len = LSA_TLV_LENGTH(tlv);
! 320:
! 321: if ((pos + len) > end)
! 322: return 0;
! 323:
! 324: pos += len;
! 325: }
! 326:
! 327: return 1;
! 328: }
! 329:
! 330:
! 331: static inline int
! 332: lsa_walk_rt2(struct ospf_lsa_rt_walk *rt)
! 333: {
! 334: if (rt->buf >= rt->bufend)
! 335: return 0;
! 336:
! 337: struct ospf_lsa_rt2_link *l = rt->buf;
! 338: rt->buf += sizeof(struct ospf_lsa_rt2_link) + l->no_tos * sizeof(struct ospf_lsa_rt2_tos);
! 339:
! 340: rt->type = l->type;
! 341: rt->metric = l->metric;
! 342: rt->id = l->id;
! 343: rt->data = l->data;
! 344: return 1;
! 345: }
! 346:
! 347: static inline int
! 348: lsa_walk_rt3(struct ospf_lsa_rt_walk *rt)
! 349: {
! 350: while (rt->buf >= rt->bufend)
! 351: {
! 352: rt->en = ospf_hash_find_rt3_next(rt->en);
! 353: if (!rt->en)
! 354: return 0;
! 355:
! 356: rt->buf = rt->en->lsa_body;
! 357: rt->bufend = rt->buf + rt->en->lsa.length - sizeof(struct ospf_lsa_header);
! 358: rt->buf += sizeof(struct ospf_lsa_rt);
! 359: }
! 360:
! 361: struct ospf_lsa_rt3_link *l = rt->buf;
! 362: rt->buf += sizeof(struct ospf_lsa_rt3_link);
! 363:
! 364: rt->type = l->type;
! 365: rt->metric = l->metric;
! 366: rt->lif = l->lif;
! 367: rt->nif = l->nif;
! 368: rt->id = l->id;
! 369: return 1;
! 370: }
! 371:
! 372: void
! 373: lsa_walk_rt_init(struct ospf_proto *p, struct top_hash_entry *act, struct ospf_lsa_rt_walk *rt)
! 374: {
! 375: rt->ospf2 = ospf_is_v2(p);
! 376: rt->id = rt->data = rt->lif = rt->nif = 0;
! 377:
! 378: if (rt->ospf2)
! 379: rt->en = act;
! 380: else
! 381: rt->en = ospf_hash_find_rt3_first(p->gr, act->domain, act->lsa.rt);
! 382:
! 383: rt->buf = rt->en->lsa_body;
! 384: rt->bufend = rt->buf + rt->en->lsa.length - sizeof(struct ospf_lsa_header);
! 385: rt->buf += sizeof(struct ospf_lsa_rt);
! 386: }
! 387:
! 388: int
! 389: lsa_walk_rt(struct ospf_lsa_rt_walk *rt)
! 390: {
! 391: return rt->ospf2 ? lsa_walk_rt2(rt) : lsa_walk_rt3(rt);
! 392: }
! 393:
! 394:
! 395: void
! 396: lsa_parse_sum_net(struct top_hash_entry *en, int ospf2, int af, net_addr *net, u8 *pxopts, u32 *metric)
! 397: {
! 398: if (ospf2)
! 399: {
! 400: uint opts = lsa_get_options(&en->lsa);
! 401: struct ospf_lsa_sum2 *ls = en->lsa_body;
! 402: net_fill_ip4(net, ip4_from_u32(en->lsa.id & ls->netmask), u32_masklen(ls->netmask));
! 403: *pxopts = (opts & OPT_DN) ? OPT_PX_DN : 0;
! 404: *metric = ls->metric & LSA_METRIC_MASK;
! 405: }
! 406: else
! 407: {
! 408: struct ospf_lsa_sum3_net *ls = en->lsa_body;
! 409: ospf3_get_prefix(ls->prefix, af, net, pxopts, NULL);
! 410: *metric = ls->metric & LSA_METRIC_MASK;
! 411: }
! 412: }
! 413:
! 414: void
! 415: lsa_parse_sum_rt(struct top_hash_entry *en, int ospf2, u32 *drid, u32 *metric, u32 *options)
! 416: {
! 417: if (ospf2)
! 418: {
! 419: struct ospf_lsa_sum2 *ls = en->lsa_body;
! 420: *drid = en->lsa.id;
! 421: *metric = ls->metric & LSA_METRIC_MASK;
! 422: *options = 0;
! 423: }
! 424: else
! 425: {
! 426: struct ospf_lsa_sum3_rt *ls = en->lsa_body;
! 427: *drid = ls->drid;
! 428: *metric = ls->metric & LSA_METRIC_MASK;
! 429: *options = ls->options & LSA_OPTIONS_MASK;
! 430: }
! 431: }
! 432:
! 433: void
! 434: lsa_parse_ext(struct top_hash_entry *en, int ospf2, int af, struct ospf_lsa_ext_local *rt)
! 435: {
! 436: if (ospf2)
! 437: {
! 438: struct ospf_lsa_ext2 *ext = en->lsa_body;
! 439: net_fill_ip4(&rt->net,
! 440: ip4_from_u32(en->lsa.id & ext->netmask),
! 441: u32_masklen(ext->netmask));
! 442: rt->pxopts = 0;
! 443: rt->metric = ext->metric & LSA_METRIC_MASK;
! 444: rt->ebit = ext->metric & LSA_EXT2_EBIT;
! 445:
! 446: rt->fbit = ext->fwaddr;
! 447: rt->fwaddr = ipa_from_u32(ext->fwaddr);
! 448:
! 449: rt->tag = ext->tag;
! 450: rt->propagate = lsa_get_options(&en->lsa) & OPT_P;
! 451: rt->downwards = lsa_get_options(&en->lsa) & OPT_DN;
! 452: }
! 453: else
! 454: {
! 455: struct ospf_lsa_ext3 *ext = en->lsa_body;
! 456: u32 *buf = ospf3_get_prefix(ext->rest, af, &rt->net, &rt->pxopts, NULL);
! 457: rt->metric = ext->metric & LSA_METRIC_MASK;
! 458: rt->ebit = ext->metric & LSA_EXT3_EBIT;
! 459:
! 460: rt->fbit = ext->metric & LSA_EXT3_FBIT;
! 461: if (rt->fbit)
! 462: buf = ospf3_get_addr(buf, af, &rt->fwaddr);
! 463: else
! 464: rt->fwaddr = IPA_NONE;
! 465:
! 466: rt->tag = (ext->metric & LSA_EXT3_TBIT) ? *buf++ : 0;
! 467: rt->propagate = rt->pxopts & OPT_PX_P;
! 468: rt->downwards = rt->pxopts & OPT_PX_DN;
! 469: }
! 470: }
! 471:
! 472:
! 473: static int
! 474: lsa_validate_rt2(struct ospf_lsa_header *lsa, struct ospf_lsa_rt *body)
! 475: {
! 476: if (lsa->length < (HDRLEN + sizeof(struct ospf_lsa_rt)))
! 477: return 0;
! 478:
! 479: uint i = 0;
! 480: void *buf = body;
! 481: void *bufend = buf + lsa->length - HDRLEN;
! 482: buf += sizeof(struct ospf_lsa_rt);
! 483:
! 484: while (buf < bufend)
! 485: {
! 486: struct ospf_lsa_rt2_link *l = buf;
! 487: buf += sizeof(struct ospf_lsa_rt2_link) + l->no_tos * sizeof(struct ospf_lsa_rt2_tos);
! 488: i++;
! 489:
! 490: if (buf > bufend)
! 491: return 0;
! 492:
! 493: if (!((l->type == LSART_PTP) ||
! 494: (l->type == LSART_NET) ||
! 495: (l->type == LSART_STUB) ||
! 496: (l->type == LSART_VLNK)))
! 497: return 0;
! 498: }
! 499:
! 500: if ((body->options & LSA_RT2_LINKS) != i)
! 501: return 0;
! 502:
! 503: return 1;
! 504: }
! 505:
! 506:
! 507: static int
! 508: lsa_validate_rt3(struct ospf_lsa_header *lsa, struct ospf_lsa_rt *body)
! 509: {
! 510: if (lsa->length < (HDRLEN + sizeof(struct ospf_lsa_rt)))
! 511: return 0;
! 512:
! 513: void *buf = body;
! 514: void *bufend = buf + lsa->length - HDRLEN;
! 515: buf += sizeof(struct ospf_lsa_rt);
! 516:
! 517: while (buf < bufend)
! 518: {
! 519: struct ospf_lsa_rt3_link *l = buf;
! 520: buf += sizeof(struct ospf_lsa_rt3_link);
! 521:
! 522: if (buf > bufend)
! 523: return 0;
! 524:
! 525: if (!((l->type == LSART_PTP) ||
! 526: (l->type == LSART_NET) ||
! 527: (l->type == LSART_VLNK)))
! 528: return 0;
! 529: }
! 530: return 1;
! 531: }
! 532:
! 533: static int
! 534: lsa_validate_net(struct ospf_lsa_header *lsa, struct ospf_lsa_net *body UNUSED)
! 535: {
! 536: if (lsa->length < (HDRLEN + sizeof(struct ospf_lsa_net)))
! 537: return 0;
! 538:
! 539: return 1;
! 540: }
! 541:
! 542: static int
! 543: lsa_validate_sum2(struct ospf_lsa_header *lsa, struct ospf_lsa_sum2 *body)
! 544: {
! 545: if (lsa->length < (HDRLEN + sizeof(struct ospf_lsa_sum2)))
! 546: return 0;
! 547:
! 548: /* First field should have TOS = 0, we ignore other TOS fields */
! 549: if ((body->metric & LSA_SUM2_TOS) != 0)
! 550: return 0;
! 551:
! 552: return 1;
! 553: }
! 554:
! 555: static inline int
! 556: pxlen(u32 *buf)
! 557: {
! 558: return *buf >> 24;
! 559: }
! 560:
! 561: static int
! 562: lsa_validate_sum3_net(struct ospf_lsa_header *lsa, struct ospf_lsa_sum3_net *body)
! 563: {
! 564: if (lsa->length < (HDRLEN + sizeof(struct ospf_lsa_sum3_net) + 4))
! 565: return 0;
! 566:
! 567: u8 pxl = pxlen(body->prefix);
! 568: if (pxl > IP6_MAX_PREFIX_LENGTH)
! 569: return 0;
! 570:
! 571: if (lsa->length != (HDRLEN + sizeof(struct ospf_lsa_sum3_net) +
! 572: IPV6_PREFIX_SPACE(pxl)))
! 573: return 0;
! 574:
! 575: return 1;
! 576: }
! 577:
! 578: static int
! 579: lsa_validate_sum3_rt(struct ospf_lsa_header *lsa, struct ospf_lsa_sum3_rt *body UNUSED)
! 580: {
! 581: if (lsa->length != (HDRLEN + sizeof(struct ospf_lsa_sum3_rt)))
! 582: return 0;
! 583:
! 584: return 1;
! 585: }
! 586:
! 587: static int
! 588: lsa_validate_ext2(struct ospf_lsa_header *lsa, struct ospf_lsa_ext2 *body)
! 589: {
! 590: if (lsa->length < (HDRLEN + sizeof(struct ospf_lsa_ext2)))
! 591: return 0;
! 592:
! 593: /* First field should have TOS = 0, we ignore other TOS fields */
! 594: if ((body->metric & LSA_EXT2_TOS) != 0)
! 595: return 0;
! 596:
! 597: return 1;
! 598: }
! 599:
! 600: static int
! 601: lsa_validate_ext3(struct ospf_lsa_header *lsa, struct ospf_lsa_ext3 *body)
! 602: {
! 603: if (lsa->length < (HDRLEN + sizeof(struct ospf_lsa_ext3) + 4))
! 604: return 0;
! 605:
! 606: u8 pxl = pxlen(body->rest);
! 607: if (pxl > IP6_MAX_PREFIX_LENGTH)
! 608: return 0;
! 609:
! 610: int len = IPV6_PREFIX_SPACE(pxl);
! 611: if (body->metric & LSA_EXT3_FBIT) // forwarding address
! 612: len += 16;
! 613: if (body->metric & LSA_EXT3_TBIT) // route tag
! 614: len += 4;
! 615: if (*body->rest & 0xFFFF) // referenced LS type field
! 616: len += 4;
! 617:
! 618: if (lsa->length != (HDRLEN + sizeof(struct ospf_lsa_ext3) + len))
! 619: return 0;
! 620:
! 621: return 1;
! 622: }
! 623:
! 624: static int
! 625: lsa_validate_pxlist(struct ospf_lsa_header *lsa, u32 pxcount, uint offset, u8 *pbuf)
! 626: {
! 627: uint bound = lsa->length - HDRLEN - 4;
! 628: u32 i;
! 629:
! 630: for (i = 0; i < pxcount; i++)
! 631: {
! 632: if (offset > bound)
! 633: return 0;
! 634:
! 635: u8 pxl = pxlen((u32 *) (pbuf + offset));
! 636: if (pxl > IP6_MAX_PREFIX_LENGTH)
! 637: return 0;
! 638:
! 639: offset += IPV6_PREFIX_SPACE(pxl);
! 640: }
! 641:
! 642: if (lsa->length != (HDRLEN + offset))
! 643: return 0;
! 644:
! 645: return 1;
! 646: }
! 647:
! 648: static int
! 649: lsa_validate_link(struct ospf_lsa_header *lsa, struct ospf_lsa_link *body)
! 650: {
! 651: if (lsa->length < (HDRLEN + sizeof(struct ospf_lsa_link)))
! 652: return 0;
! 653:
! 654: return lsa_validate_pxlist(lsa, body->pxcount, sizeof(struct ospf_lsa_link), (u8 *) body);
! 655: }
! 656:
! 657: static int
! 658: lsa_validate_prefix(struct ospf_lsa_header *lsa, struct ospf_lsa_prefix *body)
! 659: {
! 660: if (lsa->length < (HDRLEN + sizeof(struct ospf_lsa_prefix)))
! 661: return 0;
! 662:
! 663: return lsa_validate_pxlist(lsa, body->pxcount, sizeof(struct ospf_lsa_prefix), (u8 *) body);
! 664: }
! 665:
! 666: static int
! 667: lsa_validate_gr(struct ospf_lsa_header *lsa, void *body)
! 668: {
! 669: return lsa_validate_tlvs(body, lsa->length - HDRLEN);
! 670: }
! 671:
! 672: static int
! 673: lsa_validate_ri(struct ospf_lsa_header *lsa UNUSED, struct ospf_lsa_net *body UNUSED)
! 674: {
! 675: /*
! 676: * There should be proper validation. But we do not really process RI LSAs, so
! 677: * we can just accept them like another unknown opaque LSAs.
! 678: */
! 679:
! 680: return 1;
! 681: }
! 682:
! 683:
! 684: /**
! 685: * lsa_validate - check whether given LSA is valid
! 686: * @lsa: LSA header
! 687: * @lsa_type: internal LSA type (%LSA_T_xxx)
! 688: * @ospf2: %true for OSPFv2, %false for OSPFv3
! 689: * @body: pointer to LSA body
! 690: *
! 691: * Checks internal structure of given LSA body (minimal length,
! 692: * consistency). Returns true if valid.
! 693: */
! 694: int
! 695: lsa_validate(struct ospf_lsa_header *lsa, u32 lsa_type, int ospf2, void *body)
! 696: {
! 697: if (ospf2)
! 698: {
! 699: switch (lsa_type)
! 700: {
! 701: case LSA_T_RT:
! 702: return lsa_validate_rt2(lsa, body);
! 703: case LSA_T_NET:
! 704: return lsa_validate_net(lsa, body);
! 705: case LSA_T_SUM_NET:
! 706: return lsa_validate_sum2(lsa, body);
! 707: case LSA_T_SUM_RT:
! 708: return lsa_validate_sum2(lsa, body);
! 709: case LSA_T_EXT:
! 710: case LSA_T_NSSA:
! 711: return lsa_validate_ext2(lsa, body);
! 712: case LSA_T_GR:
! 713: return lsa_validate_gr(lsa, body);
! 714: case LSA_T_RI_LINK:
! 715: case LSA_T_RI_AREA:
! 716: case LSA_T_RI_AS:
! 717: return lsa_validate_ri(lsa, body);
! 718: case LSA_T_OPAQUE_LINK:
! 719: case LSA_T_OPAQUE_AREA:
! 720: case LSA_T_OPAQUE_AS:
! 721: return 1; /* Unknown Opaque LSAs */
! 722: default:
! 723: return 0; /* Should not happen, unknown LSAs are already rejected */
! 724: }
! 725: }
! 726: else
! 727: {
! 728: switch (lsa_type)
! 729: {
! 730: case LSA_T_RT:
! 731: return lsa_validate_rt3(lsa, body);
! 732: case LSA_T_NET:
! 733: return lsa_validate_net(lsa, body);
! 734: case LSA_T_SUM_NET:
! 735: return lsa_validate_sum3_net(lsa, body);
! 736: case LSA_T_SUM_RT:
! 737: return lsa_validate_sum3_rt(lsa, body);
! 738: case LSA_T_EXT:
! 739: case LSA_T_NSSA:
! 740: return lsa_validate_ext3(lsa, body);
! 741: case LSA_T_LINK:
! 742: return lsa_validate_link(lsa, body);
! 743: case LSA_T_PREFIX:
! 744: return lsa_validate_prefix(lsa, body);
! 745: case LSA_T_GR:
! 746: return lsa_validate_gr(lsa, body);
! 747: case LSA_T_RI_LINK:
! 748: case LSA_T_RI_AREA:
! 749: case LSA_T_RI_AS:
! 750: return lsa_validate_ri(lsa, body);
! 751: default:
! 752: return 1; /* Unknown LSAs are OK in OSPFv3 */
! 753: }
! 754: }
! 755: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to lsalib.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