Android DNS之getaddrinfo()的实现

这篇笔记分析了库函数getaddrinfo()的代码实现。

原型解读

int getaddrinfo(const char *hostname, const char *servname,
    const struct addrinfo *hints, struct addrinfo **res);

• hostname: 和gethostbyname()的入参hostname相同，要查询的域名；
• servname：要查询的服务名，如果指定，则返回值中还会有服务名对应的端口号；也就是该函数还有getservbyname()的功能；
• hints：表面意思为暗示，使用该参数可以对查询结果进行约束，只返回那些满足条件的查询结果；后面称该参数为过滤器；
• res：该参数用于保存指向查询结果地址的指针，保存查询结果的内存有该函数内部分配，使用完毕后调用者需要调用freeaddrinfo()清除，调用者只需要提供保存struct addrinfo *的地址即可。

关于该函数的更详细介绍可以参考getaddrinfo(3)。

入口

int getaddrinfo(const char *hostname, const char *servname,
    const struct addrinfo *hints, struct addrinfo **res)
{
	//增加了入参NETID_UNSET和MARK_UNSET
	return android_getaddrinfofornet(hostname, servname, hints, NETID_UNSET, MARK_UNSET, res);
}

int android_getaddrinfofornet(const char *hostname, const char *servname,
    const struct addrinfo *hints, unsigned netid, unsigned mark, struct addrinfo **res)
{
	//入参中netid和mark值可以影响DNS请求包从哪个网卡出去，属于网络相关的配置，将这些信息组织成参数
    //netcontext继续向下传递
	struct android_net_context netcontext = {
		.app_netid = netid,
		.app_mark = mark,
		.dns_netid = netid,
		.dns_mark = mark,
		.uid = NET_CONTEXT_INVALID_UID,
        };
	return android_getaddrinfofornetcontext(hostname, servname, hints, &netcontext, res);
}

这里有必要对这两个函数做个说明：

• getaddrinfo()是标准的libc接口，系统中Framework以下的C/C++代码可以调用该接口实现DNS查询；
• android_getaddrinfofornet()是Android对libc的扩展，当APP在Framework通过InetAddress类提供的接口进行DNS查询时，最终会通过JNI调用到该函数，也就是说该接口是给Framework使用的。

android_getaddrinfofornetcontext()

该函数的作用主要是对输入参数的合法性进行检查，以及处理hostname为空或者是纯数字格式的情形，如果需要真正发起DNS请求，调用explore_fqdn()完成。

/* 定义了faimly、socktype、protocol字段的有效组合 */
static const struct explore explore[] = {
#ifdef INET6
	{ PF_INET6, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },
	{ PF_INET6, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },
	{ PF_INET6, SOCK_RAW, ANY, NULL, 0x05 },
#endif
	{ PF_INET, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },
	{ PF_INET, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },
	{ PF_INET, SOCK_RAW, ANY, NULL, 0x05 },
	{ PF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },
	{ PF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },
	{ PF_UNSPEC, SOCK_RAW, ANY, NULL, 0x05 },
	{ -1, 0, 0, NULL, 0 },
};

int android_getaddrinfofornetcontext(const char *hostname, const char *servname,
    const struct addrinfo *hints, const struct android_net_context *netcontext,
    struct addrinfo **res)
{
	//这里定义了3个addrinfo结构变量，后面对于这些变量的使用非常绕，要注意理解下面的注释说明
	struct addrinfo sentinel;
	struct addrinfo *cur;
	int error = 0;
	struct addrinfo ai;
	struct addrinfo ai0;
	struct addrinfo *pai;
	const struct explore *ex;

	/* hostname is allowed to be NULL */
	/* servname is allowed to be NULL */
	/* hints is allowed to be NULL */
	assert(res != NULL);
	assert(netcontext != NULL);
    //sentinel清零，并且cur指向该结构
	memset(&sentinel, 0, sizeof(sentinel));
	cur = &sentinel;
    //pai指向ai，并且对ai的成员进行初始化
	pai = &ai;
	pai->ai_flags = 0;
	pai->ai_family = PF_UNSPEC;
	pai->ai_socktype = ANY;
	pai->ai_protocol = ANY;
	pai->ai_addrlen = 0;
	pai->ai_canonname = NULL;
	pai->ai_addr = NULL;
	pai->ai_next = NULL;

    //hostname和servname二者不能同时为空，至少要指定一个
	if (hostname == NULL && servname == NULL)
		return EAI_NONAME;

	//如果指定了过滤器，则对过滤器成员进行检查，因为作为过滤器，并非addrinfo中的每个成员都是可以指定的
	if (hints) {
		/* error check for hints */
        //作为过滤器，addrinfo的这四个成员是不能指定的，必须保持为0才行
		if (hints->ai_addrlen || hints->ai_canonname ||
		    hints->ai_addr || hints->ai_next)
			ERR(EAI_BADHINTS); /* xxx */
        //ai_flags中有没有指定非法的标记
		if (hints->ai_flags & ~AI_MASK)
			ERR(EAI_BADFLAGS);
        //ai_faimly成员只可取下面这三个值，其它值均非法
		switch (hints->ai_family) {
		case PF_UNSPEC:
		case PF_INET:
#ifdef INET6
		case PF_INET6:
#endif
			break;
		default:
			ERR(EAI_FAMILY);
		}
        //从这里可以看出，过滤器参数最终是被保存在了ai中，这就是ai的作用
		memcpy(pai, hints, sizeof(*pai));

		/*
		 * if both socktype/protocol are specified, check if they
		 * are meaningful combination.
		 */
        //如果同时指定了hints参数中的ai_socktype和ai_protocol字段（非0），那么继续检查这两个参数的组合是否合理
        //因为并非所有的组合都是有效的，比如socktype指定为STREAM，但是protocol指定为DGRAM就不合理
		if (pai->ai_socktype != ANY && pai->ai_protocol != ANY) {
        	//expore数组定义了faimly、socktype、protocol的有效组合
			for (ex = explore; ex->e_af >= 0; ex++) {
				if (pai->ai_family != ex->e_af)
					continue;
				if (ex->e_socktype == ANY)
					continue;
				if (ex->e_protocol == ANY)
					continue;
                //如果是非法组合返回BADHINTS错误
				if (pai->ai_socktype == ex->e_socktype && pai->ai_protocol != ex->e_protocol) {
					ERR(EAI_BADHINTS);
				}
			}
		}
	}//end of "if (hints)"

	/*
	 * check for special cases.  (1) numeric servname is disallowed if
	 * socktype/protocol are left unspecified. (2) servname is disallowed
	 * for raw and other inet{,6} sockets.
	 */
    //这段逻辑用于检查服务名和hints参数是否存在冲突（见注释）
	if (MATCH_FAMILY(pai->ai_family, PF_INET, 1)
#ifdef PF_INET6
	 || MATCH_FAMILY(pai->ai_family, PF_INET6, 1)
#endif
	    ) {
        //ai0的作用就是备份hints的内容
		ai0 = *pai;	/* backup *pai */

		if (pai->ai_family == PF_UNSPEC) {
#ifdef PF_INET6
			pai->ai_family = PF_INET6;
#else
			pai->ai_family = PF_INET;
#endif
		}
		error = get_portmatch(pai, servname);
		if (error)
			ERR(error);
		//将备份的hints参数内容再赋值回去，保证这步检查不会修改hints本身的内容
		*pai = ai0;
	}

	ai0 = *pai;
    //处理hostname为空，或者hostname为纯数字的情形
	/* NULL hostname, or numeric hostname */
	for (ex = explore; ex->e_af >= 0; ex++) {
		*pai = ai0;

		/* PF_UNSPEC entries are prepared for DNS queries only */
		if (ex->e_af == PF_UNSPEC)
			continue;

		if (!MATCH_FAMILY(pai->ai_family, ex->e_af, WILD_AF(ex)))
			continue;
		if (!MATCH(pai->ai_socktype, ex->e_socktype, WILD_SOCKTYPE(ex)))
			continue;
		if (!MATCH(pai->ai_protocol, ex->e_protocol, WILD_PROTOCOL(ex)))
			continue;

		if (pai->ai_family == PF_UNSPEC)
			pai->ai_family = ex->e_af;
		if (pai->ai_socktype == ANY && ex->e_socktype != ANY)
			pai->ai_socktype = ex->e_socktype;
		if (pai->ai_protocol == ANY && ex->e_protocol != ANY)
			pai->ai_protocol = ex->e_protocol;

		if (hostname == NULL)
        	//处理只请求服务名转换的情况，转黄结果保存到cur->ai_next中。
            //从这里可以看出sentinel的作用来，它本身不保存查询结果，但是查询结果就保存在
            //sentinel.ai_next后面的addrinfo链表中，而cur指针永远指向当前链表的最后一个成员，
            //这样便于查询过程中不断添加查询结果，见下面的while循环
			error = explore_null(pai, servname, &cur->ai_next);
		else
        	//尝试按照数字格式解析hostname以及服务名装换
			error = explore_numeric_scope(pai, hostname, servname,
			    &cur->ai_next);

		if (error)
			goto free;
		//移动cur指针，使其指向当前查询结果链表的最后一个成员
		while (cur->ai_next)
			cur = cur->ai_next;
	}

	/*
	 * XXX
	 * If numeric representation of AF1 can be interpreted as FQDN
	 * representation of AF2, we need to think again about the code below.
	 */
    //如果这里非空，说明上一个for循环中已经解析的结果，请求的hostname就是为空或者是纯数字格式，
    //那么无需再发起DNS查询，返回结果即可
	if (sentinel.ai_next)
		goto good;

	//hostname为空的场景上面应该已经处理，不应该会执行到这里
	if (hostname == NULL)
		ERR(EAI_NODATA);
    //hostname为数字格式的情形上面应该已经处理，不应该会执行到这里
	if (pai->ai_flags & AI_NUMERICHOST)
		ERR(EAI_NONAME);

	//这里是Android的变化，就是将DNS查询导向到netd中，然后由netd处理后再回到这里，
    //这个过程和gethostbyname()中的处理流程一致，可见gethostbyname()实现中的分析
#if defined(__ANDROID__)
	//非netd调用会阻塞到这里，等待netd查询完后返回
	int gai_error = android_getaddrinfo_proxy(
		hostname, servname, hints, res, netcontext->app_netid);
	//如果是netd调用，那么android_getaddrinfo_proxy()会返回EAI_SYSTEM错误，继续后续的逻辑
    if (gai_error != EAI_SYSTEM) {
		return gai_error;
	}
#endif

	/*
	 * hostname as alphabetical name.
	 * we would like to prefer AF_INET6 than AF_INET, so we'll make a
	 * outer loop by AFs.
	 */
    //按照explore数组中指定的有效组合，调用explore_fqdn()进行DNS查询
	for (ex = explore; ex->e_af >= 0; ex++) {
		*pai = ai0;

		/* require exact match for family field */
		if (pai->ai_family != ex->e_af)
			continue;

		if (!MATCH(pai->ai_socktype, ex->e_socktype,
				WILD_SOCKTYPE(ex))) {
			continue;
		}
		if (!MATCH(pai->ai_protocol, ex->e_protocol,
				WILD_PROTOCOL(ex))) {
			continue;
		}
		//这步会执行，以为explore中，socktype字段都是固定的，并非通配
		if (pai->ai_socktype == ANY && ex->e_socktype != ANY)
			pai->ai_socktype = ex->e_socktype;
		if (pai->ai_protocol == ANY && ex->e_protocol != ANY)
			pai->ai_protocol = ex->e_protocol;
		//进行DNS查询
		error = explore_fqdn(
			pai, hostname, servname, &cur->ai_next, netcontext);
		//查询结果指针cur前移
		while (cur && cur->ai_next)
			cur = cur->ai_next;
	}
	//sentinel.ai_next不为空，说明有查询结果，所以设置error为0
	if (sentinel.ai_next)
		error = 0;
	//有错误发生，需要调用freeaddrinfo()释放可能已经分配的内存空间
	if (error)
		goto free;

	if (error == 0) {
		if (sentinel.ai_next) {
 good:
 			//查询过程没有问题 && 查询到了结果，返回成功
			*res = sentinel.ai_next;
			return SUCCESS;
		} else
        	//查询过程没有问题(error=0)，但是没有查到结果(sentinel.ai_next=NULL)，也是失败
			error = EAI_FAIL;
	}
 free:
 bad:
 	//查询失败，或者查询过程出错，释放内存后返回错误码
	if (sentinel.ai_next)
		freeaddrinfo(sentinel.ai_next);
	*res = NULL;
	return error;
}

explore_fqdn()

看到该函数的代码，一定会非常熟悉，在gethostbyname()的实现中，已经见过这种查询表方式，这里不再赘述。

/*
 * FQDN hostname, DNS lookup
 */
static int explore_fqdn(const struct addrinfo *pai, const char *hostname,
    const char *servname, struct addrinfo **res,
    const struct android_net_context *netcontext)
{
	struct addrinfo *result;
	struct addrinfo *cur;
	int error = 0;
    //_files_getaddrinfo()完成基于文件的查询；_dns_getaddrinfo()完成基于DNS服务器的查询；
    //_yp_getaddrinfo()不会被调用
	static const ns_dtab dtab[] = {
		NS_FILES_CB(_files_getaddrinfo, NULL)
		{ NSSRC_DNS, _dns_getaddrinfo, NULL },	/* force -DHESIOD */
		NS_NIS_CB(_yp_getaddrinfo, NULL)
		{ 0, 0, 0 }
	};

	assert(pai != NULL);
	/* hostname may be NULL */
	/* servname may be NULL */
	assert(res != NULL);
	result = NULL;

	/*
	 * if the servname does not match socktype/protocol, ignore it.
	 */
    //如果指定了servname，检查socktype和protocol是否有冲突，Android中不涉及
	if (get_portmatch(pai, servname) != 0)
		return 0;

	//调用nsdispatch()进行查询分发
	switch (nsdispatch(&result, dtab, NSDB_HOSTS, "getaddrinfo",
			default_dns_files, hostname, pai, netcontext)) {
	case NS_TRYAGAIN:
		error = EAI_AGAIN;
		goto free;
	case NS_UNAVAIL:
		error = EAI_FAIL;
		goto free;
	case NS_NOTFOUND:
		error = EAI_NODATA;
		goto free;
	case NS_SUCCESS:
		error = 0;
        //如果hostname查询成功，如果指定了servname，将对应的端口名转换为端口号，Android不涉及
		for (cur = result; cur; cur = cur->ai_next) {
			GET_PORT(cur, servname);
			/* canonname should be filled already */
		}
		break;
	}

	*res = result;
	return 0;

free:
	if (result)
		freeaddrinfo(result);
	return error;
}

_dns_getaddrinfo()

我们不关注基于文件的查询_files_getaddrinfo()的实现，只看基于DNS服务器的查询实现。

static int _dns_getaddrinfo(void *rv, void *cb_data, va_list ap)
{
	struct addrinfo *ai;
	querybuf *buf, *buf2;
	const char *name;
	const struct addrinfo *pai;
	struct addrinfo sentinel, *cur;
	struct res_target q, q2;
	res_state res;
	const struct android_net_context *netcontext;

	//从explore_fqdn()传入的三个参数
	name = va_arg(ap, char *);
	pai = va_arg(ap, const struct addrinfo *);
	netcontext = va_arg(ap, const struct android_net_context *);

	memset(&q, 0, sizeof(q));
	memset(&q2, 0, sizeof(q2));
	memset(&sentinel, 0, sizeof(sentinel));
	cur = &sentinel;
	//buf和buf2用于保存查询结果，见下文的getanswer()
	buf = malloc(sizeof(*buf));
	if (buf == NULL) {
		h_errno = NETDB_INTERNAL;
		return NS_NOTFOUND;
	}
	buf2 = malloc(sizeof(*buf2));
	if (buf2 == NULL) {
		free(buf);
		h_errno = NETDB_INTERNAL;
		return NS_NOTFOUND;
	}

	//这段逻辑非常重要，决定了是否发起AAAA与A查询以及它们的顺序
	switch (pai->ai_family) {
	case AF_UNSPEC:
		//当没有指定具体的failmy时，优先IPv6
		/* prefer IPv6 */
		q.name = name;
		q.qclass = C_IN;
		q.answer = buf->buf;
		q.anslen = sizeof(buf->buf);
		int query_ipv6 = 1, query_ipv4 = 1;
        //如果设置了AI_ADDRCONFIG标记，那么表示要发起对应的请求时，本机必须至少有一个相应类型的IP地址，
        //_have_ipv6()和_have_ipv4()就是分别用来检测本机是否有IPv4和IPv6地址的
		if (pai->ai_flags & AI_ADDRCONFIG) {
			query_ipv6 = _have_ipv6(netcontext->app_mark, netcontext->uid);
			query_ipv4 = _have_ipv4(netcontext->app_mark, netcontext->uid);
		}
        //注意：在需要发起AAAA请求的条件中会判断是否需要发起A请求，这是为了在AAAA请求查询失败时可以继续发起A请求
		if (query_ipv6) {
			q.qtype = T_AAAA;
			if (query_ipv4) {
            	//将q2接入到q的后面，这样可以在AAAA请求查询失败时可以继续发起A请求
				q.next = &q2;
				q2.name = name;
				q2.qclass = C_IN;
				q2.qtype = T_A;
				q2.answer = buf2->buf;
				q2.anslen = sizeof(buf2->buf);
			}
		} else if (query_ipv4) {
			q.qtype = T_A;
		} else {
			free(buf);
			free(buf2);
			return NS_NOTFOUND;
		}
		break
    //如果已经已经具体指定了faimy，那么按照指定的failmy发起A或者AAAA即可
	case AF_INET:
		q.name = name;
		q.qclass = C_IN;
        //A查询
		q.qtype = T_A;
		q.answer = buf->buf;
		q.anslen = sizeof(buf->buf);
		break;
	case AF_INET6:
		q.name = name;
		q.qclass = C_IN;
        //AAAA查询
		q.qtype = T_AAAA;
		q.answer = buf->buf;
		q.anslen = sizeof(buf->buf);
		break;
	default:
    	//其它faimy均为非法值
		free(buf);
		free(buf2);
		return NS_UNAVAIL;
	}
	//获取线程独立的resolver状态结构
	res = __res_get_state();
	if (res == NULL) {
		free(buf);
		free(buf2);
		return NS_NOTFOUND;
	}

	/* this just sets our netid val in the thread private data so we don't have to
	 * modify the api's all the way down to res_send.c's res_nsend.  We could
	 * fully populate the thread private data here, but if we get down there
	 * and have a cache hit that would be wasted, so we do the rest there on miss
	 */
    //将netid、mark和qhook参数设置到res_stats中，这三个参数在res_nsend()中都有使用
	res_setnetcontext(res, netcontext);
    //getaddrinfo()将res_search.c中的三个接口重新实现了一遍，这样做的原因见上面的注释(本人没有理解!!!)
	if (res_searchN(name, &q, res) < 0) {
		__res_put_state(res);
		free(buf);
		free(buf2);
		return NS_NOTFOUND;
	}
    //解析查询结果报文
	ai = getanswer(buf, q.n, q.name, q.qtype, pai);
	if (ai) {
		cur->ai_next = ai;
		while (cur && cur->ai_next)
			cur = cur->ai_next;
	}
    //如果有A请求查询结果，继续解析A请求查询结果报文
	if (q.next) {
		ai = getanswer(buf2, q2.n, q2.name, q2.qtype, pai);
		if (ai)
			cur->ai_next = ai;
	}
	free(buf);
	free(buf2);
    //如果查询失败，返回对应的错误码
	if (sentinel.ai_next == NULL) {
		__res_put_state(res);
		switch (h_errno) {
		case HOST_NOT_FOUND:
			return NS_NOTFOUND;
		case TRY_AGAIN:
			return NS_TRYAGAIN;
		default:
			return NS_UNAVAIL;
		}
	}
	//按照RFC 6762中要求的顺序将查询结果排序后返回，关于这个排序有需要再研究吧
	_rfc6724_sort(&sentinel, netcontext->app_mark, netcontext->uid);

	__res_put_state(res);

	*((struct addrinfo **)rv) = sentinel.ai_next;
	return NS_SUCCESS;
}

后面的代码不再继续分析，它和res_search()中的逻辑非常类似，感兴趣的可以自行分析。

其它

MATCH宏

#define MATCH(x, y, w) 							\
	((x) == (y) || (/*CONSTCOND*/(w) && ((x) == ANY || (y) == ANY)))

作用是检查x和y是否匹配，返回布尔值，匹配分两种情况：

1. x和y的值确实是相等的，那么匹配，对应表达式中的(x) == (y)
2. x和y不等，但是w参数非0，并且x和y中有任何一个是通配的，即值为ANY(0)，那么也认为是匹配的。实际上，这里的w含义是wildcard，即通配，如果w为0，即表示把通配考虑进去，否则按照x和y的真实值是否相等来判断是否匹配。