目录

1.eloop 机制

2.eloop结构体

2.1.eloop_data结构体

2.2 Socket事件结构体

2.3 Timeout事件结构体

2.4 Signal事件结构体

3.eloop_init

4.eloop_run

4.1 signal事件

4.2 socket事件

4.3 timeout事件

1.eloop 机制

        主线程中启动事件监听机制，对不同的事件响应不同的处理函数。即所有的操作都是基于事件驱动的。事件驱动和消息驱动类似，主线程运行一个 event loop，等待事件的发生并处理它们。

2.eloop结构体

2.1.eloop_data结构体

 eloop.c中主要核心结构体为eloop_data，以下是eloop_data结构体：

eloop主要处理三大类型的Event事件：Socket事件，Timeout事件，Signal事件:

2.2 Socket事件结构体

      Socket事件：有 readers，writers，exceptions 三个 eloop_sock_table 结构体，
每个里面都有一个 eloop_sock 类型的指针table，这里可以将该指针变量理解成动态数组，
可以向各个table里面添加、删除 eloop_sock，
事件处理就是遍历 eloop_sock_table，依次运行里面的每个handler。

2.3 Timeout事件结构体

        Timeout事件：每个 struct eloop_timeout 都被放在一个双向链表中dl_list中，
链表头就是 eloop_data 中的“timeout”项。这些struct eloop_timeout按超时先后排序。

2.4 Signal事件结构体

        Signal事件：每个 struct eloop_signal 都通过 eloop_signal 类型的指针链接起来，下面是eloop_signal结构体：

3.eloop_init

  eloop为静态全局变量：

  eloop初始化函数为eloop_init，如下： 

1.  通过os_memset将eloop结构体清0；
2. 通过dl_list_init初始化双向链表prev和next指向eloop.timeout；
3. 初始化eaders，writers，exceptionsSocket事件类型为EVENT_TYPE_READ、EVENT_TYPE_WRITE、EVENT_TYPE_EXCEPTION。

4.eloop_run

         下面结合eloop_run函数来分析eloop机制，部分内容摘自链接: wpa_supplicant之eloop_run分析

先看eloop_run源码：

void eloop_run(void)
{
	fd_set *rfds, *wfds, *efds;
	struct timeval _tv;
	int res;
	struct os_reltime tv, now;

	rfds = os_malloc(sizeof(*rfds));
	wfds = os_malloc(sizeof(*wfds));
	efds = os_malloc(sizeof(*efds));
	if (rfds == NULL || wfds == NULL || efds == NULL)
		goto out;

	while (!eloop.terminate &&
	       (!dl_list_empty(&eloop.timeout) || eloop.readers.count > 0 ||
		eloop.writers.count > 0 || eloop.exceptions.count > 0)) {
		struct eloop_timeout *timeout;

		if (eloop.pending_terminate) {
			/*
			 * This may happen in some corner cases where a signal
			 * is received during a blocking operation. We need to
			 * process the pending signals and exit if requested to
			 * avoid hitting the SIGALRM limit if the blocking
			 * operation took more than two seconds.
			 */
			eloop_process_pending_signals();
			if (eloop.terminate)
				break;
		}

		timeout = dl_list_first(&eloop.timeout, struct eloop_timeout,
					list);
		if (timeout) {
			os_get_reltime(&now);
			if (os_reltime_before(&now, &timeout->time))
				os_reltime_sub(&timeout->time, &now, &tv);
			else
				tv.sec = tv.usec = 0;
			_tv.tv_sec = tv.sec;
			_tv.tv_usec = tv.usec;
		}

		eloop_sock_table_set_fds(&eloop.readers, rfds);
		eloop_sock_table_set_fds(&eloop.writers, wfds);
		eloop_sock_table_set_fds(&eloop.exceptions, efds);
		res = select(eloop.max_sock + 1, rfds, wfds, efds,
			     timeout ? &_tv : NULL);
		if (res < 0 && errno != EINTR && errno != 0) {
			wpa_printf(MSG_ERROR, "eloop: %s: %s",
				   "select"

				   , strerror(errno));
			goto out;
		}

		eloop.readers.changed = 0;
		eloop.writers.changed = 0;
		eloop.exceptions.changed = 0;

		eloop_process_pending_signals();

		/* check if some registered timeouts have occurred */
		timeout = dl_list_first(&eloop.timeout, struct eloop_timeout,
					list);
		if (timeout) {
			os_get_reltime(&now);
			if (!os_reltime_before(&now, &timeout->time)) {
				void *eloop_data = timeout->eloop_data;
				void *user_data = timeout->user_data;
				eloop_timeout_handler handler =
					timeout->handler;
				eloop_remove_timeout(timeout);
				handler(eloop_data, user_data);
			}

		}

		if (res <= 0)
			continue;

		if (eloop.readers.changed ||
		    eloop.writers.changed ||
		    eloop.exceptions.changed) {
			 /*
			  * Sockets may have been closed and reopened with the
			  * same FD in the signal or timeout handlers, so we
			  * must skip the previous results and check again
			  * whether any of the currently registered sockets have
			  * events.
			  */
			continue;
		}

		eloop_sock_table_dispatch(&eloop.readers, rfds);
		eloop_sock_table_dispatch(&eloop.writers, wfds);
		eloop_sock_table_dispatch(&eloop.exceptions, efds);
	}

	eloop.terminate = 0;
out:
	os_free(rfds);
	os_free(wfds);
	os_free(efds);
	return;
}

	while (!eloop.terminate &&
	       (!dl_list_empty(&eloop.timeout) || eloop.readers.count > 0 ||
		eloop.writers.count > 0 || eloop.exceptions.count > 0))

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

 int eloop_register_signal(int sig, eloop_signal_handler handler,
 			  void *user_data)
 {
 	struct eloop_signal *tmp;
 
 	tmp = os_realloc_array(eloop.signals, eloop.signal_count + 1,
 			       sizeof(struct eloop_signal));
 	if (tmp == NULL)
 		return -1;

	tmp[eloop.signal_count].sig = sig;
	tmp[eloop.signal_count].user_data = user_data;
	tmp[eloop.signal_count].handler = handler;
	tmp[eloop.signal_count].signaled = 0;
	eloop.signal_count++;
	eloop.signals = tmp;
	signal(sig, eloop_handle_signal);

	return 0;
}