VirtualBox

source: vbox/trunk/src/VBox/Main/src-server/HostNetworkInterfaceImpl.cpp@ 43445

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

Main/Metrics: Host network metrics, linux only (#6345)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 19.2 KB
Line 
1/* $Id: HostNetworkInterfaceImpl.cpp 43445 2012-09-27 08:28:59Z vboxsync $ */
2
3/** @file
4 *
5 * VirtualBox COM class implementation
6 */
7
8/*
9 * Copyright (C) 2006-2012 Oracle Corporation
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.virtualbox.org. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License (GPL) as published by the Free Software
15 * Foundation, in version 2 as it comes in the "COPYING" file of the
16 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18 */
19
20#include "HostNetworkInterfaceImpl.h"
21#include "AutoCaller.h"
22#include "Logging.h"
23#include "netif.h"
24#include "Performance.h"
25#include "PerformanceImpl.h"
26
27#include <iprt/cpp/utils.h>
28
29#ifdef RT_OS_FREEBSD
30# include <netinet/in.h> /* INADDR_NONE */
31#endif /* RT_OS_FREEBSD */
32
33// constructor / destructor
34/////////////////////////////////////////////////////////////////////////////
35
36HostNetworkInterface::HostNetworkInterface()
37 : mVBox(NULL)
38{
39}
40
41HostNetworkInterface::~HostNetworkInterface()
42{
43}
44
45HRESULT HostNetworkInterface::FinalConstruct()
46{
47 return BaseFinalConstruct();
48}
49
50void HostNetworkInterface::FinalRelease()
51{
52 uninit();
53 BaseFinalRelease();
54}
55
56// public initializer/uninitializer for internal purposes only
57/////////////////////////////////////////////////////////////////////////////
58
59/**
60 * Initializes the host object.
61 *
62 * @returns COM result indicator
63 * @param aInterfaceName name of the network interface
64 * @param aGuid GUID of the host network interface
65 */
66HRESULT HostNetworkInterface::init(Bstr aInterfaceName, Bstr aShortName, Guid aGuid, HostNetworkInterfaceType_T ifType)
67{
68 LogFlowThisFunc(("aInterfaceName={%ls}, aGuid={%s}\n",
69 aInterfaceName.raw(), aGuid.toString().c_str()));
70
71 ComAssertRet(!aInterfaceName.isEmpty(), E_INVALIDARG);
72 ComAssertRet(!aGuid.isEmpty(), E_INVALIDARG);
73
74 /* Enclose the state transition NotReady->InInit->Ready */
75 AutoInitSpan autoInitSpan(this);
76 AssertReturn(autoInitSpan.isOk(), E_FAIL);
77
78 unconst(mInterfaceName) = aInterfaceName;
79 unconst(mNetworkName) = composeNetworkName(aShortName);
80 unconst(mGuid) = aGuid;
81 mIfType = ifType;
82
83 /* Confirm a successful initialization */
84 autoInitSpan.setSucceeded();
85
86 return S_OK;
87}
88
89void HostNetworkInterface::registerMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr)
90{
91 LogFlowThisFunc(("mInterfaceName={%ls}, mGuid={%s}\n",
92 mInterfaceName.raw(), mGuid.toString().c_str()));
93 pm::CollectorHAL *hal = aCollector->getHAL();
94 /* Create sub metrics */
95 Utf8StrFmt strName("Net/%ls/Load", mInterfaceName.raw());
96 pm::SubMetric *networkLoadRx = new pm::SubMetric(strName + "/Rx",
97 "Percentage of network interface bandwidth used.");
98 pm::SubMetric *networkLoadTx = new pm::SubMetric(strName + "/Tx",
99 "Percentage of network interface bandwidth used.");
100
101 /* Create and register base metrics */
102 pm::BaseMetric *networkLoad = new pm::HostNetworkLoadRaw(hal, objptr, strName, Utf8Str(mInterfaceName), networkLoadRx, networkLoadTx);
103 aCollector->registerBaseMetric(networkLoad);
104
105 aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx, 0));
106 aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
107 new pm::AggregateAvg()));
108 aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
109 new pm::AggregateMin()));
110 aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
111 new pm::AggregateMax()));
112
113 aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx, 0));
114 aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
115 new pm::AggregateAvg()));
116 aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
117 new pm::AggregateMin()));
118 aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
119 new pm::AggregateMax()));
120}
121
122void HostNetworkInterface::unregisterMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr)
123{
124 LogFlowThisFunc(("mInterfaceName={%ls}, mGuid={%s}\n",
125 mInterfaceName.raw(), mGuid.toString().c_str()));
126 aCollector->unregisterMetricsFor(objptr);
127 aCollector->unregisterBaseMetricsFor(objptr);
128}
129
130#ifdef VBOX_WITH_HOSTNETIF_API
131
132HRESULT HostNetworkInterface::updateConfig()
133{
134 NETIFINFO info;
135 int rc = NetIfGetConfig(this, &info);
136 if (RT_SUCCESS(rc))
137 {
138 m.realIPAddress = m.IPAddress = info.IPAddress.u;
139 m.realNetworkMask = m.networkMask = info.IPNetMask.u;
140 m.dhcpEnabled = info.bDhcpEnabled;
141 m.realIPV6Address = m.IPV6Address = composeIPv6Address(&info.IPv6Address);
142 m.realIPV6PrefixLength = m.IPV6NetworkMaskPrefixLength = composeIPv6PrefixLenghFromAddress(&info.IPv6NetMask);
143 m.hardwareAddress = composeHardwareAddress(&info.MACAddress);
144#ifdef RT_OS_WINDOWS
145 m.mediumType = (HostNetworkInterfaceMediumType)info.enmMediumType;
146 m.status = (HostNetworkInterfaceStatus)info.enmStatus;
147#else /* !RT_OS_WINDOWS */
148 m.mediumType = info.enmMediumType;
149 m.status = info.enmStatus;
150
151#endif /* !RT_OS_WINDOWS */
152 return S_OK;
153 }
154 return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
155}
156
157Bstr HostNetworkInterface::composeNetworkName(const Utf8Str aShortName)
158{
159 return Utf8Str("HostInterfaceNetworking-").append(aShortName);
160}
161/**
162 * Initializes the host object.
163 *
164 * @returns COM result indicator
165 * @param aInterfaceName name of the network interface
166 * @param aGuid GUID of the host network interface
167 */
168HRESULT HostNetworkInterface::init(Bstr aInterfaceName, HostNetworkInterfaceType_T ifType, PNETIFINFO pIf)
169{
170// LogFlowThisFunc(("aInterfaceName={%ls}, aGuid={%s}\n",
171// aInterfaceName.raw(), aGuid.toString().raw()));
172
173// ComAssertRet(aInterfaceName, E_INVALIDARG);
174// ComAssertRet(!aGuid.isEmpty(), E_INVALIDARG);
175 ComAssertRet(pIf, E_INVALIDARG);
176
177 /* Enclose the state transition NotReady->InInit->Ready */
178 AutoInitSpan autoInitSpan(this);
179 AssertReturn(autoInitSpan.isOk(), E_FAIL);
180
181 unconst(mInterfaceName) = aInterfaceName;
182 unconst(mGuid) = pIf->Uuid;
183 if (pIf->szShortName[0])
184 unconst(mNetworkName) = composeNetworkName(pIf->szShortName);
185 else
186 unconst(mNetworkName) = composeNetworkName(aInterfaceName);
187 mIfType = ifType;
188
189 m.realIPAddress = m.IPAddress = pIf->IPAddress.u;
190 m.realNetworkMask = m.networkMask = pIf->IPNetMask.u;
191 m.realIPV6Address = m.IPV6Address = composeIPv6Address(&pIf->IPv6Address);
192 m.realIPV6PrefixLength = m.IPV6NetworkMaskPrefixLength = composeIPv6PrefixLenghFromAddress(&pIf->IPv6NetMask);
193 m.dhcpEnabled = pIf->bDhcpEnabled;
194 m.hardwareAddress = composeHardwareAddress(&pIf->MACAddress);
195#ifdef RT_OS_WINDOWS
196 m.mediumType = (HostNetworkInterfaceMediumType)pIf->enmMediumType;
197 m.status = (HostNetworkInterfaceStatus)pIf->enmStatus;
198#else /* !RT_OS_WINDOWS */
199 m.mediumType = pIf->enmMediumType;
200 m.status = pIf->enmStatus;
201#endif /* !RT_OS_WINDOWS */
202
203 /* Confirm a successful initialization */
204 autoInitSpan.setSucceeded();
205
206 return S_OK;
207}
208#endif
209
210// IHostNetworkInterface properties
211/////////////////////////////////////////////////////////////////////////////
212
213/**
214 * Returns the name of the host network interface.
215 *
216 * @returns COM status code
217 * @param aInterfaceName address of result pointer
218 */
219STDMETHODIMP HostNetworkInterface::COMGETTER(Name)(BSTR *aInterfaceName)
220{
221 CheckComArgOutPointerValid(aInterfaceName);
222
223 AutoCaller autoCaller(this);
224 if (FAILED(autoCaller.rc())) return autoCaller.rc();
225
226 mInterfaceName.cloneTo(aInterfaceName);
227
228 return S_OK;
229}
230
231/**
232 * Returns the GUID of the host network interface.
233 *
234 * @returns COM status code
235 * @param aGuid address of result pointer
236 */
237STDMETHODIMP HostNetworkInterface::COMGETTER(Id)(BSTR *aGuid)
238{
239 CheckComArgOutPointerValid(aGuid);
240
241 AutoCaller autoCaller(this);
242 if (FAILED(autoCaller.rc())) return autoCaller.rc();
243
244 mGuid.toUtf16().cloneTo(aGuid);
245
246 return S_OK;
247}
248
249STDMETHODIMP HostNetworkInterface::COMGETTER(DHCPEnabled)(BOOL *aDHCPEnabled)
250{
251 CheckComArgOutPointerValid(aDHCPEnabled);
252
253 AutoCaller autoCaller(this);
254 if (FAILED(autoCaller.rc())) return autoCaller.rc();
255
256 *aDHCPEnabled = m.dhcpEnabled;
257
258 return S_OK;
259}
260
261
262/**
263 * Returns the IP address of the host network interface.
264 *
265 * @returns COM status code
266 * @param aIPAddress address of result pointer
267 */
268STDMETHODIMP HostNetworkInterface::COMGETTER(IPAddress)(BSTR *aIPAddress)
269{
270 CheckComArgOutPointerValid(aIPAddress);
271
272 AutoCaller autoCaller(this);
273 if (FAILED(autoCaller.rc())) return autoCaller.rc();
274
275 in_addr tmp;
276#if defined(RT_OS_WINDOWS)
277 tmp.S_un.S_addr = m.IPAddress;
278#else
279 tmp.s_addr = m.IPAddress;
280#endif
281 char *addr = inet_ntoa(tmp);
282 if (addr)
283 {
284 Bstr(addr).detachTo(aIPAddress);
285 return S_OK;
286 }
287
288 return E_FAIL;
289}
290
291/**
292 * Returns the netwok mask of the host network interface.
293 *
294 * @returns COM status code
295 * @param aNetworkMask address of result pointer
296 */
297STDMETHODIMP HostNetworkInterface::COMGETTER(NetworkMask)(BSTR *aNetworkMask)
298{
299 CheckComArgOutPointerValid(aNetworkMask);
300
301 AutoCaller autoCaller(this);
302 if (FAILED(autoCaller.rc())) return autoCaller.rc();
303
304 in_addr tmp;
305#if defined(RT_OS_WINDOWS)
306 tmp.S_un.S_addr = m.networkMask;
307#else
308 tmp.s_addr = m.networkMask;
309#endif
310 char *addr = inet_ntoa(tmp);
311 if (addr)
312 {
313 Bstr(addr).detachTo(aNetworkMask);
314 return S_OK;
315 }
316
317 return E_FAIL;
318}
319
320STDMETHODIMP HostNetworkInterface::COMGETTER(IPV6Supported)(BOOL *aIPV6Supported)
321{
322 CheckComArgOutPointerValid(aIPV6Supported);
323#if defined(RT_OS_WINDOWS)
324 *aIPV6Supported = FALSE;
325#else
326 *aIPV6Supported = TRUE;
327#endif
328
329 return S_OK;
330}
331
332/**
333 * Returns the IP V6 address of the host network interface.
334 *
335 * @returns COM status code
336 * @param aIPV6Address address of result pointer
337 */
338STDMETHODIMP HostNetworkInterface::COMGETTER(IPV6Address)(BSTR *aIPV6Address)
339{
340 CheckComArgOutPointerValid(aIPV6Address);
341
342 AutoCaller autoCaller(this);
343 if (FAILED(autoCaller.rc())) return autoCaller.rc();
344
345 m.IPV6Address.cloneTo(aIPV6Address);
346
347 return S_OK;
348}
349
350/**
351 * Returns the IP V6 network mask of the host network interface.
352 *
353 * @returns COM status code
354 * @param aIPV6Mask address of result pointer
355 */
356STDMETHODIMP HostNetworkInterface::COMGETTER(IPV6NetworkMaskPrefixLength)(ULONG *aIPV6NetworkMaskPrefixLength)
357{
358 CheckComArgOutPointerValid(aIPV6NetworkMaskPrefixLength);
359
360 AutoCaller autoCaller(this);
361 if (FAILED(autoCaller.rc())) return autoCaller.rc();
362
363 *aIPV6NetworkMaskPrefixLength = m.IPV6NetworkMaskPrefixLength;
364
365 return S_OK;
366}
367
368/**
369 * Returns the hardware address of the host network interface.
370 *
371 * @returns COM status code
372 * @param aHardwareAddress address of result pointer
373 */
374STDMETHODIMP HostNetworkInterface::COMGETTER(HardwareAddress)(BSTR *aHardwareAddress)
375{
376 CheckComArgOutPointerValid(aHardwareAddress);
377
378 AutoCaller autoCaller(this);
379 if (FAILED(autoCaller.rc())) return autoCaller.rc();
380
381 m.hardwareAddress.cloneTo(aHardwareAddress);
382
383 return S_OK;
384}
385
386/**
387 * Returns the encapsulation protocol type of the host network interface.
388 *
389 * @returns COM status code
390 * @param aType address of result pointer
391 */
392STDMETHODIMP HostNetworkInterface::COMGETTER(MediumType)(HostNetworkInterfaceMediumType_T *aType)
393{
394 CheckComArgOutPointerValid(aType);
395
396 AutoCaller autoCaller(this);
397 if (FAILED(autoCaller.rc())) return autoCaller.rc();
398
399 *aType = m.mediumType;
400
401 return S_OK;
402}
403
404/**
405 * Returns the current state of the host network interface.
406 *
407 * @returns COM status code
408 * @param aStatus address of result pointer
409 */
410STDMETHODIMP HostNetworkInterface::COMGETTER(Status)(HostNetworkInterfaceStatus_T *aStatus)
411{
412 CheckComArgOutPointerValid(aStatus);
413
414 AutoCaller autoCaller(this);
415 if (FAILED(autoCaller.rc())) return autoCaller.rc();
416
417 *aStatus = m.status;
418
419 return S_OK;
420}
421
422/**
423 * Returns network interface type
424 *
425 * @returns COM status code
426 * @param aType address of result pointer
427 */
428STDMETHODIMP HostNetworkInterface::COMGETTER(InterfaceType)(HostNetworkInterfaceType_T *aType)
429{
430 CheckComArgOutPointerValid(aType);
431
432 AutoCaller autoCaller(this);
433 if (FAILED(autoCaller.rc())) return autoCaller.rc();
434
435 *aType = mIfType;
436
437 return S_OK;
438
439}
440
441STDMETHODIMP HostNetworkInterface::COMGETTER(NetworkName)(BSTR *aNetworkName)
442{
443 CheckComArgOutPointerValid(aNetworkName);
444
445 AutoCaller autoCaller(this);
446 if (FAILED(autoCaller.rc())) return autoCaller.rc();
447
448 mNetworkName.cloneTo(aNetworkName);
449
450 return S_OK;
451}
452
453STDMETHODIMP HostNetworkInterface::EnableStaticIPConfig(IN_BSTR aIPAddress, IN_BSTR aNetMask)
454{
455#ifndef VBOX_WITH_HOSTNETIF_API
456 return E_NOTIMPL;
457#else
458 AutoCaller autoCaller(this);
459 if (FAILED(autoCaller.rc())) return autoCaller.rc();
460
461 if (Bstr(aIPAddress).isEmpty())
462 {
463 if (m.IPAddress)
464 {
465 int rc = NetIfEnableStaticIpConfig(mVBox, this, m.IPAddress, 0, 0);
466 if (RT_SUCCESS(rc))
467 {
468 m.realIPAddress = 0;
469 if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress", mInterfaceName.raw()).raw(), NULL)))
470 return E_FAIL;
471 if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", mInterfaceName.raw()).raw(), NULL)))
472 return E_FAIL;
473 return S_OK;
474 }
475 }
476 else
477 return S_OK;
478 }
479
480 ULONG ip, mask;
481 ip = inet_addr(Utf8Str(aIPAddress).c_str());
482 if (ip != INADDR_NONE)
483 {
484 if (Bstr(aNetMask).isEmpty())
485 mask = 0xFFFFFF;
486 else
487 mask = inet_addr(Utf8Str(aNetMask).c_str());
488 if (mask != INADDR_NONE)
489 {
490 if (m.realIPAddress == ip && m.realNetworkMask == mask)
491 return S_OK;
492 int rc = NetIfEnableStaticIpConfig(mVBox, this, m.IPAddress, ip, mask);
493 if (RT_SUCCESS(rc))
494 {
495 m.realIPAddress = ip;
496 m.realNetworkMask = mask;
497 if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress", mInterfaceName.raw()).raw(),
498 Bstr(aIPAddress).raw())))
499 return E_FAIL;
500 if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", mInterfaceName.raw()).raw(),
501 Bstr(aNetMask).raw())))
502 return E_FAIL;
503 return S_OK;
504 }
505 else
506 {
507 LogRel(("Failed to EnableStaticIpConfig with rc=%Rrc\n", rc));
508 return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
509 }
510
511 }
512 }
513 return E_FAIL;
514#endif
515}
516
517STDMETHODIMP HostNetworkInterface::EnableStaticIPConfigV6(IN_BSTR aIPV6Address, ULONG aIPV6MaskPrefixLength)
518{
519#ifndef VBOX_WITH_HOSTNETIF_API
520 return E_NOTIMPL;
521#else
522 if (!aIPV6Address)
523 return E_INVALIDARG;
524 if (aIPV6MaskPrefixLength > 128)
525 return E_INVALIDARG;
526
527 AutoCaller autoCaller(this);
528 if (FAILED(autoCaller.rc())) return autoCaller.rc();
529
530 int rc = S_OK;
531 if (m.realIPV6Address != aIPV6Address || m.realIPV6PrefixLength != aIPV6MaskPrefixLength)
532 {
533 if (aIPV6MaskPrefixLength == 0)
534 aIPV6MaskPrefixLength = 64;
535 rc = NetIfEnableStaticIpConfigV6(mVBox, this, m.IPV6Address.raw(), aIPV6Address, aIPV6MaskPrefixLength);
536 if (RT_FAILURE(rc))
537 {
538 LogRel(("Failed to EnableStaticIpConfigV6 with rc=%Rrc\n", rc));
539 return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
540 }
541 else
542 {
543 m.realIPV6Address = aIPV6Address;
544 m.realIPV6PrefixLength = aIPV6MaskPrefixLength;
545 if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPV6Address", mInterfaceName.raw()).raw(),
546 Bstr(aIPV6Address).raw())))
547 return E_FAIL;
548 if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPV6NetMask", mInterfaceName.raw()).raw(),
549 BstrFmt("%u", aIPV6MaskPrefixLength).raw())))
550 return E_FAIL;
551 }
552
553 }
554 return S_OK;
555#endif
556}
557
558STDMETHODIMP HostNetworkInterface::EnableDynamicIPConfig()
559{
560#ifndef VBOX_WITH_HOSTNETIF_API
561 return E_NOTIMPL;
562#else
563 AutoCaller autoCaller(this);
564 if (FAILED(autoCaller.rc())) return autoCaller.rc();
565
566 int rc = NetIfEnableDynamicIpConfig(mVBox, this);
567 if (RT_FAILURE(rc))
568 {
569 LogRel(("Failed to EnableDynamicIpConfig with rc=%Rrc\n", rc));
570 return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
571 }
572 return S_OK;
573#endif
574}
575
576STDMETHODIMP HostNetworkInterface::DHCPRediscover()
577{
578#ifndef VBOX_WITH_HOSTNETIF_API
579 return E_NOTIMPL;
580#else
581 AutoCaller autoCaller(this);
582 if (FAILED(autoCaller.rc())) return autoCaller.rc();
583
584 int rc = NetIfDhcpRediscover(mVBox, this);
585 if (RT_FAILURE(rc))
586 {
587 LogRel(("Failed to DhcpRediscover with rc=%Rrc\n", rc));
588 return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
589 }
590 return S_OK;
591#endif
592}
593
594HRESULT HostNetworkInterface::setVirtualBox(VirtualBox *pVBox)
595{
596 AutoCaller autoCaller(this);
597 if (FAILED(autoCaller.rc())) return autoCaller.rc();
598 AssertReturn(mVBox != pVBox, S_OK);
599
600 unconst(mVBox) = pVBox;
601
602#if !defined(RT_OS_WINDOWS)
603 /* If IPv4 address hasn't been initialized */
604 if (m.IPAddress == 0 && mIfType == HostNetworkInterfaceType_HostOnly)
605 {
606 Bstr tmpAddr, tmpMask;
607 HRESULT hrc = mVBox->GetExtraData(BstrFmt("HostOnly/%ls/IPAddress", mInterfaceName.raw()).raw(),
608 tmpAddr.asOutParam());
609 if (FAILED(hrc) || tmpAddr.isEmpty())
610 tmpAddr = getDefaultIPv4Address(mInterfaceName);
611
612 hrc = mVBox->GetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", mInterfaceName.raw()).raw(),
613 tmpMask.asOutParam());
614 if (FAILED(hrc) || tmpMask.isEmpty())
615 tmpMask = Bstr(VBOXNET_IPV4MASK_DEFAULT);
616
617 m.IPAddress = inet_addr(Utf8Str(tmpAddr).c_str());
618 m.networkMask = inet_addr(Utf8Str(tmpMask).c_str());
619 }
620
621 if (m.IPV6Address.isEmpty())
622 {
623 Bstr tmpPrefixLen;
624 HRESULT hrc = mVBox->GetExtraData(BstrFmt("HostOnly/%ls/IPV6Address", mInterfaceName.raw()).raw(),
625 m.IPV6Address.asOutParam());
626 if (SUCCEEDED(hrc) && !m.IPV6Address.isEmpty())
627 {
628 hrc = mVBox->GetExtraData(BstrFmt("HostOnly/%ls/IPV6PrefixLen", mInterfaceName.raw()).raw(),
629 tmpPrefixLen.asOutParam());
630 if (SUCCEEDED(hrc) && !tmpPrefixLen.isEmpty())
631 m.IPV6NetworkMaskPrefixLength = Utf8Str(tmpPrefixLen).toUInt32();
632 else
633 m.IPV6NetworkMaskPrefixLength = 64;
634 }
635 }
636#endif
637
638 return S_OK;
639}
640
641/* vi: set tabstop=4 shiftwidth=4 expandtab: */
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