Revision 8b58f565

View differences:

proto/babel/babel.c
70 70
{
71 71
  struct babel_entry *e = E;
72 72

  
73
  e->updated = now;
73
  e->updated = current_time();
74 74
  init_list(&e->sources);
75 75
  init_list(&e->routes);
76 76
}
......
114 114

  
115 115
  s = sl_alloc(p->source_slab);
116 116
  s->router_id = router_id;
117
  s->expires = now + BABEL_GARBAGE_INTERVAL;
117
  s->expires = current_time() + BABEL_GARBAGE_INTERVAL;
118 118
  s->seqno = 0;
119 119
  s->metric = BABEL_INFINITY;
120 120
  add_tail(&e->sources, NODE s);
......
127 127
{
128 128
  struct babel_proto *p = e->proto;
129 129
  struct babel_source *n, *nx;
130
  btime now_ = current_time();
130 131

  
131 132
  WALK_LIST_DELSAFE(n, nx, e->sources)
132 133
  {
133
    if (n->expires && n->expires <= now)
134
    if (n->expires && n->expires <= now_)
134 135
    {
135 136
      rem_node(NODE n);
136 137
      sl_free(p->source_slab, n);
......
167 168
  if (nbr)
168 169
  {
169 170
    r->neigh = nbr;
170
    r->expires = now + BABEL_GARBAGE_INTERVAL;
171
    r->expires = current_time() + BABEL_GARBAGE_INTERVAL;
171 172
    add_tail(&nbr->routes, NODE &r->neigh_route);
172 173
  }
173 174

  
......
208 209
  if (r->metric < BABEL_INFINITY)
209 210
  {
210 211
    r->metric = BABEL_INFINITY;
211
    r->expires = now + r->expiry_interval;
212
    r->expires = current_time() + r->expiry_interval;
212 213
  }
213 214
  else
214 215
  {
......
230 231
{
231 232
  struct babel_route *r, *rx;
232 233
  struct fib_iterator fit;
234
  btime now_ = current_time();
233 235

  
234 236
  FIB_ITERATE_INIT(&fit, rtable);
235 237

  
......
240 242

  
241 243
    WALK_LIST_DELSAFE(r, rx, e->routes)
242 244
    {
243
      if (r->refresh_time && r->refresh_time <= now)
245
      if (r->refresh_time && r->refresh_time <= now_)
244 246
	babel_refresh_route(r);
245 247

  
246
      if (r->expires && r->expires <= now)
248
      if (r->expires && r->expires <= now_)
247 249
      {
248 250
	babel_expire_route(r);
249 251
	changed = 1;
......
360 362
{
361 363
  struct babel_iface *ifa;
362 364
  struct babel_neighbor *nbr, *nbx;
365
  btime now_ = current_time();
363 366

  
364 367
  WALK_LIST(ifa, p->interfaces)
365 368
  {
366 369
    WALK_LIST_DELSAFE(nbr, nbx, ifa->neigh_list)
367 370
    {
368
      if (nbr->ihu_expiry && nbr->ihu_expiry <= now)
371
      if (nbr->ihu_expiry && nbr->ihu_expiry <= now_)
369 372
        babel_expire_ihu(nbr);
370 373

  
371
      if (nbr->hello_expiry && nbr->hello_expiry <= now)
374
      if (nbr->hello_expiry && nbr->hello_expiry <= now_)
372 375
        babel_expire_hello(nbr);
373 376
    }
374 377
  }
......
546 549
	  e->n.addr, cur->router_id, cur->metric);
547 550

  
548 551
    e->selected_in = cur;
549
    e->updated = now;
552
    e->updated = current_time();
550 553
    babel_announce_rte(p, e);
551 554
  }
552 555
  else if (!cur || cur->metric == BABEL_INFINITY)
......
562 565
	    e->n.addr);
563 566

  
564 567
      e->selected_in->metric = BABEL_INFINITY;
565
      e->updated = now;
568
      e->updated = current_time();
566 569

  
567 570
      babel_send_seqno_request(e);
568 571
      babel_announce_rte(p, e);
......
580 583
      TRACE(D_EVENTS, "Flushing route for prefix %N", e->n.addr);
581 584

  
582 585
      e->selected_in = NULL;
583
      e->updated = now;
586
      e->updated = current_time();
584 587
      babel_announce_rte(p, e);
585 588
    }
586 589
  }
......
614 617
  msg->ihu.rxcost = babel_compute_rxcost(n);
615 618
  msg->ihu.interval = ifa->cf->ihu_interval;
616 619

  
617
  TRACE(D_PACKETS, "Sending IHU for %I with rxcost %d interval %d",
618
        msg->ihu.addr, msg->ihu.rxcost, msg->ihu.interval);
620
  TRACE(D_PACKETS, "Sending IHU for %I with rxcost %d interval %t",
621
        msg->ihu.addr, msg->ihu.rxcost, (btime) msg->ihu.interval);
619 622
}
620 623

  
621 624
static void
......
648 651
  msg.hello.seqno = ifa->hello_seqno++;
649 652
  msg.hello.interval = ifa->cf->hello_interval;
650 653

  
651
  TRACE(D_PACKETS, "Sending hello on %s with seqno %d interval %d",
652
	ifa->ifname, msg.hello.seqno, msg.hello.interval);
654
  TRACE(D_PACKETS, "Sending hello on %s with seqno %d interval %t",
655
	ifa->ifname, msg.hello.seqno, (btime) msg.hello.interval);
653 656

  
654 657
  babel_enqueue(&msg, ifa);
655 658

  
......
750 753
 * transmitted entry is updated.
751 754
 */
752 755
static void
753
babel_send_update_(struct babel_iface *ifa, bird_clock_t changed, struct fib *rtable)
756
babel_send_update_(struct babel_iface *ifa, btime changed, struct fib *rtable)
754 757
{
755 758
  struct babel_proto *p = ifa->proto;
756 759

  
......
766 769
    if ((r->router_id == p->router_id) && (r->seqno < p->update_seqno))
767 770
    {
768 771
      r->seqno = p->update_seqno;
769
      e->updated = now;
772
      e->updated = current_time();
770 773
    }
771 774

  
772 775
    /* Skip routes that weren't updated since 'changed' time */
......
793 796
    if (!OUR_ROUTE(r))
794 797
    {
795 798
      struct babel_source *s = babel_get_source(e, r->router_id);
796
      s->expires = now + BABEL_GARBAGE_INTERVAL;
799
      s->expires = current_time() + BABEL_GARBAGE_INTERVAL;
797 800

  
798 801
      if ((msg.update.seqno > s->seqno) ||
799 802
	  ((msg.update.seqno == s->seqno) && (msg.update.metric < s->metric)))
......
807 810
}
808 811

  
809 812
static void
810
babel_send_update(struct babel_iface *ifa, bird_clock_t changed)
813
babel_send_update(struct babel_iface *ifa, btime changed)
811 814
{
812 815
  struct babel_proto *p = ifa->proto;
813 816

  
......
827 830
  TRACE(D_EVENTS, "Scheduling triggered updates for %s seqno %d",
828 831
	ifa->iface->name, p->update_seqno);
829 832

  
830
  ifa->want_triggered = now;
833
  ifa->want_triggered = current_time();
831 834
  babel_iface_kick_timer(ifa);
832 835
}
833 836

  
......
887 890

  
888 891
/* Update hello history according to Appendix A1 of the RFC */
889 892
static void
890
babel_update_hello_history(struct babel_neighbor *n, u16 seqno, u16 interval)
893
babel_update_hello_history(struct babel_neighbor *n, u16 seqno, uint interval)
891 894
{
892 895
  /*
893 896
   * Compute the difference between expected and received seqno (modulo 2^16).
......
925 928
  n->hello_map = (n->hello_map << 1) | 1;
926 929
  n->next_hello_seqno = seqno+1;
927 930
  if (n->hello_cnt < 16) n->hello_cnt++;
928
  n->hello_expiry = now + BABEL_HELLO_EXPIRY_FACTOR(interval);
931
  n->hello_expiry = current_time() + BABEL_HELLO_EXPIRY_FACTOR(interval);
929 932
}
930 933

  
931 934
static void
932 935
babel_expire_seqno_requests(struct babel_proto *p)
933 936
{
937
  btime now_ = current_time();
938

  
934 939
  struct babel_seqno_request *n, *nx;
935 940
  WALK_LIST_DELSAFE(n, nx, p->seqno_cache)
936 941
  {
937
    if ((n->updated + BABEL_SEQNO_REQUEST_EXPIRY) <= now)
942
    if ((n->updated + BABEL_SEQNO_REQUEST_EXPIRY) <= now_)
938 943
    {
939 944
      rem_node(NODE n);
940 945
      sl_free(p->seqno_slab, n);
......
963 968
  net_copy(&r->net, n);
964 969
  r->router_id = router_id;
965 970
  r->seqno = seqno;
966
  r->updated = now;
971
  r->updated = current_time();
967 972
  add_tail(&p->seqno_cache, NODE r);
968 973

  
969 974
  return 1;
......
1013 1018
  struct babel_proto *p = ifa->proto;
1014 1019
  struct babel_msg_ack_req *msg = &m->ack_req;
1015 1020

  
1016
  TRACE(D_PACKETS, "Handling ACK request nonce %d interval %d",
1017
	msg->nonce, msg->interval);
1021
  TRACE(D_PACKETS, "Handling ACK request nonce %d interval %t",
1022
	msg->nonce, (btime) msg->interval);
1018 1023

  
1019 1024
  babel_send_ack(ifa, msg->sender, msg->nonce);
1020 1025
}
......
1025 1030
  struct babel_proto *p = ifa->proto;
1026 1031
  struct babel_msg_hello *msg = &m->hello;
1027 1032

  
1028
  TRACE(D_PACKETS, "Handling hello seqno %d interval %d",
1029
	msg->seqno, msg->interval);
1033
  TRACE(D_PACKETS, "Handling hello seqno %d interval %t",
1034
	msg->seqno, (btime) msg->interval);
1030 1035

  
1031 1036
  struct babel_neighbor *n = babel_get_neighbor(ifa, msg->sender);
1032 1037
  babel_update_hello_history(n, msg->seqno, msg->interval);
......
1044 1049
  if ((msg->ae != BABEL_AE_WILDCARD) && !ipa_equal(msg->addr, ifa->addr))
1045 1050
    return;
1046 1051

  
1047
  TRACE(D_PACKETS, "Handling IHU rxcost %d interval %d",
1048
	msg->rxcost, msg->interval);
1052
  TRACE(D_PACKETS, "Handling IHU rxcost %d interval %t",
1053
	msg->rxcost, (btime) msg->interval);
1049 1054

  
1050 1055
  struct babel_neighbor *n = babel_get_neighbor(ifa, msg->sender);
1051 1056
  n->txcost = msg->rxcost;
1052
  n->ihu_expiry = now + BABEL_IHU_EXPIRY_FACTOR(msg->interval);
1057
  n->ihu_expiry = current_time() + BABEL_IHU_EXPIRY_FACTOR(msg->interval);
1053 1058
}
1054 1059

  
1055 1060
/**
......
1214 1219
    r->seqno = msg->seqno;
1215 1220

  
1216 1221
    r->expiry_interval = BABEL_ROUTE_EXPIRY_FACTOR(msg->interval);
1217
    r->expires = now + r->expiry_interval;
1222
    r->expires = current_time() + r->expiry_interval;
1218 1223
    if (r->expiry_interval > BABEL_ROUTE_REFRESH_INTERVAL)
1219
      r->refresh_time = now + r->expiry_interval - BABEL_ROUTE_REFRESH_INTERVAL;
1224
      r->refresh_time = current_time() + r->expiry_interval - BABEL_ROUTE_REFRESH_INTERVAL;
1220 1225

  
1221 1226
    /* If the route is not feasible at this point, it means it is from another
1222 1227
       neighbour than the one currently selected; so send a unicast seqno
......
1256 1261
  else
1257 1262
  {
1258 1263
    babel_trigger_iface_update(ifa);
1259
    e->updated = now;
1264
    e->updated = current_time();
1260 1265
  }
1261 1266
}
1262 1267

  
......
1283 1288
  if ((r->router_id != msg->router_id) || ge_mod64k(r->seqno, msg->seqno))
1284 1289
  {
1285 1290
    babel_trigger_iface_update(ifa);
1286
    e->updated = now;
1291
    e->updated = current_time();
1287 1292
    return;
1288 1293
  }
1289 1294

  
......
1333 1338
{
1334 1339
  struct babel_iface *ifa = t->data;
1335 1340
  struct babel_proto *p = ifa->proto;
1336
  bird_clock_t hello_period = ifa->cf->hello_interval;
1337
  bird_clock_t update_period = ifa->cf->update_interval;
1341
  btime hello_period = ifa->cf->hello_interval;
1342
  btime update_period = ifa->cf->update_interval;
1343
  btime now_ = current_time();
1338 1344

  
1339
  if (now >= ifa->next_hello)
1345
  if (now_ >= ifa->next_hello)
1340 1346
  {
1341 1347
    babel_send_hello(ifa, (ifa->cf->type == BABEL_IFACE_TYPE_WIRELESS ||
1342 1348
                           ifa->hello_seqno % BABEL_IHU_INTERVAL_FACTOR == 0));
1343
    ifa->next_hello +=  hello_period * (1 + (now - ifa->next_hello) / hello_period);
1349
    ifa->next_hello += hello_period * (1 + (now_ - ifa->next_hello) / hello_period);
1344 1350
  }
1345 1351

  
1346
  if (now >= ifa->next_regular)
1352
  if (now_ >= ifa->next_regular)
1347 1353
  {
1348 1354
    TRACE(D_EVENTS, "Sending regular updates on %s", ifa->ifname);
1349 1355
    babel_send_update(ifa, 0);
1350
    ifa->next_regular += update_period * (1 + (now - ifa->next_regular) / update_period);
1356
    ifa->next_regular += update_period * (1 + (now_ - ifa->next_regular) / update_period);
1351 1357
    ifa->want_triggered = 0;
1352 1358
    p->triggered = 0;
1353 1359
  }
1354
  else if (ifa->want_triggered && (now >= ifa->next_triggered))
1360
  else if (ifa->want_triggered && (now_ >= ifa->next_triggered))
1355 1361
  {
1356 1362
    TRACE(D_EVENTS, "Sending triggered updates on %s", ifa->ifname);
1357 1363
    babel_send_update(ifa, ifa->want_triggered);
1358
    ifa->next_triggered = now + MIN(5, update_period / 2 + 1);
1364
    ifa->next_triggered = now_ + MIN(5 S, update_period / 2);
1359 1365
    ifa->want_triggered = 0;
1360 1366
    p->triggered = 0;
1361 1367
  }
1362 1368

  
1363
  bird_clock_t next_event = MIN(ifa->next_hello, ifa->next_regular);
1364
  tm_start(ifa->timer, ifa->want_triggered ? 1 : (next_event - now));
1369
  btime next_event = MIN(ifa->next_hello, ifa->next_regular);
1370
  if (ifa->want_triggered) next_event = MIN(next_event, ifa->next_triggered);
1371
  tm2_set(ifa->timer, next_event);
1365 1372
}
1366 1373

  
1367 1374
static inline void
1368 1375
babel_iface_kick_timer(struct babel_iface *ifa)
1369 1376
{
1370
  if (ifa->timer->expires TO_S > (now + 1))
1371
    tm_start(ifa->timer, 1);
1377
  if (ifa->timer->expires > (current_time() + 100 MS))
1378
    tm2_start(ifa->timer, 100 MS);
1372 1379
}
1373 1380

  
1374 1381
static void
......
1378 1385

  
1379 1386
  TRACE(D_EVENTS, "Starting interface %s", ifa->ifname);
1380 1387

  
1381
  ifa->next_hello = now + (random() % ifa->cf->hello_interval) + 1;
1382
  ifa->next_regular = now + (random() % ifa->cf->update_interval) + 1;
1383
  ifa->next_triggered = now + MIN(5, ifa->cf->update_interval / 2 + 1);
1388
  ifa->next_hello = current_time() + (random() % ifa->cf->hello_interval);
1389
  ifa->next_regular = current_time() + (random() % ifa->cf->update_interval);
1390
  ifa->next_triggered = current_time() + MIN(5 S, ifa->cf->update_interval / 2);
1384 1391
  ifa->want_triggered = 0;	/* We send an immediate update (below) */
1385
  tm_start(ifa->timer, 1);
1392
  tm2_start(ifa->timer, 100 MS);
1386 1393
  ifa->up = 1;
1387 1394

  
1388 1395
  babel_send_hello(ifa, 0);
......
1398 1405
  struct babel_neighbor *nbr;
1399 1406
  struct babel_route *r;
1400 1407
  node *n;
1408
  btime now_ = current_time();
1401 1409

  
1402 1410
  TRACE(D_EVENTS, "Stopping interface %s", ifa->ifname);
1403 1411

  
......
1412 1420
    {
1413 1421
      r = SKIP_BACK(struct babel_route, neigh_route, n);
1414 1422
      r->metric = BABEL_INFINITY;
1415
      r->expires = now + r->expiry_interval;
1423
      r->expires = now_ + r->expiry_interval;
1416 1424
      babel_select_route(r->e);
1417 1425
    }
1418 1426
  }
1419 1427

  
1420
  tm_stop(ifa->timer);
1428
  tm2_stop(ifa->timer);
1421 1429
  ifa->up = 0;
1422 1430
}
1423 1431

  
......
1515 1523
  init_list(&ifa->neigh_list);
1516 1524
  ifa->hello_seqno = 1;
1517 1525

  
1518
  ifa->timer = tm_new_set(ifa->pool, babel_iface_timer, ifa, 0, 0);
1526
  ifa->timer = tm2_new_init(ifa->pool, babel_iface_timer, ifa, 0, 0);
1519 1527

  
1520 1528
  init_list(&ifa->msg_queue);
1521 1529
  ifa->send_event = ev_new(ifa->pool);
......
1614 1622
  if (ipa_zero(ifa->next_hop_ip4) && p->ip4_channel)
1615 1623
    log(L_WARN "%s: Cannot find IPv4 next hop addr on %s", p->p.name, ifa->ifname);
1616 1624

  
1617
  if (ifa->next_hello > (now + new->hello_interval))
1618
    ifa->next_hello = now + (random() % new->hello_interval) + 1;
1625
  if (ifa->next_hello > (current_time() + new->hello_interval))
1626
    ifa->next_hello = current_time() + (random() % new->hello_interval);
1619 1627

  
1620
  if (ifa->next_regular > (now + new->update_interval))
1621
    ifa->next_regular = now + (random() % new->update_interval) + 1;
1628
  if (ifa->next_regular > (current_time() + new->update_interval))
1629
    ifa->next_regular = current_time() + (random() % new->update_interval);
1622 1630

  
1623 1631
  if ((new->tx_length != old->tx_length) || (new->rx_buffer != old->rx_buffer))
1624 1632
    babel_iface_update_buffers(ifa);
......
1680 1688
static void
1681 1689
babel_dump_source(struct babel_source *s)
1682 1690
{
1683
  debug("Source router_id %lR seqno %d metric %d expires %d\n",
1684
	s->router_id, s->seqno, s->metric, s->expires ? s->expires-now : 0);
1691
  debug("Source router_id %lR seqno %d metric %d expires %t\n",
1692
	s->router_id, s->seqno, s->metric,
1693
	s->expires ? s->expires - current_time() : 0);
1685 1694
}
1686 1695

  
1687 1696
static void
1688 1697
babel_dump_route(struct babel_route *r)
1689 1698
{
1690
  debug("Route neigh %I if %s seqno %d metric %d/%d router_id %lR expires %d\n",
1699
  debug("Route neigh %I if %s seqno %d metric %d/%d router_id %lR expires %t\n",
1691 1700
	r->neigh ? r->neigh->addr : IPA_NONE,
1692 1701
        r->neigh ? r->neigh->ifa->ifname : "(none)",
1693
        r->seqno, r->advert_metric, r->metric,
1694
	r->router_id, r->expires ? r->expires-now : 0);
1702
        r->seqno, r->advert_metric, r->metric, r->router_id,
1703
	r->expires ? r->expires - current_time() : 0);
1695 1704
}
1696 1705

  
1697 1706
static void
......
1717 1726
static void
1718 1727
babel_dump_neighbor(struct babel_neighbor *n)
1719 1728
{
1720
  debug("Neighbor %I txcost %d hello_map %x next seqno %d expires %d/%d\n",
1729
  debug("Neighbor %I txcost %d hello_map %x next seqno %d expires %t/%t\n",
1721 1730
	n->addr, n->txcost, n->hello_map, n->next_hello_seqno,
1722
        n->hello_expiry ? n->hello_expiry - now : 0,
1723
        n->ihu_expiry ? n->ihu_expiry - now : 0);
1731
	n->hello_expiry ? n->hello_expiry - current_time() : 0,
1732
        n->ihu_expiry ? n->ihu_expiry - current_time() : 0);
1724 1733
}
1725 1734

  
1726 1735
static void
......
1728 1737
{
1729 1738
  struct babel_neighbor *n;
1730 1739

  
1731
  debug("Babel: Interface %s addr %I rxcost %d type %d hello seqno %d intervals %d %d",
1740
  debug("Babel: Interface %s addr %I rxcost %d type %d hello seqno %d intervals %t %t",
1732 1741
	ifa->ifname, ifa->addr, ifa->cf->rxcost, ifa->cf->type, ifa->hello_seqno,
1733 1742
	ifa->cf->hello_interval, ifa->cf->update_interval);
1734 1743
  debug(" next hop v4 %I next hop v6 %I\n", ifa->next_hop_ip4, ifa->next_hop_ip6);
......
1803 1812
  }
1804 1813

  
1805 1814
  cli_msg(-1023, "%s:", p->p.name);
1806
  cli_msg(-1023, "%-10s %-6s %7s %6s %6s %-15s %s",
1815
  cli_msg(-1023, "%-10s %-6s %7s %6s %7s %-15s %s",
1807 1816
	  "Interface", "State", "RX cost", "Nbrs", "Timer",
1808 1817
	  "Next hop (v4)", "Next hop (v6)");
1809 1818

  
......
1816 1825
    WALK_LIST(nbr, ifa->neigh_list)
1817 1826
	nbrs++;
1818 1827

  
1819
    int timer = MIN(ifa->next_regular, ifa->next_hello) - now;
1820
    cli_msg(-1023, "%-10s %-6s %7u %6u %6u %-15I %I",
1828
    btime timer = MIN(ifa->next_regular, ifa->next_hello) - current_time();
1829
    cli_msg(-1023, "%-10s %-6s %7u %6u %7t %-15I %I",
1821 1830
	    ifa->iface->name, (ifa->up ? "Up" : "Down"),
1822 1831
	    ifa->cf->rxcost, nbrs, MAX(timer, 0),
1823 1832
	    ifa->next_hop_ip4, ifa->next_hop_ip6);
......
1842 1851
  }
1843 1852

  
1844 1853
  cli_msg(-1024, "%s:", p->p.name);
1845
  cli_msg(-1024, "%-25s %-10s %6s %6s %10s",
1846
	  "IP address", "Interface", "Metric", "Routes", "Next hello");
1854
  cli_msg(-1024, "%-25s %-10s %6s %6s %6s %7s",
1855
	  "IP address", "Interface", "Metric", "Routes", "Hellos", "Expires");
1847 1856

  
1848 1857
  WALK_LIST(ifa, p->interfaces)
1849 1858
  {
......
1856 1865
      WALK_LIST(r, n->routes)
1857 1866
        rts++;
1858 1867

  
1859
      int timer = n->hello_expiry - now;
1860
      cli_msg(-1024, "%-25I %-10s %6u %6u %10u",
1861
	      n->addr, ifa->iface->name, n->txcost, rts, MAX(timer, 0));
1868
      uint hellos = u32_popcount(n->hello_map);
1869
      btime timer = n->hello_expiry - current_time();
1870
      cli_msg(-1024, "%-25I %-10s %6u %6u %6u %7t",
1871
	      n->addr, ifa->iface->name, n->txcost, rts, hellos, MAX(timer, 0));
1862 1872
    }
1863 1873
  }
1864 1874

  
......
1888 1898
      else
1889 1899
        bsprintf(ridbuf, "%lR", r->router_id);
1890 1900

  
1891
      int time = r->expires ? r->expires - now : 0;
1892
      cli_msg(-1025, "%-29N %-23s %6u %5u %7u %7u",
1901
      btime time = r->expires ? r->expires - current_time() : 0;
1902
      cli_msg(-1025, "%-29N %-23s %6u %5u %7t %7u",
1893 1903
	      e->n.addr, ridbuf, r->metric, r->seqno, MAX(time, 0), srcs);
1894 1904
    }
1895 1905
    else
......
1948 1958
static inline void
1949 1959
babel_kick_timer(struct babel_proto *p)
1950 1960
{
1951
  if (p->timer->expires TO_S > (now + 1))
1952
    tm_start(p->timer, 1);
1961
  if (p->timer->expires > (current_time() + 100 MS))
1962
    tm2_start(p->timer, 100 MS);
1953 1963
}
1954 1964

  
1955 1965

  
......
2032 2042

  
2033 2043
    if (r != e->selected_out)
2034 2044
    {
2035
      e->selected_out = r;
2036
      e->updated = now;
2037 2045
      babel_trigger_update(p);
2046
      e->updated = current_time();
2047
      e->selected_out = r;
2038 2048
    }
2039 2049
  }
2040 2050
  else
......
2051 2061
       * expiry time. This causes a retraction to be sent, and later the route
2052 2062
       * to be flushed once the hold time has passed.
2053 2063
       */
2054
      e->selected_out->metric = BABEL_INFINITY;
2055
      e->selected_out->expires = now + BABEL_HOLD_TIME;
2056
      e->updated = now;
2057 2064
      babel_trigger_update(p);
2065
      e->updated = current_time();
2066
      e->selected_out->metric = BABEL_INFINITY;
2067
      e->selected_out->expires = current_time() + BABEL_HOLD_TIME;
2058 2068
    }
2059 2069
    else
2060 2070
    {
......
2121 2131
	   OFFSETOF(struct babel_entry, n), 0, babel_init_entry);
2122 2132

  
2123 2133
  init_list(&p->interfaces);
2124
  p->timer = tm_new_set(P->pool, babel_timer, p, 0, 1);
2125
  tm_start(p->timer, 2);
2134
  p->timer = tm2_new_init(P->pool, babel_timer, p, 1 S, 0);
2135
  tm2_start(p->timer, 1 S);
2126 2136
  p->update_seqno = 1;
2127 2137
  p->router_id = proto_get_router_id(&cf->c);
2128 2138

  
proto/babel/babel.h
32 32
#define BABEL_INFINITY		0xFFFF
33 33

  
34 34

  
35
#define BABEL_HELLO_INTERVAL_WIRED	4	/* Default hello intervals in seconds */
36
#define BABEL_HELLO_INTERVAL_WIRELESS	4
35
#define BABEL_HELLO_INTERVAL_WIRED	(4 S_)	/* Default hello intervals in seconds */
36
#define BABEL_HELLO_INTERVAL_WIRELESS	(4 S_)
37 37
#define BABEL_UPDATE_INTERVAL_FACTOR	4
38 38
#define BABEL_IHU_INTERVAL_FACTOR	3
39
#define BABEL_IHU_EXPIRY_FACTOR(X)	((X)*3/2)	/* 1.5 */
40
#define BABEL_HELLO_EXPIRY_FACTOR(X)	((X)*3/2)	/* 1.5 */
41
#define BABEL_ROUTE_EXPIRY_FACTOR(X)	((X)*7/2)	/* 3.5 */
42
#define BABEL_ROUTE_REFRESH_INTERVAL	2	/* Seconds before route expiry to send route request */
43
#define BABEL_HOLD_TIME			10	/* Expiry time for our own routes */
39
#define BABEL_IHU_EXPIRY_FACTOR(X)	((btime)(X)*3/2)	/* 1.5 */
40
#define BABEL_HELLO_EXPIRY_FACTOR(X)	((btime)(X)*3/2)	/* 1.5 */
41
#define BABEL_ROUTE_EXPIRY_FACTOR(X)	((btime)(X)*7/2)	/* 3.5 */
42
#define BABEL_ROUTE_REFRESH_INTERVAL	(2 S_)	/* Time before route expiry to send route request */
43
#define BABEL_HOLD_TIME			(10 S_)	/* Expiry time for our own routes */
44
#define BABEL_SEQNO_REQUEST_EXPIRY	(60 S_)
45
#define BABEL_GARBAGE_INTERVAL		(300 S_)
44 46
#define BABEL_RXCOST_WIRED		96
45 47
#define BABEL_RXCOST_WIRELESS		256
46 48
#define BABEL_INITIAL_HOP_COUNT		255
47
#define BABEL_MAX_SEND_INTERVAL		5
48
#define BABEL_TIME_UNITS		100	/* On-wire times are counted in centiseconds */
49
#define BABEL_SEQNO_REQUEST_EXPIRY	60
50
#define BABEL_GARBAGE_INTERVAL		300
49
#define BABEL_MAX_SEND_INTERVAL		5	/* Unused ? */
51 50

  
52 51
/* Max interval that will not overflow when carried as 16-bit centiseconds */
53
#define BABEL_MAX_INTERVAL		(0xFFFF/BABEL_TIME_UNITS)
52
#define BABEL_TIME_UNITS		10000	/* On-wire times are counted in centiseconds */
53
#define BABEL_MIN_INTERVAL		(0x0001 * BABEL_TIME_UNITS)
54
#define BABEL_MAX_INTERVAL		(0xFFFF * BABEL_TIME_UNITS)
54 55

  
55 56
#define BABEL_OVERHEAD		(IP6_HEADER_LENGTH+UDP_HEADER_LENGTH)
56 57
#define BABEL_MIN_MTU		(512 + BABEL_OVERHEAD)
......
113 114
  u8 type;
114 115
  u8 check_link;
115 116
  uint port;
116
  u16 hello_interval;
117
  u16 ihu_interval;
118
  u16 update_interval;
117
  uint hello_interval;			/* Hello interval, in us */
118
  uint ihu_interval;			/* IHU interval, in us */
119
  uint update_interval;			/* Update interval, in us */
119 120

  
120 121
  u16 rx_buffer;			/* RX buffer size, 0 for MTU */
121 122
  u16 tx_length;			/* TX packet length limit (including headers), 0 for MTU */
......
172 173

  
173 174
  u16 hello_seqno;			/* To be increased on each hello */
174 175

  
175
  bird_clock_t next_hello;
176
  bird_clock_t next_regular;
177
  bird_clock_t next_triggered;
178
  bird_clock_t want_triggered;
176
  btime next_hello;
177
  btime next_regular;
178
  btime next_triggered;
179
  btime want_triggered;
179 180

  
180 181
  timer *timer;
181 182
  event *send_event;
......
191 192
  u16 hello_map;
192 193
  u16 next_hello_seqno;
193 194
  /* expiry timers */
194
  bird_clock_t hello_expiry;
195
  bird_clock_t ihu_expiry;
195
  btime hello_expiry;
196
  btime ihu_expiry;
196 197

  
197 198
  list routes;				/* Routes this neighbour has sent us (struct babel_route) */
198 199
};
......
203 204
  u64 router_id;
204 205
  u16 seqno;
205 206
  u16 metric;
206
  bird_clock_t expires;
207
  btime expires;
207 208
};
208 209

  
209 210
struct babel_route {
......
217 218
  u16 metric;
218 219
  u64 router_id;
219 220
  ip_addr next_hop;
220
  bird_clock_t refresh_time;
221
  bird_clock_t expires;
222
  u16 expiry_interval;
221
  btime refresh_time;
222
  btime expires;
223
  btime expiry_interval;
223 224
};
224 225

  
225 226
struct babel_entry {
......
227 228
  struct babel_route *selected_in;
228 229
  struct babel_route *selected_out;
229 230

  
230
  bird_clock_t updated;
231
  btime updated;
231 232

  
232 233
  list sources;				/* Source entries for this prefix (struct babel_source). */
233 234
  list routes;				/* Routes for this prefix (struct babel_route) */
......
241 242
  net_addr net;
242 243
  u64 router_id;
243 244
  u16 seqno;
244
  bird_clock_t updated;
245
  btime updated;
245 246
};
246 247

  
247 248

  
......
252 253
struct babel_msg_ack_req {
253 254
  u8 type;
254 255
  u16 nonce;
255
  u16 interval;
256
  uint interval;
256 257
  ip_addr sender;
257 258
};
258 259

  
......
264 265
struct babel_msg_hello {
265 266
  u8 type;
266 267
  u16 seqno;
267
  u16 interval;
268
  uint interval;
268 269
  ip_addr sender;
269 270
};
270 271

  
......
272 273
  u8 type;
273 274
  u8 ae;
274 275
  u16 rxcost;
275
  u16 interval;
276
  uint interval;
276 277
  ip_addr addr;
277 278
  ip_addr sender;
278 279
};
......
280 281
struct babel_msg_update {
281 282
  u8 type;
282 283
  u8 wildcard;
283
  u16 interval;
284
  uint interval;
284 285
  u16 seqno;
285 286
  u16 metric;
286 287
  u64 router_id;
proto/babel/config.Y
89 89
babel_iface_item:
90 90
 | PORT expr { BABEL_IFACE->port = $2; if (($2<1) || ($2>65535)) cf_error("Invalid port number"); }
91 91
 | RXCOST expr { BABEL_IFACE->rxcost = $2; if (($2<1) || ($2>65535)) cf_error("Invalid rxcost"); }
92
 | HELLO INTERVAL expr { BABEL_IFACE->hello_interval = $3; if (($3<1) || ($3>BABEL_MAX_INTERVAL)) cf_error("Invalid hello interval"); }
93
 | UPDATE INTERVAL expr { BABEL_IFACE->update_interval = $3; if (($3<1) || ($3>BABEL_MAX_INTERVAL)) cf_error("Invalid update interval"); }
94 92
 | TYPE WIRED { BABEL_IFACE->type = BABEL_IFACE_TYPE_WIRED; }
95 93
 | TYPE WIRELESS { BABEL_IFACE->type = BABEL_IFACE_TYPE_WIRELESS; }
94
 | HELLO INTERVAL expr_us { BABEL_IFACE->hello_interval = $3; if (($3<BABEL_MIN_INTERVAL) || ($3>BABEL_MAX_INTERVAL)) cf_error("Hello interval must be in range 10 ms - 655 s"); }
95
 | UPDATE INTERVAL expr_us { BABEL_IFACE->update_interval = $3; if (($3<BABEL_MIN_INTERVAL) || ($3>BABEL_MAX_INTERVAL)) cf_error("Update interval must be in range 10 ms - 655 s"); }
96 96
 | RX BUFFER expr { BABEL_IFACE->rx_buffer = $3; if (($3<256) || ($3>65535)) cf_error("RX buffer must be in range 256-65535"); }
97 97
 | TX LENGTH expr { BABEL_IFACE->tx_length = $3; if (($3<256) || ($3>65535)) cf_error("TX length must be in range 256-65535"); }
98 98
 | TX tos { BABEL_IFACE->tx_tos = $2; }
proto/babel/packets.c
162 162
  return i;
163 163
}
164 164

  
165
static inline u16
165
static inline uint
166 166
get_time16(const void *p)
167 167
{
168
  u16 v = get_u16(p) / BABEL_TIME_UNITS;
169
  return MAX(1, v);
168
  uint v = get_u16(p) * BABEL_TIME_UNITS;
169
  return MAX(BABEL_MIN_INTERVAL, v);
170 170
}
171 171

  
172 172
static inline void
173
put_time16(void *p, u16 v)
173
put_time16(void *p, uint v)
174 174
{
175
  put_u16(p, v * BABEL_TIME_UNITS);
175
  put_u16(p, v / BABEL_TIME_UNITS);
176 176
}
177 177

  
178 178
static inline void

Also available in: Unified diff