VirtualBox

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

Last change on this file since 43673 was 43673, checked in by vboxsync, 13 years ago

NAT: handles resolv.conf-less distributions (vbox/10640).
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 12.3 KB
Line 
1/* $Id: slirp_dns.c 43673 2012-10-17 17:02:43Z 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
33static 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
154static 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
180static 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# ifdef RT_OS_OS2
188 /* Try various locations. */
189 NOREF(home);
190 etc = getenv("ETC");
191 if (etc)
192 {
193 RTStrmPrintf(buff, sizeof(buff), "%s/RESOLV2", etc);
194 rc = RTFileOpen(pResolvConfFile, buff, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
195 }
196 if (RT_FAILURE(rc))
197 {
198 RTStrmPrintf(buff, sizeof(buff), "%s/RESOLV2", _PATH_ETC);
199 rc = RTFileOpen(pResolvConfFile, buff, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
200 }
201 if (RT_FAILURE(rc))
202 {
203 RTStrmPrintf(buff, sizeof(buff), "%s/resolv.conf", _PATH_ETC);
204 rc = RTFileOpen(pResolvConfFile, buff, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
205 }
206# else /* !RT_OS_OS2 */
207# ifndef DEBUG_vvl
208 rc = RTFileOpen(pResolvConfFile, "/etc/resolv.conf", RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
209# else
210 NOREF(etc);
211 home = getenv("HOME");
212 RTStrPrintf(buff, sizeof(buff), "%s/resolv.conf", home);
213 rc = RTFileOpen(pResolvConfFile, buff, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
214 if (RT_SUCCESS(rc))
215 Log(("NAT: DNS we're using %s\n", buff));
216 else
217 {
218 rc = RTFileOpen(pResolvConfFile, "/etc/resolv.conf", RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
219 Log(("NAT: DNS we're using %s\n", buff));
220 }
221# endif
222# endif /* !RT_OS_OS2 */
223 return rc;
224}
225static int get_dns_addr_domain(PNATState pData, const char **ppszDomain)
226{
227 char buff[256];
228 char buff2[256];
229 RTFILE ResolvConfFile;
230 int cNameserversFound = 0;
231 bool fWarnTooManyDnsServers = false;
232 struct in_addr tmp_addr;
233 int rc;
234 size_t bytes;
235
236 rc = slirpOpenResolvConfFile(&ResolvConfFile);
237 if (RT_FAILURE(rc))
238 {
239 LogRel(("NAT: there're some problems with accessing resolv.conf (or known analog), thus NAT switches to use host resolver mechanism\n"));
240 pData->fUseHostResolver = 1;
241 return VINF_SUCCESS;
242 }
243
244 if (ppszDomain)
245 *ppszDomain = NULL;
246
247 Log(("NAT: DNS Servers:\n"));
248 while ( RT_SUCCESS(rc = RTFileGets(ResolvConfFile, buff, sizeof(buff), &bytes))
249 && rc != VERR_EOF)
250 {
251 struct dns_entry *pDns = NULL;
252 if ( cNameserversFound == 4
253 && !fWarnTooManyDnsServers
254 && sscanf(buff, "nameserver%*[ \t]%255s", buff2) == 1)
255 {
256 fWarnTooManyDnsServers = true;
257 LogRel(("NAT: too many nameservers registered.\n"));
258 }
259 if ( sscanf(buff, "nameserver%*[ \t]%255s", buff2) == 1
260 && cNameserversFound < 4) /* Unix doesn't accept more than 4 name servers*/
261 {
262 if (!inet_aton(buff2, &tmp_addr))
263 continue;
264
265 /* localhost mask */
266 pDns = RTMemAllocZ(sizeof (struct dns_entry));
267 if (!pDns)
268 {
269 Log(("can't alloc memory for DNS entry\n"));
270 return -1;
271 }
272
273 /* check */
274 pDns->de_addr.s_addr = tmp_addr.s_addr;
275 if ((pDns->de_addr.s_addr & RT_H2N_U32_C(IN_CLASSA_NET)) == RT_N2H_U32_C(INADDR_LOOPBACK & IN_CLASSA_NET))
276 {
277 if ((pDns->de_addr.s_addr) == RT_N2H_U32_C(INADDR_LOOPBACK))
278 pDns->de_addr.s_addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | CTL_ALIAS);
279 else
280 {
281 /* Modern Ubuntu register 127.0.1.1 as DNS server */
282 LogRel(("NAT: DNS server %RTnaipv4 registration detected, switching to the host resolver.\n",
283 pDns->de_addr.s_addr));
284 RTMemFree(pDns);
285 /* Releasing fetched DNS information. */
286 slirpReleaseDnsSettings(pData);
287 pData->fUseHostResolver = 1;
288 return VINF_SUCCESS;
289 }
290 }
291 TAILQ_INSERT_HEAD(&pData->pDnsList, pDns, de_list);
292 cNameserversFound++;
293 }
294 if ((!strncmp(buff, "domain", 6) || !strncmp(buff, "search", 6)))
295 {
296 char *tok;
297 char *saveptr;
298 struct dns_domain_entry *pDomain = NULL;
299 int fFoundDomain = 0;
300 tok = strtok_r(&buff[6], " \t\n", &saveptr);
301 LIST_FOREACH(pDomain, &pData->pDomainList, dd_list)
302 {
303 if ( tok != NULL
304 && strcmp(tok, pDomain->dd_pszDomain) == 0)
305 {
306 fFoundDomain = 1;
307 break;
308 }
309 }
310 if (tok != NULL && !fFoundDomain)
311 {
312 pDomain = RTMemAllocZ(sizeof(struct dns_domain_entry));
313 if (!pDomain)
314 {
315 Log(("NAT: not enought memory to add domain list\n"));
316 return VERR_NO_MEMORY;
317 }
318 pDomain->dd_pszDomain = RTStrDup(tok);
319 Log(("NAT: adding domain name %s to search list\n", pDomain->dd_pszDomain));
320 LIST_INSERT_HEAD(&pData->pDomainList, pDomain, dd_list);
321 }
322 }
323 }
324 RTFileClose(ResolvConfFile);
325 if (!cNameserversFound)
326 return -1;
327 return 0;
328}
329
330#endif /* !RT_OS_WINDOWS */
331
332int slirpInitializeDnsSettings(PNATState pData)
333{
334 int rc = VINF_SUCCESS;
335 AssertPtrReturn(pData, VERR_INVALID_PARAMETER);
336 LogFlowFuncEnter();
337 if (!pData->fUseHostResolver)
338 {
339 TAILQ_INIT(&pData->pDnsList);
340 LIST_INIT(&pData->pDomainList);
341 /**
342 * Some distributions haven't got /etc/resolv.conf
343 * so we should other way to configure DNS settings.
344 */
345 if (get_dns_addr_domain(pData, NULL) < 0)
346 pData->fUseHostResolver = 1;
347 else
348 dnsproxy_init(pData);
349
350 if (!pData->fUseHostResolver)
351 {
352 struct dns_entry *pDNSEntry = NULL;
353 int cDNSListEntry = 0;
354 TAILQ_FOREACH_REVERSE(pDNSEntry, &pData->pDnsList, dns_list_head, de_list)
355 {
356 LogRel(("NAT: DNS#%i: %RTnaipv4\n", cDNSListEntry, pDNSEntry->de_addr.s_addr));
357 cDNSListEntry++;
358 }
359 }
360 }
361
362 LogFlowFuncLeaveRC(rc);
363 return rc;
364}
365
366int slirpReleaseDnsSettings(PNATState pData)
367{
368 struct dns_entry *pDns = NULL;
369 struct dns_domain_entry *pDomain = NULL;
370 int rc = VINF_SUCCESS;
371 AssertPtrReturn(pData, VERR_INVALID_PARAMETER);
372 LogFlowFuncEnter();
373
374 while (!TAILQ_EMPTY(&pData->pDnsList))
375 {
376 pDns = TAILQ_FIRST(&pData->pDnsList);
377 TAILQ_REMOVE(&pData->pDnsList, pDns, de_list);
378 RTMemFree(pDns);
379 }
380
381 while (!LIST_EMPTY(&pData->pDomainList))
382 {
383 pDomain = LIST_FIRST(&pData->pDomainList);
384 LIST_REMOVE(pDomain, dd_list);
385 if (pDomain->dd_pszDomain != NULL)
386 RTStrFree(pDomain->dd_pszDomain);
387 RTMemFree(pDomain);
388 }
389 LogFlowFuncLeaveRC(rc);
390 return rc;
391}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette