VirtualBox

Version 56 (modified by Frank Mehnert, 7 years ago) ( diff )

typo

Windows build instructions

As VirtualBox is a cross platform project, we use a cross platform build system meaning that there won't be any Visual C++ project files that you can open and just build. Instead, you have to follow these steps but they aren't overly difficult.

Prerequisites

  • Windows 10, Windows 8.1, Windows 8 or Windows 7.
    Older versions of Windows might work.
  • Visual Studio 2010 with service pack 1.
  • Qt v5.6.x or later
    Note! This has to be built with the Visual C++ compiler mentioned above.
    Use --with-qt5= to specify the path for configure.vbs.
  • SDL v1.2.7 or later development package (VC6):
    ​http://www.libsdl.org/download-1.2.php
    Use --with-libsdl= to specify the path for configure.vbs.
    Use --disable-sdl to disable the SDL frontend and to remove the dependency to SDL.
  • the zlib library. Grab the sources from:
    ​http://www.zlib.net/
    Actually the tarball includes zlib in the src\libs\ directory so downloading this library is only necessary if you need a more recent version. In that case look for SDK_VBOX_ZLIB_INCS and SDK_VBOX_ZLIB_LIBS in Config.kmk and override these entries in your LocalConfig.kmk accordingly. See below for some notes about using LocalConfig.kmk to override the default build configuration).
  • the cURL library. Grab the binaries from:
    ​http://curl.haxx.se/download.html
    (use the devel version without SSL support)
    Use --with-libcurl= to specify the path for configure.vbs. For building the 64-bit target you need to add --with-libcurl32= to specify the path to the 32-bit cURL development package as both cURL variants (32-bit and 64-bit) are required then.
  • OpenSSL 1.1.0. Grab the binaries from:
    ​https://slproweb.com/products/Win32OpenSSL.html
    Use --with-openssl= to specify the path for configure.vbs. For building the 64-bit target you need to add --with-openssl32= to specify the path to the 32-bit OpenSSL development package as both OpenSSL variants (32-bit and 64-bit) are required then.
  • code signing utilities (64-bit Windows only).
    Normally part of the WDK: certmgr.exe, makecert.exe, signtool.exe and so on.

Manual compilation of certain prerequisites

If you don't find development packages of certain prerequisites it's also possible to manually compile them. For instance, there does not seem to be proper libcurl packages avaible for Windows which contain libcurl.lib, libcurl.dll' files and the include\` directory.

To manually build the cURL devel package on Windows you have to

  1. Take care that the compiler binary path is part of the PATH environment variable, usually the bin\ directory of the installation directory. That directory has to contain cl.exe, link.exe, lib.exe, nmake.exe etc. Take care to specify the correct architecture path (amd64 or x86).
  2. Set the INCLUDE environment variable to include the compilers atlmfc\include\ (ATL/MFC) and include\ directories.
  3. Set the LIB environment variable to include the compilers atlmfc\lib\ (ATL/MFC) and lib\ directories. Take care to specify the correct architecture path (amd64 or x86).
  4. Set the LIBPATH environment variable to include the compilers atlmfc\lib\ (ATL/MFC) directory. Take care to specify the correct architecture path (amd64 or x86).
  5. Set the PATH environment variable to include the (7.1) SDK bin\ directory. Take care to point to the correct architecture path (amd64 or x86).
  6. Set the INCLUDE environment variable to include the (7.1) SDK include\ directory.
  7. Set the LIB environment variable to include the (7.1) SDK lib\ directory. Take care to specify the correct architecture path (amd64 or x86).

After all these environment variables are set up, go to the curl-VERSION\winbuild\ directory and perform 

nmake /f Makefile.vc mode=dll VC=10 MACHINE=x64 or
nmake /f Makefile.vc mode=dll VC=10 MACHINE=x86

The resulting package can be found in the builds\libcurl-vc10-*-winssl\ directory. The configure.vbs script expects that libcurl.lib and libcurl.dll are located next to the include\ directory. It's a good idea to copy the libcurl-vc10-*-winssl\ directory to another place. Then use the --with-libcurl= parameter to specify the path for configure.vbs.

Building VirtualBox

  1. Change to the root directory and execute our configure script to setup your build environment: 
    cscript configure.vbs
    If the script finds all the tools necessary, it will output two files: AutoConfig.kmk containing information where to find the tools on your system and env.bat, a batch file to setup your environment for building VirtualBox. You only have to execute this step once, unless something about your tools changes in which case you have to repeat the above step. Keep in mind that the script always overwrites the two generated files so you should not manually edit them.

The default target will be the same target as the host, that is, on a 32-bit host the environment will be set up to compile the 32-bit VirtualBox target (x86) while on a 64-bit host the environment will be set up to compile the 64-bit VirtualBox target (amd64). The default setting can be overridden by using the --target-arch= parameter.

  1. Change to the root directory of the sources and enter our build shell environment: env.bat.
  1. To manually override any tool or change Config.kmk settings, create LocalConfig.kmk in the root directory of the sources and place the setting there. See below for an incomplete of possible settings.
  1. To build a release package, type kmk. This produces the binaries in out\win.x86\release\bin (or out\win.amd64\release\bin on 64-bit hosts). If you want to build a debug version, enter kmk KBUILD_TYPE=debug.
  1. To create an .msi package, type `kmk packing'.
    This step will fail for a 64-bit (amd64) target if the Guest Additions are part of the build process (which is the default). It will complain about a dependency to VBoxOGL* libraries in out\win.x86\release\bin\additions. In that case, create the 32-bit Guest Additions by executing 
    kmk VBOX_ONLY_ADDITIONS=1 KBUILD_TARGET_ARCH=x86
    After that, type kmk packing again and it should succeed.

Using Visual C++ 2010 Express

If you don't have a Visual C++ license you can use ​Visual C++ 2010 Express. However, you will not be able to build any frontend because the VirtualBox COM API - which all the other front ends program against - requires the Active Template Library (ATL) to build, and unfortunately the express edition doesn't include this (see ​http://msdn.microsoft.com/vstudio/express/support/faq/#vcpp).

When doing the first build step, you have to add --with-VC-Express-Edition to the argument list: 

cscript configure.vbs --with-VC-Express-Edition

Excluding certain features from building

Here is an incomplete list of settings which could be added to LocalConfig.kmk:

VBOX_WITH_ADDITIONS=
Don't build the VirtualBox Guest Additions.
VBOX_ONLY_ADDITIONS=1
Build the Guest Additions exclusively.
VBOX_WITH_VALIDATIONKIT=
Don't build the !VirtualBVox validation kit.
VBOX_WITHOUT_HARDENING=1
Disable Windows hardening. Useful for testing. Do not use this setting for production builds! Without hardening the binaries are not signed and VirtualBox.exe can be started straight away from the out\...\bin directory (kmk packing + installation not required).

Only for 64 bit builds: setting up self signing

Part 1: creating and installing the test certificate

  1. Launch an elevated command line shell (Vista and later).
  2. makecert.exe -r -pe -ss my -n "CN=MyTestCertificate" mytestcert.cer
  3. certmgr.exe -add mytestcert.cer -s -r localMachine root
  4. Start certmgr.exe and check that "MyTestCertificate" is listed both under "Personal" and "Trusted Root Certification Authorities".
    If you have a self-signed certificate installed and upgrade to Windows 10 it might happen that the certificate is still listed under "Trusted Root Certification Authorities" but not under "Personal" anymore. In that case, remove the old certificate using certmgr.msc and create a new certificate (see above) and install it.
  5. Keep the mytestcert.cer file in a safe place.

Part 2: configuring the system to run test signed code (Vista and later)

  1. Launch an elevated command line shell (Vista and later).
  2. Run Bcdedit.exe -set TESTSIGNING ON on an elevated cmd.exe prompt.
  3. certmgr.exe -add mytestcert.cer -s -r localMachine root
  4. certmgr.exe -add mytestcert.cer -s -r localMachine trustedpublisher
  5. Reboot.
  6. Vista: "Test Mode" will appear in all four corners of the desktop and "Microsoft (R) Windows (R) (Build 6000)" will appear on the top. Windows 7: "Test Mode<CR>Windows 7<CR>Build 7600" will appear in the lower right corner.

Part 3: building VirtualBox with signing enabled

  1. If you called the certificate something other than MyTestCertificate you'll have make the appropriate overrides in LocalConfig.kmk. See the Code Signing section of Config.kmk for what can be overridden.
  2. Add VBOX_SIGNING_MODE=test to LocalConfig.kmk.
  3. Build (incremental is sufficient).

Running VirtualBox

VirtualBox requires devices drivers and COM classes to operate. Whenever these change, you will have to re-register them. In order to re-register the COM classes, execute 

comregister.cmd

which can be found in the output directory (out\win.ARCH\release\bin). Note that for this to work, VBoxSVC.exe must not be running, so use the Windows task manager to verify this. Usually VBoxSVC.exe terminates automatically after 5 seconds of inactivity (i.e. no client connection) but especially when developing, it might sometimes stay around. In case the COM classes change (this usually happens when the file VirtualBox.xidl is updated) and you forget to re-register the classes, weird problems may appear.

Before you can start any binary from the output directory you have to make sure that external libraries (for example libcurl.dll or libcrypto.dll) are located in a directory which is accessible by the PATH variable or by copying these libraries to the output directory.

In order to (re-)install the VirtualBox kernel drivers, issue the following: 

loadall.cmd

Starting VirtualBox is accomplished by invoking one of its frontends, such as 

VirtualBox.exe

or 

VBoxHeadless.exe
Note: See TracWiki for help on using the wiki.

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