int
twoway_received (struct thread *thread)
{
struct ospf6_neighbor *on;
on = (struct ospf6_neighbor *) THREAD_ARG (thread);
assert (on);
if (on->state > OSPF6_NEIGHBOR_INIT)
return 0;
if (IS_OSPF6_DEBUG_NEIGHBOR (EVENT))
zlog_info ("Neighbor Event %s: *2Way-Received*", on->name);
thread_add_event (master, neighbor_change, on->ospf6_if, 0);
if (! need_adjacency (on))
{
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_TWOWAY, on);
return 0;
}
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_EXSTART, on);
SET_FLAG (on->dbdesc_bits, OSPF6_DBDESC_MSBIT);
SET_FLAG (on->dbdesc_bits, OSPF6_DBDESC_MBIT);
SET_FLAG (on->dbdesc_bits, OSPF6_DBDESC_IBIT);
THREAD_OFF (on->thread_send_dbdesc);
on->thread_send_dbdesc =
thread_add_event (master, ospf6_dbdesc_send, on, 0);
return 0;
}
/* Interface State Machine */
int
interface_up (struct thread *thread)
{
struct ospf6_interface *oi;
oi = (struct ospf6_interface *) THREAD_ARG (thread);
assert (oi && oi->interface);
if (IS_OSPF6_DEBUG_INTERFACE)
zlog_debug ("Interface Event %s: [InterfaceUp]",
oi->interface->name);
/* check physical interface is up */
if (! if_is_up (oi->interface))
{
if (IS_OSPF6_DEBUG_INTERFACE)
zlog_debug ("Interface %s is down, can't execute [InterfaceUp]",
oi->interface->name);
return 0;
}
/* if already enabled, do nothing */
if (oi->state > OSPF6_INTERFACE_DOWN)
{
if (IS_OSPF6_DEBUG_INTERFACE)
zlog_debug ("Interface %s already enabled",
oi->interface->name);
return 0;
}
/* Join AllSPFRouters */
// send join allspfrouters message to shim
thread_add_event (master, rospf6_join_allspfrouters_send, oi, 0);
// ospf6_join_allspfrouters (oi->interface->ifindex);
/* Update interface route */
ospf6_interface_connected_route_update (oi->interface);
zlog_debug("about to send hello message...");
/* Schedule Hello */
if (! CHECK_FLAG (oi->flag, OSPF6_INTERFACE_PASSIVE))
thread_add_event (master, rospf6_hello_send, oi, 0);
/* decide next interface state */
if (if_is_pointopoint (oi->interface))
ospf6_interface_state_change (OSPF6_INTERFACE_POINTTOPOINT, oi);
else if (oi->priority == 0)
ospf6_interface_state_change (OSPF6_INTERFACE_DROTHER, oi);
else
{
ospf6_interface_state_change (OSPF6_INTERFACE_WAITING, oi);
thread_add_timer (master, wait_timer, oi, oi->dead_interval);
}
return 0;
}
int
interface_down (struct thread *thread)
{
struct ospf6_interface *oi;
struct listnode *node, *nnode;
struct ospf6_neighbor *on;
oi = (struct ospf6_interface *) THREAD_ARG (thread);
assert (oi && oi->interface);
if (IS_OSPF6_DEBUG_INTERFACE)
zlog_debug ("Interface Event %s: [InterfaceDown]",
oi->interface->name);
/* Leave AllSPFRouters */
if (oi->state > OSPF6_INTERFACE_DOWN)
thread_add_event (master, rospf6_leave_allspfrouters_send, oi, 0);
// ospf6_leave_allspfrouters (oi->interface->ifindex);
ospf6_interface_state_change (OSPF6_INTERFACE_DOWN, oi);
for (ALL_LIST_ELEMENTS (oi->neighbor_list, node, nnode, on))
ospf6_neighbor_delete (on);
list_delete_all_node (oi->neighbor_list);
return 0;
}
/* Daemon init sequence */
static void
start_vrrp(void)
{
/* Initialize sub-system */
init_interface_queue();
kernel_netlink_init();
gratuitous_arp_init();
ndisc_init();
#ifdef _WITH_SNMP_
if (!reload && snmp)
vrrp_snmp_agent_init();
#endif
#ifdef _WITH_LVS_
/* Initialize ipvs related */
ipvs_start();
#endif
/* Parse configuration file */
data = alloc_global_data();
vrrp_data = alloc_vrrp_data();
alloc_vrrp_buffer();
init_data(conf_file, vrrp_init_keywords);
if (!vrrp_data) {
stop_vrrp();
return;
}
if (reload) {
clear_diff_saddresses();
clear_diff_sroutes();
clear_diff_vrrp();
clear_diff_script();
}
/* Complete VRRP initialization */
if (!vrrp_complete_init()) {
stop_vrrp();
return;
}
/* Post initializations */
log_message(LOG_INFO, "Configuration is using : %lu Bytes", mem_allocated);
/* Set static entries */
netlink_iplist(vrrp_data->static_addresses, IPADDRESS_ADD);
netlink_rtlist_ipv4(vrrp_data->static_routes, IPROUTE_ADD);
/* Dump configuration */
if (debug & 4) {
dump_global_data(data);
dump_vrrp_data(vrrp_data);
}
/* Initialize linkbeat */
init_interface_linkbeat();
/* Init & start the VRRP packet dispatcher */
thread_add_event(master, vrrp_dispatcher_init, NULL,
VRRP_DISPATCHER);
}
static int
bgp_dump_interval_add (struct bgp_dump *bgp_dump, int interval)
{
int secs_into_day;
time_t t;
struct tm *tm;
if (interval > 0)
{
/* Periodic dump every interval seconds */
if ((interval < 86400) && ((86400 % interval) == 0))
{
/* Dump at predictable times: if a day has a whole number of
* intervals, dump every interval seconds starting from midnight
*/
(void) time(&t);
tm = localtime(&t);
secs_into_day = tm->tm_sec + 60*tm->tm_min + 60*60*tm->tm_hour;
interval = interval - secs_into_day % interval; /* always > 0 */
}
bgp_dump->t_interval = thread_add_timer (bm->master, bgp_dump_interval_func,
bgp_dump, interval);
}
else
{
/* One-off dump: execute immediately, don't affect any scheduled dumps */
bgp_dump->t_interval = thread_add_event (bm->master, bgp_dump_interval_func,
bgp_dump, 0);
}
return 0;
}
void
ospf6_interface_if_add (struct interface *ifp)
{
struct ospf6_interface *oi;
unsigned int iobuflen;
oi = (struct ospf6_interface *) ifp->info;
if (oi == NULL)
return;
/* Try to adjust I/O buffer size with IfMtu */
if (oi->ifmtu == 0)
oi->ifmtu = ifp->mtu6;
iobuflen = ospf6_iobuf_size (ifp->mtu6);
if (oi->ifmtu > iobuflen)
{
if (IS_OSPF6_DEBUG_INTERFACE)
zlog_debug ("Interface %s: IfMtu is adjusted to I/O buffer size: %d.",
ifp->name, iobuflen);
oi->ifmtu = iobuflen;
}
/* interface start */
if (oi->area)
thread_add_event (master, interface_up, oi, 0);
}
void frrzmq_check_events(struct frrzmq_cb **cbp, struct cb_core *core,
int event)
{
struct frrzmq_cb *cb;
int events;
size_t len;
if (!cbp)
return;
cb = (*cbp);
if (!cb || !cb->zmqsock)
return;
len = sizeof(events);
if (zmq_getsockopt(cb->zmqsock, ZMQ_EVENTS, &events, &len))
return;
if (events & event && core->thread && !core->cancelled) {
struct thread_master *tm = core->thread->master;
thread_cancel(core->thread);
core->thread = NULL;
thread_add_event(tm, (event == ZMQ_POLLIN ? frrzmq_read_msg
: frrzmq_write_msg),
cbp, cb->fd, &core->thread);
}
}
int bad_lsreq(struct thread * thread)
{
struct ospf6_neighbor * on;
struct ospf6_lsa * lsa;
on = (struct ospf6_neighbor *) THREAD_ARG(thread);
assert(on);
if(on->state < OSPF6_NEIGHBOR_EXCHANGE)
return 0;
if(IS_OSPF6_SIBLING_DEBUG_NEIGHBOR)
zlog_debug("Neighbor Event %s: *BadLSReq*", on->name);
ospf6_neighbor_state_change(OSPF6_NEIGHBOR_EXSTART, on);
SET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MSBIT);
SET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MBIT);
SET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_IBIT);
ospf6_lsdb_remove_all(on->summary_list);
ospf6_lsdb_remove_all(on->request_list);
for(lsa = ospf6_lsdb_head(on->retrans_list); lsa;
lsa = ospf6_lsdb_next(lsa))
{
ospf6_decrement_retrans_count(lsa);
ospf6_lsdb_remove(lsa, on->retrans_list);
}
THREAD_OFF(on->thread_send_dbdesc);
on->thread_send_dbdesc =
thread_add_event(master, ospf6_dbdesc_send, on, 0);
return 0;
}
/* Init socket handler */
void
init_sock(void)
{
sock = (SOCK *) MALLOC(sizeof (SOCK));
memset(sock, 0, sizeof (SOCK));
thread_add_event(master, tcp_connect_thread, sock, 0);
}
void
sigusr2_vrrp(void *v, int sig)
{
log_message(LOG_INFO, "Printing VRRP stats for process(%d) on signal",
getpid());
thread_add_event(master, print_vrrp_stats, NULL, 0);
}
static void
zclient_event (enum event event, struct zclient *zclient)
{
switch (event)
{
case ZCLIENT_SCHEDULE:
if (! zclient->t_connect)
zclient->t_connect =
thread_add_event (master, zclient_connect, zclient, 0);
break;
case ZCLIENT_CONNECT:
if (zclient->fail >= 10)
return;
if (zclient_debug)
zlog_debug ("zclient connect schedule interval is %d",
zclient->fail < 3 ? 10 : 60);
if (! zclient->t_connect)
zclient->t_connect =
thread_add_timer (master, zclient_connect, zclient,
zclient->fail < 3 ? 10 : 60);
break;
case ZCLIENT_READ:
zclient->t_read =
thread_add_read (master, zclient_read, zclient, zclient->sock);
break;
}
}
void
sighup_vrrp(void *v, int sig)
{
log_message(LOG_INFO, "Reloading VRRP child process(%d) on signal",
getpid());
thread_add_event(master, reload_vrrp_thread, NULL, 0);
}
void
sighup_check(void *v, int sig)
{
log_message(LOG_INFO, "Reloading Healthchecker child process(%d) on signal",
getpid());
thread_add_event(master, reload_check_thread, NULL, 0);
}
static int
zebra_server_send_message(struct zserv *client)
{
if (client->t_suicide)
return -1;
switch (buffer_write(client->wb, client->sock, STREAM_DATA(client->obuf),
stream_get_endp(client->obuf)))
{
case BUFFER_ERROR:
zlog_warn("%s: buffer_write failed to zserv client fd %d, closing",
__func__, client->sock);
/* Schedule a delayed close since many of the functions that call this
one do not check the return code. They do not allow for the
possibility that an I/O error may have caused the client to be
deleted. */
client->t_suicide = thread_add_event(zebrad.master, zserv_delayed_close,
client, 0);
return -1;
case BUFFER_EMPTY:
THREAD_OFF(client->t_write);
break;
case BUFFER_PENDING:
THREAD_WRITE_ON(zebrad.master, client->t_write,
zserv_flush_data, client, client->sock);
break;
}
return 0;
}
int
oneway_received (struct thread *thread)
{
struct ospf6_neighbor *on;
struct ospf6_lsa *lsa;
on = (struct ospf6_neighbor *) THREAD_ARG (thread);
assert (on);
if (on->state < OSPF6_NEIGHBOR_TWOWAY)
return 0;
if (IS_OSPF6_DEBUG_NEIGHBOR (EVENT))
zlog_info ("Neighbor Event %s: *1Way-Received*", on->name);
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_INIT, on);
thread_add_event (master, neighbor_change, on->ospf6_if, 0);
ospf6_lsdb_remove_all (on->summary_list);
ospf6_lsdb_remove_all (on->request_list);
for (lsa = ospf6_lsdb_head (on->retrans_list); lsa;
lsa = ospf6_lsdb_next (lsa))
{
ospf6_decrement_retrans_count (lsa);
ospf6_lsdb_remove (lsa, on->retrans_list);
}
THREAD_OFF (on->thread_send_dbdesc);
THREAD_OFF (on->thread_send_lsreq);
THREAD_OFF (on->thread_send_lsupdate);
THREAD_OFF (on->thread_send_lsack);
return 0;
}
int
bgp_dump_interval_add (struct bgp_dump *bgp_dump, int interval)
{
int bgp_dump_interval_func (struct thread *);
int interval2, secs_into_day;
time_t t;
struct tm *tm;
if (interval > 0 )
{
if ((interval < 86400) && ((86400 % interval) == 0))
{
(void) time(&t);
tm = localtime(&t);
secs_into_day = tm->tm_sec + 60*tm->tm_min + 60*60*tm->tm_hour;
interval2 = interval - secs_into_day % interval;
if(interval2 == 0) interval2 = interval;
}
else
{
interval2 = interval;
}
bgp_dump->t_interval = thread_add_timer (master, bgp_dump_interval_func,
bgp_dump, interval2);
}
else
{
bgp_dump->t_interval = thread_add_event (master, bgp_dump_interval_func,
bgp_dump, 0);
}
return 0;
}
void
ospf6_spf_schedule (struct ospf6_area *oa)
{
if (oa->thread_spf_calculation)
return;
oa->thread_spf_calculation =
thread_add_event (master, ospf6_spf_calculation_thread, oa, 0);
}
void
ospf6_interface_enable (struct ospf6_interface *oi)
{
UNSET_FLAG (oi->flag, OSPF6_INTERFACE_DISABLE);
oi->thread_send_hello =
thread_add_event (master, ospf6_hello_send, oi, 0);
}
void
ospf6_interface_enable (struct ospf6_interface *oi)
{
UNSET_FLAG (oi->flag, OSPF6_INTERFACE_DISABLE);
zlog_debug("about to send hello message...");
oi->thread_send_hello =
thread_add_event (master, rospf6_hello_send, oi, 0);
}
void
ospf6_interface_state_update (struct interface *ifp)
{
struct ospf6_interface *oi;
oi = (struct ospf6_interface *) ifp->info;
if (oi == NULL)
return;
if (oi->area == NULL)
return;
if (if_is_up (ifp))
thread_add_event (master, interface_up, oi, 0);
else
thread_add_event (master, interface_down, oi, 0);
return;
}
/* Schedule connection for now. */
static void zclient_lookup_sched_now(struct zclient *zlookup)
{
zassert(!zlookup->t_connect);
zlookup->t_connect = thread_add_event(master, zclient_lookup_connect,
zlookup, 0);
zlog_notice("%s: zclient lookup immediate connection scheduled",
__PRETTY_FUNCTION__);
}
/* if run after vrrp_init_state(), it will be able to detect scripts that
* have been disabled because of a sync group and will avoid to start them.
*/
static void
vrrp_init_script(list l)
{
vrrp_script_t *vscript;
element e;
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
vscript = ELEMENT_DATA(e);
if (vscript->inuse == 0)
vscript->result = VRRP_SCRIPT_STATUS_DISABLED;
if (vscript->result == VRRP_SCRIPT_STATUS_INIT) {
vscript->result = vscript->rise - 1; /* one success is enough */
thread_add_event(master, vrrp_script_thread, vscript, vscript->interval);
} else if (vscript->result == VRRP_SCRIPT_STATUS_INIT_GOOD) {
vscript->result = vscript->rise; /* one failure is enough */
thread_add_event(master, vrrp_script_thread, vscript, vscript->interval);
}
}
}
void
ospf6_area_schedule_maxage_remover (void *arg, int val, void *obj)
{
struct ospf6_area *o6a = (struct ospf6_area *) obj;
if (o6a->maxage_remover != NULL)
return;
o6a->maxage_remover =
thread_add_event (master, ospf6_area_maxage_remover, o6a, 0);
}
void hello_on_eth_state_changed(struct backbone_eth* eth)
{
if(!eth->hello_master)//insert init code.
eth->hello_master = malloc_z(struct hello_master);
struct hello_master* hello_master = eth->hello_master;
printf("hello state changed\n");
if(eth->_state == ETH_DOWN)
{
//THREAD_OFF(hello_master->dead_timer_high);
//THREAD_OFF(hello_master->dead_timer_low);
THREAD_OFF(hello_master->hello_timer_high);
THREAD_OFF(hello_master->hello_timer_low);
}
else if(eth->_state == ETH_UP)
{
//if(check_global_hello_config()==0)
//{
hello_master->h_hello_val = H_HELLO_VAL;
hello_master->l_hello_val = L_HELLO_VAL;
hello_master->h_dead_val = H_DEAD_VAL;
hello_master->l_dead_val = L_DEAD_VAL;
//}
//else
//{
// int ifid = global_config.if_id;
// if(ifid == -1)
// {
// update_timer_by_backbone(eth);
// }
// else if(global_config.if_id == eth->interface_id)
// {
// update_timer_by_backbone(eth);
// }
// }
hello_master->hello_timer_high = thread_add_event(master, hello_high_send, eth, 0);
hello_master->hello_timer_low = thread_add_event(master, hello_low_send, eth, 0);
}
}
void ospf6_spf_schedule(struct ospf6_area * oa, unsigned int hostnum)
{
if(oa->thread_spf_calculation)
return;
struct ospf6_area_hostnum * ah = calloc(1, sizeof(struct ospf6_area_hostnum));
ah->oa = oa;
ah->hostnum = hostnum;
oa->thread_spf_calculation =
thread_add_event(master, ospf6_spf_calculation_thread, ah, 0);
}
int
tcp_check_thread(thread_t * thread)
{
SOCK *sock_obj = THREAD_ARG(thread);
int ret = 1;
sock_obj->status =
tcp_socket_state(thread->u.fd, thread, req->addr_ip, req->addr_port,
tcp_check_thread);
switch (sock_obj->status) {
case connect_error:
DBG("Error connecting server [%s:%d].\n",
inet_ntop2(req->addr_ip), ntohs(req->addr_port));
thread_add_terminate_event(thread->master);
return -1;
break;
case connect_timeout:
DBG("Timeout connecting server [%s:%d].\n",
inet_ntop2(req->addr_ip), ntohs(req->addr_port));
thread_add_terminate_event(thread->master);
return -1;
break;
case connect_success:{
if (req->ssl)
ret = ssl_connect(thread);
if (ret) {
/* Remote WEB server is connected.
* Unlock eventual locked socket.
*/
sock_obj->lock = 0;
thread_add_event(thread->master,
http_request_thread, sock_obj, 0);
} else {
DBG("Connection trouble to: [%s:%d].\n",
inet_ntop2(req->addr_ip),
ntohs(req->addr_port));
if (req->ssl)
ssl_printerr(SSL_get_error
(sock_obj->ssl, ret));
sock_obj->status = connect_error;
return -1;
}
}
break;
}
return 1;
}
/* connect remote SMTP server */
static void
smtp_connect(smtp_t * smtp)
{
enum connect_result status;
if ((smtp->fd = socket(global_data->smtp_server.ss_family, SOCK_STREAM, IPPROTO_TCP)) == -1) {
DBG("SMTP connect fail to create socket.");
free_smtp_all(smtp);
return;
}
status = tcp_connect(smtp->fd, &global_data->smtp_server);
/* Handle connection status code */
thread_add_event(master, SMTP_FSM[status].send, smtp, smtp->fd);
}
int oneway_received(struct thread * thread)
{
struct ospf6_neighbor * on;
on = (struct ospf6_neighbor *)THREAD_ARG(thread);
if(on->state < OSPF6_NEIGHBOR_TWOWAY)
return 0;
if(IS_OSPF6_SIBLING_DEBUG_NEIGHBOR)
zlog_debug("Neighbor Event %s: *1Way-Received*", on->name);
ospf6_neighbor_state_change(OSPF6_NEIGHBOR_INIT, on);
thread_add_event(master, neighbor_change, on->ospf6_if, 0);
return 0;
}
static void
ospf6_interface_state_change (u_char next_state, struct ospf6_interface *oi)
{
u_char prev_state;
prev_state = oi->state;
oi->state = next_state;
if (prev_state == next_state)
return;
/* log */
if (IS_OSPF6_DEBUG_INTERFACE)
{
zlog_debug ("Interface state change %s: %s -> %s", oi->interface->name,
ospf6_interface_state_str[prev_state],
ospf6_interface_state_str[next_state]);
}
if ((prev_state == OSPF6_INTERFACE_DR ||
prev_state == OSPF6_INTERFACE_BDR) &&
(next_state != OSPF6_INTERFACE_DR &&
next_state != OSPF6_INTERFACE_BDR))
ospf6_leave_alldrouters (oi->interface->ifindex);
if ((prev_state != OSPF6_INTERFACE_DR &&
prev_state != OSPF6_INTERFACE_BDR) &&
(next_state == OSPF6_INTERFACE_DR ||
next_state == OSPF6_INTERFACE_BDR))
// ospf6_join_alldrouters (oi->interface->ifindex);
thread_add_event (master, rospf6_join_alldrouters_send, oi, 0);
OSPF6_ROUTER_LSA_SCHEDULE (oi->area);
if (next_state == OSPF6_INTERFACE_DOWN)
{
OSPF6_NETWORK_LSA_EXECUTE (oi);
OSPF6_INTRA_PREFIX_LSA_EXECUTE_TRANSIT (oi);
OSPF6_INTRA_PREFIX_LSA_SCHEDULE_STUB (oi->area);
}
else if (prev_state == OSPF6_INTERFACE_DR ||
next_state == OSPF6_INTERFACE_DR)
{
OSPF6_NETWORK_LSA_SCHEDULE (oi);
OSPF6_INTRA_PREFIX_LSA_SCHEDULE_TRANSIT (oi);
OSPF6_INTRA_PREFIX_LSA_SCHEDULE_STUB (oi->area);
}
}
void
smux_event (enum smux_event event, int sock)
{
switch (event)
{
case SMUX_SCHEDULE:
smux_connect_thread = thread_add_event (master, smux_connect, NULL, 0);
break;
case SMUX_CONNECT:
smux_connect_thread = thread_add_timer (master, smux_connect, NULL, 10);
break;
case SMUX_READ:
smux_read_thread = thread_add_read (master, smux_read, NULL, sock);
break;
default:
break;
}
}
