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

static void proxy_client_worker_input(struct proxy_client_dsync_worker *worker){    const char *line;    int ret;    if (worker->to_input != NULL)        timeout_remove(&worker->to_input);    if (worker->worker.input_callback != NULL) {        worker->worker.input_callback(worker->worker.input_context);        timeout_reset(worker->to);        return;    }    while ((ret = proxy_client_worker_read_line(worker, &line)) > 0) {        if (!proxy_client_worker_next_reply(worker, line))            break;    }    if (ret < 0) {        /* try to continue */        proxy_client_worker_next_reply(worker, "");    }    if (worker->to_input != NULL) {        /* input stream's destroy callback was already called.           don't get back here. */        timeout_remove(&worker->to_input);    }    timeout_reset(worker->to);}

static voididle_finish(struct cmd_idle_context *ctx, bool done_ok, bool free_cmd){	struct client *client = ctx->client;	if (ctx->keepalive_to != NULL)		timeout_remove(&ctx->keepalive_to);	if (ctx->to_hibernate != NULL)		timeout_remove(&ctx->to_hibernate);	if (ctx->sync_ctx != NULL) {		/* we're here only in connection failure cases */		(void)imap_sync_deinit(ctx->sync_ctx, ctx->cmd);	}	o_stream_cork(client->output);	if (client->io != NULL)		io_remove(&client->io);	if (client->mailbox != NULL)		mailbox_notify_changes_stop(client->mailbox);	if (done_ok)		client_send_tagline(ctx->cmd, "OK Idle completed.");	else		client_send_tagline(ctx->cmd, "BAD Expected DONE.");	o_stream_uncork(client->output);	if (free_cmd)		client_command_free(&ctx->cmd);}

void ldap_connection_kill(struct ldap_connection *conn){	if (conn->io != NULL)		io_remove_closed(&(conn->io));	if (conn->to_disconnect != NULL)		timeout_remove(&(conn->to_disconnect));	if (conn->to_reconnect != NULL)		timeout_remove(&(conn->to_reconnect));	if (conn->request_queue != NULL) {		unsigned int n = aqueue_count(conn->request_queue);		for (unsigned int i = 0; i < n; i++) {			struct ldap_op_queue_entry *const *reqp =				array_idx(&(conn->request_array),					  aqueue_idx(conn->request_queue, i));			if ((*reqp)->msgid > -1)				ldap_abandon_ext(conn->conn, (*reqp)->msgid, NULL, NULL);			(*reqp)->msgid = -1;		}	}	if (conn->conn != NULL) {		ldap_unbind_ext(conn->conn, NULL, NULL);		ldap_memfree(conn->scred);	}	conn->conn = NULL;	conn->state = LDAP_STATE_DISCONNECT;}

static void login_proxy_disconnect(struct login_proxy *proxy){	if (proxy->to != NULL)		timeout_remove(&proxy->to);	if (proxy->to_notify != NULL)		timeout_remove(&proxy->to_notify);	if (!proxy->num_waiting_connections_updated) {		i_assert(proxy->state_rec->num_waiting_connections > 0);		proxy->state_rec->num_waiting_connections--;	}	if (proxy->connected) {		i_assert(proxy->state_rec->num_proxying_connections > 0);		proxy->state_rec->num_proxying_connections--;	}	if (proxy->server_io != NULL)		io_remove(&proxy->server_io);	if (proxy->server_input != NULL)		i_stream_destroy(&proxy->server_input);	if (proxy->server_output != NULL)		o_stream_destroy(&proxy->server_output);	if (proxy->server_fd != -1)		net_disconnect(proxy->server_fd);}

void service_process_destroy(struct service_process *process){	struct service *service = process->service;	struct service_list *service_list = service->list;	DLLIST_REMOVE(&service->processes, process);	hash_table_remove(service_pids, POINTER_CAST(process->pid));	if (process->available_count > 0)		service->process_avail--;	service->process_count--;	i_assert(service->process_avail <= service->process_count);	if (process->to_status != NULL)		timeout_remove(&process->to_status);	if (process->to_idle != NULL)		timeout_remove(&process->to_idle);	if (service->list->log_byes != NULL)		service_process_notify_add(service->list->log_byes, process);	process->destroyed = TRUE;	service_process_unref(process);	if (service->process_count < service->process_limit &&	    service->type == SERVICE_TYPE_LOGIN)		service_login_notify(service, FALSE);	service_list_unref(service_list);}

static void shutdown_complete(const void *data, uint8_t size, void *user_data){	unsigned int id = PTR_TO_UINT(user_data);	timeout_remove(id);	mainloop_quit();}

static void idle_add_keepalive_timeout(struct cmd_idle_context *ctx){	unsigned int interval = ctx->client->set->imap_idle_notify_interval;	unsigned int client_hash;	if (interval == 0)		return;	/* set the interval so that the client gets the keepalive notifications	   at exactly the same time for all the connections. this helps to	   reduce battery usage in mobile devices. but we don't really want to	   send this notification for everyone at the same time, because it	   would cause huge peaks of activity.	   basing the notifications on the username works well for one account,	   but basing it on the IP address allows the client to get all of the	   notifications at the same time for multiple accounts as well (of	   course assuming Dovecot is running on all the servers :)	   one potential downside to using IP is that if a proxy hides the	   client's IP address notifications are sent to everyone at the same	   time, but this can be avoided by using a properly configured Dovecot	   proxy. we'll also try to avoid this by not doing it for the commonly	   used intranet IP ranges. */	client_hash = ctx->client->user->remote_ip != NULL &&		remote_ip_is_usable(ctx->client->user->remote_ip) ?		net_ip_hash(ctx->client->user->remote_ip) :		crc32_str(ctx->client->user->username);	interval -= (time(NULL) + client_hash) % interval;	if (ctx->keepalive_to != NULL)		timeout_remove(&ctx->keepalive_to);	ctx->keepalive_to = timeout_add(interval * 1000,					keepalive_timeout, ctx);}

static void destroy_unrefed(bool all){	struct mail_index_alloc_cache_list **list, *rec;	bool seen_ref0 = FALSE;	for (list = &indexes; *list != NULL;) {		rec = *list;		if (rec->refcount == 0 &&		    (all || rec->destroy_time <= ioloop_time)) {			*list = rec->next;			mail_index_alloc_cache_list_free(rec);		} else {			if (rec->refcount == 0)				seen_ref0 = TRUE;			if (all && rec->index->open_count == 1 &&			    rec->referenced) {				/* we're the only one keeping this index open.				   we might be here, because the caller is				   deleting this mailbox and wants its indexes				   to be closed. so close it. */				rec->referenced = FALSE;				mail_index_close(rec->index);			}			list = &(*list)->next;		}	}	if (!seen_ref0 && to_index != NULL)		timeout_remove(&to_index);}

void auth_request_handler_flush_failures(bool flush_all){	struct auth_request **auth_requests, *auth_request;	unsigned int i, count;	time_t diff;	count = aqueue_count(auth_failures);	if (count == 0) {		if (to_auth_failures != NULL)			timeout_remove(&to_auth_failures);		return;	}	auth_requests = array_idx_modifiable(&auth_failures_arr, 0);	for (i = 0; i < count; i++) {		auth_request = auth_requests[aqueue_idx(auth_failures, 0)];		/* FIXME: assumess that failure_delay is always the same. */		diff = ioloop_time - auth_request->last_access;		if (diff < (time_t)auth_request->set->failure_delay &&		    !flush_all)			break;		aqueue_delete_tail(auth_failures);		i_assert(auth_request->state == AUTH_REQUEST_STATE_FINISHED);		auth_request_handler_reply(auth_request,					   AUTH_CLIENT_RESULT_FAILURE,					   &uchar_nul, 0);		auth_request_unref(&auth_request);	}}

static void client_input(struct client *client){	const char *const *args, *error;	int ret;	if (client->to_pending != NULL)		timeout_remove(&client->to_pending);	switch (i_stream_read(client->input)) {	case -2:		i_error("BUG: Stats client sent too much data");		client_destroy(&client);		return;	case -1:		client_destroy(&client);		return;	}	o_stream_cork(client->output);	while ((args = client_read_next_line(client)) != NULL) {		ret = client_handle_request(client, args, &error);		if (ret < 0) {			i_error("Stats client input error: %s", error);			client_destroy(&client);			return;		}		if (ret == 0) {			o_stream_set_flush_pending(client->output, TRUE);			io_remove(&client->io);			break;		}		client->cmd_more = NULL;	}	o_stream_uncork(client->output);}

static void pop3c_client_disconnect(struct pop3c_client *client){	client->state = POP3C_CLIENT_STATE_DISCONNECTED;	client->async_commands = 0;	if (client->running)		io_loop_stop(current_ioloop);	if (client->dns_lookup != NULL)		dns_lookup_abort(&client->dns_lookup);	if (client->to != NULL)		timeout_remove(&client->to);	if (client->io != NULL)		io_remove(&client->io);	if (client->input != NULL)		i_stream_destroy(&client->input);	if (client->output != NULL)		o_stream_destroy(&client->output);	if (client->ssl_iostream != NULL)		ssl_iostream_unref(&client->ssl_iostream);	if (client->fd != -1) {		if (close(client->fd) < 0)			i_error("close(pop3c) failed: %m");		client->fd = -1;	}	client_login_callback(client, POP3C_COMMAND_STATE_DISCONNECTED,			      "Disconnected");}

static void login_proxy_free_final(struct login_proxy *proxy){	if (proxy->delayed_disconnect) {		DLLIST_REMOVE(&login_proxies_disconnecting, proxy);		i_assert(proxy->state_rec->num_delayed_client_disconnects > 0);		if (--proxy->state_rec->num_delayed_client_disconnects == 0)			proxy->state_rec->num_disconnects_since_ts = 0;		timeout_remove(&proxy->to);	}	if (proxy->client_io != NULL)		io_remove(&proxy->client_io);	if (proxy->client_input != NULL)		i_stream_destroy(&proxy->client_input);	if (proxy->client_output != NULL)		o_stream_destroy(&proxy->client_output);	if (proxy->client_fd != -1)		net_disconnect(proxy->client_fd);	if (proxy->ssl_server_proxy != NULL) {		ssl_proxy_destroy(proxy->ssl_server_proxy);		ssl_proxy_free(&proxy->ssl_server_proxy);	}	i_free(proxy->host);	i_free(proxy);}

void client_command_free(struct client_command_context **_cmd){	struct client_command_context *cmd = *_cmd;	struct client *client = cmd->client;	enum client_command_state state = cmd->state;	*_cmd = NULL;	i_assert(client->output_cmd_lock == NULL);	/* reset input idle time because command output might have taken a	   long time and we don't want to disconnect client immediately then */	client->last_input = ioloop_time;	timeout_reset(client->to_idle);	if (cmd->cancel) {		cmd->cancel = FALSE;		client_send_tagline(cmd, "NO Command cancelled.");	}	if (!cmd->param_error)		client->bad_counter = 0;	if (client->input_lock == cmd)		client->input_lock = NULL;	if (client->mailbox_change_lock == cmd)		client->mailbox_change_lock = NULL;	if (client->free_parser == NULL) {		imap_parser_reset(cmd->parser);		client->free_parser = cmd->parser;	} else if (cmd->parser != NULL) {		imap_parser_unref(&cmd->parser);	}	client->command_queue_size--;	DLLIST_REMOVE(&client->command_queue, cmd);	cmd = NULL;	if (client->command_queue == NULL) {		/* no commands left in the queue, we can clear the pool */		p_clear(client->command_pool);		if (client->to_idle_output != NULL)			timeout_remove(&client->to_idle_output);	}	imap_client_notify_command_freed(client);	imap_refresh_proctitle();	/* if command finished from external event, check input for more	   unhandled commands since we may not be executing from client_input	   or client_output. */	if (state == CLIENT_COMMAND_STATE_WAIT_EXTERNAL &&	    !client->disconnected) {		client_add_missing_io(client);		if (client->to_delayed_input == NULL) {			client->to_delayed_input =				timeout_add(0, client_input, client);		}	}}

staticvoid ldap_connection_abort_request(struct ldap_op_queue_entry *req){	struct ldap_result res;	/* too bad */	if (req->to_abort != NULL)		timeout_remove(&req->to_abort);	if (req->msgid > -1)		ldap_abandon_ext(req->conn->conn, req->msgid, NULL, NULL);	memset(&res, 0, sizeof(res));	res.openldap_ret = LDAP_TIMEOUT;	res.error_string = "Aborting LDAP request after timeout";	if (req->result_callback != NULL)		req->result_callback(&res, req->result_callback_ctx);	unsigned int n = aqueue_count(req->conn->request_queue);	for (unsigned int i = 0; i < n; i++) {		struct ldap_op_queue_entry *const *reqp =			array_idx(&(req->conn->request_array),				  aqueue_idx(req->conn->request_queue, i));		if (req == *reqp) {			aqueue_delete(req->conn->request_queue, i);			ldap_connection_request_destroy(&req);			return;		}	}	i_unreached();}

void lmtp_client_close(struct lmtp_client *client){	if (client->dns_lookup != NULL)		dns_lookup_abort(&client->dns_lookup);	if (client->to != NULL)		timeout_remove(&client->to);	if (client->io != NULL)		io_remove(&client->io);	if (client->input != NULL)		i_stream_close(client->input);	if (client->output != NULL)		o_stream_close(client->output);	if (client->fd != -1) {		net_disconnect(client->fd);		client->fd = -1;	}	if (client->data_input != NULL)		i_stream_unref(&client->data_input);	client->output_finished = TRUE;	if (!client->finish_called) {		client->finish_called = TRUE;		client->finish_callback(client->finish_context);	}}

static void stats_user_deinit(struct mail_user *user){	struct stats_user *suser = STATS_USER_CONTEXT(user);	struct stats_connection *stats_conn = suser->stats_conn;	i_assert(stats_user_count > 0);	stats_user_count--;	if (stats_global_user != NULL) {		/* we were updating the session lazily. do one final update. */		i_assert(stats_global_user == user);		stats_add_session(user);		stats_global_user = NULL;	}	io_loop_context_remove_callbacks(suser->ioloop_ctx,					 stats_io_activate,					 stats_io_deactivate, user);	/* send final stats before disconnection */	session_stats_refresh(user);	mail_stats_connection_disconnect(stats_conn, user);	if (suser->to_stats_timeout != NULL)		timeout_remove(&suser->to_stats_timeout);	suser->module_ctx.super.deinit(user);	stats_connection_unref(&stats_conn);}

int main(int argc, char *argv[]){	const char *error;	master_service = master_service_init("indexer", 0, &argc, &argv, "");	if (master_getopt(master_service) > 0)		return FATAL_DEFAULT;	if (master_service_settings_read_simple(master_service, NULL,						&error) < 0)		i_fatal("Error reading configuration: %s", error);	set = master_service_settings_get(master_service);	master_service_init_log(master_service, "indexer: ");	restrict_access_by_env(RESTRICT_ACCESS_FLAG_ALLOW_ROOT, NULL);	restrict_access_allow_coredumps(TRUE);	master_service_set_idle_die_callback(master_service, idle_die);	queue = indexer_queue_init(indexer_client_status_callback);	indexer_queue_set_listen_callback(queue, queue_listen_callback);	worker_pool = worker_pool_init("indexer-worker",				       worker_status_callback);	master_service_init_finish(master_service);	master_service_run(master_service, client_connected);	indexer_queue_cancel_all(queue);	indexer_clients_destroy_all();	worker_pool_deinit(&worker_pool);	indexer_queue_deinit(&queue);	timeout_remove(&to_send_more);	master_service_deinit(&master_service);        return 0;}

static void auth_client_idle_timeout(struct auth_client *auth_client){	i_assert(clients == NULL);	auth_client_disconnect(auth_client, "idle disconnect");	timeout_remove(&auth_client_to);}

static void mail_session_free(struct mail_session *session){	i_assert(session->refcount == 0);	global_memory_free(mail_session_memsize(session));	if (session->to_idle != NULL)		timeout_remove(&session->to_idle);	if (!session->disconnected)		hash_table_remove(mail_sessions_hash, session->id);	DLLIST_REMOVE_FULL(&stable_mail_sessions, session,			   stable_prev, stable_next);	DLLIST2_REMOVE_FULL(&mail_sessions_head, &mail_sessions_tail, session,			    sorted_prev, sorted_next);	DLLIST_REMOVE_FULL(&session->user->sessions, session,			   user_prev, user_next);	mail_user_unref(&session->user);	if (session->ip != NULL) {		DLLIST_REMOVE_FULL(&session->ip->sessions, session,				   ip_prev, ip_next);		mail_ip_unref(&session->ip);	}	str_table_unref(services, &session->service);	i_free(session->id);	i_free(session);}

static void mailbox_list_index_refresh_timeout(struct mailbox_list *list){	struct mailbox_list_index *ilist = INDEX_LIST_CONTEXT(list);	timeout_remove(&ilist->to_refresh);	(void)mailbox_list_index_refresh(list);}

static void mbox_mailbox_close(struct mailbox *box){	struct mbox_mailbox *mbox = (struct mbox_mailbox *)box;	const struct mail_index_header *hdr;	enum mbox_sync_flags sync_flags = 0;	if (mbox->mbox_stream != NULL &&	    istream_raw_mbox_is_corrupted(mbox->mbox_stream)) {		/* clear the corruption by forcing a full resync */		sync_flags |= MBOX_SYNC_UNDIRTY | MBOX_SYNC_FORCE_SYNC;	}	if (box->view != NULL) {		hdr = mail_index_get_header(box->view);		if ((hdr->flags & MAIL_INDEX_HDR_FLAG_HAVE_DIRTY) != 0 &&		    !mbox_is_backend_readonly(mbox)) {			/* we've done changes to mbox which haven't been			   written yet. do it now. */			sync_flags |= MBOX_SYNC_REWRITE;		}	}	if (sync_flags != 0 && !mbox->invalid_mbox_file)		(void)mbox_sync(mbox, sync_flags);	if (mbox->mbox_global_lock_id != 0)		mbox_unlock(mbox, mbox->mbox_global_lock_id);	if (mbox->keep_lock_to != NULL)		timeout_remove(&mbox->keep_lock_to);        mbox_file_close(mbox);	if (mbox->mbox_file_stream != NULL)		i_stream_destroy(&mbox->mbox_file_stream);	index_storage_mailbox_close(box);}

void master_login_auth_disconnect(struct master_login_auth *auth){	struct master_login_auth_request *request;	while (auth->request_head != NULL) {		request = auth->request_head;		DLLIST2_REMOVE(&auth->request_head,			       &auth->request_tail, request);		request_internal_failure(request,			"Disconnected from auth server, aborting");		i_free(request);	}	hash_table_clear(auth->requests, FALSE);	if (auth->to != NULL)		timeout_remove(&auth->to);	if (auth->io != NULL)		io_remove(&auth->io);	if (auth->fd != -1) {		i_stream_destroy(&auth->input);		o_stream_destroy(&auth->output);		net_disconnect(auth->fd);		auth->fd = -1;	}	auth->version_received = FALSE;}

void auth_server_connection_disconnect(struct auth_server_connection *conn,				       const char *reason){	conn->handshake_received = FALSE;	conn->version_received = FALSE;	conn->has_plain_mech = FALSE;	conn->server_pid = 0;	conn->connect_uid = 0;	conn->cookie = NULL;	array_clear(&conn->available_auth_mechs);	if (conn->to != NULL)		timeout_remove(&conn->to);	if (conn->io != NULL)		io_remove(&conn->io);	if (conn->fd != -1) {		i_stream_destroy(&conn->input);		o_stream_destroy(&conn->output);		if (close(conn->fd) < 0)			i_error("close(auth server connection) failed: %m");		conn->fd = -1;	}	auth_server_connection_remove_requests(conn, reason);	if (conn->client->connect_notify_callback != NULL) {		conn->client->connect_notify_callback(conn->client, FALSE,				conn->client->connect_notify_context);	}}

static void replication_notify(struct mail_namespace *ns,			       enum replication_priority priority,			       const char *event){	struct replication_user *ruser;	ruser = REPLICATION_USER_CONTEXT(ns->user);	if (ruser == NULL)		return;	if (ns->user->mail_debug) {		i_debug("replication: Replication requested by '%s', priority=%d",			event, priority);	}	if (priority == REPLICATION_PRIORITY_SYNC) {		if (replication_notify_sync(ns->user) == 0) {			timeout_remove(&ruser->to);			ruser->priority = REPLICATION_PRIORITY_NONE;			return;		}		/* sync replication failed, try as "high" via fifo */		priority = REPLICATION_PRIORITY_HIGH;	}	if (ruser->priority < priority)		ruser->priority = priority;	if (ruser->to == NULL) {		ruser->to = timeout_add_short(REPLICATION_NOTIFY_DELAY_MSECS,					      replication_notify_now, ns->user);	}}

static void client_destroy(struct client *client){	char **app;	i_set_failure_prefix("imap-urlauth[%s](%s): ",			     my_pid, client->access_user);	if (client->url != NULL) {		/* deinitialize url */		i_stream_close(client->input);		o_stream_close(client->output);		(void)client_run_url(client);		i_assert(client->url == NULL);	}	imap_urlauth_worker_client_count--;	DLLIST_REMOVE(&imap_urlauth_worker_clients, client);	if (client->urlauth_ctx != NULL)		imap_urlauth_deinit(&client->urlauth_ctx);	if (client->mail_user != NULL)		mail_user_unref(&client->mail_user);	if (client->io != NULL)		io_remove(&client->io);	if (client->ctrl_io != NULL)		io_remove(&client->ctrl_io);	if (client->to_idle != NULL)		timeout_remove(&client->to_idle);	if (client->input != NULL)		i_stream_destroy(&client->input);	if (client->output != NULL)		o_stream_destroy(&client->output);	if (client->ctrl_input != NULL)		i_stream_destroy(&client->ctrl_input);	if (client->ctrl_output != NULL)		o_stream_destroy(&client->ctrl_output);	if (client->fd_in >= 0)		net_disconnect(client->fd_in);	if (client->fd_out >= 0 && client->fd_in != client->fd_out)		net_disconnect(client->fd_out);	if (client->fd_ctrl >= 0)		net_disconnect(client->fd_ctrl);	if (client->service_user != NULL)		mail_storage_service_user_free(&client->service_user);	i_free(client->access_user);	array_foreach_modifiable(&client->access_apps, app)		i_free(*app);	array_free(&client->access_apps);	i_free(client);	imap_urlauth_worker_refresh_proctitle();	master_service_client_connection_destroyed(master_service);}

static void notify_delay_callback(struct mailbox *box){	struct index_mailbox_context *ibox = INDEX_STORAGE_CONTEXT(box);	if (ibox->notify_delay_to != NULL)		timeout_remove(&ibox->notify_delay_to);	box->notify_callback(box, box->notify_context);}

static gbooleanunmap_event(GtkWidget *widget,            GdkEvent  *event){  timeout_remove(widget);  return TRUE;}

void login_proxy_detach(struct login_proxy *proxy){	struct client *client = proxy->client;	const unsigned char *data;	size_t size;	i_assert(proxy->client_fd == -1);	i_assert(proxy->server_input != NULL);	i_assert(proxy->server_output != NULL);	if (proxy->to != NULL)		timeout_remove(&proxy->to);	proxy->client_fd = i_stream_get_fd(client->input);	proxy->client_input = client->input;	proxy->client_output = client->output;	i_stream_set_persistent_buffers(client->input, FALSE);	o_stream_set_max_buffer_size(client->output, (size_t)-1);	o_stream_set_flush_callback(client->output, proxy_client_output, proxy);	client->input = NULL;	client->output = NULL;	/* send all pending client input to proxy */	data = i_stream_get_data(proxy->client_input, &size);	if (size != 0)		o_stream_nsend(proxy->server_output, data, size);	/* from now on, just do dummy proxying */	io_remove(&proxy->server_io);	proxy->server_io =		io_add(proxy->server_fd, IO_READ, server_input, proxy);	proxy->client_io =		io_add_istream(proxy->client_input, proxy_client_input, proxy);	o_stream_set_flush_callback(proxy->server_output, server_output, proxy);	i_stream_destroy(&proxy->server_input);	if (proxy->notify_refresh_secs != 0) {		proxy->to_notify =			timeout_add(proxy->notify_refresh_secs * 1000,				    login_proxy_notify, proxy);	}	proxy->callback = NULL;	if (login_proxy_ipc_server == NULL) {		login_proxy_ipc_server =			ipc_server_init(LOGIN_PROXY_IPC_PATH,					LOGIN_PROXY_IPC_NAME,					login_proxy_ipc_cmd);	}	DLLIST_REMOVE(&login_proxies_pending, proxy);	DLLIST_PREPEND(&login_proxies, proxy);	client->fd = -1;	client->login_proxy = NULL;}

static void pending_write_result(struct pending_write *p, int err){	if (p->timeout_id > 0)		timeout_remove(p->timeout_id);	p->func(p->attrib, err, p->user_data);	free(p);}

static void stats_top_start(struct top_context *ctx){	struct timeout *to;	stats_top_output(ctx);	to = timeout_add(1000, stats_top_output, ctx);	io_loop_run(current_ioloop);	timeout_remove(&to);}