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

static void aio_linux_housekeeping(struct tevent_context *event_ctx,                                        struct tevent_timer *te,                                        struct timeval now,                                        void *private_data){	/* Remove this timed event handler. */	TALLOC_FREE(te);	if ((num_busy != 0) || used) {		used = false;		/* Still busy. Look again in 30 seconds. */		(void)tevent_add_timer(event_ctx,					NULL,					timeval_current_ofs(30, 0),					aio_linux_housekeeping,					NULL);		return;	}	/* No activity for 30 seconds. Close out kernel resources. */	io_queue_release(io_ctx);	memset(&io_ctx, '/0', sizeof(io_ctx));	if (event_fd != -1) {		close(event_fd);		event_fd = -1;	}	TALLOC_FREE(aio_read_event);}

void switch_sigint_enabled(struct tevent_context *ev,                           struct tevent_timer *te,                           struct timeval t,                           void *private_data){    struct timeval tv;    struct tevent_timer *event_timer = NULL;    struct main_context *main_ctx = talloc_get_type(private_data,                                    struct main_context);    if (main_ctx->is_sigint_enabled) {        main_ctx->is_sigint_enabled = 0;        DEBUG("SIGINT disabled");    } else {        main_ctx->is_sigint_enabled = 1;        DEBUG("SIGINT enabled");    }    tv = tevent_timeval_current_ofs(SIGINT_SWITCH_TIMEOUT, 0);    event_timer = tevent_add_timer(main_ctx->event_ctx, main_ctx->event_ctx, tv,                                   switch_sigint_enabled, main_ctx);    if (event_timer == NULL) {        DEBUG("tevent_add_signal() failed");    }}

static void ctdb_mutex_rados_timer_cb(struct tevent_context *ev,				      struct tevent_timer *te,				      struct timeval current_time,				      void *private_data){	struct ctdb_mutex_rados_state *cmr_state = private_data;	int ret;	if (!cmr_state->holding_mutex) {		fprintf(stderr, "Timer callback invoked without mutex!/n");		ret = -EINVAL;		goto err_ctx_cleanup;	}	if ((kill(cmr_state->ppid, 0) == 0) || (errno != ESRCH)) {		/* parent still around, keep waiting */		cmr_state->timer_ev = tevent_add_timer(cmr_state->ev, cmr_state,					       tevent_timeval_current_ofs(5, 0),						      ctdb_mutex_rados_timer_cb,						       cmr_state);		if (cmr_state->timer_ev == NULL) {			fprintf(stderr, "Failed to create timer event/n");			/* rely on signal cb */		}		return;	}	/* parent ended, drop lock and exit */	ret = ctdb_mutex_rados_unlock(cmr_state->ioctx, cmr_state->object);err_ctx_cleanup:	ctdb_mutex_rados_ctx_destroy(cmr_state->ceph_cluster,				     cmr_state->ioctx);	talloc_free(cmr_state);	exit(ret ? 1 : 0);}

static PyObject *py_tevent_context_add_timer(TeventContext_Object *self, PyObject *args){	TeventTimer_Object *ret;	struct timeval next_event;	struct tevent_timer *timer;	PyObject *handler;	if (!PyArg_ParseTuple(args, "lO", &next_event, &handler))		return NULL;	timer = tevent_add_timer(self->ev, NULL, next_event, py_timer_handler,							 handler);	if (timer == NULL) {		PyErr_SetNone(PyExc_RuntimeError);		return NULL;	}	ret = PyObject_New(TeventTimer_Object, &TeventTimer_Type);	if (ret == NULL) {		PyErr_NoMemory();		talloc_free(timer);		return NULL;	}	ret->timer = timer;	return (PyObject *)ret;}

static void add_oplock_timeout_handler(files_struct *fsp){	struct smbd_server_connection *sconn = fsp->conn->sconn;	struct kernel_oplocks *koplocks = sconn->oplocks.kernel_ops;	/*	 * If kernel oplocks already notifies smbds when an oplock break times	 * out, just return.	 */	if (koplocks &&	    (koplocks->flags & KOPLOCKS_TIMEOUT_NOTIFICATION)) {		return;	}	if (fsp->oplock_timeout != NULL) {		DEBUG(0, ("Logic problem -- have an oplock event hanging "			  "around/n"));	}	fsp->oplock_timeout =		tevent_add_timer(fsp->conn->sconn->ev_ctx, fsp,				 timeval_current_ofs(OPLOCK_BREAK_TIMEOUT, 0),				 oplock_timeout_handler, fsp);	if (fsp->oplock_timeout == NULL) {		DEBUG(0, ("Could not add oplock timeout handler/n"));	}}

static void wait_replies(struct tevent_context *ev_ctx,			 struct messaging_context *msg_ctx,			 bool multiple_replies){	struct tevent_timer *te;	bool timed_out = False;	te = tevent_add_timer(ev_ctx, NULL,			      timeval_current_ofs(timeout, 0),			      smbcontrol_timeout, (void *)&timed_out);	if (te == NULL) {		DEBUG(0, ("tevent_add_timer failed/n"));		return;	}	while (!timed_out) {		int ret;		if (num_replies > 0 && !multiple_replies)			break;		ret = tevent_loop_once(ev_ctx);		if (ret != 0) {			break;		}	}}

static void remove_child_pid(struct smbd_parent_context *parent,			     pid_t pid,			     bool unclean_shutdown){	struct smbd_child_pid *child;	struct server_id child_id;	int ret;	child_id = pid_to_procid(pid);	ret = messaging_cleanup(parent->msg_ctx, pid);	if ((ret != 0) && (ret != ENOENT)) {		DEBUG(10, ("%s: messaging_cleanup returned %s/n",			   __func__, strerror(ret)));	}	smbprofile_cleanup(pid);	for (child = parent->children; child != NULL; child = child->next) {		if (child->pid == pid) {			struct smbd_child_pid *tmp = child;			DLIST_REMOVE(parent->children, child);			TALLOC_FREE(tmp);			parent->num_children -= 1;			break;		}	}	if (child == NULL) {		/* not all forked child processes are added to the children list */		DEBUG(2, ("Could not find child %d -- ignoring/n", (int)pid));		return;	}	if (unclean_shutdown) {		/* a child terminated uncleanly so tickle all		   processes to see if they can grab any of the		   pending locks                */		DEBUG(3,(__location__ " Unclean shutdown of pid %u/n",			(unsigned int)pid));		if (parent->cleanup_te == NULL) {			/* call the cleanup timer, but not too often */			int cleanup_time = lp_parm_int(-1, "smbd", "cleanuptime", 20);			parent->cleanup_te = tevent_add_timer(parent->ev_ctx,						parent,						timeval_current_ofs(cleanup_time, 0),						cleanup_timeout_fn,						parent);			DEBUG(1,("Scheduled cleanup of brl and lock database after unclean shutdown/n"));		}	}	if (!serverid_deregister(child_id)) {		DEBUG(1, ("Could not remove pid %d from serverid.tdb/n",			  (int)pid));	}}

static void ldap_id_enumerate_timer(struct tevent_context *ev,                                    struct tevent_timer *tt,                                    struct timeval tv, void *pvt){    struct sdap_id_ctx *ctx = talloc_get_type(pvt, struct sdap_id_ctx);    struct tevent_timer *timeout;    struct tevent_req *req;    int delay;    errno_t ret;    if (be_is_offline(ctx->be)) {        DEBUG(4, ("Backend is marked offline, retry later!/n"));        /* schedule starting from now, not the last run */        delay = dp_opt_get_int(ctx->opts->basic, SDAP_ENUM_REFRESH_TIMEOUT);        tv = tevent_timeval_current_ofs(delay, 0);        ldap_id_enumerate_set_timer(ctx, tv);        return;    }    req = ldap_id_enumerate_send(ev, ctx);    if (!req) {        DEBUG(1, ("Failed to schedule enumeration, retrying later!/n"));        /* schedule starting from now, not the last run */        delay = dp_opt_get_int(ctx->opts->basic, SDAP_ENUM_REFRESH_TIMEOUT);        tv = tevent_timeval_current_ofs(delay, 0);        ret = ldap_id_enumerate_set_timer(ctx, tv);        if (ret != EOK) {            DEBUG(1, ("Error setting up enumerate timer/n"));        }        return;    }    tevent_req_set_callback(req, ldap_id_enumerate_reschedule, ctx);    /* if enumeration takes so long, either we try to enumerate too     * frequently, or something went seriously wrong */    delay = dp_opt_get_int(ctx->opts->basic, SDAP_ENUM_REFRESH_TIMEOUT);    tv = tevent_timeval_current_ofs(delay, 0);    timeout = tevent_add_timer(ctx->be->ev, req, tv,                               ldap_id_enumerate_timeout, req);    if (timeout == NULL) {        /* If we can't guarantee a timeout, we         * need to cancel the request, to avoid         * the possibility of starting another         * concurrently         */        talloc_zfree(req);        DEBUG(1, ("Failed to schedule enumeration, retrying later!/n"));        /* schedule starting from now, not the last run */        delay = dp_opt_get_int(ctx->opts->basic, SDAP_ENUM_REFRESH_TIMEOUT);        tv = tevent_timeval_current_ofs(delay, 0);        ret = ldap_id_enumerate_set_timer(ctx, tv);        if (ret != EOK) {            DEBUG(1, ("Error setting up enumerate timer/n"));        }        return;    }    return;}

/*  setup a timer to destroy a open search after a inactivity period*/static void pvfs_search_setup_timer(struct pvfs_search_state *search){	struct tevent_context *ev = search->pvfs->ntvfs->ctx->event_ctx;	if (search->handle == INVALID_SEARCH_HANDLE) return;	talloc_free(search->te);	search->te = tevent_add_timer(ev, search,				     timeval_current_ofs(search->pvfs->search.inactivity_time, 0), 				     pvfs_search_timer, search);}

static bool init_aio_linux(struct vfs_handle_struct *handle){	struct tevent_timer *te = NULL;	if (event_fd != -1) {		/* Already initialized. */		return true;	}	/* Schedule a shutdown event for 30 seconds from now. */	te = tevent_add_timer(handle->conn->sconn->ev_ctx,				NULL,				timeval_current_ofs(30, 0),				aio_linux_housekeeping,				NULL);	if (te == NULL) {		goto fail;	}	event_fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);	if (event_fd == -1) {		goto fail;	}	aio_read_event = tevent_add_fd(server_event_context(),				NULL,				event_fd,				TEVENT_FD_READ,				aio_linux_done,				NULL);	if (aio_read_event == NULL) {		goto fail;	}	if (io_queue_init(lp_aio_max_threads(), &io_ctx)) {		goto fail;	}	DEBUG(10,("init_aio_linux: initialized with up to %d events/n",		  (int)lp_aio_max_threads()));	return true;  fail:	DEBUG(10,("init_aio_linux: initialization failed/n"));	TALLOC_FREE(te);	TALLOC_FREE(aio_read_event);	if (event_fd != -1) {		close(event_fd);		event_fd = -1;	}	memset(&io_ctx, '/0', sizeof(io_ctx));	return false;}

/*  see if any nodes are dead */static void ctdb_check_for_dead_nodes(struct tevent_context *ev,				      struct tevent_timer *te,				      struct timeval t, void *private_data){	struct ctdb_context *ctdb = talloc_get_type(private_data, struct ctdb_context);	int i;	/* send a keepalive to all other nodes, unless */	for (i=0;i<ctdb->num_nodes;i++) {		struct ctdb_node *node = ctdb->nodes[i];		if (node->flags & NODE_FLAGS_DELETED) {			continue;		}		if (node->pnn == ctdb->pnn) {			continue;		}				if (node->flags & NODE_FLAGS_DISCONNECTED) {			/* it might have come alive again */			if (node->rx_cnt != 0) {				ctdb_node_connected(node);			}			continue;		}		if (node->rx_cnt == 0) {			node->dead_count++;		} else {			node->dead_count = 0;		}		node->rx_cnt = 0;		if (node->dead_count >= ctdb->tunable.keepalive_limit) {			DEBUG(DEBUG_NOTICE,("dead count reached for node %u/n", node->pnn));			ctdb_node_dead(node);			ctdb_send_keepalive(ctdb, node->pnn);			/* maybe tell the transport layer to kill the			   sockets as well?			*/			continue;		}				DEBUG(DEBUG_DEBUG,("sending keepalive to %u/n", node->pnn));		ctdb_send_keepalive(ctdb, node->pnn);		node->tx_cnt = 0;	}	tevent_add_timer(ctdb->ev, ctdb->keepalive_ctx,			 timeval_current_ofs(ctdb->tunable.keepalive_interval, 0),			 ctdb_check_for_dead_nodes, ctdb);}

bool fsp_lease_update(struct share_mode_lock *lck,		      const struct GUID *client_guid,		      struct fsp_lease *lease){	struct share_mode_data *d = lck->data;	int idx;	struct share_mode_lease *l = NULL;	idx = find_share_mode_lease(d, client_guid, &lease->lease.lease_key);	if (idx != -1) {		l = &d->leases[idx];	}	if (l == NULL) {		DEBUG(1, ("%s: Could not find lease entry/n", __func__));		TALLOC_FREE(lease->timeout);		lease->lease.lease_state = SMB2_LEASE_NONE;		lease->lease.lease_epoch += 1;		lease->lease.lease_flags = 0;		return false;	}	DEBUG(10,("%s: refresh lease state/n", __func__));	/* Ensure we're in sync with current lease state. */	if (lease->lease.lease_epoch != l->epoch) {		DEBUG(10,("%s: cancel outdated timeout/n", __func__));		TALLOC_FREE(lease->timeout);	}	lease->lease.lease_epoch = l->epoch;	lease->lease.lease_state = l->current_state;	if (l->breaking) {		lease->lease.lease_flags |= SMB2_LEASE_FLAG_BREAK_IN_PROGRESS;		if (lease->timeout == NULL) {			struct timeval t = timeval_current_ofs(OPLOCK_BREAK_TIMEOUT, 0);			DEBUG(10,("%s: setup timeout handler/n", __func__));			lease->timeout = tevent_add_timer(lease->sconn->ev_ctx,							  lease, t,							  lease_timeout_handler,							  lease);			if (lease->timeout == NULL) {				DEBUG(0, ("%s: Could not add lease timeout handler/n",					  __func__));			}		}	} else {		lease->lease.lease_flags &= ~SMB2_LEASE_FLAG_BREAK_IN_PROGRESS;		TALLOC_FREE(lease->timeout);	}	return true;}

static void add_krb5_ticket_gain_handler_event(struct WINBINDD_CCACHE_ENTRY *entry,				     struct timeval t){	entry->refresh_time = 0;	entry->event = tevent_add_timer(winbind_event_context(),				       entry,				       t,				       krb5_ticket_gain_handler,				       entry);}

_PUBLIC_ void composite_done(struct composite_context *ctx){	if (!ctx->used_wait && !ctx->async.fn) {		tevent_add_timer(ctx->event_ctx, ctx, timeval_zero(), composite_trigger, ctx);	}	ctx->state = COMPOSITE_STATE_DONE;	if (ctx->async.fn != NULL) {		ctx->async.fn(ctx);	}}

/* * Callback routine when required locks are not obtained within timeout * Called from parent context */static void ctdb_lock_timeout_handler(struct tevent_context *ev,				    struct tevent_timer *ttimer,				    struct timeval current_time,				    void *private_data){	static const char * debug_locks = NULL;	struct lock_context *lock_ctx;	struct ctdb_context *ctdb;	pid_t pid;	lock_ctx = talloc_get_type_abort(private_data, struct lock_context);	ctdb = lock_ctx->ctdb;	if (lock_ctx->type == LOCK_RECORD || lock_ctx->type == LOCK_DB) {		DEBUG(DEBUG_WARNING,		      ("Unable to get %s lock on database %s for %.0lf seconds/n",		       (lock_ctx->type == LOCK_RECORD ? "RECORD" : "DB"),		       lock_ctx->ctdb_db->db_name,		       timeval_elapsed(&lock_ctx->start_time)));	} else {		DEBUG(DEBUG_WARNING,		      ("Unable to get ALLDB locks for %.0lf seconds/n",		       timeval_elapsed(&lock_ctx->start_time)));	}	/* Fire a child process to find the blocking process. */	if (debug_locks == NULL) {		debug_locks = getenv("CTDB_DEBUG_LOCKS");		if (debug_locks == NULL) {			debug_locks = talloc_asprintf(ctdb,						      "%s/debug_locks.sh",						      getenv("CTDB_BASE"));		}	}	if (debug_locks != NULL) {		pid = vfork();		if (pid == 0) {			execl(debug_locks, debug_locks, NULL);			_exit(0);		}		ctdb_track_child(ctdb, pid);	} else {		DEBUG(DEBUG_WARNING,		      (__location__		       " Unable to setup lock debugging - no memory?/n"));	}	/* reset the timeout timer */	// talloc_free(lock_ctx->ttimer);	lock_ctx->ttimer = tevent_add_timer(ctdb->ev,					    lock_ctx,					    timeval_current_ofs(10, 0),					    ctdb_lock_timeout_handler,					    (void *)lock_ctx);}

static void each_second(struct tevent_context *ev,			struct tevent_timer *te,			struct timeval t,			void *private_data){	struct db_context *db = talloc_get_type(private_data, struct db_context);	print_counters();	tevent_add_timer(ev, db, timeval_current_ofs(1, 0), each_second, db);}

/*  re-enable receiving */_PUBLIC_ void packet_recv_enable(struct packet_context *pc){	if (pc->recv_need_enable) {		pc->recv_need_enable = false;		TEVENT_FD_READABLE(pc->fde);	}	pc->recv_disable = false;	if (pc->num_read != 0 && pc->packet_size >= pc->num_read) {		tevent_add_timer(pc->ev, pc, timeval_zero(), packet_next_event, pc);	}}

/*  start a timer to refresh this name*/static void nbtd_wins_start_refresh_timer(struct nbtd_iface_name *iname){	uint32_t refresh_time;	uint32_t max_refresh_time = lpcfg_parm_int(iname->iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "max_refresh_time", 7200);	refresh_time = MIN(max_refresh_time, iname->ttl/2);		tevent_add_timer(iname->iface->nbtsrv->task->event_ctx,			iname, 			timeval_add(&iname->registration_time, refresh_time, 0),			nbtd_wins_refresh, iname);}

static bool test_event_context_threaded(struct torture_context *test,					const void *test_data){	struct tevent_context *ev;	struct tevent_timer *te;	struct tevent_fd *fde;	pthread_t poll_thread;	int fds[2];	int ret;	char c = 0;	ev = tevent_context_init_byname(test, "poll_mt");	torture_assert(test, ev != NULL, "poll_mt not supported");	tevent_set_trace_callback(ev, test_event_threaded_trace, NULL);	te = tevent_add_timer(ev, ev, timeval_current_ofs(5, 0),			      test_event_threaded_timer, NULL);	torture_assert(test, te != NULL, "Could not add timer");	ret = pthread_create(&poll_thread, NULL, test_event_poll_thread, ev);	torture_assert(test, ret == 0, "Could not create poll thread");	ret = pipe(fds);	torture_assert(test, ret == 0, "Could not create pipe");	poll(NULL, 0, 100);	test_event_threaded_lock();	fde = tevent_add_fd(ev, ev, fds[0], TEVENT_FD_READ,			    test_event_threaded_read_handler, &fds[0]);	torture_assert(test, fde != NULL, "Could not add fd event");	test_event_threaded_unlock();	poll(NULL, 0, 100);	write(fds[1], &c, 1);	poll(NULL, 0, 100);	test_event_threaded_lock();	do_shutdown = true;	test_event_threaded_unlock();	write(fds[1], &c, 1);	ret = pthread_join(poll_thread, NULL);	torture_assert(test, ret == 0, "pthread_join failed");	return true;}

/*  called when the startup event script finishes */static void ctdb_startup_callback(struct ctdb_context *ctdb, int status, void *p){	if (status != 0) {		DEBUG(DEBUG_ERR,("startup event failed/n"));		tevent_add_timer(ctdb->ev, ctdb->monitor->monitor_context,				 timeval_current_ofs(5, 0),				 ctdb_run_startup, ctdb);		return;	}	DEBUG(DEBUG_NOTICE,("startup event OK - enabling monitoring/n"));	ctdb_set_runstate(ctdb, CTDB_RUNSTATE_RUNNING);	ctdb->monitor->next_interval = 2;	ctdb_run_notification_script(ctdb, "startup");	ctdb->monitor->monitoring_mode = CTDB_MONITORING_ACTIVE;	tevent_add_timer(ctdb->ev, ctdb->monitor->monitor_context,			 timeval_current_ofs(ctdb->monitor->next_interval, 0),			 ctdb_check_health, ctdb);}

/*  shutdown and try to restart a connection to a node after it has been  disconnected*/static void ctdb_tcp_restart(struct ctdb_node *node){    struct ctdb_tcp_node *tnode = talloc_get_type(                                      node->private_data, struct ctdb_tcp_node);    DEBUG(DEBUG_NOTICE,("Tearing down connection to dead node :%d/n", node->pnn));    ctdb_tcp_stop_connection(node);    tnode->connect_te = tevent_add_timer(node->ctdb->ev, tnode,                                         timeval_zero(),                                         ctdb_tcp_node_connect, node);}

/*  see if the event scripts think we are healthy */static void ctdb_check_health(struct tevent_context *ev,			      struct tevent_timer *te,			      struct timeval t, void *private_data){	struct ctdb_context *ctdb = talloc_get_type(private_data, struct ctdb_context);	bool skip_monitoring = false;	int ret = 0;	if (ctdb->recovery_mode != CTDB_RECOVERY_NORMAL ||	    ctdb->monitor->monitoring_mode == CTDB_MONITORING_DISABLED) {		skip_monitoring = true;	} else {		if (ctdb_db_all_frozen(ctdb)) {			DEBUG(DEBUG_ERR,			      ("Skip monitoring since databases are frozen/n"));			skip_monitoring = true;		}	}	if (skip_monitoring) {		tevent_add_timer(ctdb->ev, ctdb->monitor->monitor_context,				 timeval_current_ofs(ctdb->monitor->next_interval, 0),				 ctdb_check_health, ctdb);		return;	}	ret = ctdb_event_script_callback(ctdb,					 ctdb->monitor->monitor_context,					 ctdb_health_callback,					 ctdb, CTDB_EVENT_MONITOR, "%s", "");	if (ret != 0) {		DEBUG(DEBUG_ERR,("Unable to launch monitor event script/n"));		ctdb->monitor->next_interval = 5;		tevent_add_timer(ctdb->ev, ctdb->monitor->monitor_context,				 timeval_current_ofs(5, 0),				 ctdb_check_health, ctdb);	}}

static void ctdb_run_startup(struct tevent_context *ev,			     struct tevent_timer *te,			     struct timeval t, void *private_data){	struct ctdb_context *ctdb = talloc_get_type(private_data,						    struct ctdb_context);	int ret;	/* This is necessary to avoid the "startup" event colliding	 * with the "ipreallocated" event from the takeover run	 * following the first recovery.  We might as well serialise	 * these things if we can.	 */	if (ctdb->runstate < CTDB_RUNSTATE_STARTUP) {		DEBUG(DEBUG_NOTICE,		      ("Not yet in startup runstate. Wait one more second/n"));		tevent_add_timer(ctdb->ev, ctdb->monitor->monitor_context,				 timeval_current_ofs(1, 0),				 ctdb_run_startup, ctdb);		return;	}	/* release any IPs we hold from previous runs of the daemon */	ctdb_release_all_ips(ctdb);	DEBUG(DEBUG_NOTICE,("Running the /"startup/" event./n"));	ret = ctdb_event_script_callback(ctdb,					 ctdb->monitor->monitor_context,					 ctdb_startup_callback,					 ctdb, CTDB_EVENT_STARTUP, "%s", "");	if (ret != 0) {		DEBUG(DEBUG_ERR,("Unable to launch startup event script/n"));		tevent_add_timer(ctdb->ev, ctdb->monitor->monitor_context,				 timeval_current_ofs(5, 0),				 ctdb_run_startup, ctdb);	}}

void ctdb_start_keepalive(struct ctdb_context *ctdb){	struct tevent_timer *te;	ctdb->keepalive_ctx = talloc_new(ctdb);	CTDB_NO_MEMORY_FATAL(ctdb, ctdb->keepalive_ctx);	te = tevent_add_timer(ctdb->ev, ctdb->keepalive_ctx,			      timeval_current_ofs(ctdb->tunable.keepalive_interval, 0),			      ctdb_check_for_dead_nodes, ctdb);	CTDB_NO_MEMORY_FATAL(ctdb, te);	DEBUG(DEBUG_NOTICE,("Keepalive monitoring has been started/n"));}

void smbprofile_dump_schedule_timer(void){	struct timeval tv;	GetTimeOfDay(&tv);	tv.tv_sec += 1;	smbprofile_state.internal.te = tevent_add_timer(				smbprofile_state.internal.ev,				smbprofile_state.internal.ev,				tv,				smbprofile_dump_timer,				NULL);}

/*  start watching for nodes that might be dead */void ctdb_wait_for_first_recovery(struct ctdb_context *ctdb){	ctdb_set_runstate(ctdb, CTDB_RUNSTATE_FIRST_RECOVERY);	ctdb->monitor = talloc(ctdb, struct ctdb_monitor_state);	CTDB_NO_MEMORY_FATAL(ctdb, ctdb->monitor);	ctdb->monitor->monitor_context = talloc_new(ctdb->monitor);	CTDB_NO_MEMORY_FATAL(ctdb, ctdb->monitor->monitor_context);	tevent_add_timer(ctdb->ev, ctdb->monitor->monitor_context,			 timeval_current_ofs(1, 0),			 ctdb_wait_until_recovered, ctdb);}

/*  called when a complete packet has come in - should not happen on this socket  unless the other side closes the connection with RST or FIN */void ctdb_tcp_tnode_cb(uint8_t *data, size_t cnt, void *private_data){	struct ctdb_node *node = talloc_get_type(private_data, struct ctdb_node);	struct ctdb_tcp_node *tnode = talloc_get_type(		node->private_data, struct ctdb_tcp_node);	if (data == NULL) {		node->ctdb->upcalls->node_dead(node);	}	ctdb_tcp_stop_connection(node);	tnode->connect_te = tevent_add_timer(node->ctdb->ev, tnode,					     timeval_current_ofs(3, 0),					     ctdb_tcp_node_connect, node);}

int ctdb_statistics_init(struct ctdb_context *ctdb){	bzero(&ctdb->statistics, sizeof(struct ctdb_statistics));	ctdb->statistics.statistics_start_time = timeval_current();	bzero(&ctdb->statistics_current, sizeof(struct ctdb_statistics));	ctdb->statistics_current.statistics_start_time = timeval_current();	bzero(ctdb->statistics_history, sizeof(ctdb->statistics_history));	tevent_add_timer(ctdb->ev, ctdb,			 timeval_current_ofs(ctdb->tunable.stat_history_interval, 0),			 ctdb_statistics_update, ctdb);	return 0;}

bool tevent_req_set_endtime(struct tevent_req *req,			    struct tevent_context *ev,			    struct timeval endtime){	TALLOC_FREE(req->internal.timer);	req->internal.timer = tevent_add_timer(ev, req, endtime,					       tevent_req_timedout,					       req);	if (tevent_req_nomem(req->internal.timer, req)) {		return false;	}	return true;}

void ccache_regain_all_now(void){	struct WINBINDD_CCACHE_ENTRY *cur;	struct timeval t = timeval_current();	for (cur = ccache_list; cur; cur = cur->next) {		struct tevent_timer *new_event;		/*		 * if refresh_time is 0, we know that the		 * the event has the krb5_ticket_gain_handler		 */		if (cur->refresh_time == 0) {			new_event = tevent_add_timer(winbind_event_context(),						    cur,						    t,						    krb5_ticket_gain_handler,						    cur);		} else {			new_event = tevent_add_timer(winbind_event_context(),						    cur,						    t,						    krb5_ticket_refresh_handler,						    cur);		}		if (!new_event) {			continue;		}		TALLOC_FREE(cur->event);		cur->event = new_event;	}	return;}