NetIf-darwin.cpp@ 105016

Last change on this file since 105016 was 103147, checked in by vboxsync, 10 months ago
Main: Some warning fixes about externally visible functions which should be static, bugref:3409
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 19.2 KB

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

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

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

Download in other formats: