NetIf-darwin.cpp@ 76592

Last change on this file since 76592 was 76592, checked in by vboxsync, 6 years ago
Main: Don't use Logging.h.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 18.9 KB

Line
1	/* $Id: NetIf-darwin.cpp 76592 2019-01-01 20:13:07Z vboxsync $ */
2	/** @file
3	* Main - NetIfList, Darwin implementation.
4	*/
5
6	/*
7	* Copyright (C) 2008-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.215389.xyz. 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
20	/*********************************************************************************************************************************
21	* Header Files *
22	*********************************************************************************************************************************/
23	#define LOG_GROUP LOG_GROUP_MAIN_HOST
24
25	/*
26	* Deal with conflicts first.
27	* PVM - BSD mess, that FreeBSD has correct a long time ago.
28	* iprt/types.h before sys/param.h - prevents UINT32_C and friends.
29	*/
30	#include <iprt/types.h>
31	#include <sys/param.h>
32	#undef PVM
33
34	#define LOG_GROUP LOG_GROUP_MAIN
35
36	#include <iprt/errcore.h>
37	#include <iprt/alloc.h>
38
39	#include <string.h>
40	#include <sys/socket.h>
41	#include <sys/ioctl.h>
42	#include <sys/sysctl.h>
43	#include <netinet/in.h>
44	#include <net/if.h>
45	#include <net/if_dl.h>
46	#include <net/if_types.h>
47	#include <net/route.h>
48	#include <ifaddrs.h>
49	#include <errno.h>
50	#include <unistd.h>
51	#include <list>
52
53	#include "HostNetworkInterfaceImpl.h"
54	#include "netif.h"
55	#include "iokit.h"
56	#include "LoggingNew.h"
57
58	#if 0
59	int NetIfList(std::list <ComObjPtr<HostNetworkInterface> > &list)
60	{
61	int sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
62	if (sock < 0)
63	{
64	Log(("NetIfList: socket() -> %d\n", errno));
65	return NULL;
66	}
67	struct ifaddrs IfAddrs, pAddr;
68	int rc = getifaddrs(&IfAddrs);
69	if (rc)
70	{
71	close(sock);
72	Log(("NetIfList: getifaddrs() -> %d\n", rc));
73	return VERR_INTERNAL_ERROR;
74	}
75
76	PDARWINETHERNIC pEtherNICs = DarwinGetEthernetControllers();
77	while (pEtherNICs)
78	{
79	size_t cbNameLen = strlen(pEtherNICs->szName) + 1;
80	PNETIFINFO pNew = (PNETIFINFO)RTMemAllocZ(RT_OFFSETOF(NETIFINFO, szName[cbNameLen]));
81	pNew->MACAddress = pEtherNICs->Mac;
82	pNew->enmMediumType = NETIF_T_ETHERNET;
83	pNew->Uuid = pEtherNICs->Uuid;
84	Assert(sizeof(pNew->szShortName) > sizeof(pEtherNICs->szBSDName));
85	memcpy(pNew->szShortName, pEtherNICs->szBSDName, sizeof(pEtherNICs->szBSDName));
86	pNew->szShortName[sizeof(pEtherNICs->szBSDName)] = '\0';
87	memcpy(pNew->szName, pEtherNICs->szName, cbNameLen);
88
89	struct ifreq IfReq;
90	RTStrCopy(IfReq.ifr_name, sizeof(IfReq.ifr_name), pNew->szShortName);
91	if (ioctl(sock, SIOCGIFFLAGS, &IfReq) < 0)
92	{
93	Log(("NetIfList: ioctl(SIOCGIFFLAGS) -> %d\n", errno));
94	pNew->enmStatus = NETIF_S_UNKNOWN;
95	}
96	else
97	pNew->enmStatus = (IfReq.ifr_flags & IFF_UP) ? NETIF_S_UP : NETIF_S_DOWN;
98
99	for (pAddr = IfAddrs; pAddr != NULL; pAddr = pAddr->ifa_next)
100	{
101	if (strcmp(pNew->szShortName, pAddr->ifa_name))
102	continue;
103
104	struct sockaddr_in pIPAddr, pIPNetMask;
105	struct sockaddr_in6 pIPv6Addr, pIPv6NetMask;
106
107	switch (pAddr->ifa_addr->sa_family)
108	{
109	case AF_INET:
110	if (pNew->IPAddress.u)
111	break;
112	pIPAddr = (struct sockaddr_in *)pAddr->ifa_addr;
113	Assert(sizeof(pNew->IPAddress) == sizeof(pIPAddr->sin_addr));
114	pNew->IPAddress.u = pIPAddr->sin_addr.s_addr;
115	pIPNetMask = (struct sockaddr_in *)pAddr->ifa_netmask;
116	Assert(pIPNetMask->sin_family == AF_INET);
117	Assert(sizeof(pNew->IPNetMask) == sizeof(pIPNetMask->sin_addr));
118	pNew->IPNetMask.u = pIPNetMask->sin_addr.s_addr;
119	break;
120	case AF_INET6:
121	if (pNew->IPv6Address.s.Lo \|\| pNew->IPv6Address.s.Hi)
122	break;
123	pIPv6Addr = (struct sockaddr_in6 *)pAddr->ifa_addr;
124	Assert(sizeof(pNew->IPv6Address) == sizeof(pIPv6Addr->sin6_addr));
125	memcpy(pNew->IPv6Address.au8,
126	pIPv6Addr->sin6_addr.__u6_addr.__u6_addr8,
127	sizeof(pNew->IPv6Address));
128	pIPv6NetMask = (struct sockaddr_in6 *)pAddr->ifa_netmask;
129	Assert(pIPv6NetMask->sin6_family == AF_INET6);
130	Assert(sizeof(pNew->IPv6NetMask) == sizeof(pIPv6NetMask->sin6_addr));
131	memcpy(pNew->IPv6NetMask.au8,
132	pIPv6NetMask->sin6_addr.__u6_addr.__u6_addr8,
133	sizeof(pNew->IPv6NetMask));
134	break;
135	}
136	}
137
138	ComObjPtr<HostNetworkInterface> IfObj;
139	IfObj.createObject();
140	if (SUCCEEDED(IfObj->init(Bstr(pEtherNICs->szName), HostNetworkInterfaceType_Bridged, pNew)))
141	list.push_back(IfObj);
142	RTMemFree(pNew);
143
144	/* next, free current */
145	void *pvFree = pEtherNICs;
146	pEtherNICs = pEtherNICs->pNext;
147	RTMemFree(pvFree);
148	}
149
150	freeifaddrs(IfAddrs);
151	close(sock);
152	return VINF_SUCCESS;
153	}
154	#else
155
156	#define ROUNDUP(a) \
157	(((a) & (sizeof(u_long) - 1)) ? (1 + ((a) \| (sizeof(u_long) - 1))) : (a))
158	#define ADVANCE(x, n) (x += (n)->sa_len ? ROUNDUP((n)->sa_len) : sizeof(u_long))
159
160	void extractAddresses(int iAddrMask, caddr_t cp, caddr_t cplim, struct sockaddr **pAddresses)
161	{
162	struct sockaddr *sa;
163
164	for (int i = 0; i < RTAX_MAX && cp < cplim; i++) {
165	if (iAddrMask & (1 << i))
166	{
167	sa = (struct sockaddr *)cp;
168
169	pAddresses[i] = sa;
170
171	ADVANCE(cp, sa);
172	}
173	else
174	pAddresses[i] = NULL;
175	}
176	}
177
178	void extractAddressesToNetInfo(int iAddrMask, caddr_t cp, caddr_t cplim, PNETIFINFO pInfo)
179	{
180	struct sockaddr *addresses[RTAX_MAX];
181
182	extractAddresses(iAddrMask, cp, cplim, addresses);
183	switch (addresses[RTAX_IFA]->sa_family)
184	{
185	case AF_INET:
186	if (!pInfo->IPAddress.u)
187	{
188	pInfo->IPAddress.u = ((struct sockaddr_in *)addresses[RTAX_IFA])->sin_addr.s_addr;
189	pInfo->IPNetMask.u = ((struct sockaddr_in *)addresses[RTAX_NETMASK])->sin_addr.s_addr;
190	}
191	break;
192	case AF_INET6:
193	if (!pInfo->IPv6Address.s.Lo && !pInfo->IPv6Address.s.Hi)
194	{
195	memcpy(pInfo->IPv6Address.au8,
196	((struct sockaddr_in6 *)addresses[RTAX_IFA])->sin6_addr.__u6_addr.__u6_addr8,
197	sizeof(pInfo->IPv6Address));
198	memcpy(pInfo->IPv6NetMask.au8,
199	((struct sockaddr_in6 *)addresses[RTAX_NETMASK])->sin6_addr.__u6_addr.__u6_addr8,
200	sizeof(pInfo->IPv6NetMask));
201	}
202	break;
203	default:
204	Log(("NetIfList: Unsupported address family: %u\n", addresses[RTAX_IFA]->sa_family));
205	break;
206	}
207	}
208
209	static int getDefaultIfaceIndex(unsigned short *pu16Index)
210	{
211	size_t cbNeeded;
212	char pBuf, pNext;
213	int aiMib[6];
214	struct sockaddr *addresses[RTAX_MAX];
215
216	aiMib[0] = CTL_NET;
217	aiMib[1] = PF_ROUTE;
218	aiMib[2] = 0;
219	aiMib[3] = PF_INET; /* address family */
220	aiMib[4] = NET_RT_DUMP;
221	aiMib[5] = 0;
222
223	if (sysctl(aiMib, 6, NULL, &cbNeeded, NULL, 0) < 0)
224	{
225	Log(("getDefaultIfaceIndex: Failed to get estimate for list size (errno=%d).\n", errno));
226	return RTErrConvertFromErrno(errno);
227	}
228	if ((pBuf = (char *)RTMemAlloc(cbNeeded)) == NULL)
229	return VERR_NO_MEMORY;
230	if (sysctl(aiMib, 6, pBuf, &cbNeeded, NULL, 0) < 0)
231	{
232	RTMemFree(pBuf);
233	Log(("getDefaultIfaceIndex: Failed to retrieve interface table (errno=%d).\n", errno));
234	return RTErrConvertFromErrno(errno);
235	}
236
237	char *pEnd = pBuf + cbNeeded;
238	struct rt_msghdr *pRtMsg;
239	for (pNext = pBuf; pNext < pEnd; pNext += pRtMsg->rtm_msglen)
240	{
241	pRtMsg = (struct rt_msghdr *)pNext;
242
243	if (pRtMsg->rtm_type != RTM_GET)
244	{
245	Log(("getDefaultIfaceIndex: Got message %u while expecting %u.\n",
246	pRtMsg->rtm_type, RTM_GET));
247	//rc = VERR_INTERNAL_ERROR;
248	continue;
249	}
250	if ((char*)(pRtMsg + 1) < pEnd)
251	{
252	/* Extract addresses from the message. */
253	extractAddresses(pRtMsg->rtm_addrs, (char *)(pRtMsg + 1),
254	pRtMsg->rtm_msglen + 1 + (char *)pRtMsg, addresses);
255	if ((pRtMsg->rtm_addrs & RTA_DST)
256	&& (pRtMsg->rtm_addrs & RTA_NETMASK))
257	{
258	if (addresses[RTAX_DST]->sa_family != AF_INET)
259	continue;
260	struct sockaddr_in addr = (struct sockaddr_in )addresses[RTAX_DST];
261	struct sockaddr_in mask = (struct sockaddr_in )addresses[RTAX_NETMASK];
262	if ((addr->sin_addr.s_addr == INADDR_ANY) &&
263	mask &&
264	(ntohl(mask->sin_addr.s_addr) == 0L \|\|
265	mask->sin_len == 0))
266	{
267	*pu16Index = pRtMsg->rtm_index;
268	RTMemFree(pBuf);
269	return VINF_SUCCESS;
270	}
271	}
272	}
273	}
274	RTMemFree(pBuf);
275	return 0; /* Failed to find default interface, take the first one in the list. */
276	}
277
278	int NetIfList(std::list <ComObjPtr<HostNetworkInterface> > &list)
279	{
280	int rc = VINF_SUCCESS;
281	size_t cbNeeded;
282	char pBuf, pNext;
283	int aiMib[6];
284	unsigned short u16DefaultIface = 0; /* initialized to shut up gcc */
285
286	/* Get the index of the interface associated with default route. */
287	rc = getDefaultIfaceIndex(&u16DefaultIface);
288	if (RT_FAILURE(rc))
289	return rc;
290
291	aiMib[0] = CTL_NET;
292	aiMib[1] = PF_ROUTE;
293	aiMib[2] = 0;
294	aiMib[3] = 0; /* address family */
295	aiMib[4] = NET_RT_IFLIST;
296	aiMib[5] = 0;
297
298	if (sysctl(aiMib, 6, NULL, &cbNeeded, NULL, 0) < 0)
299	{
300	Log(("NetIfList: Failed to get estimate for list size (errno=%d).\n", errno));
301	return RTErrConvertFromErrno(errno);
302	}
303	if ((pBuf = (char*)RTMemAlloc(cbNeeded)) == NULL)
304	return VERR_NO_MEMORY;
305	if (sysctl(aiMib, 6, pBuf, &cbNeeded, NULL, 0) < 0)
306	{
307	RTMemFree(pBuf);
308	Log(("NetIfList: Failed to retrieve interface table (errno=%d).\n", errno));
309	return RTErrConvertFromErrno(errno);
310	}
311
312	int sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
313	if (sock < 0)
314	{
315	RTMemFree(pBuf);
316	Log(("NetIfList: socket() -> %d\n", errno));
317	return RTErrConvertFromErrno(errno);
318	}
319
320	PDARWINETHERNIC pNIC;
321	PDARWINETHERNIC pEtherNICs = DarwinGetEthernetControllers();
322
323	char *pEnd = pBuf + cbNeeded;
324	for (pNext = pBuf; pNext < pEnd;)
325	{
326	struct if_msghdr pIfMsg = (struct if_msghdr )pNext;
327
328	if (pIfMsg->ifm_type != RTM_IFINFO)
329	{
330	Log(("NetIfList: Got message %u while expecting %u.\n",
331	pIfMsg->ifm_type, RTM_IFINFO));
332	rc = VERR_INTERNAL_ERROR;
333	break;
334	}
335	struct sockaddr_dl pSdl = (struct sockaddr_dl )(pIfMsg + 1);
336
337	size_t cbNameLen = pSdl->sdl_nlen + 1;
338	Assert(pSdl->sdl_nlen < sizeof(pNIC->szBSDName));
339	for (pNIC = pEtherNICs; pNIC; pNIC = pNIC->pNext)
340	if ( !strncmp(pSdl->sdl_data, pNIC->szBSDName, pSdl->sdl_nlen)
341	&& pNIC->szBSDName[pSdl->sdl_nlen] == '\0')
342	{
343	cbNameLen = strlen(pNIC->szName) + 1;
344	break;
345	}
346	PNETIFINFO pNew = (PNETIFINFO)RTMemAllocZ(RT_UOFFSETOF_DYN(NETIFINFO, szName[cbNameLen]));
347	if (!pNew)
348	{
349	rc = VERR_NO_MEMORY;
350	break;
351	}
352	memcpy(pNew->MACAddress.au8, LLADDR(pSdl), sizeof(pNew->MACAddress.au8));
353	pNew->enmMediumType = NETIF_T_ETHERNET;
354	Assert(sizeof(pNew->szShortName) > pSdl->sdl_nlen);
355	memcpy(pNew->szShortName, pSdl->sdl_data, RT_MIN(pSdl->sdl_nlen, sizeof(pNew->szShortName) - 1));
356
357	/*
358	* If we found the adapter in the list returned by
359	* DarwinGetEthernetControllers() copy the name and UUID from there.
360	*/
361	if (pNIC)
362	{
363	memcpy(pNew->szName, pNIC->szName, cbNameLen);
364	pNew->Uuid = pNIC->Uuid;
365	pNew->fWireless = pNIC->fWireless;
366	}
367	else
368	{
369	memcpy(pNew->szName, pSdl->sdl_data, pSdl->sdl_nlen);
370	/* Generate UUID from name and MAC address. */
371	RTUUID uuid;
372	RTUuidClear(&uuid);
373	memcpy(&uuid, pNew->szShortName, RT_MIN(cbNameLen, sizeof(uuid)));
374	uuid.Gen.u8ClockSeqHiAndReserved = (uuid.Gen.u8ClockSeqHiAndReserved & 0x3f) \| 0x80;
375	uuid.Gen.u16TimeHiAndVersion = (uuid.Gen.u16TimeHiAndVersion & 0x0fff) \| 0x4000;
376	memcpy(uuid.Gen.au8Node, pNew->MACAddress.au8, sizeof(uuid.Gen.au8Node));
377	pNew->Uuid = uuid;
378	}
379
380	pNext += pIfMsg->ifm_msglen;
381	while (pNext < pEnd)
382	{
383	struct ifa_msghdr pIfAddrMsg = (struct ifa_msghdr )pNext;
384
385	if (pIfAddrMsg->ifam_type != RTM_NEWADDR)
386	break;
387	extractAddressesToNetInfo(pIfAddrMsg->ifam_addrs,
388	(char *)(pIfAddrMsg + 1),
389	pIfAddrMsg->ifam_msglen + (char *)pIfAddrMsg,
390	pNew);
391	pNext += pIfAddrMsg->ifam_msglen;
392	}
393
394	if (pSdl->sdl_type == IFT_ETHER)
395	{
396	struct ifreq IfReq;
397	RTStrCopy(IfReq.ifr_name, sizeof(IfReq.ifr_name), pNew->szShortName);
398	if (ioctl(sock, SIOCGIFFLAGS, &IfReq) < 0)
399	{
400	Log(("NetIfList: ioctl(SIOCGIFFLAGS) -> %d\n", errno));
401	pNew->enmStatus = NETIF_S_UNKNOWN;
402	}
403	else
404	pNew->enmStatus = (IfReq.ifr_flags & IFF_UP) ? NETIF_S_UP : NETIF_S_DOWN;
405
406	HostNetworkInterfaceType_T enmType;
407	if (strncmp(pNew->szName, RT_STR_TUPLE("vboxnet")))
408	enmType = HostNetworkInterfaceType_Bridged;
409	else
410	enmType = HostNetworkInterfaceType_HostOnly;
411
412	ComObjPtr<HostNetworkInterface> IfObj;
413	IfObj.createObject();
414	if (SUCCEEDED(IfObj->init(Bstr(pNew->szName), enmType, pNew)))
415	{
416	/* Make sure the default interface gets to the beginning. */
417	if (pIfMsg->ifm_index == u16DefaultIface)
418	list.push_front(IfObj);
419	else
420	list.push_back(IfObj);
421	}
422	}
423	RTMemFree(pNew);
424	}
425	for (pNIC = pEtherNICs; pNIC;)
426	{
427	void *pvFree = pNIC;
428	pNIC = pNIC->pNext;
429	RTMemFree(pvFree);
430	}
431	close(sock);
432	RTMemFree(pBuf);
433	return rc;
434	}
435
436	int NetIfGetConfigByName(PNETIFINFO pInfo)
437	{
438	int rc = VINF_SUCCESS;
439	size_t cbNeeded;
440	char pBuf, pNext;
441	int aiMib[6];
442
443	aiMib[0] = CTL_NET;
444	aiMib[1] = PF_ROUTE;
445	aiMib[2] = 0;
446	aiMib[3] = 0; /* address family */
447	aiMib[4] = NET_RT_IFLIST;
448	aiMib[5] = 0;
449
450	if (sysctl(aiMib, 6, NULL, &cbNeeded, NULL, 0) < 0)
451	{
452	Log(("NetIfList: Failed to get estimate for list size (errno=%d).\n", errno));
453	return RTErrConvertFromErrno(errno);
454	}
455	if ((pBuf = (char*)RTMemAlloc(cbNeeded)) == NULL)
456	return VERR_NO_MEMORY;
457	if (sysctl(aiMib, 6, pBuf, &cbNeeded, NULL, 0) < 0)
458	{
459	RTMemFree(pBuf);
460	Log(("NetIfList: Failed to retrieve interface table (errno=%d).\n", errno));
461	return RTErrConvertFromErrno(errno);
462	}
463
464	int sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
465	if (sock < 0)
466	{
467	RTMemFree(pBuf);
468	Log(("NetIfList: socket() -> %d\n", errno));
469	return RTErrConvertFromErrno(errno);
470	}
471
472	char *pEnd = pBuf + cbNeeded;
473	for (pNext = pBuf; pNext < pEnd;)
474	{
475	struct if_msghdr pIfMsg = (struct if_msghdr )pNext;
476
477	if (pIfMsg->ifm_type != RTM_IFINFO)
478	{
479	Log(("NetIfList: Got message %u while expecting %u.\n",
480	pIfMsg->ifm_type, RTM_IFINFO));
481	rc = VERR_INTERNAL_ERROR;
482	break;
483	}
484	struct sockaddr_dl pSdl = (struct sockaddr_dl )(pIfMsg + 1);
485
486	bool fSkip = !!strncmp(pInfo->szShortName, pSdl->sdl_data, pSdl->sdl_nlen)
487	\|\| pInfo->szShortName[pSdl->sdl_nlen] != '\0';
488
489	pNext += pIfMsg->ifm_msglen;
490	while (pNext < pEnd)
491	{
492	struct ifa_msghdr pIfAddrMsg = (struct ifa_msghdr )pNext;
493
494	if (pIfAddrMsg->ifam_type != RTM_NEWADDR)
495	break;
496	if (!fSkip)
497	extractAddressesToNetInfo(pIfAddrMsg->ifam_addrs,
498	(char *)(pIfAddrMsg + 1),
499	pIfAddrMsg->ifam_msglen + (char *)pIfAddrMsg,
500	pInfo);
501	pNext += pIfAddrMsg->ifam_msglen;
502	}
503
504	if (!fSkip && pSdl->sdl_type == IFT_ETHER)
505	{
506	size_t cbNameLen = pSdl->sdl_nlen + 1;
507	memcpy(pInfo->MACAddress.au8, LLADDR(pSdl), sizeof(pInfo->MACAddress.au8));
508	pInfo->enmMediumType = NETIF_T_ETHERNET;
509	/* Generate UUID from name and MAC address. */
510	RTUUID uuid;
511	RTUuidClear(&uuid);
512	memcpy(&uuid, pInfo->szShortName, RT_MIN(cbNameLen, sizeof(uuid)));
513	uuid.Gen.u8ClockSeqHiAndReserved = (uuid.Gen.u8ClockSeqHiAndReserved & 0x3f) \| 0x80;
514	uuid.Gen.u16TimeHiAndVersion = (uuid.Gen.u16TimeHiAndVersion & 0x0fff) \| 0x4000;
515	memcpy(uuid.Gen.au8Node, pInfo->MACAddress.au8, sizeof(uuid.Gen.au8Node));
516	pInfo->Uuid = uuid;
517
518	struct ifreq IfReq;
519	RTStrCopy(IfReq.ifr_name, sizeof(IfReq.ifr_name), pInfo->szShortName);
520	if (ioctl(sock, SIOCGIFFLAGS, &IfReq) < 0)
521	{
522	Log(("NetIfList: ioctl(SIOCGIFFLAGS) -> %d\n", errno));
523	pInfo->enmStatus = NETIF_S_UNKNOWN;
524	}
525	else
526	pInfo->enmStatus = (IfReq.ifr_flags & IFF_UP) ? NETIF_S_UP : NETIF_S_DOWN;
527
528	return VINF_SUCCESS;
529	}
530	}
531	close(sock);
532	RTMemFree(pBuf);
533	return rc;
534	}
535
536	/**
537	* Retrieve the physical link speed in megabits per second. If the interface is
538	* not up or otherwise unavailable the zero speed is returned.
539	*
540	* @returns VBox status code.
541	*
542	* @param pcszIfName Interface name.
543	* @param puMbits Where to store the link speed.
544	*/
545	int NetIfGetLinkSpeed(const char pcszIfName, uint32_t puMbits)
546	{
547	RT_NOREF(pcszIfName, puMbits);
548	return VERR_NOT_IMPLEMENTED;
549	}
550	#endif

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

source: vbox/trunk/src/VBox/Main/src-server/darwin/NetIf-darwin.cpp@ 76592

Download in other formats: