Revision fe9f1a6d proto/ospf/rt.c

View differences:

proto/ospf/rt.c
21 21
  bzero(&ort->n, sizeof(orta));
22 22
}
23 23

  
24
void
25
ospf_rt_initort(struct fib_node *fn)
26
{
27
  ort *ri = (ort *) fn;
28
  reset_ri(ri);
29
  ri->old_rta = NULL;
30
  ri->fn.flags = 0;
31
}
32

  
33 24
static inline int
34 25
nh_is_vlink(struct mpnh *nhs)
35 26
{
......
334 325

  
335 326

  
336 327
static inline void
337
ri_install_net(struct ospf_proto *p, ip_addr prefix, int pxlen, const orta *new)
328
ri_install_net(struct ospf_proto *p, net_addr *net, const orta *new)
338 329
{
339
  ort *old = (ort *) fib_get(&p->rtf, &prefix, pxlen);
330
  ort *old = fib_get(&p->rtf, net);
340 331
  int cmp = orta_compare(p, new, &old->n);
341 332

  
342 333
  if (cmp > 0)
......
348 339
static inline void
349 340
ri_install_rt(struct ospf_area *oa, u32 rid, const orta *new)
350 341
{
351
  ip_addr addr = ipa_from_rid(rid);
352
  ort *old = (ort *) fib_get(&oa->rtr, &addr, MAX_PREFIX_LENGTH);
342
  net_addr_ip4 nrid = net_from_rid(rid);
343
  ort *old = fib_get(&oa->rtr, (net_addr *) &nrid);
353 344
  int cmp = orta_compare(oa->po, new, &old->n);
354 345

  
355 346
  if (cmp > 0)
......
359 350
}
360 351

  
361 352
static inline void
362
ri_install_asbr(struct ospf_proto *p, ip_addr *addr, const orta *new)
353
ri_install_asbr(struct ospf_proto *p, u32 rid, const orta *new)
363 354
{
364
  ort *old = (ort *) fib_get(&p->backbone->rtr, addr, MAX_PREFIX_LENGTH);
355
  net_addr_ip4 nrid = net_from_rid(rid);
356
  ort *old = fib_get(&p->backbone->rtr, (net_addr *) &nrid);
357

  
365 358
  if (orta_compare_asbr(p, new, &old->n) > 0)
366 359
    ort_replace(old, new);
367 360
}
368 361

  
369 362
static inline void
370
ri_install_ext(struct ospf_proto *p, ip_addr prefix, int pxlen, const orta *new)
363
ri_install_ext(struct ospf_proto *p, net_addr *net, const orta *new)
371 364
{
372
  ort *old = (ort *) fib_get(&p->rtf, &prefix, pxlen);
365
  ort *old = fib_get(&p->rtf, net);
373 366
  int cmp = orta_compare_ext(p, new, &old->n);
374 367

  
375 368
  if (cmp > 0)
......
404 397

  
405 398

  
406 399
static void
407
add_network(struct ospf_area *oa, ip_addr px, int pxlen, int metric, struct top_hash_entry *en, int pos)
400
add_network(struct ospf_area *oa, net_addr *net, int metric, struct top_hash_entry *en, int pos)
408 401
{
409 402
  struct ospf_proto *p = oa->po;
410 403

  
......
419 412
    .nhs = en->nhs
420 413
  };
421 414

  
422
  if (pxlen < 0 || pxlen > MAX_PREFIX_LENGTH)
415
  if (net->pxlen > MAX_PREFIX_LENGTH)
423 416
  {
424 417
    log(L_WARN "%s: Invalid prefix in LSA (Type: %04x, Id: %R, Rt: %R)",
425 418
	p->p.name, en->lsa_type, en->lsa.id, en->lsa.rt);
......
441 434
    nf.nhs = ifa ? new_nexthop(p, IPA_NONE, ifa->iface, ifa->ecmp_weight) : NULL;
442 435
  }
443 436

  
444
  ri_install_net(p, px, pxlen, &nf);
437
  ri_install_net(p, net, &nf);
445 438
}
446 439

  
447 440

  
......
452 445
  struct ospf_lsa_rt *rt = act->lsa_body;
453 446
  struct ospf_lsa_rt_walk rtl;
454 447
  struct top_hash_entry *tmp;
455
  ip_addr prefix;
456
  int pxlen, i;
448
  int i;
457 449

  
458 450
  if (rt->options & OPT_RT_V)
459 451
    oa->trcap = 1;
......
503 495
       * the same result by handing them here because add_network()
504 496
       * will keep the best (not the first) found route.
505 497
       */
506
      prefix = ipa_from_u32(rtl.id & rtl.data);
507
      pxlen = u32_masklen(rtl.data);
508
      add_network(oa, prefix, pxlen, act->dist + rtl.metric, act, i);
498
      net_addr_ip4 net =
499
	NET_ADDR_IP4(ip4_from_u32(rtl.id & rtl.data), u32_masklen(rtl.data));
500

  
501
      add_network(oa, (net_addr *) &net, act->dist + rtl.metric, act, i);
509 502
      break;
510 503

  
511 504
    case LSART_NET:
......
527 520
{
528 521
  struct ospf_lsa_net *ln = act->lsa_body;
529 522
  struct top_hash_entry *tmp;
530
  ip_addr prefix;
531
  int pxlen, i, cnt;
523
  int i, cnt;
532 524

  
533 525
  if (ospf_is_v2(p))
534 526
  {
535
    prefix = ipa_from_u32(act->lsa.id & ln->optx);
536
    pxlen = u32_masklen(ln->optx);
537
    add_network(oa, prefix, pxlen, act->dist, act, -1);
527
    net_addr_ip4 net =
528
      NET_ADDR_IP4(ip4_from_u32(act->lsa.id & ln->optx), u32_masklen(ln->optx));
529

  
530
    add_network(oa, (net_addr *) &net, act->dist, act, -1);
538 531
  }
539 532

  
540 533
  cnt = lsa_net_count(&act->lsa);
......
550 543
{
551 544
  struct top_hash_entry *en, *src;
552 545
  struct ospf_lsa_prefix *px;
553
  ip_addr pxa;
554
  int pxlen;
555
  u8 pxopts;
556
  u16 metric;
557 546
  u32 *buf;
558 547
  int i;
559 548

  
......
588 577

  
589 578
    buf = px->rest;
590 579
    for (i = 0; i < px->pxcount; i++)
591
      {
592
	buf = lsa_get_ipv6_prefix(buf, &pxa, &pxlen, &pxopts, &metric);
580
    {
581
      net_addr_ip6 net;
582
      u8 pxopts;
583
      u16 metric;
593 584

  
594
	if (pxopts & OPT_PX_NU)
595
	  continue;
585
      buf = ospf_get_ipv6_prefix(buf, (net_addr *) &net, &pxopts, &metric);
596 586

  
597
	/* Store the first global address to use it later as a vlink endpoint */
598
	if ((pxopts & OPT_PX_LA) && ipa_zero(src->lb))
599
	  src->lb = pxa;
587
      if (pxopts & OPT_PX_NU)
588
	continue;
600 589

  
601
	add_network(oa, pxa, pxlen, src->dist + metric, src, i);
602
      }
590
      /* Store the first global address to use it later as a vlink endpoint */
591
      if ((pxopts & OPT_PX_LA) && ipa_zero(src->lb))
592
	src->lb = ipa_from_ip6(net.prefix);
593

  
594
      add_network(oa, (net_addr *) &net, src->dist + metric, src, i);
595
    }
603 596
  }
604 597
}
605 598

  
......
742 735
{
743 736
  struct ospf_proto *p = oa->po;
744 737
  struct top_hash_entry *en;
745
  ip_addr ip, abrip;
738
  net_addr net;
746 739
  u32 dst_rid, metric, options;
747 740
  ort *abr;
748
  int pxlen = -1, type = -1;
741
  int type;
749 742
  u8 pxopts;
750 743

  
751

  
752 744
  OSPF_TRACE(D_EVENTS, "Starting routing table calculation for inter-area (area %R)", oa->areaid);
753 745

  
754 746
  WALK_SLIST(en, p->lsal)
......
771 763

  
772 764
    if (en->lsa_type == LSA_T_SUM_NET)
773 765
    {
774
      lsa_parse_sum_net(en, ospf_is_v2(p), &ip, &pxlen, &pxopts, &metric);
766
      lsa_parse_sum_net(en, ospf_is_v2(p), &net, &pxopts, &metric);
775 767

  
776 768
      if (pxopts & OPT_PX_NU)
777 769
	continue;
778 770

  
779
      if (pxlen < 0 || pxlen > MAX_PREFIX_LENGTH)
771
      if (net.pxlen > MAX_PREFIX_LENGTH)
780 772
      {
781 773
	log(L_WARN "%s: Invalid prefix in LSA (Type: %04x, Id: %R, Rt: %R)",
782 774
	    p->p.name, en->lsa_type, en->lsa.id, en->lsa.rt);
......
803 795
      continue;
804 796

  
805 797
    /* 16.2. (4) */
806
    abrip = ipa_from_rid(en->lsa.rt);
807
    abr = (ort *) fib_find(&oa->rtr, &abrip, MAX_PREFIX_LENGTH);
798
    net_addr_ip4 nrid = net_from_rid(en->lsa.rt);
799
    abr = fib_find(&oa->rtr, (net_addr *) &nrid);
808 800
    if (!abr || !abr->n.type)
809 801
      continue;
810 802

  
......
828 820
    };
829 821

  
830 822
    if (type == ORT_NET)
831
      ri_install_net(p, ip, pxlen, &nf);
823
      ri_install_net(p, &net, &nf);
832 824
    else
833 825
      ri_install_rt(oa, dst_rid, &nf);
834 826
  }
......
842 834
  struct ospf_area *bb = p->backbone;
843 835
  struct top_hash_entry *en;
844 836
  ort *re, *abr;
845
  ip_addr ip, abrip;
846
  u32 dst_rid, metric, options;
847
  int pxlen;
848
  u8 pxopts;
849

  
837
  u32 metric;
850 838

  
851 839
  if (!bb)
852 840
    return;
......
869 857

  
870 858
    if (en->lsa_type == LSA_T_SUM_NET)
871 859
    {
872
      lsa_parse_sum_net(en, ospf_is_v2(p), &ip, &pxlen, &pxopts, &metric);
860
      net_addr net;
861
      u8 pxopts;
862

  
863
      lsa_parse_sum_net(en, ospf_is_v2(p), &net, &pxopts, &metric);
873 864

  
874 865
      if (pxopts & OPT_PX_NU)
875 866
	continue;
876 867

  
877
      if (pxlen < 0 || pxlen > MAX_PREFIX_LENGTH)
868
      if (net.pxlen > MAX_PREFIX_LENGTH)
878 869
      {
879 870
	log(L_WARN "%s: Invalid prefix in LSA (Type: %04x, Id: %R, Rt: %R)",
880 871
	    p->p.name, en->lsa_type, en->lsa.id, en->lsa.rt);
881 872
	continue;
882 873
      }
883 874

  
884
      re = fib_find(&p->rtf, &ip, pxlen);
875
      re = fib_find(&p->rtf, &net);
885 876
    }
886 877
    else // en->lsa_type == LSA_T_SUM_RT
887 878
    {
879
      u32 dst_rid, options;
880

  
888 881
      lsa_parse_sum_rt(en, ospf_is_v2(p), &dst_rid, &metric, &options);
889 882

  
890
      ip = ipa_from_rid(dst_rid);
891
      re = fib_find(&bb->rtr, &ip, MAX_PREFIX_LENGTH);
883
      net_addr_ip4 nrid = net_from_rid(dst_rid);
884
      re = fib_find(&bb->rtr, (net_addr *) &nrid);
892 885
    }
893 886

  
894 887
    /* 16.3 (1b) */
......
906 899
      continue;
907 900

  
908 901
    /* 16.3. (4) */
909
    abrip = ipa_from_rid(en->lsa.rt);
910
    abr = fib_find(&oa->rtr, &abrip, MAX_PREFIX_LENGTH);
902
    net_addr_ip4 nrid = net_from_rid(en->lsa.rt);
903
    abr = fib_find(&oa->rtr, (net_addr *) &nrid);
911 904
    if (!abr || !abr->n.type)
912 905
      continue;
913 906

  
......
998 991
    return 1;
999 992

  
1000 993
  struct area_net *anet = (struct area_net *)
1001
    fib_route(&nf->n.oa->net_fib, nf->fn.prefix, nf->fn.pxlen);
994
    fib_route(&nf->n.oa->net_fib, nf->fn.addr);
1002 995

  
1003 996
  /* Condensed area network found */
1004 997
  if (anet)
......
1017 1010
  if (nf->area_net)
1018 1011
  {
1019 1012
    /* It is a default route for stub areas, handled entirely in ospf_rt_abr() */
1020
    if (nf->fn.pxlen == 0)
1013
    if (nf->fn.addr->pxlen == 0)
1021 1014
      return;
1022 1015

  
1023 1016
    /* Find that area network */
1024 1017
    WALK_LIST(anet_oa, p->area_list)
1025 1018
    {
1026
      anet = (struct area_net *) fib_find(&anet_oa->net_fib, &nf->fn.prefix, nf->fn.pxlen);
1019
      anet = fib_find(&anet_oa->net_fib, nf->fn.addr);
1027 1020
      if (anet)
1028 1021
	break;
1029 1022
    }
......
1042 1035
static inline void
1043 1036
check_sum_rt_lsa(struct ospf_proto *p, ort *nf)
1044 1037
{
1038
  u32 rid = rid_from_net(nf->fn.addr);
1039

  
1045 1040
  struct ospf_area *oa;
1046 1041
  WALK_LIST(oa, p->area_list)
1047 1042
    if (decide_sum_lsa(oa, nf, ORT_ROUTER))
1048
      ospf_originate_sum_rt_lsa(p, oa, nf, nf->n.metric1, nf->n.options);
1043
      ospf_originate_sum_rt_lsa(p, oa, rid, nf->n.metric1, nf->n.options);
1049 1044
}
1050 1045

  
1051 1046
static inline int
......
1058 1053
    return 0;
1059 1054

  
1060 1055
  /* Condensed area network found */
1061
  if (fib_route(&oa->enet_fib, nf->fn.prefix, nf->fn.pxlen))
1056
  if (fib_route(&oa->enet_fib, nf->fn.addr))
1062 1057
    return 0;
1063 1058

  
1064 1059
  if (!en || (en->lsa_type != LSA_T_NSSA))
......
1093 1088
    /* Find that area network */
1094 1089
    WALK_LIST(oa, p->area_list)
1095 1090
    {
1096
      anet = (struct area_net *) fib_find(&oa->enet_fib, &nf->fn.prefix, nf->fn.pxlen);
1091
      anet = fib_find(&oa->enet_fib, nf->fn.addr);
1097 1092
      if (anet)
1098 1093
	break;
1099 1094
    }
......
1164 1159
{
1165 1160
  struct area_net *anet;
1166 1161
  ort *nf, *default_nf;
1162
  net_addr default_net;
1167 1163

  
1168 1164
  /* RFC 2328 G.3 - incomplete resolution of virtual next hops - routers */
1169 1165
  FIB_WALK(&p->backbone->rtr, nftmp)
......
1189 1185
    /* Compute condensed area networks */
1190 1186
    if (nf->n.type == RTS_OSPF)
1191 1187
    {
1192
      anet = (struct area_net *) fib_route(&nf->n.oa->net_fib, nf->fn.prefix, nf->fn.pxlen);
1188
      anet = (struct area_net *) fib_route(&nf->n.oa->net_fib, nf->fn.addr);
1193 1189
      if (anet)
1194 1190
      {
1195 1191
	if (!anet->active)
......
1197 1193
	  anet->active = 1;
1198 1194

  
1199 1195
	  /* Get a RT entry and mark it to know that it is an area network */
1200
	  ort *nfi = (ort *) fib_get(&p->rtf, &anet->fn.prefix, anet->fn.pxlen);
1196
	  ort *nfi = fib_get(&p->rtf, anet->fn.addr);
1201 1197
	  nfi->area_net = 1;
1202 1198

  
1203 1199
	  /* 16.2. (3) */
......
1212 1208
  }
1213 1209
  FIB_WALK_END;
1214 1210

  
1215
  ip_addr addr = IPA_NONE;
1216
  default_nf = (ort *) fib_get(&p->rtf, &addr, 0);
1211

  
1212
  if (ospf_is_v2(p))
1213
    net_fill_ip4(&default_net, IP4_NONE, 0);
1214
  else
1215
    net_fill_ip6(&default_net, IP6_NONE, 0);
1216

  
1217
  default_nf = fib_get(&p->rtf, &default_net);
1217 1218
  default_nf->area_net = 1;
1218 1219

  
1219 1220
  struct ospf_area *oa;
......
1244 1245
      {
1245 1246
	nf = (ort *) nftmp;
1246 1247
	if (nf->n.options & ORTA_ASBR)
1247
	  ri_install_asbr(p, &nf->fn.prefix, &nf->n);
1248
	  ri_install_asbr(p, rid_from_net(nf->fn.addr), &nf->n);
1248 1249
      }
1249 1250
      FIB_WALK_END;
1250 1251
    }
......
1300 1301
	if (!nf->n.type || !(nf->n.options & ORTA_ABR))
1301 1302
	  continue;
1302 1303

  
1303
	nf2 = fib_find(&bb->rtr, &nf->fn.prefix, MAX_PREFIX_LENGTH);
1304
	nf2 = fib_find(&bb->rtr, nf->fn.addr);
1304 1305
	if (!nf2 || !nf2->n.type || !(nf2->n.options & ORTA_ABR))
1305 1306
	  continue;
1306 1307

  
......
1346 1347
    if (rt_is_nssa(nf) && (nf->n.options & ORTA_PROP))
1347 1348
    {
1348 1349
      struct area_net *anet = (struct area_net *)
1349
	fib_route(&nf->n.oa->enet_fib, nf->fn.prefix, nf->fn.pxlen);
1350
	fib_route(&nf->n.oa->enet_fib, nf->fn.addr);
1350 1351

  
1351 1352
      if (anet)
1352 1353
      {
......
1355 1356
	  anet->active = 1;
1356 1357

  
1357 1358
	  /* Get a RT entry and mark it to know that it is an area network */
1358
	  nf2 = (ort *) fib_get(&p->rtf, &anet->fn.prefix, anet->fn.pxlen);
1359
	  nf2 = fib_get(&p->rtf, anet->fn.addr);
1359 1360
	  nf2->area_net = 1;
1360 1361
	}
1361 1362

  
......
1383 1384

  
1384 1385
/* Like fib_route(), but ignores dummy rt entries */
1385 1386
static void *
1386
ospf_fib_route(struct fib *f, ip_addr a, int len)
1387
ospf_fib_route_ip4(struct fib *f, ip4_addr a, int len)
1388
{
1389
  net_addr_ip4 net = NET_ADDR_IP4(a, len);
1390
  ort *nf;
1391

  
1392
loop:
1393
  nf = fib_find(f, (net_addr *) &net);
1394
  if (nf && nf->n.type)
1395
    return nf;
1396

  
1397
  if (net.pxlen > 0)
1398
  {
1399
    net.pxlen--;
1400
    ip4_clrbit(&net.prefix, net.pxlen);
1401
    goto loop;
1402
  }
1403

  
1404
  return NULL;
1405
}
1406

  
1407
static void *
1408
ospf_fib_route_ip6(struct fib *f, ip6_addr a, int len)
1387 1409
{
1388
  ip_addr a0;
1410
  net_addr_ip6 net = NET_ADDR_IP6(a, len);
1389 1411
  ort *nf;
1390 1412

  
1391
  while (len >= 0)
1413
loop:
1414
  nf = fib_find(f, (net_addr *) &net);
1415
  if (nf && nf->n.type)
1416
    return nf;
1417

  
1418
  if (net.pxlen > 0)
1392 1419
  {
1393
    a0 = ipa_and(a, ipa_mkmask(len));
1394
    nf = fib_find(f, &a0, len);
1395
    if (nf && nf->n.type)
1396
      return nf;
1397
    len--;
1420
    net.pxlen--;
1421
    ip6_clrbit(&net.prefix, net.pxlen);
1422
    goto loop;
1398 1423
  }
1424

  
1399 1425
  return NULL;
1400 1426
}
1401 1427

  
1428
static void *
1429
ospf_fib_route(struct fib *f, ip_addr a)
1430
{
1431
  if (ospf_is_v2(p))
1432
    return ospf_fib_route_ip4(f, ipa_to_ip4(a), IP4_MAX_PREFIX_LENGTH);
1433
  else
1434
    return ospf_fib_route_ip6(f, ipa_to_ip6(a), IP6_MAX_PREFIX_LENGTH);
1435
}
1436

  
1437

  
1402 1438
/* RFC 2328 16.4. calculating external routes */
1403 1439
static void
1404 1440
ospf_ext_spf(struct ospf_proto *p)
......
1407 1443
  struct ospf_lsa_ext_local rt;
1408 1444
  ort *nf1, *nf2;
1409 1445
  orta nfa = {};
1410
  ip_addr rtid;
1411 1446
  u32 br_metric;
1412 1447
  struct ospf_area *atmp;
1413 1448

  
......
1437 1472
    if (rt.pxopts & OPT_PX_NU)
1438 1473
      continue;
1439 1474

  
1440
    if (rt.pxlen < 0 || rt.pxlen > MAX_PREFIX_LENGTH)
1475
    if (rt.net.pxlen > MAX_PREFIX_LENGTH)
1441 1476
    {
1442 1477
      log(L_WARN "%s: Invalid prefix in LSA (Type: %04x, Id: %R, Rt: %R)",
1443 1478
	  p->p.name, en->lsa_type, en->lsa.id, en->lsa.rt);
......
1457 1492
    if (!atmp)
1458 1493
      continue;			/* Should not happen */
1459 1494

  
1460
    rtid = ipa_from_rid(en->lsa.rt);
1461
    nf1 = fib_find(&atmp->rtr, &rtid, MAX_PREFIX_LENGTH);
1495
    net_addr_ip4 nrid = net_from_rid(en->lsa.rt);
1496
    nf1 = fib_find(&atmp->rtr, (net_addr *) &nrid);
1462 1497

  
1463 1498
    if (!nf1 || !nf1->n.type)
1464 1499
      continue;			/* No AS boundary router found */
......
1468 1503

  
1469 1504
    /* 16.4. (3) NSSA - special rule for default routes */
1470 1505
    /* ABR should use default only if P-bit is set and summaries are active */
1471
    if ((en->lsa_type == LSA_T_NSSA) && ipa_zero(rt.ip) && (rt.pxlen == 0) &&
1506
    if ((en->lsa_type == LSA_T_NSSA) && (rt.net.pxlen == 0) &&
1472 1507
	(p->areano > 1) && !(rt.propagate && atmp->ac->summary))
1473 1508
      continue;
1474 1509

  
......
1480 1515
    }
1481 1516
    else
1482 1517
    {
1483
      nf2 = ospf_fib_route(&p->rtf, rt.fwaddr, MAX_PREFIX_LENGTH);
1518
      nf2 = ospf_fib_route(&p->rtf, rt.fwaddr);
1484 1519
      if (!nf2)
1485 1520
	continue;
1486 1521

  
......
1542 1577
    nfa.oa = atmp; /* undefined in RFC 2328 */
1543 1578
    nfa.en = en; /* store LSA for later (NSSA processing) */
1544 1579

  
1545
    ri_install_ext(p, rt.ip, rt.pxlen, &nfa);
1580
    ri_install_ext(p, &rt.net, &nfa);
1546 1581
  }
1547 1582
}
1548 1583

  
......
1961 1996

  
1962 1997
      if (reload || ort_changed(nf, &a0))
1963 1998
      {
1964
	net *ne = net_get(p->p.table, nf->fn.prefix, nf->fn.pxlen);
1999
	net *ne = net_get(p->p.table, nf->fn.addr);
1965 2000
	rta *a = rta_lookup(&a0);
1966 2001
	rte *e = rte_get_temp(a);
1967 2002

  
......
1975 2010
	e->net = ne;
1976 2011
	e->pref = p->p.preference;
1977 2012

  
1978
	DBG("Mod rte type %d - %I/%d via %I on iface %s, met %d\n",
1979
	    a0.source, nf->fn.prefix, nf->fn.pxlen, a0.gw, a0.iface ? a0.iface->name : "(none)", nf->n.metric1);
2013
	DBG("Mod rte type %d - %N via %I on iface %s, met %d\n",
2014
	    a0.source, nf->fn.addr, a0.gw, a0.iface ? a0.iface->name : "(none)", nf->n.metric1);
1980 2015
	rte_update(&p->p, ne, e);
1981 2016
      }
1982 2017
    }
......
1986 2021
      rta_free(nf->old_rta);
1987 2022
      nf->old_rta = NULL;
1988 2023

  
1989
      net *ne = net_get(p->p.table, nf->fn.prefix, nf->fn.pxlen);
2024
      net *ne = net_get(p->p.table, nf->fn.addr);
1990 2025
      rte_update(&p->p, ne, NULL);
1991 2026
    }
1992 2027

  

Also available in: Unified diff