void
bgp_conn_enter_close_state(struct bgp_conn *conn)
{
struct bgp_proto *p = conn->bgp;
int os = conn->state;
bgp_conn_set_state(conn, BS_CLOSE);
tm_stop(conn->hold_timer);
tm_stop(conn->keepalive_timer);
conn->sk->rx_hook = NULL;
if (os == BS_ESTABLISHED)
bgp_conn_leave_established_state(p);
}
void
bgp_conn_enter_established_state(struct bgp_conn *conn)
{
struct bgp_proto *p = conn->bgp;
BGP_TRACE(D_EVENTS, "BGP session established");
DBG("BGP: UP!!!\n");
/* For multi-hop BGP sessions */
if (ipa_zero(p->source_addr))
p->source_addr = conn->sk->saddr;
p->conn = conn;
p->last_error_class = 0;
p->last_error_code = 0;
bgp_init_bucket_table(p);
bgp_init_prefix_table(p, 8);
int peer_gr_ready = conn->peer_gr_aware && !(conn->peer_gr_flags & BGP_GRF_RESTART);
if (p->p.gr_recovery && !peer_gr_ready)
proto_graceful_restart_unlock(&p->p);
if (p->p.gr_recovery && (p->cf->gr_mode == BGP_GR_ABLE) && peer_gr_ready)
p->p.gr_wait = 1;
if (p->gr_active)
tm_stop(p->gr_timer);
if (p->gr_active && (!conn->peer_gr_able || !(conn->peer_gr_aflags & BGP_GRF_FORWARDING)))
bgp_graceful_restart_done(p);
bgp_conn_set_state(conn, BS_ESTABLISHED);
proto_notify_state(&p->p, PS_UP);
}
static void
bgp_send_open(struct bgp_conn *conn)
{
conn->start_state = conn->bgp->start_state;
// Default values, possibly changed by receiving capabilities.
conn->advertised_as = 0;
conn->peer_refresh_support = 0;
conn->peer_as4_support = 0;
conn->peer_add_path = 0;
conn->peer_enhanced_refresh_support = 0;
conn->peer_gr_aware = 0;
conn->peer_gr_able = 0;
conn->peer_gr_time = 0;
conn->peer_gr_flags = 0;
conn->peer_gr_aflags = 0;
conn->peer_ext_messages_support = 0;
DBG("BGP: Sending open\n");
conn->sk->rx_hook = bgp_rx;
conn->sk->tx_hook = bgp_tx;
tm_stop(conn->connect_retry_timer);
bgp_schedule_packet(conn, PKT_OPEN);
bgp_conn_set_state(conn, BS_OPENSENT);
bgp_start_timer(conn->hold_timer, conn->bgp->cf->initial_hold_time);
}
/**
* bgp_graceful_restart_done - finish active BGP graceful restart
* @p: BGP instance
*
* This function is called when the active BGP graceful restart of the neighbor
* should be finished - either successfully (the neighbor sends all paths and
* reports end-of-RIB on the new session) or unsuccessfully (the neighbor does
* not support BGP graceful restart on the new session). The function ends
* routing table refresh cycle and stops BGP restart timer.
*/
void
bgp_graceful_restart_done(struct bgp_proto *p)
{
BGP_TRACE(D_EVENTS, "Neighbor graceful restart done");
p->gr_active = 0;
tm_stop(p->gr_timer);
rt_refresh_end(p->p.main_ahook->table, p->p.main_ahook);
}
/**
* @brief Stops a measurement and chains to the next one using the same time
* stamp.
*
* @param[in,out] tmp1 pointer to the @p time_measurement_t structure to be
* stopped
* @param[in,out] tmp2 pointer to the @p time_measurement_t structure to be
* started
*
*
* @xclass
*/
NOINLINE void chTMChainMeasurementToX(time_measurement_t *tmp1,
time_measurement_t *tmp2) {
/* Starts new measurement.*/
tmp2->last = chSysGetRealtimeCounterX();
/* Stops previous measurement using the same time stamp.*/
tm_stop(tmp1, tmp2->last, 0);
}
/**
* bgp_start_timer - start a BGP timer
* @t: timer
* @value: time to fire (0 to disable the timer)
*
* This functions calls tm_start() on @t with time @value and the
* amount of randomization suggested by the BGP standard. Please use
* it for all BGP timers.
*/
void
bgp_start_timer(timer *t, int value)
{
if (value)
{
/* The randomization procedure is specified in RFC 1771: 9.2.3.3 */
t->randomize = value / 4;
tm_start(t, value - t->randomize);
}
else
tm_stop(t);
}
void adc_sync_cb(U32 time)
{
TRACE_INFO("ADC SYNC\n");
SANITY_CHECK(gAdcDesc.state==ADC_SYNC);
tm_stop();
gAdcDesc.state=ADC_PIO;
pio_start(nDRDY_mask[gAdcDesc.drdy],adc_pio_cb);
pio_set(ADC_nSYNC);
#if PWM_DEBUG
pwm_start();
#endif
}
static void
bgp_send_open(struct bgp_conn *conn)
{
conn->start_state = conn->bgp->start_state;
conn->want_as4_support = conn->bgp->cf->enable_as4 && (conn->start_state != BSS_CONNECT_NOCAP);
conn->peer_as4_support = 0; // Default value, possibly changed by receiving capability.
conn->advertised_as = 0;
DBG("BGP: Sending open\n");
conn->sk->rx_hook = bgp_rx;
conn->sk->tx_hook = bgp_tx;
tm_stop(conn->connect_retry_timer);
bgp_schedule_packet(conn, PKT_OPEN);
bgp_conn_set_state(conn, BS_OPENSENT);
bgp_start_timer(conn->hold_timer, conn->bgp->cf->initial_hold_time);
}
void
bgp_conn_enter_close_state(struct bgp_conn *conn)
{
struct bgp_proto *p = conn->bgp;
int os = conn->state;
bgp_conn_set_state(conn, BS_CLOSE);
tm_stop(conn->keepalive_timer);
conn->sk->rx_hook = NULL;
/* Timeout for CLOSE state, if we cannot send notification soon then we just hangup */
bgp_start_timer(conn->hold_timer, 10);
if (os == BS_ESTABLISHED)
bgp_conn_leave_established_state(p);
}
void clk_wait500us( void )
{
int ret;
ETM2 = 0;
(void)tm_init( (unsigned char)CLKSYS_TM_CHNO, /* Timer channel */
(unsigned char)TM_M16_8BIT, /* 8bit or 16bit mode */
(unsigned char)TM_CS_LSCLK, /* Operation clock */
(unsigned short)CLKSYS_TIMER_CNT ); /* Timer count value */
CLKSYS_TM_IRQ = 0;
(void)tm_start( (unsigned char)CLKSYS_TM_CHNO );
do {
ret = tm_checkOvf( (unsigned char)CLKSYS_TM_CHNO );
} while( ret == TM_R_NOT_OVF );
(void)tm_stop( (unsigned char)CLKSYS_TM_CHNO );
CLKSYS_TM_IRQ = 0;
}
void
bgp_conn_enter_established_state(struct bgp_conn *conn)
{
struct bgp_proto *p = conn->bgp;
BGP_TRACE(D_EVENTS, "BGP session established");
DBG("BGP: UP!!!\n");
/* For multi-hop BGP sessions */
if (ipa_zero(p->source_addr))
p->source_addr = conn->sk->saddr;
p->conn = conn;
p->last_error_class = 0;
p->last_error_code = 0;
p->feed_state = BFS_NONE;
p->load_state = BFS_NONE;
bgp_init_bucket_table(p);
bgp_init_prefix_table(p, 8);
int peer_gr_ready = conn->peer_gr_aware && !(conn->peer_gr_flags & BGP_GRF_RESTART);
if (p->p.gr_recovery && !peer_gr_ready)
proto_graceful_restart_unlock(&p->p);
if (p->p.gr_recovery && (p->cf->gr_mode == BGP_GR_ABLE) && peer_gr_ready)
p->p.gr_wait = 1;
if (p->gr_active)
tm_stop(p->gr_timer);
if (p->gr_active && (!conn->peer_gr_able || !(conn->peer_gr_aflags & BGP_GRF_FORWARDING)))
bgp_graceful_restart_done(p);
/* GR capability implies that neighbor will send End-of-RIB */
if (conn->peer_gr_aware)
p->load_state = BFS_LOADING;
/* proto_notify_state() will likely call bgp_feed_begin(), setting p->feed_state */
bgp_conn_set_state(conn, BS_ESTABLISHED);
proto_notify_state(&p->p, PS_UP);
}
/**
* @brief Stops a measurement.
* @pre The @p time_measurement_t structure must be initialized.
*
* @param[in,out] tmp pointer to a @p time_measurement_t structure
*
* @xclass
*/
NOINLINE void chTMStopMeasurementX(time_measurement_t *tmp) {
tm_stop(tmp, chSysGetRealtimeCounterX(), ch.tm.offset);
}
/**
* Initialize the collection/allocation phase.
*/
void _tm_phase_init(int p)
{
tm_msg("p %s\n", tm_phase_name[p]);
#if 0
/* DEBUG: DELETE ME! */
if ( tm.alloc_id == 1987 )
tm_stop();
#endif
#if 0
++ tm.p.n_phase_transitions[tm.p.phase][p];
++ tm.p.n_phase_transitions[tm.p.phase][tm_phase_END];
++ tm.p.n_phase_transitions[tm_phase_END][p];
++ tm.p.n_phase_transitions[tm_phase_END][tm_phase_END];
if ( tm.p.phase == tm_SWEEP && tm.p.phase != p ) {
tm.alloc_since_sweep = 0;
}
#endif
#if 0
fprintf(stderr, "\n%s->%s #%lu %lu %lu %lu %lu\n", tm_phase_name[tm.phase], tm_phase_name[p], (unsigned long) tm.alloc_id,
(unsigned long) tm.n[WHITE],
(unsigned long) tm.n[ECRU],
(unsigned long) tm.n[GREY],
(unsigned long) tm.n[BLACK],
0
);
#endif
switch ( (tm.p.phase = p) ) {
case tm_ALLOC:
/**
* - tm_ALLOC: allocate nodes until memory pressure is high.
*/
tm.p.allocating = 1;
tm.p.unmarking = 0;
tm.p.marking = 0;
tm.p.scanning = 0;
tm.p.sweeping = 0;
tm.alloc_color = tm_DEFAULT_ALLOC_COLOR;
break;
case tm_UNMARK:
/**
* - tm_UNMARK: begin unmarking BLACK nodes as ECRU:
*/
tm.p.allocating = 0;
tm.p.unmarking = 1;
tm.p.marking = 0;
tm.p.scanning = 0;
tm.p.sweeping = 0;
tm.alloc_color = tm_DEFAULT_ALLOC_COLOR;
/*! Set up for unmarking. */
tm_node_LOOP_INIT(BLACK);
/*! Keep track of how many BLACK nodes are in use. */
tm.n[tm_NU] = tm.n[BLACK];
break;
case tm_ROOT:
/**
* - tm_ROOT: begin scanning roots for potential pointers:
*/
tm.p.allocating = 0;
tm.p.unmarking = 0;
tm.p.marking = 1;
tm.p.scanning = 0;
tm.p.sweeping = 0;
tm.alloc_color = tm_DEFAULT_ALLOC_COLOR;
/*! Mark stack and data roots as un-mutated. */
tm.stack_mutations = tm.data_mutations = 0;
/*! Initialize root mark loop. */
_tm_root_loop_init();
break;
case tm_SCAN:
/**
* - tm_SCAN: begin scanning tm_GREY nodes for internal pointers:
*/
tm.p.allocating = 0;
tm.p.unmarking = 0;
tm.p.marking = 1;
tm.p.scanning = 1;
tm.p.sweeping = 0;
tm.alloc_color = tm_DEFAULT_ALLOC_COLOR;
/*! Mark stack and data roots as un-mutated. */
tm.stack_mutations = tm.data_mutations = 0;
/*! Set up for marking. */
tm_node_LOOP_INIT(GREY);
break;
case tm_SWEEP:
/**
* - tm_SWEEP: begin reclaiming any ECRU nodes as WHITE.
*/
tm.p.allocating = 0;
tm.p.unmarking = 0;
tm.p.marking = 0;
tm.p.scanning = 0;
tm.p.sweeping = 1;
tm.alloc_color = tm_SWEEP_ALLOC_COLOR;
tm_assert_test(tm.n[GREY] == 0);
/* Set up for scanning. */
// tm_node_LOOP_INIT(GREY);
/* Set up for sweeping. */
// tm_node_LOOP_INIT(ECRU);
break;
default:
tm_fatal();
break;
}
if ( 1 || p == tm_SWEEP ) {
// tm_print_stats();
}
//tm_validate_lists();
}
void
ospf_receive_dbdes(struct ospf_packet *pkt, struct ospf_iface *ifa,
struct ospf_neighbor *n)
{
struct ospf_proto *p = ifa->oa->po;
const char *err_dsc = NULL;
u32 rcv_ddseq, rcv_options;
u16 rcv_iface_mtu;
u8 rcv_imms;
uint plen, err_val = 0;
/* RFC 2328 10.6 */
plen = ntohs(pkt->length);
if (plen < ospf_dbdes_hdrlen(p))
{
LOG_PKT("Bad DBDES packet from nbr %R on %s - %s (%u)", n->rid, ifa->ifname, "too short", plen);
return;
}
OSPF_PACKET(ospf_dump_dbdes, pkt, "DBDES packet received from nbr %R on %s", n->rid, ifa->ifname);
ospf_neigh_sm(n, INM_HELLOREC);
if (ospf_is_v2(p))
{
struct ospf_dbdes2_packet *ps = (void *) pkt;
rcv_iface_mtu = ntohs(ps->iface_mtu);
rcv_options = ps->options;
rcv_imms = ps->imms;
rcv_ddseq = ntohl(ps->ddseq);
}
else /* OSPFv3 */
{
struct ospf_dbdes3_packet *ps = (void *) pkt;
rcv_options = ntohl(ps->options);
rcv_iface_mtu = ntohs(ps->iface_mtu);
rcv_imms = ps->imms;
rcv_ddseq = ntohl(ps->ddseq);
}
switch (n->state)
{
case NEIGHBOR_DOWN:
case NEIGHBOR_ATTEMPT:
case NEIGHBOR_2WAY:
OSPF_TRACE(D_PACKETS, "DBDES packet ignored - lesser state than ExStart");
return;
case NEIGHBOR_INIT:
ospf_neigh_sm(n, INM_2WAYREC);
if (n->state != NEIGHBOR_EXSTART)
return;
case NEIGHBOR_EXSTART:
if ((ifa->type != OSPF_IT_VLINK) &&
(rcv_iface_mtu != ifa->iface->mtu) &&
(rcv_iface_mtu != 0) &&
(ifa->iface->mtu != 0))
LOG_PKT_WARN("MTU mismatch with nbr %R on %s (remote %d, local %d)",
n->rid, ifa->ifname, rcv_iface_mtu, ifa->iface->mtu);
if ((rcv_imms == DBDES_IMMS) &&
(n->rid > p->router_id) &&
(plen == ospf_dbdes_hdrlen(p)))
{
/* I'm slave! */
n->dds = rcv_ddseq;
n->ddr = rcv_ddseq;
n->options = rcv_options;
n->myimms &= ~DBDES_MS;
n->imms = rcv_imms;
tm_stop(n->dbdes_timer);
ospf_neigh_sm(n, INM_NEGDONE);
ospf_send_dbdes(p, n);
break;
}
if (!(rcv_imms & DBDES_I) &&
!(rcv_imms & DBDES_MS) &&
(n->rid < p->router_id) &&
(n->dds == rcv_ddseq))
{
/* I'm master! */
n->options = rcv_options;
n->ddr = rcv_ddseq - 1; /* It will be set corectly a few lines down */
n->imms = rcv_imms;
ospf_neigh_sm(n, INM_NEGDONE);
/* Continue to the NEIGHBOR_EXCHANGE case */
}
else
{
DBG("%s: Nothing happend to %I (imms=%d)\n", p->name, n->ip, rcv_imms);
break;
}
case NEIGHBOR_EXCHANGE:
if ((rcv_imms == n->imms) &&
(rcv_options == n->options) &&
(rcv_ddseq == n->ddr))
goto duplicate;
if ((rcv_imms & DBDES_MS) != (n->imms & DBDES_MS))
DROP("MS-bit mismatch", rcv_imms);
if (rcv_imms & DBDES_I)
DROP("I-bit mismatch", rcv_imms);
if (rcv_options != n->options)
DROP("options mismatch", rcv_options);
n->ddr = rcv_ddseq;
n->imms = rcv_imms;
if (n->myimms & DBDES_MS)
{
/* MASTER */
if (rcv_ddseq != n->dds)
DROP("DD sequence number mismatch", rcv_ddseq);
n->dds++;
if (ospf_process_dbdes(p, pkt, n) < 0)
return;
if (!(n->myimms & DBDES_M) && !(n->imms & DBDES_M))
{
tm_stop(n->dbdes_timer);
ospf_neigh_sm(n, INM_EXDONE);
break;
}
ospf_send_dbdes(p, n);
tm_start(n->dbdes_timer, n->ifa->rxmtint);
}
else
{
/* SLAVE */
if (rcv_ddseq != (n->dds + 1))
DROP("DD sequence number mismatch", rcv_ddseq);
n->ddr = rcv_ddseq;
n->dds = rcv_ddseq;
if (ospf_process_dbdes(p, pkt, n) < 0)
return;
ospf_send_dbdes(p, n);
if (!(n->myimms & DBDES_M) && !(n->imms & DBDES_M))
ospf_neigh_sm(n, INM_EXDONE);
}
break;
case NEIGHBOR_LOADING:
case NEIGHBOR_FULL:
if ((rcv_imms == n->imms) &&
(rcv_options == n->options) &&
(rcv_ddseq == n->ddr))
goto duplicate;
DROP("too late for DD exchange", n->state);
default:
bug("Undefined interface state");
}
return;
duplicate:
OSPF_TRACE(D_PACKETS, "DBDES packet is duplicate");
/* Slave should retransmit DBDES packet */
if (!(n->myimms & DBDES_MS))
ospf_rxmt_dbdes(p, n);
return;
drop:
LOG_PKT("Bad DBDES packet from nbr %R on %s - %s (%u)",
n->rid, ifa->ifname, err_dsc, err_val);
ospf_neigh_sm(n, INM_SEQMIS);
return;
}
