VirtualBox

source: vbox/trunk/src/VBox/Main/HostNetworkInterfaceImpl.cpp@ 28296

Last change on this file since 28296 was 28296, checked in by vboxsync, 15 years ago

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