自学教程：C++ thread_add_event函数代码示例

inttwoway_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 */intinterface_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;}

intinterface_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 voidstart_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 intbgp_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;}

voidospf6_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 */voidinit_sock(void){	sock = (SOCK *) MALLOC(sizeof (SOCK));	memset(sock, 0, sizeof (SOCK));	thread_add_event(master, tcp_connect_thread, sock, 0);}

voidsigusr2_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 voidzclient_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;    }}

voidsighup_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);}

voidsighup_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 intzebra_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;}

intoneway_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;}

intbgp_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;}

voidospf6_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);}

voidospf6_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);}

voidospf6_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);}

voidospf6_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 voidvrrp_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 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);}

inttcp_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 voidsmtp_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 voidospf6_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);    }}

voidsmux_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;    }}