VirtualBox

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

Last change on this file since 42699 was 42551, checked in by vboxsync, 12 years ago

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

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