VirtualBox

source: vbox/trunk/src/VBox/Main/ConsoleImpl2.cpp@ 18754

Last change on this file since 18754 was 18710, checked in by vboxsync, 16 years ago

Updated dirty hack to use slot 0x11 instead of 11.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 123.7 KB
Line 
1/* $Id: ConsoleImpl2.cpp 18710 2009-04-03 18:38:34Z vboxsync $ */
2/** @file
3 * VBox Console COM Class implementation
4 *
5 * @remark We've split out the code that the 64-bit VC++ v8 compiler
6 * finds problematic to optimize so we can disable optimizations
7 * and later, perhaps, find a real solution for it.
8 */
9
10/*
11 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
12 *
13 * This file is part of VirtualBox Open Source Edition (OSE), as
14 * available from http://www.virtualbox.org. This file is free software;
15 * you can redistribute it and/or modify it under the terms of the GNU
16 * General Public License (GPL) as published by the Free Software
17 * Foundation, in version 2 as it comes in the "COPYING" file of the
18 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20 *
21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
22 * Clara, CA 95054 USA or visit http://www.sun.com if you need
23 * additional information or have any questions.
24 */
25
26/*******************************************************************************
27* Header Files *
28*******************************************************************************/
29#include "ConsoleImpl.h"
30#include "DisplayImpl.h"
31#include "VMMDev.h"
32
33// generated header
34#include "SchemaDefs.h"
35
36#include "Logging.h"
37
38#include <iprt/string.h>
39#include <iprt/path.h>
40#include <iprt/dir.h>
41#include <iprt/param.h>
42#if 0 /* enable to play with lots of memory. */
43# include <iprt/env.h>
44# include <iprt/string.h>
45#endif
46
47#include <VBox/vmapi.h>
48#include <VBox/err.h>
49#include <VBox/version.h>
50#include <VBox/HostServices/VBoxClipboardSvc.h>
51#ifdef VBOX_WITH_CROGL
52#include <VBox/HostServices/VBoxCrOpenGLSvc.h>
53#endif
54#ifdef VBOX_WITH_GUEST_PROPS
55# include <VBox/HostServices/GuestPropertySvc.h>
56# include <VBox/com/defs.h>
57# include <VBox/com/array.h>
58# include <hgcm/HGCM.h> /** @todo it should be possible to register a service
59 * extension using a VMMDev callback. */
60# include <vector>
61#endif /* VBOX_WITH_GUEST_PROPS */
62#include <VBox/intnet.h>
63
64#include <VBox/com/string.h>
65#include <VBox/com/array.h>
66
67#if defined(RT_OS_SOLARIS) && defined(VBOX_WITH_NETFLT)
68# include <zone.h>
69#endif
70
71#if defined(RT_OS_LINUX) && defined(VBOX_WITH_NETFLT)
72# include <unistd.h>
73# include <sys/ioctl.h>
74# include <sys/socket.h>
75# include <linux/types.h>
76# include <linux/if.h>
77# include <linux/wireless.h>
78#endif
79
80#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT)
81# include <VBox/WinNetConfig.h>
82# include <Ntddndis.h>
83# include <devguid.h>
84#endif
85
86#if !defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT)
87# include <HostNetworkInterfaceImpl.h>
88# include <netif.h>
89#endif
90
91#include "DHCPServerRunner.h"
92
93#include <VBox/param.h>
94
95/* Comment out the following line to remove VMWare compatibility hack. */
96#define VMWARE_NET_IN_SLOT_11
97
98/**
99 * Translate IDE StorageControllerType_T to string representation.
100 */
101const char* controllerString(StorageControllerType_T enmType)
102{
103 switch (enmType)
104 {
105 case StorageControllerType_PIIX3:
106 return "PIIX3";
107 case StorageControllerType_PIIX4:
108 return "PIIX4";
109 case StorageControllerType_ICH6:
110 return "ICH6";
111 default:
112 return "Unknown";
113 }
114}
115
116/*
117 * VC++ 8 / amd64 has some serious trouble with this function.
118 * As a temporary measure, we'll drop global optimizations.
119 */
120#if defined(_MSC_VER) && defined(RT_ARCH_AMD64)
121# pragma optimize("g", off)
122#endif
123
124/**
125 * Construct the VM configuration tree (CFGM).
126 *
127 * This is a callback for VMR3Create() call. It is called from CFGMR3Init()
128 * in the emulation thread (EMT). Any per thread COM/XPCOM initialization
129 * is done here.
130 *
131 * @param pVM VM handle.
132 * @param pvConsole Pointer to the VMPowerUpTask object.
133 * @return VBox status code.
134 *
135 * @note Locks the Console object for writing.
136 */
137DECLCALLBACK(int) Console::configConstructor(PVM pVM, void *pvConsole)
138{
139 LogFlowFuncEnter();
140 /* Note: hardcoded assumption about number of slots; see rom bios */
141 bool afPciDeviceNo[32] = {false};
142
143#if !defined (VBOX_WITH_XPCOM)
144 {
145 /* initialize COM */
146 HRESULT hrc = CoInitializeEx(NULL,
147 COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE |
148 COINIT_SPEED_OVER_MEMORY);
149 LogFlow (("Console::configConstructor(): CoInitializeEx()=%08X\n", hrc));
150 AssertComRCReturn (hrc, VERR_GENERAL_FAILURE);
151 }
152#endif
153
154 AssertReturn (pvConsole, VERR_GENERAL_FAILURE);
155 ComObjPtr <Console> pConsole = static_cast <Console *> (pvConsole);
156
157 AutoCaller autoCaller (pConsole);
158 AssertComRCReturn (autoCaller.rc(), VERR_ACCESS_DENIED);
159
160 /* lock the console because we widely use internal fields and methods */
161 AutoWriteLock alock (pConsole);
162
163 ComPtr <IMachine> pMachine = pConsole->machine();
164
165 int rc;
166 HRESULT hrc;
167 char *psz = NULL;
168 BSTR str = NULL;
169
170 Bstr bstr; /* use this bstr when calling COM methods instead
171 of str as it manages memory! */
172
173#define STR_CONV() do { rc = RTUtf16ToUtf8(str, &psz); RC_CHECK(); } while (0)
174#define STR_FREE() do { if (str) { SysFreeString(str); str = NULL; } if (psz) { RTStrFree(psz); psz = NULL; } } while (0)
175#define RC_CHECK() do { if (RT_FAILURE(rc)) { AssertMsgFailed(("rc=%Rrc\n", rc)); STR_FREE(); return rc; } } while (0)
176#define H() do { if (FAILED(hrc)) { AssertMsgFailed(("hrc=%#x\n", hrc)); STR_FREE(); return VERR_GENERAL_FAILURE; } } while (0)
177
178 /*
179 * Get necessary objects and frequently used parameters.
180 */
181 ComPtr<IVirtualBox> virtualBox;
182 hrc = pMachine->COMGETTER(Parent)(virtualBox.asOutParam()); H();
183
184 ComPtr<IHost> host;
185 hrc = virtualBox->COMGETTER(Host)(host.asOutParam()); H();
186
187 ComPtr <ISystemProperties> systemProperties;
188 hrc = virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam()); H();
189
190 ComPtr<IBIOSSettings> biosSettings;
191 hrc = pMachine->COMGETTER(BIOSSettings)(biosSettings.asOutParam()); H();
192
193 Guid uuid;
194 hrc = pMachine->COMGETTER(Id)(uuid.asOutParam()); H();
195 PCRTUUID pUuid = uuid.raw();
196
197 ULONG cRamMBs;
198 hrc = pMachine->COMGETTER(MemorySize)(&cRamMBs); H();
199#if 0 /* enable to play with lots of memory. */
200 if (RTEnvExist("VBOX_RAM_SIZE"))
201 cRamMBs = RTStrToUInt64(RTEnvGet("VBOX_RAM_SIZE")) * 1024;
202#endif
203 uint64_t const cbRam = cRamMBs * (uint64_t)_1M;
204 uint32_t const cbRamHole = MM_RAM_HOLE_SIZE_DEFAULT;
205
206 ULONG cCpus = 1;
207#ifdef VBOX_WITH_SMP_GUESTS
208 hrc = pMachine->COMGETTER(CPUCount)(&cCpus); H();
209#endif
210
211 /*
212 * Get root node first.
213 * This is the only node in the tree.
214 */
215 PCFGMNODE pRoot = CFGMR3GetRoot(pVM);
216 Assert(pRoot);
217
218 /*
219 * Set the root (and VMM) level values.
220 */
221 hrc = pMachine->COMGETTER(Name)(&str); H();
222 STR_CONV();
223 rc = CFGMR3InsertString(pRoot, "Name", psz); RC_CHECK();
224 STR_FREE();
225 rc = CFGMR3InsertBytes(pRoot, "UUID", pUuid, sizeof(*pUuid)); RC_CHECK();
226 rc = CFGMR3InsertInteger(pRoot, "RamSize", cbRam); RC_CHECK();
227 rc = CFGMR3InsertInteger(pRoot, "RamHoleSize", cbRamHole); RC_CHECK();
228 rc = CFGMR3InsertInteger(pRoot, "NumCPUs", cCpus); RC_CHECK();
229 rc = CFGMR3InsertInteger(pRoot, "TimerMillies", 10); RC_CHECK();
230 rc = CFGMR3InsertInteger(pRoot, "RawR3Enabled", 1); /* boolean */ RC_CHECK();
231 rc = CFGMR3InsertInteger(pRoot, "RawR0Enabled", 1); /* boolean */ RC_CHECK();
232 /** @todo Config: RawR0, PATMEnabled and CASMEnabled needs attention later. */
233 rc = CFGMR3InsertInteger(pRoot, "PATMEnabled", 1); /* boolean */ RC_CHECK();
234 rc = CFGMR3InsertInteger(pRoot, "CSAMEnabled", 1); /* boolean */ RC_CHECK();
235
236 /* hardware virtualization extensions */
237 TSBool_T hwVirtExEnabled;
238 BOOL fHWVirtExEnabled;
239 hrc = pMachine->COMGETTER(HWVirtExEnabled)(&hwVirtExEnabled); H();
240 if (hwVirtExEnabled == TSBool_Default)
241 {
242 /* check the default value */
243 hrc = systemProperties->COMGETTER(HWVirtExEnabled)(&fHWVirtExEnabled); H();
244 }
245 else
246 fHWVirtExEnabled = (hwVirtExEnabled == TSBool_True);
247#ifdef RT_OS_DARWIN
248 rc = CFGMR3InsertInteger(pRoot, "HwVirtExtForced", fHWVirtExEnabled); RC_CHECK();
249#else
250 /* With more than 4GB PGM will use different RAMRANGE sizes for raw mode and hv mode to optimize lookup times. */
251 rc = CFGMR3InsertInteger(pRoot, "HwVirtExtForced", fHWVirtExEnabled && cbRam > (_4G - cbRamHole)); RC_CHECK();
252#endif
253
254 PCFGMNODE pHWVirtExt;
255 rc = CFGMR3InsertNode(pRoot, "HWVirtExt", &pHWVirtExt); RC_CHECK();
256 if (fHWVirtExEnabled)
257 {
258 rc = CFGMR3InsertInteger(pHWVirtExt, "Enabled", 1); RC_CHECK();
259
260 /* Indicate whether 64-bit guests are supported or not. */
261 /** @todo This is currently only forced off on 32-bit hosts only because it
262 * makes a lof of difference there (REM and Solaris performance).
263 */
264
265 Bstr osTypeId;
266 hrc = pMachine->COMGETTER(OSTypeId)(osTypeId.asOutParam()); H();
267
268 ComPtr <IGuestOSType> guestOSType;
269 hrc = virtualBox->GetGuestOSType(osTypeId, guestOSType.asOutParam()); H();
270
271 BOOL fSupportsLongMode = false;
272 hrc = host->GetProcessorFeature(ProcessorFeature_LongMode,
273 &fSupportsLongMode); H();
274 BOOL fIs64BitGuest = false;
275 hrc = guestOSType->COMGETTER(Is64Bit)(&fIs64BitGuest); H();
276
277 if (fSupportsLongMode && fIs64BitGuest)
278 {
279 rc = CFGMR3InsertInteger(pHWVirtExt, "64bitEnabled", 1); RC_CHECK();
280#if ARCH_BITS == 32 /* The recompiler must use load VBoxREM64 (32-bit host only). */
281 PCFGMNODE pREM;
282 rc = CFGMR3InsertNode(pRoot, "REM", &pREM); RC_CHECK();
283 rc = CFGMR3InsertInteger(pREM, "64bitEnabled", 1); RC_CHECK();
284#endif
285 }
286#if ARCH_BITS == 32 /* 32-bit guests only. */
287 else
288 {
289 rc = CFGMR3InsertInteger(pHWVirtExt, "64bitEnabled", 0); RC_CHECK();
290 }
291#endif
292 }
293
294 /* Nested paging (VT-x/AMD-V) */
295 BOOL fEnableNestedPaging = false;
296 hrc = pMachine->COMGETTER(HWVirtExNestedPagingEnabled)(&fEnableNestedPaging); H();
297 rc = CFGMR3InsertInteger(pRoot, "EnableNestedPaging", fEnableNestedPaging); RC_CHECK();
298
299 /* VPID (VT-x) */
300 BOOL fEnableVPID = false;
301 hrc = pMachine->COMGETTER(HWVirtExVPIDEnabled)(&fEnableVPID); H();
302 rc = CFGMR3InsertInteger(pRoot, "EnableVPID", fEnableVPID); RC_CHECK();
303
304 /* Physical Address Extension (PAE) */
305 BOOL fEnablePAE = false;
306 hrc = pMachine->COMGETTER(PAEEnabled)(&fEnablePAE); H();
307 rc = CFGMR3InsertInteger(pRoot, "EnablePAE", fEnablePAE); RC_CHECK();
308
309 BOOL fIOAPIC;
310 hrc = biosSettings->COMGETTER(IOAPICEnabled)(&fIOAPIC); H();
311
312 BOOL fPXEDebug;
313 hrc = biosSettings->COMGETTER(PXEDebugEnabled)(&fPXEDebug); H();
314
315 /*
316 * PDM config.
317 * Load drivers in VBoxC.[so|dll]
318 */
319 PCFGMNODE pPDM;
320 PCFGMNODE pDrivers;
321 PCFGMNODE pMod;
322 rc = CFGMR3InsertNode(pRoot, "PDM", &pPDM); RC_CHECK();
323 rc = CFGMR3InsertNode(pPDM, "Drivers", &pDrivers); RC_CHECK();
324 rc = CFGMR3InsertNode(pDrivers, "VBoxC", &pMod); RC_CHECK();
325#ifdef VBOX_WITH_XPCOM
326 // VBoxC is located in the components subdirectory
327 char szPathVBoxC[RTPATH_MAX];
328 rc = RTPathAppPrivateArch(szPathVBoxC, RTPATH_MAX - sizeof("/components/VBoxC")); AssertRC(rc);
329 strcat(szPathVBoxC, "/components/VBoxC");
330 rc = CFGMR3InsertString(pMod, "Path", szPathVBoxC); RC_CHECK();
331#else
332 rc = CFGMR3InsertString(pMod, "Path", "VBoxC"); RC_CHECK();
333#endif
334
335 /*
336 * Devices
337 */
338 PCFGMNODE pDevices = NULL; /* /Devices */
339 PCFGMNODE pDev = NULL; /* /Devices/Dev/ */
340 PCFGMNODE pInst = NULL; /* /Devices/Dev/0/ */
341 PCFGMNODE pCfg = NULL; /* /Devices/Dev/.../Config/ */
342 PCFGMNODE pLunL0 = NULL; /* /Devices/Dev/0/LUN#0/ */
343 PCFGMNODE pLunL1 = NULL; /* /Devices/Dev/0/LUN#0/AttachedDriver/ */
344 PCFGMNODE pLunL2 = NULL; /* /Devices/Dev/0/LUN#0/AttachedDriver/Config/ */
345 PCFGMNODE pIdeInst = NULL; /* /Devices/piix3ide/0/ */
346 PCFGMNODE pSataInst = NULL; /* /Devices/ahci/0/ */
347 PCFGMNODE pBiosCfg = NULL; /* /Devices/pcbios/0/Config/ */
348
349 rc = CFGMR3InsertNode(pRoot, "Devices", &pDevices); RC_CHECK();
350
351 /*
352 * PC Arch.
353 */
354 rc = CFGMR3InsertNode(pDevices, "pcarch", &pDev); RC_CHECK();
355 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
356 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
357 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
358
359 BOOL fEfiEnabled;
360 /** @todo: implement appropriate getter */
361#ifdef VBOX_WITH_EFI
362 fEfiEnabled = true;
363#else
364 fEfiEnabled = false;
365#endif
366
367 if (fEfiEnabled)
368 {
369 rc = CFGMR3InsertNode(pDevices, "efi", &pDev); RC_CHECK();
370 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
371 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
372 }
373
374 /*
375 * PC Bios.
376 */
377 if (!fEfiEnabled)
378 {
379 rc = CFGMR3InsertNode(pDevices, "pcbios", &pDev); RC_CHECK();
380 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
381 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
382 rc = CFGMR3InsertNode(pInst, "Config", &pBiosCfg); RC_CHECK();
383 rc = CFGMR3InsertInteger(pBiosCfg, "RamSize", cbRam); RC_CHECK();
384 rc = CFGMR3InsertInteger(pBiosCfg, "RamHoleSize", cbRamHole); RC_CHECK();
385 rc = CFGMR3InsertInteger(pBiosCfg, "NumCPUs", cCpus); RC_CHECK();
386 rc = CFGMR3InsertString(pBiosCfg, "HardDiskDevice", "piix3ide"); RC_CHECK();
387 rc = CFGMR3InsertString(pBiosCfg, "FloppyDevice", "i82078"); RC_CHECK();
388 rc = CFGMR3InsertInteger(pBiosCfg, "IOAPIC", fIOAPIC); RC_CHECK();
389 rc = CFGMR3InsertInteger(pBiosCfg, "PXEDebug", fPXEDebug); RC_CHECK();
390 rc = CFGMR3InsertBytes(pBiosCfg, "UUID", pUuid, sizeof(*pUuid)); RC_CHECK();
391
392 DeviceType_T bootDevice;
393 if (SchemaDefs::MaxBootPosition > 9)
394 {
395 AssertMsgFailed (("Too many boot devices %d\n",
396 SchemaDefs::MaxBootPosition));
397 return VERR_INVALID_PARAMETER;
398 }
399
400 for (ULONG pos = 1; pos <= SchemaDefs::MaxBootPosition; pos ++)
401 {
402 hrc = pMachine->GetBootOrder(pos, &bootDevice); H();
403
404 char szParamName[] = "BootDeviceX";
405 szParamName[sizeof (szParamName) - 2] = ((char (pos - 1)) + '0');
406
407 const char *pszBootDevice;
408 switch (bootDevice)
409 {
410 case DeviceType_Null:
411 pszBootDevice = "NONE";
412 break;
413 case DeviceType_HardDisk:
414 pszBootDevice = "IDE";
415 break;
416 case DeviceType_DVD:
417 pszBootDevice = "DVD";
418 break;
419 case DeviceType_Floppy:
420 pszBootDevice = "FLOPPY";
421 break;
422 case DeviceType_Network:
423 pszBootDevice = "LAN";
424 break;
425 default:
426 AssertMsgFailed(("Invalid bootDevice=%d\n", bootDevice));
427 return VMSetError(pVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
428 N_("Invalid boot device '%d'"), bootDevice);
429 }
430 rc = CFGMR3InsertString(pBiosCfg, szParamName, pszBootDevice); RC_CHECK();
431 }
432 }
433
434 /*
435 * The time offset
436 */
437 LONG64 timeOffset;
438 hrc = biosSettings->COMGETTER(TimeOffset)(&timeOffset); H();
439 PCFGMNODE pTMNode;
440 rc = CFGMR3InsertNode(pRoot, "TM", &pTMNode); RC_CHECK();
441 rc = CFGMR3InsertInteger(pTMNode, "UTCOffset", timeOffset * 1000000); RC_CHECK();
442
443 /*
444 * DMA
445 */
446 rc = CFGMR3InsertNode(pDevices, "8237A", &pDev); RC_CHECK();
447 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
448 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
449
450 /*
451 * PCI buses.
452 */
453 rc = CFGMR3InsertNode(pDevices, "pci", &pDev); /* piix3 */ RC_CHECK();
454 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
455 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
456 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
457 rc = CFGMR3InsertInteger(pCfg, "IOAPIC", fIOAPIC); RC_CHECK();
458
459#if 0 /* enable this to test PCI bridging */
460 rc = CFGMR3InsertNode(pDevices, "pcibridge", &pDev); RC_CHECK();
461 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
462 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
463 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
464 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 14); RC_CHECK();
465 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
466 rc = CFGMR3InsertInteger(pInst, "PCIBusNo", 0);/* -> pci[0] */ RC_CHECK();
467
468 rc = CFGMR3InsertNode(pDev, "1", &pInst); RC_CHECK();
469 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
470 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
471 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 1); RC_CHECK();
472 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
473 rc = CFGMR3InsertInteger(pInst, "PCIBusNo", 1);/* ->pcibridge[0] */ RC_CHECK();
474
475 rc = CFGMR3InsertNode(pDev, "2", &pInst); RC_CHECK();
476 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
477 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
478 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 3); RC_CHECK();
479 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
480 rc = CFGMR3InsertInteger(pInst, "PCIBusNo", 1);/* ->pcibridge[0] */ RC_CHECK();
481#endif
482
483 /*
484 * High Precision Event Timer (HPET)
485 */
486 BOOL fHpetEnabled;
487 /** @todo: implement appropriate getter */
488#ifdef VBOX_WITH_HPET
489 fHpetEnabled = true;
490#else
491 fHpetEnabled = false;
492#endif
493
494 if (fHpetEnabled)
495 {
496 rc = CFGMR3InsertNode(pDevices, "hpet", &pDev); RC_CHECK();
497 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
498 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
499 }
500
501 /*
502 * System Management Controller (SMC)
503 */
504 BOOL fSmcEnabled;
505 /** @todo: implement appropriate getter */
506#ifdef VBOX_WITH_SMC
507 fSmcEnabled = true;
508#else
509 fSmcEnabled = false;
510#endif
511 if (fSmcEnabled)
512 {
513 rc = CFGMR3InsertNode(pDevices, "smc", &pDev); RC_CHECK();
514 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
515 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
516 }
517
518 /*
519 * Low Pin Count (LPC) bus
520 */
521 BOOL fLpcEnabled;
522 /** @todo: implement appropriate getter */
523#ifdef VBOX_WITH_LPC
524 fLpcEnabled = true;
525#else
526 fLpcEnabled = false;
527#endif
528
529 if (fLpcEnabled)
530 {
531 rc = CFGMR3InsertNode(pDevices, "lpc", &pDev); RC_CHECK();
532 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
533 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
534 }
535
536 /*
537 * PS/2 keyboard & mouse.
538 */
539 rc = CFGMR3InsertNode(pDevices, "pckbd", &pDev); RC_CHECK();
540 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
541 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
542 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
543
544 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
545 rc = CFGMR3InsertString(pLunL0, "Driver", "KeyboardQueue"); RC_CHECK();
546 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
547 rc = CFGMR3InsertInteger(pCfg, "QueueSize", 64); RC_CHECK();
548
549 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
550 rc = CFGMR3InsertString(pLunL1, "Driver", "MainKeyboard"); RC_CHECK();
551 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
552 Keyboard *pKeyboard = pConsole->mKeyboard;
553 rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pKeyboard); RC_CHECK();
554
555 rc = CFGMR3InsertNode(pInst, "LUN#1", &pLunL0); RC_CHECK();
556 rc = CFGMR3InsertString(pLunL0, "Driver", "MouseQueue"); RC_CHECK();
557 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
558 rc = CFGMR3InsertInteger(pCfg, "QueueSize", 128); RC_CHECK();
559
560 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
561 rc = CFGMR3InsertString(pLunL1, "Driver", "MainMouse"); RC_CHECK();
562 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
563 Mouse *pMouse = pConsole->mMouse;
564 rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pMouse); RC_CHECK();
565
566 /*
567 * i82078 Floppy drive controller
568 */
569 ComPtr<IFloppyDrive> floppyDrive;
570 hrc = pMachine->COMGETTER(FloppyDrive)(floppyDrive.asOutParam()); H();
571 BOOL fFdcEnabled;
572 hrc = floppyDrive->COMGETTER(Enabled)(&fFdcEnabled); H();
573 if (fFdcEnabled)
574 {
575 rc = CFGMR3InsertNode(pDevices, "i82078", &pDev); RC_CHECK();
576 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
577 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); RC_CHECK();
578 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
579 rc = CFGMR3InsertInteger(pCfg, "IRQ", 6); RC_CHECK();
580 rc = CFGMR3InsertInteger(pCfg, "DMA", 2); RC_CHECK();
581 rc = CFGMR3InsertInteger(pCfg, "MemMapped", 0 ); RC_CHECK();
582 rc = CFGMR3InsertInteger(pCfg, "IOBase", 0x3f0); RC_CHECK();
583
584 /* Attach the status driver */
585 rc = CFGMR3InsertNode(pInst, "LUN#999", &pLunL0); RC_CHECK();
586 rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
587 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
588 rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapFDLeds[0]); RC_CHECK();
589 rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
590 rc = CFGMR3InsertInteger(pCfg, "Last", 0); RC_CHECK();
591
592 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
593
594 ComPtr<IFloppyImage> floppyImage;
595 hrc = floppyDrive->GetImage(floppyImage.asOutParam()); H();
596 if (floppyImage)
597 {
598 pConsole->meFloppyState = DriveState_ImageMounted;
599 rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); RC_CHECK();
600 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
601 rc = CFGMR3InsertString(pCfg, "Type", "Floppy 1.44"); RC_CHECK();
602 rc = CFGMR3InsertInteger(pCfg, "Mountable", 1); RC_CHECK();
603
604 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
605 rc = CFGMR3InsertString(pLunL1, "Driver", "RawImage"); RC_CHECK();
606 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
607 hrc = floppyImage->COMGETTER(Location)(&str); H();
608 STR_CONV();
609 rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
610 STR_FREE();
611 }
612 else
613 {
614 ComPtr<IHostFloppyDrive> hostFloppyDrive;
615 hrc = floppyDrive->GetHostDrive(hostFloppyDrive.asOutParam()); H();
616 if (hostFloppyDrive)
617 {
618 pConsole->meFloppyState = DriveState_HostDriveCaptured;
619 rc = CFGMR3InsertString(pLunL0, "Driver", "HostFloppy"); RC_CHECK();
620 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
621 hrc = hostFloppyDrive->COMGETTER(Name)(&str); H();
622 STR_CONV();
623 rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
624 STR_FREE();
625 }
626 else
627 {
628 pConsole->meFloppyState = DriveState_NotMounted;
629 rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); RC_CHECK();
630 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
631 rc = CFGMR3InsertString(pCfg, "Type", "Floppy 1.44"); RC_CHECK();
632 rc = CFGMR3InsertInteger(pCfg, "Mountable", 1); RC_CHECK();
633 }
634 }
635 }
636
637 /*
638 * ACPI
639 */
640 BOOL fACPI;
641 hrc = biosSettings->COMGETTER(ACPIEnabled)(&fACPI); H();
642 if (fACPI)
643 {
644 rc = CFGMR3InsertNode(pDevices, "acpi", &pDev); RC_CHECK();
645 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
646 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
647 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
648 rc = CFGMR3InsertInteger(pCfg, "RamSize", cbRam); RC_CHECK();
649 rc = CFGMR3InsertInteger(pCfg, "RamHoleSize", cbRamHole); RC_CHECK();
650 rc = CFGMR3InsertInteger(pCfg, "NumCPUs", cCpus); RC_CHECK();
651
652 rc = CFGMR3InsertInteger(pCfg, "IOAPIC", fIOAPIC); RC_CHECK();
653 rc = CFGMR3InsertInteger(pCfg, "FdcEnabled", fFdcEnabled); RC_CHECK();
654#ifdef VBOX_WITH_HPET
655 rc = CFGMR3InsertInteger(pCfg, "HpetEnabled", fHpetEnabled); RC_CHECK();
656#endif
657#ifdef VBOX_WITH_SMC
658 rc = CFGMR3InsertInteger(pCfg, "SmcEnabled", fSmcEnabled); RC_CHECK();
659#endif
660 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 7); RC_CHECK();
661 Assert(!afPciDeviceNo[7]);
662 afPciDeviceNo[7] = true;
663 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
664
665 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
666 rc = CFGMR3InsertString(pLunL0, "Driver", "ACPIHost"); RC_CHECK();
667 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
668 }
669
670 /*
671 * i8254 Programmable Interval Timer And Dummy Speaker
672 */
673 rc = CFGMR3InsertNode(pDevices, "i8254", &pDev); RC_CHECK();
674 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
675 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
676#ifdef DEBUG
677 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
678#endif
679
680 /*
681 * i8259 Programmable Interrupt Controller.
682 */
683 rc = CFGMR3InsertNode(pDevices, "i8259", &pDev); RC_CHECK();
684 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
685 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
686 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
687
688 /*
689 * Advanced Programmable Interrupt Controller.
690 * SMP: Each CPU has a LAPIC, but we have a single device representing all LAPICs states,
691 * thus only single insert
692 */
693 rc = CFGMR3InsertNode(pDevices, "apic", &pDev); RC_CHECK();
694 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
695 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
696 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
697 rc = CFGMR3InsertInteger(pCfg, "IOAPIC", fIOAPIC); RC_CHECK();
698 rc = CFGMR3InsertInteger(pCfg, "NumCPUs", cCpus); RC_CHECK();
699
700 /* SMP: @todo: IOAPIC may be required for SMP configs */
701 if (fIOAPIC)
702 {
703 /*
704 * I/O Advanced Programmable Interrupt Controller.
705 */
706 rc = CFGMR3InsertNode(pDevices, "ioapic", &pDev); RC_CHECK();
707 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
708 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
709 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
710 }
711
712 /*
713 * RTC MC146818.
714 */
715 rc = CFGMR3InsertNode(pDevices, "mc146818", &pDev); RC_CHECK();
716 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
717 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
718
719 /*
720 * VGA.
721 */
722 rc = CFGMR3InsertNode(pDevices, "vga", &pDev); RC_CHECK();
723 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
724 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
725 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 2); RC_CHECK();
726 Assert(!afPciDeviceNo[2]);
727 afPciDeviceNo[2] = true;
728 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
729 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
730 ULONG cVRamMBs;
731 hrc = pMachine->COMGETTER(VRAMSize)(&cVRamMBs); H();
732 rc = CFGMR3InsertInteger(pCfg, "VRamSize", cVRamMBs * _1M); RC_CHECK();
733#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE /* not safe here yet. */
734 rc = CFGMR3InsertInteger(pCfg, "R0Enabled", fHWVirtExEnabled); RC_CHECK();
735#endif
736
737 /*
738 * BIOS logo
739 */
740 BOOL fFadeIn;
741 hrc = biosSettings->COMGETTER(LogoFadeIn)(&fFadeIn); H();
742 rc = CFGMR3InsertInteger(pCfg, "FadeIn", fFadeIn ? 1 : 0); RC_CHECK();
743 BOOL fFadeOut;
744 hrc = biosSettings->COMGETTER(LogoFadeOut)(&fFadeOut); H();
745 rc = CFGMR3InsertInteger(pCfg, "FadeOut", fFadeOut ? 1: 0); RC_CHECK();
746 ULONG logoDisplayTime;
747 hrc = biosSettings->COMGETTER(LogoDisplayTime)(&logoDisplayTime); H();
748 rc = CFGMR3InsertInteger(pCfg, "LogoTime", logoDisplayTime); RC_CHECK();
749 Bstr logoImagePath;
750 hrc = biosSettings->COMGETTER(LogoImagePath)(logoImagePath.asOutParam()); H();
751 rc = CFGMR3InsertString(pCfg, "LogoFile", logoImagePath ? Utf8Str(logoImagePath) : ""); RC_CHECK();
752
753 /*
754 * Boot menu
755 */
756 BIOSBootMenuMode_T bootMenuMode;
757 int value;
758 biosSettings->COMGETTER(BootMenuMode)(&bootMenuMode);
759 switch (bootMenuMode)
760 {
761 case BIOSBootMenuMode_Disabled:
762 value = 0;
763 break;
764 case BIOSBootMenuMode_MenuOnly:
765 value = 1;
766 break;
767 default:
768 value = 2;
769 }
770 rc = CFGMR3InsertInteger(pCfg, "ShowBootMenu", value); RC_CHECK();
771
772 /* Custom VESA mode list */
773 unsigned cModes = 0;
774 for (unsigned iMode = 1; iMode <= 16; iMode++)
775 {
776 char szExtraDataKey[sizeof("CustomVideoModeXX")];
777 RTStrPrintf(szExtraDataKey, sizeof(szExtraDataKey), "CustomVideoMode%d", iMode);
778 hrc = pMachine->GetExtraData(Bstr(szExtraDataKey), &str); H();
779 if (!str || !*str)
780 break;
781 STR_CONV();
782 rc = CFGMR3InsertString(pCfg, szExtraDataKey, psz);
783 STR_FREE();
784 cModes++;
785 }
786 rc = CFGMR3InsertInteger(pCfg, "CustomVideoModes", cModes);
787
788 /* VESA height reduction */
789 ULONG ulHeightReduction;
790 IFramebuffer *pFramebuffer = pConsole->getDisplay()->getFramebuffer();
791 if (pFramebuffer)
792 {
793 hrc = pFramebuffer->COMGETTER(HeightReduction)(&ulHeightReduction); H();
794 }
795 else
796 {
797 /* If framebuffer is not available, there is no height reduction. */
798 ulHeightReduction = 0;
799 }
800 rc = CFGMR3InsertInteger(pCfg, "HeightReduction", ulHeightReduction); RC_CHECK();
801
802 /* Attach the display. */
803 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
804 rc = CFGMR3InsertString(pLunL0, "Driver", "MainDisplay"); RC_CHECK();
805 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
806 Display *pDisplay = pConsole->mDisplay;
807 rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pDisplay); RC_CHECK();
808
809 /*
810 * Storage controllers.
811 */
812 com::SafeIfaceArray<IStorageController> ctrls;
813 hrc = pMachine->
814 COMGETTER(StorageControllers) (ComSafeArrayAsOutParam (ctrls)); H();
815
816 for (size_t i = 0; i < ctrls.size(); ++ i)
817 {
818 PCFGMNODE pCtlInst = NULL; /* /Devices/<name>/0/ */
819 StorageControllerType_T enmCtrlType;
820 StorageBus_T enmBus;
821 bool fSCSI = false;
822 BSTR controllerName;
823
824 rc = ctrls[i]->COMGETTER(ControllerType)(&enmCtrlType); H();
825 rc = ctrls[i]->COMGETTER(Bus)(&enmBus); H();
826 rc = ctrls[i]->COMGETTER(Name)(&controllerName); H();
827
828 switch(enmCtrlType)
829 {
830 case StorageControllerType_LsiLogic:
831 {
832 rc = CFGMR3InsertNode(pDevices, "lsilogicscsi", &pDev); RC_CHECK();
833 rc = CFGMR3InsertNode(pDev, "0", &pCtlInst); RC_CHECK();
834 rc = CFGMR3InsertInteger(pCtlInst, "Trusted", 1); RC_CHECK();
835 rc = CFGMR3InsertInteger(pCtlInst, "PCIDeviceNo", 20); RC_CHECK();
836 Assert(!afPciDeviceNo[20]);
837 afPciDeviceNo[20] = true;
838 rc = CFGMR3InsertInteger(pCtlInst, "PCIFunctionNo", 0); RC_CHECK();
839 rc = CFGMR3InsertNode(pCtlInst, "Config", &pCfg); RC_CHECK();
840 fSCSI = true;
841
842 /* Attach the status driver */
843 rc = CFGMR3InsertNode(pCtlInst, "LUN#999", &pLunL0); RC_CHECK();
844 rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
845 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
846 rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapSCSILeds[0]); RC_CHECK();
847 rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
848 rc = CFGMR3InsertInteger(pCfg, "Last", 15); RC_CHECK();
849 break;
850 }
851 case StorageControllerType_BusLogic:
852 {
853 rc = CFGMR3InsertNode(pDevices, "buslogic", &pDev); RC_CHECK();
854 rc = CFGMR3InsertNode(pDev, "0", &pCtlInst); RC_CHECK();
855 rc = CFGMR3InsertInteger(pCtlInst, "Trusted", 1); RC_CHECK();
856 rc = CFGMR3InsertInteger(pCtlInst, "PCIDeviceNo", 21); RC_CHECK();
857 Assert(!afPciDeviceNo[21]);
858 afPciDeviceNo[21] = true;
859 rc = CFGMR3InsertInteger(pCtlInst, "PCIFunctionNo", 0); RC_CHECK();
860 rc = CFGMR3InsertNode(pCtlInst, "Config", &pCfg); RC_CHECK();
861 fSCSI = true;
862
863 /* Attach the status driver */
864 rc = CFGMR3InsertNode(pCtlInst, "LUN#999", &pLunL0); RC_CHECK();
865 rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
866 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
867 rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapSCSILeds[0]); RC_CHECK();
868 rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
869 rc = CFGMR3InsertInteger(pCfg, "Last", 15); RC_CHECK();
870 break;
871 }
872 case StorageControllerType_IntelAhci:
873 {
874 rc = CFGMR3InsertNode(pDevices, "ahci", &pDev); RC_CHECK();
875 rc = CFGMR3InsertNode(pDev, "0", &pCtlInst); RC_CHECK();
876 rc = CFGMR3InsertInteger(pCtlInst, "Trusted", 1); RC_CHECK();
877 rc = CFGMR3InsertInteger(pCtlInst, "PCIDeviceNo", 13); RC_CHECK();
878 Assert(!afPciDeviceNo[13]);
879 afPciDeviceNo[13] = true;
880 rc = CFGMR3InsertInteger(pCtlInst, "PCIFunctionNo", 0); RC_CHECK();
881 rc = CFGMR3InsertNode(pCtlInst, "Config", &pCfg); RC_CHECK();
882
883 ULONG cPorts = 0;
884 hrc = ctrls[i]->COMGETTER(PortCount)(&cPorts); H();
885 rc = CFGMR3InsertInteger(pCfg, "PortCount", cPorts); RC_CHECK();
886
887 /* Needed configuration values for the bios. */
888 if (pBiosCfg)
889 {
890 rc = CFGMR3InsertString(pBiosCfg, "SataHardDiskDevice", "ahci"); RC_CHECK();
891 }
892
893 for (uint32_t j = 0; j < 4; j++)
894 {
895 static const char *s_apszConfig[4] =
896 { "PrimaryMaster", "PrimarySlave", "SecondaryMaster", "SecondarySlave" };
897 static const char *s_apszBiosConfig[4] =
898 { "SataPrimaryMasterLUN", "SataPrimarySlaveLUN", "SataSecondaryMasterLUN", "SataSecondarySlaveLUN" };
899
900 LONG lPortNumber = -1;
901 hrc = ctrls[i]->GetIDEEmulationPort(j, &lPortNumber); H();
902 rc = CFGMR3InsertInteger(pCfg, s_apszConfig[j], lPortNumber); RC_CHECK();
903 if (pBiosCfg)
904 {
905 rc = CFGMR3InsertInteger(pBiosCfg, s_apszBiosConfig[j], lPortNumber); RC_CHECK();
906 }
907 }
908
909 /* Attach the status driver */
910 rc = CFGMR3InsertNode(pCtlInst, "LUN#999", &pLunL0); RC_CHECK();
911 rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
912 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
913 AssertRelease(cPorts <= RT_ELEMENTS(pConsole->mapSATALeds));
914 rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapSATALeds[0]); RC_CHECK();
915 rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
916 rc = CFGMR3InsertInteger(pCfg, "Last", cPorts - 1); RC_CHECK();
917 break;
918 }
919 case StorageControllerType_PIIX3:
920 case StorageControllerType_PIIX4:
921 case StorageControllerType_ICH6:
922 {
923 /*
924 * IDE (update this when the main interface changes)
925 */
926 rc = CFGMR3InsertNode(pDevices, "piix3ide", &pDev); /* piix3 */ RC_CHECK();
927 rc = CFGMR3InsertNode(pDev, "0", &pCtlInst); RC_CHECK();
928 rc = CFGMR3InsertInteger(pCtlInst, "Trusted", 1); /* boolean */ RC_CHECK();
929 rc = CFGMR3InsertInteger(pCtlInst, "PCIDeviceNo", 1); RC_CHECK();
930 Assert(!afPciDeviceNo[1]);
931 afPciDeviceNo[1] = true;
932 rc = CFGMR3InsertInteger(pCtlInst, "PCIFunctionNo", 1); RC_CHECK();
933 rc = CFGMR3InsertNode(pCtlInst, "Config", &pCfg); RC_CHECK();
934 rc = CFGMR3InsertString(pCfg, "Type", controllerString(enmCtrlType)); RC_CHECK();
935
936 /* Attach the status driver */
937 rc = CFGMR3InsertNode(pCtlInst, "LUN#999", &pLunL0); RC_CHECK();
938 rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
939 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
940 rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapIDELeds[0]);RC_CHECK();
941 rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
942 rc = CFGMR3InsertInteger(pCfg, "Last", 3); RC_CHECK();
943
944 /*
945 * Attach the CD/DVD driver now
946 */
947 ComPtr<IDVDDrive> dvdDrive;
948 hrc = pMachine->COMGETTER(DVDDrive)(dvdDrive.asOutParam()); H();
949 if (dvdDrive)
950 {
951 // ASSUME: DVD drive is always attached to LUN#2 (i.e. secondary IDE master)
952 rc = CFGMR3InsertNode(pCtlInst, "LUN#2", &pLunL0); RC_CHECK();
953 ComPtr<IHostDVDDrive> hostDvdDrive;
954 hrc = dvdDrive->GetHostDrive(hostDvdDrive.asOutParam()); H();
955 if (hostDvdDrive)
956 {
957 pConsole->meDVDState = DriveState_HostDriveCaptured;
958 rc = CFGMR3InsertString(pLunL0, "Driver", "HostDVD"); RC_CHECK();
959 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
960 hrc = hostDvdDrive->COMGETTER(Name)(&str); H();
961 STR_CONV();
962 rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
963 STR_FREE();
964 BOOL fPassthrough;
965 hrc = dvdDrive->COMGETTER(Passthrough)(&fPassthrough); H();
966 rc = CFGMR3InsertInteger(pCfg, "Passthrough", !!fPassthrough); RC_CHECK();
967 }
968 else
969 {
970 pConsole->meDVDState = DriveState_NotMounted;
971 rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); RC_CHECK();
972 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
973 rc = CFGMR3InsertString(pCfg, "Type", "DVD"); RC_CHECK();
974 rc = CFGMR3InsertInteger(pCfg, "Mountable", 1); RC_CHECK();
975
976 ComPtr<IDVDImage> dvdImage;
977 hrc = dvdDrive->GetImage(dvdImage.asOutParam()); H();
978 if (dvdImage)
979 {
980 pConsole->meDVDState = DriveState_ImageMounted;
981 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
982 rc = CFGMR3InsertString(pLunL1, "Driver", "MediaISO"); RC_CHECK();
983 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); RC_CHECK();
984 hrc = dvdImage->COMGETTER(Location)(&str); H();
985 STR_CONV();
986 rc = CFGMR3InsertString(pCfg, "Path", psz); RC_CHECK();
987 STR_FREE();
988 }
989 }
990 }
991 break;
992 }
993 default:
994 AssertMsgFailed (("invalid storage controller type: "
995 "%d\n", enmCtrlType));
996 return VERR_GENERAL_FAILURE;
997 }
998
999 /* At the moment we only support one controller per type. So the instance id is always 0. */
1000 rc = ctrls[i]->COMSETTER(Instance)(0); H();
1001
1002 /* Attach the hard disks. */
1003 com::SafeIfaceArray<IHardDiskAttachment> atts;
1004 hrc = pMachine->
1005 GetHardDiskAttachmentsOfController (controllerName,
1006 ComSafeArrayAsOutParam (atts)); H();
1007
1008 for (size_t j = 0; j < atts.size(); ++ j)
1009 {
1010 ComPtr<IHardDisk> hardDisk;
1011 hrc = atts [j]->COMGETTER(HardDisk) (hardDisk.asOutParam()); H();
1012 LONG lDev;
1013 hrc = atts [j]->COMGETTER(Device) (&lDev); H();
1014 LONG lPort;
1015 hrc = atts [j]->COMGETTER(Port) (&lPort); H();
1016
1017 int iLUN = 0;
1018
1019 switch (enmBus)
1020 {
1021 case StorageBus_IDE:
1022 {
1023 if (lPort >= 2 || lPort < 0)
1024 {
1025 AssertMsgFailed (("invalid controller channel number: "
1026 "%d\n", lPort));
1027 return VERR_GENERAL_FAILURE;
1028 }
1029
1030 if (lDev >= 2 || lDev < 0)
1031 {
1032 AssertMsgFailed (("invalid controller device number: "
1033 "%d\n", lDev));
1034 return VERR_GENERAL_FAILURE;
1035 }
1036
1037 iLUN = 2 * lPort + lDev;
1038 break;
1039 }
1040 case StorageBus_SATA:
1041 case StorageBus_SCSI:
1042 {
1043 iLUN = lPort;
1044 break;
1045 }
1046 default:
1047 {
1048 AssertMsgFailed (("invalid storage bus type: "
1049 "%d\n", enmBus));
1050 return VERR_GENERAL_FAILURE;
1051 }
1052 }
1053
1054 char szLUN[16];
1055 RTStrPrintf (szLUN, sizeof(szLUN), "LUN#%d", iLUN);
1056
1057 rc = CFGMR3InsertNode (pCtlInst, szLUN, &pLunL0); RC_CHECK();
1058 /* SCSI has a another driver between device and block. */
1059 if (fSCSI)
1060 {
1061 rc = CFGMR3InsertString (pLunL0, "Driver", "SCSI"); RC_CHECK();
1062 rc = CFGMR3InsertNode (pLunL0, "Config", &pCfg); RC_CHECK();
1063
1064 rc = CFGMR3InsertNode (pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
1065 }
1066 rc = CFGMR3InsertString (pLunL0, "Driver", "Block"); RC_CHECK();
1067 rc = CFGMR3InsertNode (pLunL0, "Config", &pCfg); RC_CHECK();
1068 rc = CFGMR3InsertString (pCfg, "Type", "HardDisk"); RC_CHECK();
1069 rc = CFGMR3InsertInteger (pCfg, "Mountable", 0); RC_CHECK();
1070
1071 rc = CFGMR3InsertNode (pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
1072 rc = CFGMR3InsertString (pLunL1, "Driver", "VD"); RC_CHECK();
1073 rc = CFGMR3InsertNode (pLunL1, "Config", &pCfg); RC_CHECK();
1074
1075 hrc = hardDisk->COMGETTER(Location) (bstr.asOutParam()); H();
1076 rc = CFGMR3InsertString (pCfg, "Path", Utf8Str (bstr)); RC_CHECK();
1077
1078 hrc = hardDisk->COMGETTER(Format) (bstr.asOutParam()); H();
1079 rc = CFGMR3InsertString (pCfg, "Format", Utf8Str (bstr)); RC_CHECK();
1080
1081#if defined(VBOX_WITH_PDM_ASYNC_COMPLETION)
1082 if (bstr == L"VMDK")
1083 {
1084 /* Create cfgm nodes for async transport driver because VMDK is
1085 * currently the only one which may support async I/O. This has
1086 * to be made generic based on the capabiliy flags when the new
1087 * HardDisk interface is merged.
1088 */
1089 rc = CFGMR3InsertNode (pLunL1, "AttachedDriver", &pLunL2); RC_CHECK();
1090 rc = CFGMR3InsertString (pLunL2, "Driver", "TransportAsync"); RC_CHECK();
1091 /* The async transport driver has no config options yet. */
1092 }
1093#endif
1094 /* Pass all custom parameters. */
1095 bool fHostIP = true;
1096 SafeArray <BSTR> names;
1097 SafeArray <BSTR> values;
1098 hrc = hardDisk->GetProperties (NULL,
1099 ComSafeArrayAsOutParam (names),
1100 ComSafeArrayAsOutParam (values)); H();
1101
1102 if (names.size() != 0)
1103 {
1104 PCFGMNODE pVDC;
1105 rc = CFGMR3InsertNode (pCfg, "VDConfig", &pVDC); RC_CHECK();
1106 for (size_t ii = 0; ii < names.size(); ++ ii)
1107 {
1108 if (values [ii])
1109 {
1110 Utf8Str name = names [ii];
1111 Utf8Str value = values [ii];
1112 rc = CFGMR3InsertString (pVDC, name, value);
1113 if ( !(name.compare("HostIPStack"))
1114 && !(value.compare("0")))
1115 fHostIP = false;
1116 }
1117 }
1118 }
1119
1120 /* Create an inversed tree of parents. */
1121 ComPtr<IHardDisk> parentHardDisk = hardDisk;
1122 for (PCFGMNODE pParent = pCfg;;)
1123 {
1124 hrc = parentHardDisk->
1125 COMGETTER(Parent) (hardDisk.asOutParam()); H();
1126 if (hardDisk.isNull())
1127 break;
1128
1129 PCFGMNODE pCur;
1130 rc = CFGMR3InsertNode (pParent, "Parent", &pCur); RC_CHECK();
1131 hrc = hardDisk->COMGETTER(Location) (bstr.asOutParam()); H();
1132 rc = CFGMR3InsertString (pCur, "Path", Utf8Str (bstr)); RC_CHECK();
1133
1134 hrc = hardDisk->COMGETTER(Format) (bstr.asOutParam()); H();
1135 rc = CFGMR3InsertString (pCur, "Format", Utf8Str (bstr)); RC_CHECK();
1136
1137 /* Pass all custom parameters. */
1138 SafeArray <BSTR> names;
1139 SafeArray <BSTR> values;
1140 hrc = hardDisk->GetProperties (NULL,
1141 ComSafeArrayAsOutParam (names),
1142 ComSafeArrayAsOutParam (values));H();
1143
1144 if (names.size() != 0)
1145 {
1146 PCFGMNODE pVDC;
1147 rc = CFGMR3InsertNode (pCur, "VDConfig", &pVDC); RC_CHECK();
1148 for (size_t ii = 0; ii < names.size(); ++ ii)
1149 {
1150 if (values [ii])
1151 {
1152 Utf8Str name = names [ii];
1153 Utf8Str value = values [ii];
1154 rc = CFGMR3InsertString (pVDC, name, value);
1155 if ( !(name.compare("HostIPStack"))
1156 && !(value.compare("0")))
1157 fHostIP = false;
1158 }
1159 }
1160 }
1161
1162 /* Custom code: put marker to not use host IP stack to driver
1163 * configuration node. Simplifies life of DrvVD a bit. */
1164 if (!fHostIP)
1165 {
1166 rc = CFGMR3InsertInteger (pCfg, "HostIPStack", 0); RC_CHECK();
1167 }
1168
1169 /* next */
1170 pParent = pCur;
1171 parentHardDisk = hardDisk;
1172 }
1173 }
1174 H();
1175 }
1176 H();
1177
1178 /*
1179 * Network adapters
1180 */
1181#ifdef VMWARE_NET_IN_SLOT_11
1182 bool fSwapSlots3and11 = false;
1183#endif
1184 PCFGMNODE pDevPCNet = NULL; /* PCNet-type devices */
1185 rc = CFGMR3InsertNode(pDevices, "pcnet", &pDevPCNet); RC_CHECK();
1186#ifdef VBOX_WITH_E1000
1187 PCFGMNODE pDevE1000 = NULL; /* E1000-type devices */
1188 rc = CFGMR3InsertNode(pDevices, "e1000", &pDevE1000); RC_CHECK();
1189#endif
1190 for (ULONG ulInstance = 0; ulInstance < SchemaDefs::NetworkAdapterCount; ulInstance++)
1191 {
1192 ComPtr<INetworkAdapter> networkAdapter;
1193 hrc = pMachine->GetNetworkAdapter(ulInstance, networkAdapter.asOutParam()); H();
1194 BOOL fEnabled = FALSE;
1195 hrc = networkAdapter->COMGETTER(Enabled)(&fEnabled); H();
1196 if (!fEnabled)
1197 continue;
1198
1199 /*
1200 * The virtual hardware type. Create appropriate device first.
1201 */
1202 NetworkAdapterType_T adapterType;
1203 hrc = networkAdapter->COMGETTER(AdapterType)(&adapterType); H();
1204 switch (adapterType)
1205 {
1206 case NetworkAdapterType_Am79C970A:
1207 case NetworkAdapterType_Am79C973:
1208 pDev = pDevPCNet;
1209 break;
1210#ifdef VBOX_WITH_E1000
1211 case NetworkAdapterType_I82540EM:
1212 case NetworkAdapterType_I82543GC:
1213 case NetworkAdapterType_I82545EM:
1214 pDev = pDevE1000;
1215 break;
1216#endif
1217 default:
1218 AssertMsgFailed(("Invalid network adapter type '%d' for slot '%d'",
1219 adapterType, ulInstance));
1220 return VMSetError(pVM, VERR_INVALID_PARAMETER, RT_SRC_POS,
1221 N_("Invalid network adapter type '%d' for slot '%d'"),
1222 adapterType, ulInstance);
1223 }
1224
1225 char szInstance[4]; Assert(ulInstance <= 999);
1226 RTStrPrintf(szInstance, sizeof(szInstance), "%lu", ulInstance);
1227 rc = CFGMR3InsertNode(pDev, szInstance, &pInst); RC_CHECK();
1228 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
1229 /* the first network card gets the PCI ID 3, the next 3 gets 8..10,
1230 * next 4 get 16..19. */
1231 unsigned iPciDeviceNo = 3;
1232 if (ulInstance)
1233 {
1234 if (ulInstance < 4)
1235 iPciDeviceNo = ulInstance - 1 + 8;
1236 else
1237 iPciDeviceNo = ulInstance - 4 + 16;
1238 }
1239#ifdef VMWARE_NET_IN_SLOT_11
1240 /*
1241 * Dirty hack for PCI slot compatibility with VMWare,
1242 * it assigns slot 11 to the first network controller.
1243 */
1244 if (iPciDeviceNo == 3 && adapterType == NetworkAdapterType_I82545EM)
1245 {
1246 iPciDeviceNo = 0x11;
1247 fSwapSlots3and11 = true;
1248 }
1249 else if (iPciDeviceNo == 0x11 && fSwapSlots3and11)
1250 iPciDeviceNo = 3;
1251#endif
1252 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", iPciDeviceNo); RC_CHECK();
1253 Assert(!afPciDeviceNo[iPciDeviceNo]);
1254 afPciDeviceNo[iPciDeviceNo] = true;
1255 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
1256 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
1257#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE /* not safe here yet. */
1258 if (pDev == pDevPCNet)
1259 {
1260 rc = CFGMR3InsertInteger(pCfg, "R0Enabled", false); RC_CHECK();
1261 }
1262#endif
1263
1264 /*
1265 * The virtual hardware type. PCNet supports two types.
1266 */
1267 switch (adapterType)
1268 {
1269 case NetworkAdapterType_Am79C970A:
1270 rc = CFGMR3InsertInteger(pCfg, "Am79C973", 0); RC_CHECK();
1271 break;
1272 case NetworkAdapterType_Am79C973:
1273 rc = CFGMR3InsertInteger(pCfg, "Am79C973", 1); RC_CHECK();
1274 break;
1275 case NetworkAdapterType_I82540EM:
1276 rc = CFGMR3InsertInteger(pCfg, "AdapterType", 0); RC_CHECK();
1277 break;
1278 case NetworkAdapterType_I82543GC:
1279 rc = CFGMR3InsertInteger(pCfg, "AdapterType", 1); RC_CHECK();
1280 break;
1281 case NetworkAdapterType_I82545EM:
1282 rc = CFGMR3InsertInteger(pCfg, "AdapterType", 2); RC_CHECK();
1283 break;
1284 }
1285
1286 /*
1287 * Get the MAC address and convert it to binary representation
1288 */
1289 Bstr macAddr;
1290 hrc = networkAdapter->COMGETTER(MACAddress)(macAddr.asOutParam()); H();
1291 Assert(macAddr);
1292 Utf8Str macAddrUtf8 = macAddr;
1293 char *macStr = (char*)macAddrUtf8.raw();
1294 Assert(strlen(macStr) == 12);
1295 RTMAC Mac;
1296 memset(&Mac, 0, sizeof(Mac));
1297 char *pMac = (char*)&Mac;
1298 for (uint32_t i = 0; i < 6; i++)
1299 {
1300 char c1 = *macStr++ - '0';
1301 if (c1 > 9)
1302 c1 -= 7;
1303 char c2 = *macStr++ - '0';
1304 if (c2 > 9)
1305 c2 -= 7;
1306 *pMac++ = ((c1 & 0x0f) << 4) | (c2 & 0x0f);
1307 }
1308 rc = CFGMR3InsertBytes(pCfg, "MAC", &Mac, sizeof(Mac)); RC_CHECK();
1309
1310 /*
1311 * Check if the cable is supposed to be unplugged
1312 */
1313 BOOL fCableConnected;
1314 hrc = networkAdapter->COMGETTER(CableConnected)(&fCableConnected); H();
1315 rc = CFGMR3InsertInteger(pCfg, "CableConnected", fCableConnected ? 1 : 0); RC_CHECK();
1316
1317 /*
1318 * Line speed to report from custom drivers
1319 */
1320 ULONG ulLineSpeed;
1321 hrc = networkAdapter->COMGETTER(LineSpeed)(&ulLineSpeed); H();
1322 rc = CFGMR3InsertInteger(pCfg, "LineSpeed", ulLineSpeed); RC_CHECK();
1323
1324 /*
1325 * Attach the status driver.
1326 */
1327 rc = CFGMR3InsertNode(pInst, "LUN#999", &pLunL0); RC_CHECK();
1328 rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
1329 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1330 rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapNetworkLeds[ulInstance]); RC_CHECK();
1331
1332 /*
1333 * Enable the packet sniffer if requested.
1334 */
1335 BOOL fSniffer;
1336 hrc = networkAdapter->COMGETTER(TraceEnabled)(&fSniffer); H();
1337 if (fSniffer)
1338 {
1339 /* insert the sniffer filter driver. */
1340 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1341 rc = CFGMR3InsertString(pLunL0, "Driver", "NetSniffer"); RC_CHECK();
1342 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1343 hrc = networkAdapter->COMGETTER(TraceFile)(&str); H();
1344 if (str) /* check convention for indicating default file. */
1345 {
1346 STR_CONV();
1347 rc = CFGMR3InsertString(pCfg, "File", psz); RC_CHECK();
1348 STR_FREE();
1349 }
1350 }
1351
1352
1353 NetworkAttachmentType_T networkAttachment;
1354 hrc = networkAdapter->COMGETTER(AttachmentType)(&networkAttachment); H();
1355 Bstr networkName, trunkName, trunkType;
1356 switch (networkAttachment)
1357 {
1358 case NetworkAttachmentType_Null:
1359 break;
1360
1361 case NetworkAttachmentType_NAT:
1362 {
1363 if (fSniffer)
1364 {
1365 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
1366 }
1367 else
1368 {
1369 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1370 }
1371 rc = CFGMR3InsertString(pLunL0, "Driver", "NAT"); RC_CHECK();
1372 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1373 /* (Port forwarding goes here.) */
1374
1375 /* Configure TFTP prefix and boot filename. */
1376 hrc = virtualBox->COMGETTER(HomeFolder)(&str); H();
1377 STR_CONV();
1378 if (psz && *psz)
1379 {
1380 char *pszTFTPPrefix = NULL;
1381 RTStrAPrintf(&pszTFTPPrefix, "%s%c%s", psz, RTPATH_DELIMITER, "TFTP");
1382 rc = CFGMR3InsertString(pCfg, "TFTPPrefix", pszTFTPPrefix); RC_CHECK();
1383 RTStrFree(pszTFTPPrefix);
1384 }
1385 STR_FREE();
1386 hrc = pMachine->COMGETTER(Name)(&str); H();
1387 STR_CONV();
1388 char *pszBootFile = NULL;
1389 RTStrAPrintf(&pszBootFile, "%s.pxe", psz);
1390 STR_FREE();
1391 rc = CFGMR3InsertString(pCfg, "BootFile", pszBootFile); RC_CHECK();
1392 RTStrFree(pszBootFile);
1393
1394 hrc = networkAdapter->COMGETTER(NATNetwork)(&str); H();
1395 if (str)
1396 {
1397 STR_CONV();
1398 if (psz && *psz)
1399 {
1400 rc = CFGMR3InsertString(pCfg, "Network", psz); RC_CHECK();
1401 /* NAT uses its own DHCP implementation */
1402 //networkName = Bstr(psz);
1403 }
1404
1405 STR_FREE();
1406 }
1407 break;
1408 }
1409
1410 case NetworkAttachmentType_Bridged:
1411 {
1412 /*
1413 * Perform the attachment if required (don't return on error!)
1414 */
1415 hrc = pConsole->attachToBridgedInterface(networkAdapter);
1416 if (SUCCEEDED(hrc))
1417 {
1418#if !defined(VBOX_WITH_NETFLT) && defined(RT_OS_LINUX)
1419 Assert ((int)pConsole->maTapFD[ulInstance] >= 0);
1420 if ((int)pConsole->maTapFD[ulInstance] >= 0)
1421 {
1422 if (fSniffer)
1423 {
1424 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
1425 }
1426 else
1427 {
1428 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1429 }
1430 rc = CFGMR3InsertString(pLunL0, "Driver", "HostInterface"); RC_CHECK();
1431 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1432 rc = CFGMR3InsertInteger(pCfg, "FileHandle", pConsole->maTapFD[ulInstance]); RC_CHECK();
1433 }
1434#elif defined(VBOX_WITH_NETFLT)
1435 /*
1436 * This is the new VBoxNetFlt+IntNet stuff.
1437 */
1438 if (fSniffer)
1439 {
1440 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
1441 }
1442 else
1443 {
1444 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1445 }
1446
1447 Bstr HifName;
1448 hrc = networkAdapter->COMGETTER(HostInterface)(HifName.asOutParam());
1449 if(FAILED(hrc))
1450 {
1451 LogRel(("NetworkAttachmentType_Bridged: COMGETTER(HostInterface) failed, hrc (0x%x)", hrc));
1452 H();
1453 }
1454
1455 Utf8Str HifNameUtf8(HifName);
1456 const char *pszHifName = HifNameUtf8.raw();
1457
1458# if defined(RT_OS_DARWIN)
1459 /* The name is on the form 'ifX: long name', chop it off at the colon. */
1460 char szTrunk[8];
1461 strncpy(szTrunk, pszHifName, sizeof(szTrunk));
1462 char *pszColon = (char *)memchr(szTrunk, ':', sizeof(szTrunk));
1463 if (!pszColon)
1464 {
1465 hrc = networkAdapter->Detach(); H();
1466 return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
1467 N_("Malformed host interface networking name '%ls'"),
1468 HifName.raw());
1469 }
1470 *pszColon = '\0';
1471 const char *pszTrunk = szTrunk;
1472
1473# elif defined(RT_OS_SOLARIS)
1474 /* The name is on the form format 'ifX[:1] - long name, chop it off at space. */
1475 char szTrunk[256];
1476 strlcpy(szTrunk, pszHifName, sizeof(szTrunk));
1477 char *pszSpace = (char *)memchr(szTrunk, ' ', sizeof(szTrunk));
1478
1479 /*
1480 * Currently don't bother about malformed names here for the sake of people using
1481 * VBoxManage and setting only the NIC name from there. If there is a space we
1482 * chop it off and proceed, otherwise just use whatever we've got.
1483 */
1484 if (pszSpace)
1485 *pszSpace = '\0';
1486
1487 /* Chop it off at the colon (zone naming eg: e1000g:1 we need only the e1000g) */
1488 char *pszColon = (char *)memchr(szTrunk, ':', sizeof(szTrunk));
1489 if (pszColon)
1490 *pszColon = '\0';
1491
1492 const char *pszTrunk = szTrunk;
1493
1494# elif defined(RT_OS_WINDOWS)
1495 ComPtr<IHostNetworkInterface> hostInterface;
1496 rc = host->FindHostNetworkInterfaceByName(HifName, hostInterface.asOutParam());
1497 if (!SUCCEEDED(rc))
1498 {
1499 AssertBreakpoint();
1500 LogRel(("NetworkAttachmentType_Bridged: FindByName failed, rc (0x%x)", rc));
1501 return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
1502 N_("Inexistent host networking interface, name '%ls'"),
1503 HifName.raw());
1504 }
1505
1506 HostNetworkInterfaceType_T ifType;
1507 hrc = hostInterface->COMGETTER(InterfaceType)(&ifType);
1508 if(FAILED(hrc))
1509 {
1510 LogRel(("NetworkAttachmentType_Bridged: COMGETTER(InterfaceType) failed, hrc (0x%x)", hrc));
1511 H();
1512 }
1513
1514 if(ifType != HostNetworkInterfaceType_Bridged)
1515 {
1516 return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
1517 N_("Interface ('%ls') is not a Bridged Adapter interface"),
1518 HifName.raw());
1519 }
1520
1521 Guid hostIFGuid;
1522 hrc = hostInterface->COMGETTER(Id)(hostIFGuid.asOutParam());
1523 if(FAILED(hrc))
1524 {
1525 LogRel(("NetworkAttachmentType_Bridged: COMGETTER(Id) failed, hrc (0x%x)", hrc));
1526 H();
1527 }
1528
1529 INetCfg *pNc;
1530 ComPtr<INetCfgComponent> pAdaptorComponent;
1531 LPWSTR lpszApp;
1532 int rc = VERR_INTNET_FLT_IF_NOT_FOUND;
1533
1534 hrc = VBoxNetCfgWinQueryINetCfg( FALSE,
1535 L"VirtualBox",
1536 &pNc,
1537 &lpszApp );
1538 Assert(hrc == S_OK);
1539 if(hrc == S_OK)
1540 {
1541 /* get the adapter's INetCfgComponent*/
1542 hrc = VBoxNetCfgWinGetComponentByGuid(pNc, &GUID_DEVCLASS_NET, (GUID*)hostIFGuid.ptr(), pAdaptorComponent.asOutParam());
1543 if(hrc != S_OK)
1544 {
1545 VBoxNetCfgWinReleaseINetCfg( pNc, FALSE );
1546 LogRel(("NetworkAttachmentType_Bridged: VBoxNetCfgWinGetComponentByGuid failed, hrc (0x%x)", hrc));
1547 H();
1548 }
1549 }
1550#define VBOX_WIN_BINDNAME_PREFIX "\\DEVICE\\"
1551 char szTrunkName[INTNET_MAX_TRUNK_NAME];
1552 char *pszTrunkName = szTrunkName;
1553 wchar_t * pswzBindName;
1554 hrc = pAdaptorComponent->GetBindName(&pswzBindName);
1555 Assert(hrc == S_OK);
1556 if (hrc == S_OK)
1557 {
1558 int cwBindName = (int)wcslen(pswzBindName) + 1;
1559 int cbFullBindNamePrefix = sizeof(VBOX_WIN_BINDNAME_PREFIX);
1560 if(sizeof(szTrunkName) > cbFullBindNamePrefix + cwBindName)
1561 {
1562 strcpy(szTrunkName, VBOX_WIN_BINDNAME_PREFIX);
1563 pszTrunkName += cbFullBindNamePrefix-1;
1564 if(!WideCharToMultiByte(CP_ACP, 0, pswzBindName, cwBindName, pszTrunkName,
1565 sizeof(szTrunkName) - cbFullBindNamePrefix + 1, NULL, NULL))
1566 {
1567 Assert(0);
1568 DWORD err = GetLastError();
1569 hrc = HRESULT_FROM_WIN32(err);
1570 AssertMsgFailed(("%hrc=%Rhrc %#x\n", hrc, hrc));
1571 LogRel(("NetworkAttachmentType_Bridged: WideCharToMultiByte failed, hr=%Rhrc (0x%x)\n", hrc, hrc));
1572 }
1573 }
1574 else
1575 {
1576 Assert(0);
1577 LogRel(("NetworkAttachmentType_Bridged: insufficient szTrunkName buffer space\n"));
1578 /** @todo set appropriate error code */
1579 hrc = E_FAIL;
1580 }
1581
1582 if(hrc != S_OK)
1583 {
1584 Assert(0);
1585 CoTaskMemFree(pswzBindName);
1586 VBoxNetCfgWinReleaseINetCfg( pNc, FALSE );
1587 H();
1588 }
1589
1590 /* we're not freeing the bind name since we'll use it later for detecting wireless*/
1591 }
1592 else
1593 {
1594 Assert(0);
1595 VBoxNetCfgWinReleaseINetCfg( pNc, FALSE );
1596 LogRel(("NetworkAttachmentType_Bridged: VBoxNetCfgWinGetComponentByGuid failed, hrc (0x%x)", hrc));
1597 H();
1598 }
1599 const char *pszTrunk = szTrunkName;
1600 /* we're not releasing the INetCfg stuff here since we use it later to figure out whether it is wireless */
1601
1602# elif defined(RT_OS_LINUX)
1603 /* @todo Check for malformed names. */
1604 const char *pszTrunk = pszHifName;
1605
1606# else
1607# error "PORTME (VBOX_WITH_NETFLT)"
1608# endif
1609
1610 rc = CFGMR3InsertString(pLunL0, "Driver", "IntNet"); RC_CHECK();
1611 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1612 rc = CFGMR3InsertString(pCfg, "Trunk", pszTrunk); RC_CHECK();
1613 rc = CFGMR3InsertInteger(pCfg, "TrunkType", kIntNetTrunkType_NetFlt); RC_CHECK();
1614 char szNetwork[80];
1615 RTStrPrintf(szNetwork, sizeof(szNetwork), "HostInterfaceNetworking-%s", pszHifName);
1616 rc = CFGMR3InsertString(pCfg, "Network", szNetwork); RC_CHECK();
1617 networkName = Bstr(szNetwork);
1618 trunkName = Bstr(pszTrunk);
1619 trunkType = Bstr(TRUNKTYPE_NETFLT);
1620
1621# if defined(RT_OS_DARWIN)
1622 /** @todo Come up with a better deal here. Problem is that IHostNetworkInterface is completely useless here. */
1623 if ( strstr(pszHifName, "Wireless")
1624 || strstr(pszHifName, "AirPort" ))
1625 {
1626 rc = CFGMR3InsertInteger(pCfg, "SharedMacOnWire", true); RC_CHECK();
1627 }
1628# elif defined(RT_OS_LINUX)
1629 int iSock = socket(AF_INET, SOCK_DGRAM, 0);
1630 if (iSock >= 0)
1631 {
1632 struct iwreq WRq;
1633
1634 memset(&WRq, 0, sizeof(WRq));
1635 strncpy(WRq.ifr_name, pszHifName, IFNAMSIZ);
1636 if (ioctl(iSock, SIOCGIWNAME, &WRq) >= 0)
1637 {
1638 rc = CFGMR3InsertInteger(pCfg, "SharedMacOnWire", true); RC_CHECK();
1639 Log(("Set SharedMacOnWire\n"));
1640 }
1641 else
1642 {
1643 Log(("Failed to get wireless name\n"));
1644 }
1645 close(iSock);
1646 }
1647 else
1648 {
1649 Log(("Failed to open wireless socket\n"));
1650 }
1651# elif defined(RT_OS_WINDOWS)
1652# define DEVNAME_PREFIX L"\\\\.\\"
1653 /* we are getting the medium type via IOCTL_NDIS_QUERY_GLOBAL_STATS Io Control
1654 * there is a pretty long way till there though since we need to obtain the symbolic link name
1655 * for the adapter device we are going to query given the device Guid */
1656
1657 /* prepend the "\\\\.\\" to the bind name to obtain the link name */
1658 wchar_t FileName[MAX_PATH];
1659 wcscpy(FileName, DEVNAME_PREFIX);
1660 wcscpy((wchar_t*)(((char*)FileName) + sizeof(DEVNAME_PREFIX) - sizeof(FileName[0])), pswzBindName);
1661
1662 /* open the device */
1663 HANDLE hDevice = CreateFile(FileName,
1664 GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
1665 NULL,
1666 OPEN_EXISTING,
1667 FILE_ATTRIBUTE_NORMAL,
1668 NULL);
1669 if (hDevice != INVALID_HANDLE_VALUE)
1670 {
1671 /* now issue the OID_GEN_PHYSICAL_MEDIUM query */
1672 DWORD Oid = OID_GEN_PHYSICAL_MEDIUM;
1673 NDIS_PHYSICAL_MEDIUM PhMedium;
1674 DWORD cbResult;
1675 if (DeviceIoControl(hDevice, IOCTL_NDIS_QUERY_GLOBAL_STATS, &Oid, sizeof(Oid), &PhMedium, sizeof(PhMedium), &cbResult, NULL))
1676 {
1677 /* that was simple, now examine PhMedium */
1678 if(PhMedium == NdisPhysicalMediumWirelessWan
1679 || PhMedium == NdisPhysicalMediumWirelessLan
1680 || PhMedium == NdisPhysicalMediumNative802_11
1681 || PhMedium == NdisPhysicalMediumBluetooth
1682 /*|| PhMedium == NdisPhysicalMediumWiMax*/
1683 )
1684 {
1685 Log(("this is a wireless adapter"));
1686 rc = CFGMR3InsertInteger(pCfg, "SharedMacOnWire", true); RC_CHECK();
1687 Log(("Set SharedMacOnWire\n"));
1688 }
1689 else
1690 {
1691 Log(("this is NOT a wireless adapter"));
1692 }
1693 }
1694 else
1695 {
1696 int winEr = GetLastError();
1697 LogRel(("Console::configConstructor: DeviceIoControl failed, err (0x%x), ignoring\n", winEr));
1698 Assert(winEr == ERROR_INVALID_PARAMETER || winEr == ERROR_NOT_SUPPORTED || winEr == ERROR_BAD_COMMAND);
1699 }
1700
1701 CloseHandle(hDevice);
1702 }
1703 else
1704 {
1705 int winEr = GetLastError();
1706 LogRel(("Console::configConstructor: CreateFile failed, err (0x%x), ignoring\n", winEr));
1707 AssertBreakpoint();
1708 }
1709
1710 CoTaskMemFree(pswzBindName);
1711
1712 pAdaptorComponent.setNull();
1713 /* release the pNc finally */
1714 VBoxNetCfgWinReleaseINetCfg( pNc, FALSE );
1715# else
1716 /** @todo PORTME: wireless detection */
1717# endif
1718
1719# if defined(RT_OS_SOLARIS)
1720# if 0 /* bird: this is a bit questionable and might cause more trouble than its worth. */
1721 /* Zone access restriction, don't allow snopping the global zone. */
1722 zoneid_t ZoneId = getzoneid();
1723 if (ZoneId != GLOBAL_ZONEID)
1724 {
1725 rc = CFGMR3InsertInteger(pCfg, "IgnoreAllPromisc", true); RC_CHECK();
1726 }
1727# endif
1728# endif
1729
1730#elif defined(RT_OS_WINDOWS) /* not defined NetFlt */
1731 /* NOTHING TO DO HERE */
1732#elif defined(RT_OS_LINUX)
1733/// @todo aleksey: is there anything to be done here?
1734#elif defined(RT_OS_FREEBSD)
1735/** @todo FreeBSD: Check out this later (HIF networking). */
1736#else
1737# error "Port me"
1738#endif
1739 }
1740 else
1741 {
1742 switch (hrc)
1743 {
1744#ifdef RT_OS_LINUX
1745 case VERR_ACCESS_DENIED:
1746 return VMSetError(pVM, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
1747 "Failed to open '/dev/net/tun' for read/write access. Please check the "
1748 "permissions of that node. Either run 'chmod 0666 /dev/net/tun' or "
1749 "change the group of that node and make yourself a member of that group. Make "
1750 "sure that these changes are permanent, especially if you are "
1751 "using udev"));
1752#endif /* RT_OS_LINUX */
1753 default:
1754 AssertMsgFailed(("Could not attach to host interface! Bad!\n"));
1755 return VMSetError(pVM, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
1756 "Failed to initialize Host Interface Networking"));
1757 }
1758 }
1759 break;
1760 }
1761
1762 case NetworkAttachmentType_Internal:
1763 {
1764 hrc = networkAdapter->COMGETTER(InternalNetwork)(&str); H();
1765 if (str)
1766 {
1767 STR_CONV();
1768 if (psz && *psz)
1769 {
1770 if (fSniffer)
1771 {
1772 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
1773 }
1774 else
1775 {
1776 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1777 }
1778 rc = CFGMR3InsertString(pLunL0, "Driver", "IntNet"); RC_CHECK();
1779 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1780 rc = CFGMR3InsertString(pCfg, "Network", psz); RC_CHECK();
1781 rc = CFGMR3InsertInteger(pCfg, "TrunkType", kIntNetTrunkType_WhateverNone); RC_CHECK();
1782 networkName = Bstr(psz);
1783 trunkType = Bstr(TRUNKTYPE_WHATEVER);
1784 }
1785 STR_FREE();
1786 }
1787 break;
1788 }
1789
1790 case NetworkAttachmentType_HostOnly:
1791 {
1792 if (fSniffer)
1793 {
1794 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); RC_CHECK();
1795 }
1796 else
1797 {
1798 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
1799 }
1800
1801 rc = CFGMR3InsertString(pLunL0, "Driver", "IntNet"); RC_CHECK();
1802 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
1803#if defined(RT_OS_WINDOWS)
1804# ifndef VBOX_WITH_NETFLT
1805 hrc = E_NOTIMPL;
1806 LogRel(("NetworkAttachmentType_HostOnly: Not Implemented"));
1807 H();
1808# else
1809 Bstr HifName;
1810 hrc = networkAdapter->COMGETTER(HostInterface)(HifName.asOutParam());
1811 if(FAILED(hrc))
1812 {
1813 LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(HostInterface) failed, hrc (0x%x)", hrc));
1814 H();
1815 }
1816
1817 Utf8Str HifNameUtf8(HifName);
1818 const char *pszHifName = HifNameUtf8.raw();
1819 ComPtr<IHostNetworkInterface> hostInterface;
1820 rc = host->FindHostNetworkInterfaceByName(HifName, hostInterface.asOutParam());
1821 if (!SUCCEEDED(rc))
1822 {
1823 AssertBreakpoint();
1824 LogRel(("NetworkAttachmentType_HostOnly: FindByName failed, rc (0x%x)", rc));
1825 return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
1826 N_("Inexistent host networking interface, name '%ls'"),
1827 HifName.raw());
1828 }
1829
1830 HostNetworkInterfaceType_T ifType;
1831 hrc = hostInterface->COMGETTER(InterfaceType)(&ifType);
1832 if(FAILED(hrc))
1833 {
1834 LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(InterfaceType) failed, hrc (0x%x)", hrc));
1835 H();
1836 }
1837
1838 if(ifType != HostNetworkInterfaceType_HostOnly)
1839 {
1840 return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
1841 N_("Interface ('%ls') is not a Host-Only Adapter interface"),
1842 HifName.raw());
1843 }
1844
1845
1846 Guid hostIFGuid;
1847 hrc = hostInterface->COMGETTER(Id)(hostIFGuid.asOutParam());
1848 if(FAILED(hrc))
1849 {
1850 LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(Id) failed, hrc (0x%x)", hrc));
1851 H();
1852 }
1853
1854 INetCfg *pNc;
1855 ComPtr<INetCfgComponent> pAdaptorComponent;
1856 LPWSTR lpszApp;
1857 int rc = VERR_INTNET_FLT_IF_NOT_FOUND;
1858
1859 hrc = VBoxNetCfgWinQueryINetCfg( FALSE,
1860 L"VirtualBox",
1861 &pNc,
1862 &lpszApp );
1863 Assert(hrc == S_OK);
1864 if(hrc == S_OK)
1865 {
1866 /* get the adapter's INetCfgComponent*/
1867 hrc = VBoxNetCfgWinGetComponentByGuid(pNc, &GUID_DEVCLASS_NET, (GUID*)hostIFGuid.ptr(), pAdaptorComponent.asOutParam());
1868 if(hrc != S_OK)
1869 {
1870 VBoxNetCfgWinReleaseINetCfg( pNc, FALSE );
1871 LogRel(("NetworkAttachmentType_HostOnly: VBoxNetCfgWinGetComponentByGuid failed, hrc (0x%x)", hrc));
1872 H();
1873 }
1874 }
1875#define VBOX_WIN_BINDNAME_PREFIX "\\DEVICE\\"
1876 char szTrunkName[INTNET_MAX_TRUNK_NAME];
1877 char *pszTrunkName = szTrunkName;
1878 wchar_t * pswzBindName;
1879 hrc = pAdaptorComponent->GetBindName(&pswzBindName);
1880 Assert(hrc == S_OK);
1881 if (hrc == S_OK)
1882 {
1883 int cwBindName = (int)wcslen(pswzBindName) + 1;
1884 int cbFullBindNamePrefix = sizeof(VBOX_WIN_BINDNAME_PREFIX);
1885 if(sizeof(szTrunkName) > cbFullBindNamePrefix + cwBindName)
1886 {
1887 strcpy(szTrunkName, VBOX_WIN_BINDNAME_PREFIX);
1888 pszTrunkName += cbFullBindNamePrefix-1;
1889 if(!WideCharToMultiByte(CP_ACP, 0, pswzBindName, cwBindName, pszTrunkName,
1890 sizeof(szTrunkName) - cbFullBindNamePrefix + 1, NULL, NULL))
1891 {
1892 Assert(0);
1893 DWORD err = GetLastError();
1894 hrc = HRESULT_FROM_WIN32(err);
1895 AssertMsgFailed(("%hrc=%Rhrc %#x\n", hrc, hrc));
1896 LogRel(("NetworkAttachmentType_HostOnly: WideCharToMultiByte failed, hr=%Rhrc (0x%x)\n", hrc, hrc));
1897 }
1898 }
1899 else
1900 {
1901 Assert(0);
1902 LogRel(("NetworkAttachmentType_HostOnly: insufficient szTrunkName buffer space\n"));
1903 /** @todo set appropriate error code */
1904 hrc = E_FAIL;
1905 }
1906
1907 if(hrc != S_OK)
1908 {
1909 Assert(0);
1910 CoTaskMemFree(pswzBindName);
1911 VBoxNetCfgWinReleaseINetCfg( pNc, FALSE );
1912 H();
1913 }
1914 }
1915 else
1916 {
1917 Assert(0);
1918 VBoxNetCfgWinReleaseINetCfg( pNc, FALSE );
1919 LogRel(("NetworkAttachmentType_HostOnly: VBoxNetCfgWinGetComponentByGuid failed, hrc (0x%x)", hrc));
1920 H();
1921 }
1922
1923
1924 CoTaskMemFree(pswzBindName);
1925
1926 pAdaptorComponent.setNull();
1927 /* release the pNc finally */
1928 VBoxNetCfgWinReleaseINetCfg( pNc, FALSE );
1929
1930 const char *pszTrunk = szTrunkName;
1931
1932
1933 /* TODO: set the proper Trunk and Network values, currently the driver uses the first adapter instance */
1934 rc = CFGMR3InsertInteger(pCfg, "TrunkType", kIntNetTrunkType_NetAdp); RC_CHECK();
1935 rc = CFGMR3InsertString(pCfg, "Trunk", pszTrunk); RC_CHECK();
1936 char szNetwork[80];
1937 RTStrPrintf(szNetwork, sizeof(szNetwork), "HostInterfaceNetworking-%s", pszHifName);
1938 rc = CFGMR3InsertString(pCfg, "Network", szNetwork); RC_CHECK();
1939 networkName = Bstr(szNetwork);
1940 trunkName = Bstr(pszTrunk);
1941 trunkType = TRUNKTYPE_NETADP;
1942# endif /* defined VBOX_WITH_NETFLT*/
1943#elif defined(RT_OS_DARWIN)
1944 rc = CFGMR3InsertString(pCfg, "Trunk", "vboxnet0"); RC_CHECK();
1945 rc = CFGMR3InsertString(pCfg, "Network", "HostInterfaceNetworking-vboxnet0"); RC_CHECK();
1946 rc = CFGMR3InsertInteger(pCfg, "TrunkType", kIntNetTrunkType_NetAdp); RC_CHECK();
1947 networkName = Bstr("HostInterfaceNetworking-vboxnet0");
1948 trunkName = Bstr("vboxnet0");
1949 trunkType = TRUNKTYPE_NETADP;
1950#else
1951 rc = CFGMR3InsertString(pCfg, "Trunk", "vboxnet0"); RC_CHECK();
1952 rc = CFGMR3InsertString(pCfg, "Network", "HostInterfaceNetworking-vboxnet0"); RC_CHECK();
1953 rc = CFGMR3InsertInteger(pCfg, "TrunkType", kIntNetTrunkType_NetFlt); RC_CHECK();
1954 networkName = Bstr("HostInterfaceNetworking-vboxnet0");
1955 trunkName = Bstr("vboxnet0");
1956 trunkType = TRUNKTYPE_NETFLT;
1957#endif
1958#if !defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT)
1959 Bstr HifName;
1960 hrc = networkAdapter->COMGETTER(HostInterface)(HifName.asOutParam());
1961 if(FAILED(hrc))
1962 {
1963 LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(HostInterface) failed, hrc (0x%x)", hrc));
1964 H();
1965 }
1966
1967 Utf8Str HifNameUtf8(HifName);
1968 const char *pszHifName = HifNameUtf8.raw();
1969 ComPtr<IHostNetworkInterface> hostInterface;
1970 rc = host->FindHostNetworkInterfaceByName(HifName, hostInterface.asOutParam());
1971 if (!SUCCEEDED(rc))
1972 {
1973 LogRel(("NetworkAttachmentType_HostOnly: FindByName failed, rc (0x%x)", rc));
1974 return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
1975 N_("Inexistent host networking interface, name '%ls'"),
1976 HifName.raw());
1977 }
1978 Bstr tmpAddr, tmpMask;
1979 hrc = virtualBox->GetExtraData(Bstr("HostOnly/vboxnet0/IPAddress"), tmpAddr.asOutParam());
1980 if (SUCCEEDED(hrc) && !tmpAddr.isNull())
1981 {
1982 hrc = virtualBox->GetExtraData(Bstr("HostOnly/vboxnet0/IPNetMask"), tmpMask.asOutParam());
1983 if (SUCCEEDED(hrc) && !tmpAddr.isEmpty())
1984 hrc = hostInterface->EnableStaticIpConfig(tmpAddr, tmpMask);
1985 }
1986 else
1987 hrc = hostInterface->EnableStaticIpConfig(Bstr(VBOXNET_IPV4ADDR_DEFAULT),
1988 Bstr(VBOXNET_IPV4MASK_DEFAULT));
1989
1990
1991 hrc = virtualBox->GetExtraData(Bstr("HostOnly/vboxnet0/IPV6Address"), tmpAddr.asOutParam());
1992 if (SUCCEEDED(hrc))
1993 hrc = virtualBox->GetExtraData(Bstr("HostOnly/vboxnet0/IPV6NetMask"), tmpMask.asOutParam());
1994 if (SUCCEEDED(hrc) && !tmpAddr.isEmpty())
1995 hrc = hostInterface->EnableStaticIpConfigV6(tmpAddr, Utf8Str(tmpMask).toUInt32());
1996#endif
1997 break;
1998 }
1999
2000 default:
2001 AssertMsgFailed(("should not get here!\n"));
2002 break;
2003 }
2004
2005 if(!networkName.isNull())
2006 {
2007 /*
2008 * Until we implement service reference counters DHCP Server will be stopped
2009 * by DHCPServerRunner destructor.
2010 */
2011 ComPtr<IDHCPServer> dhcpServer;
2012 hrc = virtualBox->FindDHCPServerByNetworkName(networkName.mutableRaw(), dhcpServer.asOutParam());
2013 if(SUCCEEDED(hrc))
2014 {
2015 /* there is a DHCP server available for this network */
2016 BOOL bEnabled;
2017 hrc = dhcpServer->COMGETTER(Enabled)(&bEnabled);
2018 if(FAILED(hrc))
2019 {
2020 LogRel(("DHCP svr: COMGETTER(Enabled) failed, hrc (0x%x)", hrc));
2021 H();
2022 }
2023
2024 if(bEnabled)
2025 hrc = dhcpServer->Start(networkName, trunkName, trunkType);
2026 }
2027 else
2028 {
2029 hrc = S_OK;
2030 }
2031 }
2032
2033 }
2034
2035 /*
2036 * Serial (UART) Ports
2037 */
2038 rc = CFGMR3InsertNode(pDevices, "serial", &pDev); RC_CHECK();
2039 for (ULONG ulInstance = 0; ulInstance < SchemaDefs::SerialPortCount; ulInstance++)
2040 {
2041 ComPtr<ISerialPort> serialPort;
2042 hrc = pMachine->GetSerialPort (ulInstance, serialPort.asOutParam()); H();
2043 BOOL fEnabled = FALSE;
2044 if (serialPort)
2045 hrc = serialPort->COMGETTER(Enabled)(&fEnabled); H();
2046 if (!fEnabled)
2047 continue;
2048
2049 char szInstance[4]; Assert(ulInstance <= 999);
2050 RTStrPrintf(szInstance, sizeof(szInstance), "%lu", ulInstance);
2051
2052 rc = CFGMR3InsertNode(pDev, szInstance, &pInst); RC_CHECK();
2053 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
2054
2055 ULONG ulIRQ, ulIOBase;
2056 PortMode_T HostMode;
2057 Bstr path;
2058 BOOL fServer;
2059 hrc = serialPort->COMGETTER(HostMode)(&HostMode); H();
2060 hrc = serialPort->COMGETTER(IRQ)(&ulIRQ); H();
2061 hrc = serialPort->COMGETTER(IOBase)(&ulIOBase); H();
2062 hrc = serialPort->COMGETTER(Path)(path.asOutParam()); H();
2063 hrc = serialPort->COMGETTER(Server)(&fServer); H();
2064 rc = CFGMR3InsertInteger(pCfg, "IRQ", ulIRQ); RC_CHECK();
2065 rc = CFGMR3InsertInteger(pCfg, "IOBase", ulIOBase); RC_CHECK();
2066 if (HostMode != PortMode_Disconnected)
2067 {
2068 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
2069 if (HostMode == PortMode_HostPipe)
2070 {
2071 rc = CFGMR3InsertString(pLunL0, "Driver", "Char"); RC_CHECK();
2072 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
2073 rc = CFGMR3InsertString(pLunL1, "Driver", "NamedPipe"); RC_CHECK();
2074 rc = CFGMR3InsertNode(pLunL1, "Config", &pLunL2); RC_CHECK();
2075 rc = CFGMR3InsertString(pLunL2, "Location", Utf8Str(path)); RC_CHECK();
2076 rc = CFGMR3InsertInteger(pLunL2, "IsServer", fServer); RC_CHECK();
2077 }
2078 else if (HostMode == PortMode_HostDevice)
2079 {
2080 rc = CFGMR3InsertString(pLunL0, "Driver", "Host Serial"); RC_CHECK();
2081 rc = CFGMR3InsertNode(pLunL0, "Config", &pLunL1); RC_CHECK();
2082 rc = CFGMR3InsertString(pLunL1, "DevicePath", Utf8Str(path)); RC_CHECK();
2083 }
2084 }
2085 }
2086
2087 /*
2088 * Parallel (LPT) Ports
2089 */
2090 rc = CFGMR3InsertNode(pDevices, "parallel", &pDev); RC_CHECK();
2091 for (ULONG ulInstance = 0; ulInstance < SchemaDefs::ParallelPortCount; ulInstance++)
2092 {
2093 ComPtr<IParallelPort> parallelPort;
2094 hrc = pMachine->GetParallelPort (ulInstance, parallelPort.asOutParam()); H();
2095 BOOL fEnabled = FALSE;
2096 if (parallelPort)
2097 hrc = parallelPort->COMGETTER(Enabled)(&fEnabled); H();
2098 if (!fEnabled)
2099 continue;
2100
2101 char szInstance[4]; Assert(ulInstance <= 999);
2102 RTStrPrintf(szInstance, sizeof(szInstance), "%lu", ulInstance);
2103
2104 rc = CFGMR3InsertNode(pDev, szInstance, &pInst); RC_CHECK();
2105 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
2106
2107 ULONG ulIRQ, ulIOBase;
2108 Bstr DevicePath;
2109 hrc = parallelPort->COMGETTER(IRQ)(&ulIRQ); H();
2110 hrc = parallelPort->COMGETTER(IOBase)(&ulIOBase); H();
2111 hrc = parallelPort->COMGETTER(Path)(DevicePath.asOutParam()); H();
2112 rc = CFGMR3InsertInteger(pCfg, "IRQ", ulIRQ); RC_CHECK();
2113 rc = CFGMR3InsertInteger(pCfg, "IOBase", ulIOBase); RC_CHECK();
2114 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
2115 rc = CFGMR3InsertString(pLunL0, "Driver", "HostParallel"); RC_CHECK();
2116 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL1); RC_CHECK();
2117 rc = CFGMR3InsertString(pLunL1, "DevicePath", Utf8Str(DevicePath)); RC_CHECK();
2118 }
2119
2120 /*
2121 * VMM Device
2122 */
2123 rc = CFGMR3InsertNode(pDevices, "VMMDev", &pDev); RC_CHECK();
2124 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
2125 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
2126 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
2127 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 4); RC_CHECK();
2128 Assert(!afPciDeviceNo[4]);
2129 afPciDeviceNo[4] = true;
2130 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
2131 Bstr hwVersion;
2132 hrc = pMachine->COMGETTER(HardwareVersion)(hwVersion.asOutParam()); H();
2133 if (hwVersion.compare(Bstr("1")) == 0) /* <= 2.0.x */
2134 {
2135 CFGMR3InsertInteger(pCfg, "HeapEnabled", 0); RC_CHECK();
2136 }
2137
2138 /* the VMM device's Main driver */
2139 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
2140 rc = CFGMR3InsertString(pLunL0, "Driver", "MainVMMDev"); RC_CHECK();
2141 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
2142 VMMDev *pVMMDev = pConsole->mVMMDev;
2143 rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pVMMDev); RC_CHECK();
2144
2145 /*
2146 * Attach the status driver.
2147 */
2148 rc = CFGMR3InsertNode(pInst, "LUN#999", &pLunL0); RC_CHECK();
2149 rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
2150 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
2151 rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapSharedFolderLed); RC_CHECK();
2152 rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
2153 rc = CFGMR3InsertInteger(pCfg, "Last", 0); RC_CHECK();
2154
2155 /*
2156 * Audio Sniffer Device
2157 */
2158 rc = CFGMR3InsertNode(pDevices, "AudioSniffer", &pDev); RC_CHECK();
2159 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
2160 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
2161
2162 /* the Audio Sniffer device's Main driver */
2163 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
2164 rc = CFGMR3InsertString(pLunL0, "Driver", "MainAudioSniffer"); RC_CHECK();
2165 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
2166 AudioSniffer *pAudioSniffer = pConsole->mAudioSniffer;
2167 rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)pAudioSniffer); RC_CHECK();
2168
2169 /*
2170 * AC'97 ICH / SoundBlaster16 audio
2171 */
2172 BOOL enabled;
2173 ComPtr<IAudioAdapter> audioAdapter;
2174 hrc = pMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam()); H();
2175 if (audioAdapter)
2176 hrc = audioAdapter->COMGETTER(Enabled)(&enabled); H();
2177
2178 if (enabled)
2179 {
2180 AudioControllerType_T audioController;
2181 hrc = audioAdapter->COMGETTER(AudioController)(&audioController); H();
2182 switch (audioController)
2183 {
2184 case AudioControllerType_AC97:
2185 {
2186 /* default: ICH AC97 */
2187 rc = CFGMR3InsertNode(pDevices, "ichac97", &pDev); RC_CHECK();
2188 rc = CFGMR3InsertNode(pDev, "0", &pInst);
2189 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* bool */ RC_CHECK();
2190 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 5); RC_CHECK();
2191 Assert(!afPciDeviceNo[5]);
2192 afPciDeviceNo[5] = true;
2193 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
2194 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
2195 break;
2196 }
2197 case AudioControllerType_SB16:
2198 {
2199 /* legacy SoundBlaster16 */
2200 rc = CFGMR3InsertNode(pDevices, "sb16", &pDev); RC_CHECK();
2201 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
2202 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* bool */ RC_CHECK();
2203 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
2204 rc = CFGMR3InsertInteger(pCfg, "IRQ", 5); RC_CHECK();
2205 rc = CFGMR3InsertInteger(pCfg, "DMA", 1); RC_CHECK();
2206 rc = CFGMR3InsertInteger(pCfg, "DMA16", 5); RC_CHECK();
2207 rc = CFGMR3InsertInteger(pCfg, "Port", 0x220); RC_CHECK();
2208 rc = CFGMR3InsertInteger(pCfg, "Version", 0x0405); RC_CHECK();
2209 break;
2210 }
2211 }
2212
2213 /* the Audio driver */
2214 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
2215 rc = CFGMR3InsertString(pLunL0, "Driver", "AUDIO"); RC_CHECK();
2216 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
2217
2218 AudioDriverType_T audioDriver;
2219 hrc = audioAdapter->COMGETTER(AudioDriver)(&audioDriver); H();
2220 switch (audioDriver)
2221 {
2222 case AudioDriverType_Null:
2223 {
2224 rc = CFGMR3InsertString(pCfg, "AudioDriver", "null"); RC_CHECK();
2225 break;
2226 }
2227#ifdef RT_OS_WINDOWS
2228#ifdef VBOX_WITH_WINMM
2229 case AudioDriverType_WinMM:
2230 {
2231 rc = CFGMR3InsertString(pCfg, "AudioDriver", "winmm"); RC_CHECK();
2232 break;
2233 }
2234#endif
2235 case AudioDriverType_DirectSound:
2236 {
2237 rc = CFGMR3InsertString(pCfg, "AudioDriver", "dsound"); RC_CHECK();
2238 break;
2239 }
2240#endif /* RT_OS_WINDOWS */
2241#ifdef RT_OS_SOLARIS
2242 case AudioDriverType_SolAudio:
2243 {
2244 rc = CFGMR3InsertString(pCfg, "AudioDriver", "solaudio"); RC_CHECK();
2245 break;
2246 }
2247#endif
2248#ifdef RT_OS_LINUX
2249 case AudioDriverType_OSS:
2250 {
2251 rc = CFGMR3InsertString(pCfg, "AudioDriver", "oss"); RC_CHECK();
2252 break;
2253 }
2254# ifdef VBOX_WITH_ALSA
2255 case AudioDriverType_ALSA:
2256 {
2257 rc = CFGMR3InsertString(pCfg, "AudioDriver", "alsa"); RC_CHECK();
2258 break;
2259 }
2260# endif
2261# ifdef VBOX_WITH_PULSE
2262 case AudioDriverType_Pulse:
2263 {
2264 rc = CFGMR3InsertString(pCfg, "AudioDriver", "pulse"); RC_CHECK();
2265 break;
2266 }
2267# endif
2268#endif /* RT_OS_LINUX */
2269#ifdef RT_OS_DARWIN
2270 case AudioDriverType_CoreAudio:
2271 {
2272 rc = CFGMR3InsertString(pCfg, "AudioDriver", "coreaudio"); RC_CHECK();
2273 break;
2274 }
2275#endif
2276 }
2277 hrc = pMachine->COMGETTER(Name)(&str); H();
2278 STR_CONV();
2279 rc = CFGMR3InsertString(pCfg, "StreamName", psz); RC_CHECK();
2280 STR_FREE();
2281 }
2282
2283 /*
2284 * The USB Controller.
2285 */
2286 ComPtr<IUSBController> USBCtlPtr;
2287 hrc = pMachine->COMGETTER(USBController)(USBCtlPtr.asOutParam());
2288 if (USBCtlPtr)
2289 {
2290 BOOL fEnabled;
2291 hrc = USBCtlPtr->COMGETTER(Enabled)(&fEnabled); H();
2292 if (fEnabled)
2293 {
2294 rc = CFGMR3InsertNode(pDevices, "usb-ohci", &pDev); RC_CHECK();
2295 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
2296 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
2297 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ RC_CHECK();
2298 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 6); RC_CHECK();
2299 Assert(!afPciDeviceNo[6]);
2300 afPciDeviceNo[6] = true;
2301 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
2302
2303 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
2304 rc = CFGMR3InsertString(pLunL0, "Driver", "VUSBRootHub"); RC_CHECK();
2305 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
2306
2307 /*
2308 * Attach the status driver.
2309 */
2310 rc = CFGMR3InsertNode(pInst, "LUN#999", &pLunL0); RC_CHECK();
2311 rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
2312 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
2313 rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapUSBLed[0]);RC_CHECK();
2314 rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
2315 rc = CFGMR3InsertInteger(pCfg, "Last", 0); RC_CHECK();
2316
2317#ifdef VBOX_WITH_EHCI
2318 hrc = USBCtlPtr->COMGETTER(EnabledEhci)(&fEnabled); H();
2319 if (fEnabled)
2320 {
2321 rc = CFGMR3InsertNode(pDevices, "usb-ehci", &pDev); RC_CHECK();
2322 rc = CFGMR3InsertNode(pDev, "0", &pInst); RC_CHECK();
2323 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); RC_CHECK();
2324 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* bool */ RC_CHECK();
2325 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 11); RC_CHECK();
2326 Assert(!afPciDeviceNo[11]);
2327 afPciDeviceNo[11] = true;
2328 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); RC_CHECK();
2329
2330 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); RC_CHECK();
2331 rc = CFGMR3InsertString(pLunL0, "Driver", "VUSBRootHub"); RC_CHECK();
2332 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
2333
2334 /*
2335 * Attach the status driver.
2336 */
2337 rc = CFGMR3InsertNode(pInst, "LUN#999", &pLunL0); RC_CHECK();
2338 rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); RC_CHECK();
2339 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); RC_CHECK();
2340 rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&pConsole->mapUSBLed[1]);RC_CHECK();
2341 rc = CFGMR3InsertInteger(pCfg, "First", 0); RC_CHECK();
2342 rc = CFGMR3InsertInteger(pCfg, "Last", 0); RC_CHECK();
2343 }
2344 else
2345#endif
2346 {
2347 /*
2348 * Global USB options, currently unused as we'll apply the 2.0 -> 1.1 morphing
2349 * on a per device level now.
2350 */
2351 rc = CFGMR3InsertNode(pRoot, "USB", &pCfg); RC_CHECK();
2352 rc = CFGMR3InsertNode(pCfg, "USBProxy", &pCfg); RC_CHECK();
2353 rc = CFGMR3InsertNode(pCfg, "GlobalConfig", &pCfg); RC_CHECK();
2354 // This globally enables the 2.0 -> 1.1 device morphing of proxied devies to keep windows quiet.
2355 //rc = CFGMR3InsertInteger(pCfg, "Force11Device", true); RC_CHECK();
2356 // The following breaks stuff, but it makes MSDs work in vista. (I include it here so
2357 // that it's documented somewhere.) Users needing it can use:
2358 // VBoxManage setextradata "myvm" "VBoxInternal/USB/USBProxy/GlobalConfig/Force11PacketSize" 1
2359 //rc = CFGMR3InsertInteger(pCfg, "Force11PacketSize", true); RC_CHECK();
2360 }
2361 }
2362 }
2363
2364 /*
2365 * Clipboard
2366 */
2367 {
2368 ClipboardMode_T mode = ClipboardMode_Disabled;
2369 hrc = pMachine->COMGETTER(ClipboardMode) (&mode); H();
2370
2371 if (mode != ClipboardMode_Disabled)
2372 {
2373 /* Load the service */
2374 rc = pConsole->mVMMDev->hgcmLoadService ("VBoxSharedClipboard", "VBoxSharedClipboard");
2375
2376 if (RT_FAILURE (rc))
2377 {
2378 LogRel(("VBoxSharedClipboard is not available. rc = %Rrc\n", rc));
2379 /* That is not a fatal failure. */
2380 rc = VINF_SUCCESS;
2381 }
2382 else
2383 {
2384 /* Setup the service. */
2385 VBOXHGCMSVCPARM parm;
2386
2387 parm.type = VBOX_HGCM_SVC_PARM_32BIT;
2388
2389 switch (mode)
2390 {
2391 default:
2392 case ClipboardMode_Disabled:
2393 {
2394 LogRel(("VBoxSharedClipboard mode: Off\n"));
2395 parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_OFF;
2396 break;
2397 }
2398 case ClipboardMode_GuestToHost:
2399 {
2400 LogRel(("VBoxSharedClipboard mode: Guest to Host\n"));
2401 parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST;
2402 break;
2403 }
2404 case ClipboardMode_HostToGuest:
2405 {
2406 LogRel(("VBoxSharedClipboard mode: Host to Guest\n"));
2407 parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST;
2408 break;
2409 }
2410 case ClipboardMode_Bidirectional:
2411 {
2412 LogRel(("VBoxSharedClipboard mode: Bidirectional\n"));
2413 parm.u.uint32 = VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL;
2414 break;
2415 }
2416 }
2417
2418 pConsole->mVMMDev->hgcmHostCall ("VBoxSharedClipboard", VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE, 1, &parm);
2419
2420 Log(("Set VBoxSharedClipboard mode\n"));
2421 }
2422 }
2423 }
2424
2425#ifdef VBOX_WITH_CROGL
2426/* Currently broken on Snow Leopard 64-bit */
2427# if !(defined(RT_OS_DARWIN) && defined(RT_ARCH_AMD64))
2428 /*
2429 * crOpenGL
2430 */
2431 {
2432 BOOL fEnabled = false;
2433 hrc = pMachine->COMGETTER(Accelerate3DEnabled) (&fEnabled); H();
2434
2435 if (fEnabled)
2436 {
2437 /* Load the service */
2438 rc = pConsole->mVMMDev->hgcmLoadService ("VBoxSharedCrOpenGL", "VBoxSharedCrOpenGL");
2439 if (RT_FAILURE(rc))
2440 {
2441 LogRel(("Failed to load Shared OpenGL service %Rrc\n", rc));
2442 /* That is not a fatal failure. */
2443 rc = VINF_SUCCESS;
2444 }
2445 else
2446 {
2447 LogRel(("Shared crOpenGL service loaded.\n"));
2448
2449 /* Setup the service. */
2450 VBOXHGCMSVCPARM parm;
2451 parm.type = VBOX_HGCM_SVC_PARM_PTR;
2452
2453 //parm.u.pointer.addr = static_cast <IConsole *> (pData->pVMMDev->getParent());
2454 parm.u.pointer.addr = pConsole->mVMMDev->getParent()->getDisplay()->getFramebuffer();
2455 parm.u.pointer.size = sizeof(IFramebuffer *);
2456
2457 rc = pConsole->mVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SET_FRAMEBUFFER, 1, &parm);
2458 if (!RT_SUCCESS(rc))
2459 AssertMsgFailed(("SHCRGL_HOST_FN_SET_FRAMEBUFFER failed with %Rrc\n", rc));
2460 }
2461 }
2462 }
2463# endif
2464#endif
2465
2466#ifdef VBOX_WITH_GUEST_PROPS
2467 /*
2468 * Guest property service
2469 */
2470 {
2471 /* Load the service */
2472 rc = pConsole->mVMMDev->hgcmLoadService ("VBoxGuestPropSvc", "VBoxGuestPropSvc");
2473
2474 if (RT_FAILURE (rc))
2475 {
2476 LogRel(("VBoxGuestPropSvc is not available. rc = %Rrc\n", rc));
2477 /* That is not a fatal failure. */
2478 rc = VINF_SUCCESS;
2479 }
2480 else
2481 {
2482 /* Pull over the properties from the server. */
2483 SafeArray <BSTR> namesOut;
2484 SafeArray <BSTR> valuesOut;
2485 SafeArray <ULONG64> timestampsOut;
2486 SafeArray <BSTR> flagsOut;
2487 hrc = pConsole->mControl->PullGuestProperties(ComSafeArrayAsOutParam(namesOut),
2488 ComSafeArrayAsOutParam(valuesOut),
2489 ComSafeArrayAsOutParam(timestampsOut),
2490 ComSafeArrayAsOutParam(flagsOut)); H();
2491 size_t cProps = namesOut.size();
2492 if ( valuesOut.size() != cProps
2493 || timestampsOut.size() != cProps
2494 || flagsOut.size() != cProps
2495 )
2496 rc = VERR_INVALID_PARAMETER;
2497
2498 std::vector <Utf8Str> utf8Names, utf8Values, utf8Flags;
2499 std::vector <char *> names, values, flags;
2500 std::vector <ULONG64> timestamps;
2501 for (unsigned i = 0; i < cProps && RT_SUCCESS(rc); ++i)
2502 if ( !VALID_PTR(namesOut[i])
2503 || !VALID_PTR(valuesOut[i])
2504 || !VALID_PTR(flagsOut[i])
2505 )
2506 rc = VERR_INVALID_POINTER;
2507 for (unsigned i = 0; i < cProps && RT_SUCCESS(rc); ++i)
2508 {
2509 utf8Names.push_back(Bstr(namesOut[i]));
2510 utf8Values.push_back(Bstr(valuesOut[i]));
2511 timestamps.push_back(timestampsOut[i]);
2512 utf8Flags.push_back(Bstr(flagsOut[i]));
2513 if ( utf8Names.back().isNull()
2514 || utf8Values.back().isNull()
2515 || utf8Flags.back().isNull()
2516 )
2517 throw std::bad_alloc();
2518 }
2519 for (unsigned i = 0; i < cProps && RT_SUCCESS(rc); ++i)
2520 {
2521 names.push_back(utf8Names[i].mutableRaw());
2522 values.push_back(utf8Values[i].mutableRaw());
2523 flags.push_back(utf8Flags[i].mutableRaw());
2524 }
2525 names.push_back(NULL);
2526 values.push_back(NULL);
2527 timestamps.push_back(0);
2528 flags.push_back(NULL);
2529
2530 /* Setup the service. */
2531 VBOXHGCMSVCPARM parms[4];
2532
2533 parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
2534 parms[0].u.pointer.addr = &names.front();
2535 parms[0].u.pointer.size = 0; /* We don't actually care. */
2536 parms[1].type = VBOX_HGCM_SVC_PARM_PTR;
2537 parms[1].u.pointer.addr = &values.front();
2538 parms[1].u.pointer.size = 0; /* We don't actually care. */
2539 parms[2].type = VBOX_HGCM_SVC_PARM_PTR;
2540 parms[2].u.pointer.addr = &timestamps.front();
2541 parms[2].u.pointer.size = 0; /* We don't actually care. */
2542 parms[3].type = VBOX_HGCM_SVC_PARM_PTR;
2543 parms[3].u.pointer.addr = &flags.front();
2544 parms[3].u.pointer.size = 0; /* We don't actually care. */
2545
2546 pConsole->mVMMDev->hgcmHostCall ("VBoxGuestPropSvc", guestProp::SET_PROPS_HOST, 4, &parms[0]);
2547
2548 /* Register the host notification callback */
2549 HGCMSVCEXTHANDLE hDummy;
2550 HGCMHostRegisterServiceExtension (&hDummy, "VBoxGuestPropSvc",
2551 Console::doGuestPropNotification,
2552 pvConsole);
2553
2554 Log(("Set VBoxGuestPropSvc property store\n"));
2555 }
2556 }
2557#endif /* VBOX_WITH_GUEST_PROPS defined */
2558
2559 /*
2560 * CFGM overlay handling.
2561 *
2562 * Here we check the extra data entries for CFGM values
2563 * and create the nodes and insert the values on the fly. Existing
2564 * values will be removed and reinserted. CFGM is typed, so by default
2565 * we will guess whether it's a string or an integer (byte arrays are
2566 * not currently supported). It's possible to override this autodetection
2567 * by adding "string:", "integer:" or "bytes:" (future).
2568 *
2569 * We first perform a run on global extra data, then on the machine
2570 * extra data to support global settings with local overrides.
2571 *
2572 */
2573 /** @todo add support for removing nodes and byte blobs. */
2574 Bstr strExtraDataKey;
2575 bool fGlobalExtraData = true;
2576 for (;;)
2577 {
2578 /*
2579 * Get the next key
2580 */
2581 Bstr strNextExtraDataKey;
2582 Bstr strExtraDataValue;
2583 if (fGlobalExtraData)
2584 hrc = virtualBox->GetNextExtraDataKey(strExtraDataKey, strNextExtraDataKey.asOutParam(),
2585 strExtraDataValue.asOutParam());
2586 else
2587 hrc = pMachine->GetNextExtraDataKey(strExtraDataKey, strNextExtraDataKey.asOutParam(),
2588 strExtraDataValue.asOutParam());
2589
2590 /* stop if for some reason there's nothing more to request */
2591 if (FAILED(hrc) || !strNextExtraDataKey)
2592 {
2593 /* if we're out of global keys, continue with machine, otherwise we're done */
2594 if (fGlobalExtraData)
2595 {
2596 fGlobalExtraData = false;
2597 strExtraDataKey.setNull();
2598 continue;
2599 }
2600 break;
2601 }
2602 strExtraDataKey = strNextExtraDataKey;
2603
2604 /*
2605 * We only care about keys starting with "VBoxInternal/"
2606 */
2607 Utf8Str strExtraDataKeyUtf8(strExtraDataKey);
2608 char *pszExtraDataKey = (char *)strExtraDataKeyUtf8.raw();
2609 if (strncmp(pszExtraDataKey, "VBoxInternal/", sizeof("VBoxInternal/") - 1) != 0)
2610 continue;
2611 pszExtraDataKey += sizeof("VBoxInternal/") - 1;
2612
2613 /*
2614 * The key will be in the format "Node1/Node2/Value" or simply "Value".
2615 * Split the two and get the node, delete the value and create the node
2616 * if necessary.
2617 */
2618 PCFGMNODE pNode;
2619 char *pszCFGMValueName = strrchr(pszExtraDataKey, '/');
2620 if (pszCFGMValueName)
2621 {
2622 /* terminate the node and advance to the value (Utf8Str might not
2623 offically like this but wtf) */
2624 *pszCFGMValueName = '\0';
2625 pszCFGMValueName++;
2626
2627 /* does the node already exist? */
2628 pNode = CFGMR3GetChild(pRoot, pszExtraDataKey);
2629 if (pNode)
2630 CFGMR3RemoveValue(pNode, pszCFGMValueName);
2631 else
2632 {
2633 /* create the node */
2634 rc = CFGMR3InsertNode(pRoot, pszExtraDataKey, &pNode);
2635 if (RT_FAILURE(rc))
2636 {
2637 AssertLogRelMsgRC(rc, ("failed to insert node '%s'\n", pszExtraDataKey));
2638 continue;
2639 }
2640 Assert(pNode);
2641 }
2642 }
2643 else
2644 {
2645 /* root value (no node path). */
2646 pNode = pRoot;
2647 pszCFGMValueName = pszExtraDataKey;
2648 pszExtraDataKey--;
2649 CFGMR3RemoveValue(pNode, pszCFGMValueName);
2650 }
2651
2652 /*
2653 * Now let's have a look at the value.
2654 * Empty strings means that we should remove the value, which we've
2655 * already done above.
2656 */
2657 Utf8Str strCFGMValueUtf8(strExtraDataValue);
2658 const char *pszCFGMValue = strCFGMValueUtf8.raw();
2659 if ( pszCFGMValue
2660 && *pszCFGMValue)
2661 {
2662 uint64_t u64Value;
2663
2664 /* check for type prefix first. */
2665 if (!strncmp(pszCFGMValue, "string:", sizeof("string:") - 1))
2666 rc = CFGMR3InsertString(pNode, pszCFGMValueName, pszCFGMValue + sizeof("string:") - 1);
2667 else if (!strncmp(pszCFGMValue, "integer:", sizeof("integer:") - 1))
2668 {
2669 rc = RTStrToUInt64Full(pszCFGMValue + sizeof("integer:") - 1, 0, &u64Value);
2670 if (RT_SUCCESS(rc))
2671 rc = CFGMR3InsertInteger(pNode, pszCFGMValueName, u64Value);
2672 }
2673 else if (!strncmp(pszCFGMValue, "bytes:", sizeof("bytes:") - 1))
2674 rc = VERR_NOT_IMPLEMENTED;
2675 /* auto detect type. */
2676 else if (RT_SUCCESS(RTStrToUInt64Full(pszCFGMValue, 0, &u64Value)))
2677 rc = CFGMR3InsertInteger(pNode, pszCFGMValueName, u64Value);
2678 else
2679 rc = CFGMR3InsertString(pNode, pszCFGMValueName, pszCFGMValue);
2680 AssertLogRelMsgRC(rc, ("failed to insert CFGM value '%s' to key '%s'\n", pszCFGMValue, pszExtraDataKey));
2681 }
2682 }
2683
2684#undef H
2685#undef RC_CHECK
2686#undef STR_FREE
2687#undef STR_CONV
2688
2689 /* Register VM state change handler */
2690 int rc2 = VMR3AtStateRegister (pVM, Console::vmstateChangeCallback, pConsole);
2691 AssertRC (rc2);
2692 if (RT_SUCCESS (rc))
2693 rc = rc2;
2694
2695 /* Register VM runtime error handler */
2696 rc2 = VMR3AtRuntimeErrorRegister (pVM, Console::setVMRuntimeErrorCallback, pConsole);
2697 AssertRC (rc2);
2698 if (RT_SUCCESS (rc))
2699 rc = rc2;
2700
2701 /* Save the VM pointer in the machine object */
2702 pConsole->mpVM = pVM;
2703
2704 LogFlowFunc (("vrc = %Rrc\n", rc));
2705 LogFlowFuncLeave();
2706
2707 return rc;
2708}
2709/* 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