slirp_dns.c@ 47420

Last change on this file since 47420 was 43714, checked in by vboxsync, 12 years ago
NAT:dns/logging.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 12.4 KB

Line
1	/* $Id: slirp_dns.c 43714 2012-10-24 06:57:32Z vboxsync $ */
2	/** @file
3	* NAT - dns initialization.
4	*/
5
6	/*
7	* Copyright (C) 2012 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#include "slirp.h"
19	#ifdef RT_OS_OS2
20	# include <paths.h>
21	#endif
22
23	#include <VBox/err.h>
24	#include <VBox/vmm/pdmdrv.h>
25	#include <iprt/assert.h>
26	#include <iprt/file.h>
27
28	#ifdef RT_OS_WINDOWS
29	# include <Winnls.h>
30	# define _WINSOCK2API_
31	# include <IPHlpApi.h>
32
33	static int get_dns_addr_domain(PNATState pData,
34	const char **ppszDomain)
35	{
36	ULONG flags = GAA_FLAG_INCLUDE_PREFIX; /GAA_FLAG_INCLUDE_ALL_INTERFACES;/ /* all interfaces registered in NDIS */
37	PIP_ADAPTER_ADDRESSES pAdapterAddr = NULL;
38	PIP_ADAPTER_ADDRESSES pAddr = NULL;
39	PIP_ADAPTER_DNS_SERVER_ADDRESS pDnsAddr = NULL;
40	ULONG size;
41	int wlen = 0;
42	char *pszSuffix;
43	struct dns_domain_entry *pDomain = NULL;
44	ULONG ret = ERROR_SUCCESS;
45
46	/* @todo add SKIPing flags to get only required information */
47
48	/* determine size of buffer */
49	size = 0;
50	ret = pData->pfGetAdaptersAddresses(AF_INET, 0, NULL /* reserved */, pAdapterAddr, &size);
51	if (ret != ERROR_BUFFER_OVERFLOW)
52	{
53	Log(("NAT: error %lu occurred on capacity detection operation\n", ret));
54	return -1;
55	}
56	if (size == 0)
57	{
58	Log(("NAT: Win socket API returns non capacity\n"));
59	return -1;
60	}
61
62	pAdapterAddr = RTMemAllocZ(size);
63	if (!pAdapterAddr)
64	{
65	Log(("NAT: No memory available\n"));
66	return -1;
67	}
68	ret = pData->pfGetAdaptersAddresses(AF_INET, 0, NULL /* reserved */, pAdapterAddr, &size);
69	if (ret != ERROR_SUCCESS)
70	{
71	Log(("NAT: error %lu occurred on fetching adapters info\n", ret));
72	RTMemFree(pAdapterAddr);
73	return -1;
74	}
75
76	for (pAddr = pAdapterAddr; pAddr != NULL; pAddr = pAddr->Next)
77	{
78	int found;
79	if (pAddr->OperStatus != IfOperStatusUp)
80	continue;
81
82	for (pDnsAddr = pAddr->FirstDnsServerAddress; pDnsAddr != NULL; pDnsAddr = pDnsAddr->Next)
83	{
84	struct sockaddr *SockAddr = pDnsAddr->Address.lpSockaddr;
85	struct in_addr InAddr;
86	struct dns_entry *pDns;
87
88	if (SockAddr->sa_family != AF_INET)
89	continue;
90
91	InAddr = ((struct sockaddr_in *)SockAddr)->sin_addr;
92
93	/* add dns server to list */
94	pDns = RTMemAllocZ(sizeof(struct dns_entry));
95	if (!pDns)
96	{
97	Log(("NAT: Can't allocate buffer for DNS entry\n"));
98	RTMemFree(pAdapterAddr);
99	return VERR_NO_MEMORY;
100	}
101
102	Log(("NAT: adding %RTnaipv4 to DNS server list\n", InAddr));
103	if ((InAddr.s_addr & RT_H2N_U32_C(IN_CLASSA_NET)) == RT_N2H_U32_C(INADDR_LOOPBACK & IN_CLASSA_NET))
104	pDns->de_addr.s_addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) \| CTL_ALIAS);
105	else
106	pDns->de_addr.s_addr = InAddr.s_addr;
107
108	TAILQ_INSERT_HEAD(&pData->pDnsList, pDns, de_list);
109
110	if (pAddr->DnsSuffix == NULL)
111	continue;
112
113	/* uniq */
114	RTUtf16ToUtf8(pAddr->DnsSuffix, &pszSuffix);
115	if (!pszSuffix \|\| strlen(pszSuffix) == 0)
116	{
117	RTStrFree(pszSuffix);
118	continue;
119	}
120
121	found = 0;
122	LIST_FOREACH(pDomain, &pData->pDomainList, dd_list)
123	{
124	if ( pDomain->dd_pszDomain != NULL
125	&& strcmp(pDomain->dd_pszDomain, pszSuffix) == 0)
126	{
127	found = 1;
128	RTStrFree(pszSuffix);
129	break;
130	}
131	}
132	if (!found)
133	{
134	pDomain = RTMemAllocZ(sizeof(struct dns_domain_entry));
135	if (!pDomain)
136	{
137	Log(("NAT: not enough memory\n"));
138	RTStrFree(pszSuffix);
139	RTMemFree(pAdapterAddr);
140	return VERR_NO_MEMORY;
141	}
142	pDomain->dd_pszDomain = pszSuffix;
143	Log(("NAT: adding domain name %s to search list\n", pDomain->dd_pszDomain));
144	LIST_INSERT_HEAD(&pData->pDomainList, pDomain, dd_list);
145	}
146	}
147	}
148	RTMemFree(pAdapterAddr);
149	return 0;
150	}
151
152	#else /* !RT_OS_WINDOWS */
153
154	static int RTFileGets(RTFILE File, void pvBuf, size_t cbBufSize, size_t pcbRead)
155	{
156	size_t cbRead;
157	char bTest;
158	int rc = VERR_NO_MEMORY;
159	char pu8Buf = (char )pvBuf;
160	*pcbRead = 0;
161
162	while ( RT_SUCCESS(rc = RTFileRead(File, &bTest, 1, &cbRead))
163	&& (pu8Buf - (char *)pvBuf) < cbBufSize)
164	{
165	if (cbRead == 0)
166	return VERR_EOF;
167
168	if (bTest == '\r' \|\| bTest == '\n')
169	{
170	*pu8Buf = 0;
171	return VINF_SUCCESS;
172	}
173	*pu8Buf = bTest;
174	pu8Buf++;
175	(*pcbRead)++;
176	}
177	return rc;
178	}
179
180	static int slirpOpenResolvConfFile(PRTFILE pResolvConfFile)
181	{
182	int rc;
183	char buff[512];
184	char *etc = NULL;
185	char *home = NULL;
186	AssertPtrReturn(pResolvConfFile, VERR_INVALID_PARAMETER);
187	LogFlowFuncEnter();
188	# ifdef RT_OS_OS2
189	/* Try various locations. */
190	NOREF(home);
191	etc = getenv("ETC");
192	if (etc)
193	{
194	RTStrmPrintf(buff, sizeof(buff), "%s/RESOLV2", etc);
195	rc = RTFileOpen(pResolvConfFile, buff, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
196	}
197	if (RT_FAILURE(rc))
198	{
199	RTStrmPrintf(buff, sizeof(buff), "%s/RESOLV2", _PATH_ETC);
200	rc = RTFileOpen(pResolvConfFile, buff, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
201	}
202	if (RT_FAILURE(rc))
203	{
204	RTStrmPrintf(buff, sizeof(buff), "%s/resolv.conf", _PATH_ETC);
205	rc = RTFileOpen(pResolvConfFile, buff, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
206	}
207	# else /* !RT_OS_OS2 */
208	# ifndef DEBUG_vvl
209	rc = RTFileOpen(pResolvConfFile, "/etc/resolv.conf", RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
210	# else
211	NOREF(etc);
212	home = getenv("HOME");
213	RTStrPrintf(buff, sizeof(buff), "%s/resolv.conf", home);
214	rc = RTFileOpen(pResolvConfFile, buff, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
215	if (RT_SUCCESS(rc))
216	Log(("NAT: DNS we're using %s\n", buff));
217	else
218	{
219	rc = RTFileOpen(pResolvConfFile, "/etc/resolv.conf", RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
220	Log(("NAT: DNS we're using %s\n", buff));
221	}
222	# endif
223	# endif /* !RT_OS_OS2 */
224	LogFlowFuncLeaveRC(rc);
225	return rc;
226	}
227	static int get_dns_addr_domain(PNATState pData, const char **ppszDomain)
228	{
229	char buff[256];
230	char buff2[256];
231	RTFILE ResolvConfFile;
232	int cNameserversFound = 0;
233	bool fWarnTooManyDnsServers = false;
234	struct in_addr tmp_addr;
235	int rc;
236	size_t bytes;
237
238	rc = slirpOpenResolvConfFile(&ResolvConfFile);
239	if (RT_FAILURE(rc))
240	{
241	LogRel(("NAT: there're some problems with accessing resolv.conf (or known analog), thus NAT switches to use host resolver mechanism\n"));
242	pData->fUseHostResolver = 1;
243	return VINF_SUCCESS;
244	}
245
246	if (ppszDomain)
247	*ppszDomain = NULL;
248
249	Log(("NAT: DNS Servers:\n"));
250	while ( RT_SUCCESS(rc = RTFileGets(ResolvConfFile, buff, sizeof(buff), &bytes))
251	&& rc != VERR_EOF)
252	{
253	struct dns_entry *pDns = NULL;
254	if ( cNameserversFound == 4
255	&& !fWarnTooManyDnsServers
256	&& sscanf(buff, "nameserver%*[ \t]%255s", buff2) == 1)
257	{
258	fWarnTooManyDnsServers = true;
259	LogRel(("NAT: too many nameservers registered.\n"));
260	}
261	if ( sscanf(buff, "nameserver%*[ \t]%255s", buff2) == 1
262	&& cNameserversFound < 4) /* Unix doesn't accept more than 4 name servers*/
263	{
264	if (!inet_aton(buff2, &tmp_addr))
265	continue;
266
267	/* localhost mask */
268	pDns = RTMemAllocZ(sizeof (struct dns_entry));
269	if (!pDns)
270	{
271	Log(("can't alloc memory for DNS entry\n"));
272	return -1;
273	}
274
275	/* check */
276	pDns->de_addr.s_addr = tmp_addr.s_addr;
277	if ((pDns->de_addr.s_addr & RT_H2N_U32_C(IN_CLASSA_NET)) == RT_N2H_U32_C(INADDR_LOOPBACK & IN_CLASSA_NET))
278	{
279	if ((pDns->de_addr.s_addr) == RT_N2H_U32_C(INADDR_LOOPBACK))
280	pDns->de_addr.s_addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) \| CTL_ALIAS);
281	else
282	{
283	/* Modern Ubuntu register 127.0.1.1 as DNS server */
284	LogRel(("NAT: DNS server %RTnaipv4 registration detected, switching to the host resolver.\n",
285	pDns->de_addr.s_addr));
286	RTMemFree(pDns);
287	/* Releasing fetched DNS information. */
288	slirpReleaseDnsSettings(pData);
289	pData->fUseHostResolver = 1;
290	return VINF_SUCCESS;
291	}
292	}
293	TAILQ_INSERT_HEAD(&pData->pDnsList, pDns, de_list);
294	cNameserversFound++;
295	}
296	if ((!strncmp(buff, "domain", 6) \|\| !strncmp(buff, "search", 6)))
297	{
298	char *tok;
299	char *saveptr;
300	struct dns_domain_entry *pDomain = NULL;
301	int fFoundDomain = 0;
302	tok = strtok_r(&buff[6], " \t\n", &saveptr);
303	LIST_FOREACH(pDomain, &pData->pDomainList, dd_list)
304	{
305	if ( tok != NULL
306	&& strcmp(tok, pDomain->dd_pszDomain) == 0)
307	{
308	fFoundDomain = 1;
309	break;
310	}
311	}
312	if (tok != NULL && !fFoundDomain)
313	{
314	pDomain = RTMemAllocZ(sizeof(struct dns_domain_entry));
315	if (!pDomain)
316	{
317	Log(("NAT: not enought memory to add domain list\n"));
318	return VERR_NO_MEMORY;
319	}
320	pDomain->dd_pszDomain = RTStrDup(tok);
321	Log(("NAT: adding domain name %s to search list\n", pDomain->dd_pszDomain));
322	LIST_INSERT_HEAD(&pData->pDomainList, pDomain, dd_list);
323	}
324	}
325	}
326	RTFileClose(ResolvConfFile);
327	if (!cNameserversFound)
328	return -1;
329	return 0;
330	}
331
332	#endif /* !RT_OS_WINDOWS */
333
334	int slirpInitializeDnsSettings(PNATState pData)
335	{
336	int rc = VINF_SUCCESS;
337	AssertPtrReturn(pData, VERR_INVALID_PARAMETER);
338	LogFlowFuncEnter();
339	if (!pData->fUseHostResolver)
340	{
341	TAILQ_INIT(&pData->pDnsList);
342	LIST_INIT(&pData->pDomainList);
343	/**
344	* Some distributions haven't got /etc/resolv.conf
345	* so we should other way to configure DNS settings.
346	*/
347	if (get_dns_addr_domain(pData, NULL) < 0)
348	pData->fUseHostResolver = 1;
349	else
350	dnsproxy_init(pData);
351
352	if (!pData->fUseHostResolver)
353	{
354	struct dns_entry *pDNSEntry = NULL;
355	int cDNSListEntry = 0;
356	TAILQ_FOREACH_REVERSE(pDNSEntry, &pData->pDnsList, dns_list_head, de_list)
357	{
358	LogRel(("NAT: DNS#%i: %RTnaipv4\n", cDNSListEntry, pDNSEntry->de_addr.s_addr));
359	cDNSListEntry++;
360	}
361	}
362	}
363
364	LogFlowFuncLeaveRC(rc);
365	return rc;
366	}
367
368	int slirpReleaseDnsSettings(PNATState pData)
369	{
370	struct dns_entry *pDns = NULL;
371	struct dns_domain_entry *pDomain = NULL;
372	int rc = VINF_SUCCESS;
373	AssertPtrReturn(pData, VERR_INVALID_PARAMETER);
374	LogFlowFuncEnter();
375
376	while (!TAILQ_EMPTY(&pData->pDnsList))
377	{
378	pDns = TAILQ_FIRST(&pData->pDnsList);
379	TAILQ_REMOVE(&pData->pDnsList, pDns, de_list);
380	RTMemFree(pDns);
381	}
382
383	while (!LIST_EMPTY(&pData->pDomainList))
384	{
385	pDomain = LIST_FIRST(&pData->pDomainList);
386	LIST_REMOVE(pDomain, dd_list);
387	if (pDomain->dd_pszDomain != NULL)
388	RTStrFree(pDomain->dd_pszDomain);
389	RTMemFree(pDomain);
390	}
391	LogFlowFuncLeaveRC(rc);
392	return rc;
393	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/Network/slirp/slirp_dns.c@ 47420

Download in other formats: