NetIf-freebsd.cpp@ 29161

Last change on this file since 29161 was 28800, checked in by vboxsync, 15 years ago
Automated rebranding to Oracle copyright/license strings via filemuncher
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 13.1 KB

Line
1	/* $Id: NetIf-freebsd.cpp 28800 2010-04-27 08:22:32Z vboxsync $ */
2	/** @file
3	* Main - NetIfList, FreeBSD implementation.
4	*/
5
6	/*
7	* Copyright (C) 2008 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	/*
19	* Original (C) 2009 Fredrik Lindberg <fli@shapeshifter.se>. Contributed
20	* to VirtualBox under the MIT license by the author.
21	*/
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_MAIN
27	#include <sys/types.h>
28
29	#include <sys/sysctl.h>
30	#include <sys/socket.h>
31	#include <sys/sockio.h>
32	#include <net/if.h>
33	#include <net/if_types.h>
34
35	#include <net/route.h>
36	/*
37	* route.h includes net/radix.h which for some reason defines Free as a wrapper
38	* around free. This collides with Free defined in xpcom/include/nsIMemory.h
39	* Undefine it and hope for the best
40	*/
41	#undef Free
42
43	#include <net/if_dl.h>
44	#include <netinet/in.h>
45
46	#include <stdio.h>
47	#include <unistd.h>
48	#include <errno.h>
49
50	#include <list>
51
52	#include "HostNetworkInterfaceImpl.h"
53	#include "netif.h"
54	#include "Logging.h"
55
56	#define ROUNDUP(a) \
57	((a) > 0 ? (1 + (((a) - 1) \| (sizeof(long) - 1))) : sizeof(long))
58	#define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
59
60	void extractAddresses(int iAddrMask, caddr_t cp, caddr_t cplim, struct sockaddr **pAddresses)
61	{
62	struct sockaddr *sa;
63
64	for (int i = 0; i < RTAX_MAX && cp < cplim; i++) {
65	if (!(iAddrMask & (1 << i)))
66	continue;
67
68	sa = (struct sockaddr *)cp;
69
70	pAddresses[i] = sa;
71
72	ADVANCE(cp, sa);
73	}
74	}
75
76	static int getDefaultIfaceIndex(unsigned short *pu16Index, int family)
77	{
78	size_t cbNeeded;
79	char pBuf, pNext;
80	int aiMib[6];
81	struct sockaddr *addresses[RTAX_MAX];
82	aiMib[0] = CTL_NET;
83	aiMib[1] = PF_ROUTE;
84	aiMib[2] = 0;
85	aiMib[3] = family; /* address family */
86	aiMib[4] = NET_RT_DUMP;
87	aiMib[5] = 0;
88
89	if (sysctl(aiMib, 6, NULL, &cbNeeded, NULL, 0) < 0)
90	{
91	Log(("getDefaultIfaceIndex: Failed to get estimate for list size (errno=%d).\n", errno));
92	return RTErrConvertFromErrno(errno);
93	}
94	if ((pBuf = (char*)malloc(cbNeeded)) == NULL)
95	return VERR_NO_MEMORY;
96	if (sysctl(aiMib, 6, pBuf, &cbNeeded, NULL, 0) < 0)
97	{
98	free(pBuf);
99	Log(("getDefaultIfaceIndex: Failed to retrieve interface table (errno=%d).\n", errno));
100	return RTErrConvertFromErrno(errno);
101	}
102
103	char *pEnd = pBuf + cbNeeded;
104	struct rt_msghdr *pRtMsg;
105	for (pNext = pBuf; pNext < pEnd; pNext += pRtMsg->rtm_msglen)
106	{
107	pRtMsg = (struct rt_msghdr *)pNext;
108
109	if (pRtMsg->rtm_type != RTM_GET)
110	{
111	Log(("getDefaultIfaceIndex: Got message %u while expecting %u.\n",
112	pRtMsg->rtm_type, RTM_GET));
113	//rc = VERR_INTERNAL_ERROR;
114	continue;
115	}
116	if ((char*)(pRtMsg + 1) < pEnd)
117	{
118	/* Extract addresses from the message. */
119	extractAddresses(pRtMsg->rtm_addrs, (char *)(pRtMsg + 1),
120	pRtMsg->rtm_msglen + (char *)pRtMsg, addresses);
121	if ((pRtMsg->rtm_addrs & RTA_DST))
122	{
123	if (addresses[RTAX_DST]->sa_family != AF_INET)
124	continue;
125	struct sockaddr_in addr = (struct sockaddr_in )addresses[RTAX_DST];
126	struct sockaddr_in mask = (struct sockaddr_in )addresses[RTAX_NETMASK];
127	if ((addr->sin_addr.s_addr == INADDR_ANY) &&
128	mask &&
129	(ntohl(mask->sin_addr.s_addr) == 0L \|\|
130	mask->sin_len == 0))
131	{
132	*pu16Index = pRtMsg->rtm_index;
133	free(pBuf);
134	return VINF_SUCCESS;
135	}
136	}
137	}
138	}
139	free(pBuf);
140	return VERR_INTERNAL_ERROR;
141
142	}
143
144	void extractAddressesToNetInfo(int iAddrMask, caddr_t cp, caddr_t cplim, PNETIFINFO pInfo)
145	{
146	struct sockaddr *addresses[RTAX_MAX];
147
148	extractAddresses(iAddrMask, cp, cplim, addresses);
149	switch (addresses[RTAX_IFA]->sa_family)
150	{
151	case AF_INET:
152	if (!pInfo->IPAddress.u)
153	{
154	pInfo->IPAddress.u = ((struct sockaddr_in *)addresses[RTAX_IFA])->sin_addr.s_addr;
155	pInfo->IPNetMask.u = ((struct sockaddr_in *)addresses[RTAX_NETMASK])->sin_addr.s_addr;
156	}
157	break;
158	case AF_INET6:
159	if (!pInfo->IPv6Address.s.Lo && !pInfo->IPv6Address.s.Hi)
160	{
161	memcpy(pInfo->IPv6Address.au8,
162	((struct sockaddr_in6 *)addresses[RTAX_IFA])->sin6_addr.__u6_addr.__u6_addr8,
163	sizeof(pInfo->IPv6Address));
164	memcpy(pInfo->IPv6NetMask.au8,
165	((struct sockaddr_in6 *)addresses[RTAX_NETMASK])->sin6_addr.__u6_addr.__u6_addr8,
166	sizeof(pInfo->IPv6NetMask));
167	}
168	break;
169	default:
170	Log(("NetIfList: Unsupported address family: %u\n", addresses[RTAX_IFA]->sa_family));
171	break;
172	}
173	}
174
175
176	int NetIfList(std::list <ComObjPtr<HostNetworkInterface> > &list)
177	{
178	int rc = VINF_SUCCESS;
179	size_t cbNeeded;
180	char pBuf, pNext;
181	int aiMib[6];
182	unsigned short u16DefaultIface;
183
184	/* Get the index of the interface associated with default route. */
185	rc = getDefaultIfaceIndex(&u16DefaultIface, PF_INET);
186	if (RT_FAILURE(rc))
187	return rc;
188
189	aiMib[0] = CTL_NET;
190	aiMib[1] = PF_ROUTE;
191	aiMib[2] = 0;
192	aiMib[3] = 0; /* address family */
193	aiMib[4] = NET_RT_IFLIST;
194	aiMib[5] = 0;
195
196	if (sysctl(aiMib, 6, NULL, &cbNeeded, NULL, 0) < 0)
197	{
198	Log(("NetIfList: Failed to get estimate for list size (errno=%d).\n", errno));
199	return RTErrConvertFromErrno(errno);
200	}
201	if ((pBuf = (char*)malloc(cbNeeded)) == NULL)
202	return VERR_NO_MEMORY;
203	if (sysctl(aiMib, 6, pBuf, &cbNeeded, NULL, 0) < 0)
204	{
205	free(pBuf);
206	Log(("NetIfList: Failed to retrieve interface table (errno=%d).\n", errno));
207	return RTErrConvertFromErrno(errno);
208	}
209
210	int sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
211	if (sock < 0)
212	{
213	free(pBuf);
214	Log(("NetIfList: socket() -> %d\n", errno));
215	return RTErrConvertFromErrno(errno);
216	}
217
218	char *pEnd = pBuf + cbNeeded;
219	for (pNext = pBuf; pNext < pEnd;)
220	{
221	struct if_msghdr pIfMsg = (struct if_msghdr )pNext;
222
223	if (pIfMsg->ifm_type != RTM_IFINFO)
224	{
225	Log(("NetIfList: Got message %u while expecting %u.\n",
226	pIfMsg->ifm_type, RTM_IFINFO));
227	rc = VERR_INTERNAL_ERROR;
228	break;
229	}
230	struct sockaddr_dl pSdl = (struct sockaddr_dl )(pIfMsg + 1);
231
232	size_t cbNameLen = pSdl->sdl_nlen + 1;
233	PNETIFINFO pNew = (PNETIFINFO)RTMemAllocZ(RT_OFFSETOF(NETIFINFO, szName[cbNameLen]));
234	if (!pNew)
235	{
236	rc = VERR_NO_MEMORY;
237	break;
238	}
239	memcpy(pNew->MACAddress.au8, LLADDR(pSdl), sizeof(pNew->MACAddress.au8));
240	pNew->enmMediumType = NETIF_T_ETHERNET;
241	Assert(sizeof(pNew->szShortName) >= cbNameLen);
242	strlcpy(pNew->szShortName, pSdl->sdl_data, cbNameLen);
243	strlcpy(pNew->szName, pSdl->sdl_data, cbNameLen);
244	/* Generate UUID from name and MAC address. */
245	RTUUID uuid;
246	RTUuidClear(&uuid);
247	memcpy(&uuid, pNew->szShortName, RT_MIN(cbNameLen, sizeof(uuid)));
248	uuid.Gen.u8ClockSeqHiAndReserved = (uuid.Gen.u8ClockSeqHiAndReserved & 0x3f) \| 0x80;
249	uuid.Gen.u16TimeHiAndVersion = (uuid.Gen.u16TimeHiAndVersion & 0x0fff) \| 0x4000;
250	memcpy(uuid.Gen.au8Node, pNew->MACAddress.au8, sizeof(uuid.Gen.au8Node));
251	pNew->Uuid = uuid;
252
253	pNext += pIfMsg->ifm_msglen;
254	while (pNext < pEnd)
255	{
256	struct ifa_msghdr pIfAddrMsg = (struct ifa_msghdr )pNext;
257
258	if (pIfAddrMsg->ifam_type != RTM_NEWADDR)
259	break;
260	extractAddressesToNetInfo(pIfAddrMsg->ifam_addrs,
261	(char *)(pIfAddrMsg + 1),
262	pIfAddrMsg->ifam_msglen + (char *)pIfAddrMsg,
263	pNew);
264	pNext += pIfAddrMsg->ifam_msglen;
265	}
266
267	if (pSdl->sdl_type == IFT_ETHER)
268	{
269	struct ifreq IfReq;
270	strcpy(IfReq.ifr_name, pNew->szShortName);
271	if (ioctl(sock, SIOCGIFFLAGS, &IfReq) < 0)
272	{
273	Log(("NetIfList: ioctl(SIOCGIFFLAGS) -> %d\n", errno));
274	pNew->enmStatus = NETIF_S_UNKNOWN;
275	}
276	else
277	pNew->enmStatus = (IfReq.ifr_flags & IFF_UP) ? NETIF_S_UP : NETIF_S_DOWN;
278
279	HostNetworkInterfaceType_T enmType;
280	if (strncmp("vboxnet", pNew->szName, 7))
281	enmType = HostNetworkInterfaceType_Bridged;
282	else
283	enmType = HostNetworkInterfaceType_HostOnly;
284
285	ComObjPtr<HostNetworkInterface> IfObj;
286	IfObj.createObject();
287	if (SUCCEEDED(IfObj->init(Bstr(pNew->szName), enmType, pNew)))
288	/* Make sure the default interface gets to the beginning. */
289	if (pIfMsg->ifm_index == u16DefaultIface)
290	list.push_front(IfObj);
291	else
292	list.push_back(IfObj);
293	}
294	RTMemFree(pNew);
295	}
296
297	close(sock);
298	free(pBuf);
299	return rc;
300
301
302	}
303
304	int NetIfGetConfigByName(PNETIFINFO pInfo)
305	{
306	int rc = VINF_SUCCESS;
307	size_t cbNeeded;
308	char pBuf, pNext;
309	int aiMib[6];
310
311	aiMib[0] = CTL_NET;
312	aiMib[1] = PF_ROUTE;
313	aiMib[2] = 0;
314	aiMib[3] = 0; /* address family */
315	aiMib[4] = NET_RT_IFLIST;
316	aiMib[5] = 0;
317
318	if (sysctl(aiMib, 6, NULL, &cbNeeded, NULL, 0) < 0)
319	{
320	Log(("NetIfList: Failed to get estimate for list size (errno=%d).\n", errno));
321	return RTErrConvertFromErrno(errno);
322	}
323	if ((pBuf = (char*)malloc(cbNeeded)) == NULL)
324	return VERR_NO_MEMORY;
325	if (sysctl(aiMib, 6, pBuf, &cbNeeded, NULL, 0) < 0)
326	{
327	free(pBuf);
328	Log(("NetIfList: Failed to retrieve interface table (errno=%d).\n", errno));
329	return RTErrConvertFromErrno(errno);
330	}
331
332	int sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
333	if (sock < 0)
334	{
335	free(pBuf);
336	Log(("NetIfList: socket() -> %d\n", errno));
337	return RTErrConvertFromErrno(errno);
338	}
339
340	char *pEnd = pBuf + cbNeeded;
341	for (pNext = pBuf; pNext < pEnd;)
342	{
343	struct if_msghdr pIfMsg = (struct if_msghdr )pNext;
344
345	if (pIfMsg->ifm_type != RTM_IFINFO)
346	{
347	Log(("NetIfList: Got message %u while expecting %u.\n",
348	pIfMsg->ifm_type, RTM_IFINFO));
349	rc = VERR_INTERNAL_ERROR;
350	break;
351	}
352	struct sockaddr_dl pSdl = (struct sockaddr_dl )(pIfMsg + 1);
353
354	bool fSkip = !!strcmp(pInfo->szShortName, pSdl->sdl_data);
355
356	pNext += pIfMsg->ifm_msglen;
357	while (pNext < pEnd)
358	{
359	struct ifa_msghdr pIfAddrMsg = (struct ifa_msghdr )pNext;
360
361	if (pIfAddrMsg->ifam_type != RTM_NEWADDR)
362	break;
363	if (!fSkip)
364	extractAddressesToNetInfo(pIfAddrMsg->ifam_addrs,
365	(char *)(pIfAddrMsg + 1),
366	pIfAddrMsg->ifam_msglen + (char *)pIfAddrMsg,
367	pInfo);
368	pNext += pIfAddrMsg->ifam_msglen;
369	}
370
371	if (!fSkip && pSdl->sdl_type == IFT_ETHER)
372	{
373	size_t cbNameLen = pSdl->sdl_nlen + 1;
374	memcpy(pInfo->MACAddress.au8, LLADDR(pSdl), sizeof(pInfo->MACAddress.au8));
375	pInfo->enmMediumType = NETIF_T_ETHERNET;
376	/* Generate UUID from name and MAC address. */
377	RTUUID uuid;
378	RTUuidClear(&uuid);
379	memcpy(&uuid, pInfo->szShortName, RT_MIN(cbNameLen, sizeof(uuid)));
380	uuid.Gen.u8ClockSeqHiAndReserved = (uuid.Gen.u8ClockSeqHiAndReserved & 0x3f) \| 0x80;
381	uuid.Gen.u16TimeHiAndVersion = (uuid.Gen.u16TimeHiAndVersion & 0x0fff) \| 0x4000;
382	memcpy(uuid.Gen.au8Node, pInfo->MACAddress.au8, sizeof(uuid.Gen.au8Node));
383	pInfo->Uuid = uuid;
384
385	struct ifreq IfReq;
386	strcpy(IfReq.ifr_name, pInfo->szShortName);
387	if (ioctl(sock, SIOCGIFFLAGS, &IfReq) < 0)
388	{
389	Log(("NetIfList: ioctl(SIOCGIFFLAGS) -> %d\n", errno));
390	pInfo->enmStatus = NETIF_S_UNKNOWN;
391	}
392	else
393	pInfo->enmStatus = (IfReq.ifr_flags & IFF_UP) ? NETIF_S_UP : NETIF_S_DOWN;
394
395	return VINF_SUCCESS;
396	}
397	}
398	close(sock);
399	free(pBuf);
400	return rc;
401	}
402

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

source: vbox/trunk/src/VBox/Main/freebsd/NetIf-freebsd.cpp@ 29161

Download in other formats: