Index: /trunk/include/VBox/log.h =================================================================== --- /trunk/include/VBox/log.h (revision 79731) +++ /trunk/include/VBox/log.h (revision 79732) @@ -371,4 +371,14 @@ /** Main group, IDataStream. */ LOG_GROUP_MAIN_DATASTREAM, + /** Main group, IDHCPConfig. */ + LOG_GROUP_MAIN_DHCPCONFIG, + /** Main group, IDHCPGlobalConfig. */ + LOG_GROUP_MAIN_DHCPGLOBALCONFIG, + /** Main group, IDHCPGroupCondition. */ + LOG_GROUP_MAIN_DHCPGROUPCONDITION, + /** Main group, IDHCPGroupConfig. */ + LOG_GROUP_MAIN_DHCPGROUPCONFIG, + /** Main group, IDHCPIndividualConfig. */ + LOG_GROUP_MAIN_DHCPINDIVIDUALCONFIG, /** Main group, IDHCPServer. */ LOG_GROUP_MAIN_DHCPSERVER, @@ -892,4 +902,9 @@ "MAIN_DATAMODEL", \ "MAIN_DATASTREAM", \ + "MAIN_DHCPCONFIG", \ + "MAIN_DHCPGLOBALCONFIG", \ + "MAIN_DHCPGROUPCONDITION", \ + "MAIN_DHCPGROUPCONFIG", \ + "MAIN_DHCPINDIVIDUALCONFIG", \ "MAIN_DHCPSERVER", \ "MAIN_DIRECTORY", \ Index: /trunk/include/VBox/settings.h =================================================================== --- /trunk/include/VBox/settings.h (revision 79731) +++ /trunk/include/VBox/settings.h (revision 79732) @@ -338,8 +338,8 @@ { DhcpOptValue(); - DhcpOptValue(const com::Utf8Str &aText, DhcpOptEncoding_T aEncoding = DhcpOptEncoding_Legacy); - - com::Utf8Str text; - DhcpOptEncoding_T encoding; + DhcpOptValue(const com::Utf8Str &aText, DHCPOptionEncoding_T aEncoding = DHCPOptionEncoding_Legacy); + + com::Utf8Str strValue; + DHCPOptionEncoding_T enmEncoding; }; @@ -349,18 +349,25 @@ typedef DhcpOptionMap::const_iterator DhcpOptConstIterator; -typedef struct VmNameSlotKey -{ - VmNameSlotKey(const com::Utf8Str& aVmName, LONG aSlot); - - bool operator<(const VmNameSlotKey& that) const; - - const com::Utf8Str VmName; - LONG Slot; -} VmNameSlotKey; - -typedef std::map VmSlot2OptionsMap; -typedef VmSlot2OptionsMap::value_type VmSlot2OptionsPair; -typedef VmSlot2OptionsMap::iterator VmSlot2OptionsIterator; -typedef VmSlot2OptionsMap::const_iterator VmSlot2OptionsConstIterator; +struct DHCPConfig +{ + DHCPConfig(); + + DhcpOptionMap OptionMap; + uint32_t secMinLeaseTime; + uint32_t secDefaultLeaseTime; + uint32_t secMaxLeaseTime; +}; + +struct DHCPIndividualConfig : DHCPConfig +{ + DHCPIndividualConfig(); + + com::Utf8Str strMACAddress; + com::Utf8Str strVMName; + ULONG uSlot; + com::Utf8Str strFixedAddress; +}; + +typedef std::map DHCPIndividualConfigMap; struct DHCPServer @@ -368,11 +375,11 @@ DHCPServer(); - com::Utf8Str strNetworkName, - strIPAddress, - strIPLower, - strIPUpper; - bool fEnabled; - DhcpOptionMap GlobalDhcpOptions; - VmSlot2OptionsMap VmSlot2OptionsM; + com::Utf8Str strNetworkName; + com::Utf8Str strIPAddress; + com::Utf8Str strIPLower; + com::Utf8Str strIPUpper; + bool fEnabled; + DHCPConfig GlobalConfig; + DHCPIndividualConfigMap IndividualConfigs; }; @@ -409,6 +416,4 @@ void readMachineRegistry(const xml::ElementNode &elmMachineRegistry); - void readDHCPServers(const xml::ElementNode &elmDHCPServers); - void readDhcpOptions(DhcpOptionMap& map, const xml::ElementNode& options); void readNATNetworks(const xml::ElementNode &elmNATNetworks); @@ -427,4 +432,8 @@ void buildUSBDeviceSources(xml::ElementNode &elmParent, const USBDeviceSourcesList &ll); void readUSBDeviceSources(const xml::ElementNode &elmDeviceSources, USBDeviceSourcesList &ll); + void buildDHCPServers(xml::ElementNode &elmDHCPServers, DHCPServersList const &ll); + void buildDHCPOptions(xml::ElementNode &elmOptions, DHCPConfig const &rConfig, bool fIgnoreSubnetMask); + void readDHCPServers(const xml::ElementNode &elmDHCPServers); + void readDHCPOptions(DHCPConfig &rConfig, const xml::ElementNode &elmOptions, bool fIgnoreSubnetMask); bool convertGuiProxySettings(const com::Utf8Str &strUIProxySettings); }; Index: /trunk/src/VBox/Main/Makefile.kmk =================================================================== --- /trunk/src/VBox/Main/Makefile.kmk (revision 79731) +++ /trunk/src/VBox/Main/Makefile.kmk (revision 79732) @@ -550,4 +550,5 @@ src-server/DataStreamImpl.cpp \ src-server/DHCPServerImpl.cpp \ + src-server/DHCPConfigImpl.cpp \ src-server/NetworkServiceRunner.cpp \ src-server/NATNetworkImpl.cpp \ Index: /trunk/src/VBox/Main/idl/VirtualBox.xidl =================================================================== --- /trunk/src/VBox/Main/idl/VirtualBox.xidl (revision 79731) +++ /trunk/src/VBox/Main/idl/VirtualBox.xidl (revision 79732) @@ -1824,8 +1824,29 @@ + name="DHCPOptionEncoding" + uuid="84b6d460-2838-4682-c0d6-ef5b573ef28a"> - + + + + + + + + + + + + MAC address + MAC address wildcard pattern. + Vendor class ID + Vendor class ID wildcard pattern. + User class ID + User class ID wildcard pattern. @@ -1834,5 +1855,5 @@ uuid="ea2d467f-b6c2-4b9a-8eb5-6e2f275dd72e" wsmap="managed" - reservedMethods="1" reservedAttributes="6" + reservedMethods="0" reservedAttributes="3" > @@ -1881,4 +1902,5 @@ + 6.0 legacy, will be removed in 6.1. @@ -1886,27 +1908,33 @@ - - removes the specified option - - invalid option id supplied - - + 6.0 legacy, will be removed in 6.1. - - removes all global options - - failed to remove global options - - + Legacy interface, will be removed in 6.1. - + + Legacy interface, will be removed in 6.1. + - + + Legacy interface, will be removed in 6.1. + + + + Global configuration that applies to all clients. + + + + Configuration groups that applies to selected clients, selection is flexible. + + + + Individual NIC configurations either by MAC address or VM + NIC number. + + 6.0 legacy, will be removed in 6.1. @@ -1938,10 +1967,5 @@ - - removes the specified option - - invalid VM, slot, or option id supplied - - + 6.0 legacy, will be removed in 6.1. @@ -1950,10 +1974,5 @@ - - removes all option for the specified adapter - - invalid VM or slot supplied - - + 6.0 legacy, will be removed in 6.1. @@ -1962,4 +1981,5 @@ + 6.0 legacy, will be removed in 6.1. @@ -1969,4 +1989,5 @@ + 6.0 legacy, will be removed in 6.1. @@ -2074,11 +2095,224 @@ + + + Gets or adds a configuration. + + + The kind of configuration being sought or added. + + + + Meaning depends on the @a scope: + - Ignored when the @a scope is . + - A VM name or UUID for . + - A MAC address for . + - A group name for . + + + + The NIC slot when @a scope is set to , + must be zero for all other scope values. + + + + + Set to @c TRUE if the configuration should be added if not found. + If set to @c FALSE the method will fail with VBOX_E_OBJECT_NOT_FOUND. + + + + The requested configuration. + + + - - - + + + + + + The DHCP server has several configuration levels: global, group and + individual MAC. This interface implements the settings common to + each level. + + + + + Indicates the kind of config this is (mostly for IDHCPIndividualConfig). + + + + + The minimum lease time in seconds, ignored if zero. + + + The default lease time in seconds, ignored if zero. + + + The maximum lease time in seconds, ignored if zero. + + + + + Sets a DHCP option. + + + The DHCP option. + + + The value encoding. + + + The DHCP option value. The exact format depends on the DHCP + option and should be documented in . + + + + + + Removes the given DHCP option. + + + + + + Removes all the options. + + One exception here is the DhcpOpt_SubnetMask option in the global scope + that is linked to the attribute + and therefore cannot be removed. + + + + + Gets the value of a single DHCP option. + + The DHCP option being sought. + + + The value encoding. + + + The value of the requested DHCP option. + + + + + Gets all DHCP options and their values + + Array containing the DHCP option numbers. + + + Array of value encodings that runs parallel to @a options. + + + Array of values that runs parallel to @a options and @a encodings. + + + + + + + The global DHCP server configuration, see . + + + + + + + + Whether this is an inclusive or exclusive group membership condition + + + Defines how the is interpreted. + + + The condition value. + + + Remove this condition from the group. + + + + + + A configuration that applies to a group of NICs. + + + + The group name. + + + + + Group membership conditions. + + Add new conditions by calling + and use to remove. + + + + + + + + + + + + + + Configuration for a single NIC, either given directly by MAC address or by + VM + adaptor slot number. + + + + + The MAC address. If a config, this + will be queried via the VM ID. + + + + + + The virtual machine ID if a config, + null UUID for . + + + + + The NIC slot number of the VM if a config. + + + + Fixed IPv4 address assignment, dynamic if empty. + Index: /trunk/src/VBox/Main/include/DHCPConfigImpl.h =================================================================== --- /trunk/src/VBox/Main/include/DHCPConfigImpl.h (revision 79732) +++ /trunk/src/VBox/Main/include/DHCPConfigImpl.h (revision 79732) @@ -0,0 +1,318 @@ +/* $Id$ */ +/** @file + * VirtualBox Main - IDHCPConfig, IDHCPConfigGlobal, IDHCPConfigGroup, IDHCPConfigIndividual header. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef MAIN_INCLUDED_DHCPServerConfig_h +#define MAIN_INCLUDED_DHCPServerConfig_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include "DHCPGlobalConfigWrap.h" +#include "DHCPGroupConfigWrap.h" +#include "DHCPIndividualConfigWrap.h" +#include + + +class DHCPServer; + + +/** + * Base class for the a DHCP configration layer. + * + * This does not inherit from DHCPConfigWrap because its children need to + * inherit from children of DHCPConfigWrap, which smells like trouble and thus + * wasn't even attempted. Instead, we have a hack for passing a pointer that we + * can call setError and such on. + */ +class DHCPConfig +{ +protected: + /** Config scope (global, group, vm+nic, mac). */ + DHCPConfigScope_T const m_enmScope; + /** Minimum lease time. */ + ULONG m_secMinLeaseTime; + /** Default lease time. */ + ULONG m_secDefaultLeaseTime; + /** Maximum lease time. */ + ULONG m_secMaxLeaseTime; + /** DHCP option map. */ + settings::DhcpOptionMap m_OptionMap; + /** The DHCP server parent (weak). */ + DHCPServer * const m_pParent; + /** The DHCP server parent (weak). */ + VirtualBox * const m_pVirtualBox; +private: + /** For setError and such. */ + VirtualBoxBase * const m_pHack; + +protected: + /** @name Constructors and destructors. + * @{ */ + DHCPConfig(DHCPConfigScope_T a_enmScope, VirtualBoxBase *a_pHack) + : m_enmScope(a_enmScope), m_secMinLeaseTime(0), m_secDefaultLeaseTime(0), m_secMaxLeaseTime(0), m_OptionMap() + , m_pParent(NULL), m_pVirtualBox(NULL), m_pHack(a_pHack) + {} + DHCPConfig(); + virtual ~DHCPConfig() + {} + HRESULT i_initWithDefaults(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent); + HRESULT i_initWithSettings(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, const settings::DHCPConfig &rConfig); + /** @} */ + + /** @name IDHCPConfig properties + * @{ */ + HRESULT i_getScope(DHCPConfigScope_T *aScope); + HRESULT i_getMinLeaseTime(ULONG *aMinLeaseTime); + HRESULT i_setMinLeaseTime(ULONG aMinLeaseTime); + HRESULT i_getDefaultLeaseTime(ULONG *aDefaultLeaseTime); + HRESULT i_setDefaultLeaseTime(ULONG aDefaultLeaseTime); + HRESULT i_getMaxLeaseTime(ULONG *aMaxLeaseTime); + HRESULT i_setMaxLeaseTime(ULONG aMaxLeaseTime); + /** @} */ + +public: + /** @name IDHCPConfig methods + * @note public because the DHCPServer needs them for 6.0 interfaces. + * @todo Make protected again when IDHCPServer is cleaned up. + * @{ */ + virtual HRESULT i_setOption(DhcpOpt_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue); + + virtual HRESULT i_removeOption(DhcpOpt_T aOption); + virtual HRESULT i_removeAllOptions(); + HRESULT i_getOption(DhcpOpt_T aOption, DHCPOptionEncoding_T *aEncoding, com::Utf8Str &aValue); + HRESULT i_getAllOptions(std::vector &aOptions, std::vector &aEncodings, + std::vector &aValues); + /** @} */ + +protected: + HRESULT i_doWriteConfig(); + +public: + HRESULT i_saveSettings(settings::DHCPConfig &a_rDst); + DHCPConfigScope_T i_getScope() const RT_NOEXCEPT { return m_enmScope; } + virtual void i_writeDhcpdConfig(xml::ElementNode *pElm); +}; + + +/** + * Global DHCP configuration. + */ +class DHCPGlobalConfig : public DHCPGlobalConfigWrap, public DHCPConfig +{ +public: + /** @name Constructors and destructors. + * @{ */ + DHCPGlobalConfig() + : DHCPConfig(DHCPConfigScope_Global, this) + { } + HRESULT FinalConstruct() + { + return BaseFinalConstruct(); + } + void FinalRelease() + { + uninit(); + BaseFinalRelease(); + } + HRESULT initWithDefaults(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent); + HRESULT initWithSettings(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, const settings::DHCPConfig &rConfig); + void uninit(); + /** @} */ + + HRESULT i_saveSettings(settings::DHCPConfig &a_rDst); + HRESULT i_getNetworkMask(com::Utf8Str &a_rDst); + HRESULT i_setNetworkMask(const com::Utf8Str &a_rSrc); + +protected: + /** @name wrapped IDHCPConfig properties + * @{ */ + HRESULT getScope(DHCPConfigScope_T *aScope) RT_OVERRIDE { return i_getScope(aScope); } + HRESULT getMinLeaseTime(ULONG *aMinLeaseTime) RT_OVERRIDE { return i_getMinLeaseTime(aMinLeaseTime); } + HRESULT setMinLeaseTime(ULONG aMinLeaseTime) RT_OVERRIDE { return i_setMinLeaseTime(aMinLeaseTime); } + HRESULT getDefaultLeaseTime(ULONG *aDefaultLeaseTime) RT_OVERRIDE { return i_getDefaultLeaseTime(aDefaultLeaseTime); } + HRESULT setDefaultLeaseTime(ULONG aDefaultLeaseTime) RT_OVERRIDE { return i_setDefaultLeaseTime(aDefaultLeaseTime); } + HRESULT getMaxLeaseTime(ULONG *aMaxLeaseTime) RT_OVERRIDE { return i_getMaxLeaseTime(aMaxLeaseTime); } + HRESULT setMaxLeaseTime(ULONG aMaxLeaseTime) RT_OVERRIDE { return i_setMaxLeaseTime(aMaxLeaseTime); } + /** @} */ + + /** @name wrapped IDHCPConfig methods + * @{ */ + HRESULT setOption(DhcpOpt_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue) RT_OVERRIDE + { + return i_setOption(aOption, aEncoding, aValue); + } + + HRESULT removeOption(DhcpOpt_T aOption) RT_OVERRIDE + { + return i_removeOption(aOption); + } + + HRESULT removeAllOptions() RT_OVERRIDE + { + return i_removeAllOptions(); + } + + HRESULT getOption(DhcpOpt_T aOption, DHCPOptionEncoding_T *aEncoding, com::Utf8Str &aValue) RT_OVERRIDE + { + return i_getOption(aOption, aEncoding, aValue); + } + + HRESULT getAllOptions(std::vector &aOptions, std::vector &aEncodings, + std::vector &aValues) RT_OVERRIDE + { + return i_getAllOptions(aOptions, aEncodings, aValues); + } + /** @} */ + +public: + HRESULT i_setOption(DhcpOpt_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue) RT_OVERRIDE; + HRESULT i_removeOption(DhcpOpt_T aOption) RT_OVERRIDE; + HRESULT i_removeAllOptions() RT_OVERRIDE; +}; + + +/** + * Group configuration. + */ +class DHCPGroupConfig : public VirtualBoxBase, public DHCPConfig +{ + /** @todo later */ +}; + + +/** + * Individual DHCP configuration. + */ +class DHCPIndividualConfig : public DHCPIndividualConfigWrap, public DHCPConfig +{ +private: + /** The MAC address or all zeros. */ + RTMAC m_MACAddress; + /** The VM ID or all zeros. */ + com::Guid const m_idMachine; + /** The VM NIC slot number, or ~(ULONG)0. */ + ULONG const m_uSlot; + /** This is part of a hack to resolve the MAC address for + * DHCPConfigScope_MachineNIC instances. If non-zero, we m_MACAddress is valid. + * To deal with the impossibly theoretical scenario that the DHCP server is + * being started by more than one thread, this is a version number and not just + * a boolean indicator. */ + uint32_t volatile m_uMACAddressResolvedVersion; + + /** The fixed IPv4 address, empty if dynamic. */ + com::Utf8Str m_strFixedAddress; + +public: + /** @name Constructors and destructors. + * @{ */ + DHCPIndividualConfig() + : DHCPConfig(DHCPConfigScope_MAC, this) + , m_uSlot(~(ULONG)0) + , m_uMACAddressResolvedVersion(false) + { + RT_ZERO(m_MACAddress); + } + HRESULT FinalConstruct() + { + return BaseFinalConstruct(); + } + void FinalRelease() + { + uninit(); + BaseFinalRelease(); + } + HRESULT initWithMachineIdAndSlot(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, com::Guid const &a_idMachine, + ULONG a_uSlot, uint32_t a_uMACAddressVersion); + HRESULT initWithMACAddress(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, PCRTMAC a_pMACAddress); + HRESULT initWithSettingsAndMachineIdAndSlot(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, + const settings::DHCPIndividualConfig &rData, com::Guid const &a_idMachine, + ULONG a_uSlot, uint32_t a_uMACAddressVersion); + HRESULT initWithSettingsAndMACAddress(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, + const settings::DHCPIndividualConfig &rData, PCRTMAC a_pMACAddress); + void uninit(); + /** @} */ + + /** @name Internal methods that are public for various reasons + * @{ */ + HRESULT i_saveSettings(settings::DHCPIndividualConfig &a_rDst); + RTMAC const &i_getMACAddress() const RT_NOEXCEPT { return m_MACAddress; } + com::Guid const &i_getMachineId() const RT_NOEXCEPT { return m_idMachine; } + ULONG i_getSlot() const RT_NOEXCEPT { return m_uSlot; } + HRESULT i_getMachineMAC(PRTMAC pMACAddress); + + HRESULT i_resolveMACAddress(uint32_t uVersion); + /** This is used to avoid producing bogus Dhcpd configuration elements. */ + bool i_isMACAddressResolved(uint32_t uVersion) const + { + return m_enmScope != DHCPConfigScope_MachineNIC || (int32_t)(m_uMACAddressResolvedVersion - uVersion) >= 0; + } + void i_writeDhcpdConfig(xml::ElementNode *pElm) RT_OVERRIDE; + /** @} */ + +protected: + /** @name wrapped IDHCPConfig properties + * @{ */ + HRESULT getScope(DHCPConfigScope_T *aScope) RT_OVERRIDE { return i_getScope(aScope); } + HRESULT getMinLeaseTime(ULONG *aMinLeaseTime) RT_OVERRIDE { return i_getMinLeaseTime(aMinLeaseTime); } + HRESULT setMinLeaseTime(ULONG aMinLeaseTime) RT_OVERRIDE { return i_setMinLeaseTime(aMinLeaseTime); } + HRESULT getDefaultLeaseTime(ULONG *aDefaultLeaseTime) RT_OVERRIDE { return i_getDefaultLeaseTime(aDefaultLeaseTime); } + HRESULT setDefaultLeaseTime(ULONG aDefaultLeaseTime) RT_OVERRIDE { return i_setDefaultLeaseTime(aDefaultLeaseTime); } + HRESULT getMaxLeaseTime(ULONG *aMaxLeaseTime) RT_OVERRIDE { return i_getMaxLeaseTime(aMaxLeaseTime); } + HRESULT setMaxLeaseTime(ULONG aMaxLeaseTime) RT_OVERRIDE { return i_setMaxLeaseTime(aMaxLeaseTime); } + /** @} */ + + /** @name wrapped IDHCPConfig methods + * @{ */ + HRESULT setOption(DhcpOpt_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue) RT_OVERRIDE + { + return i_setOption(aOption, aEncoding, aValue); + } + + HRESULT removeOption(DhcpOpt_T aOption) RT_OVERRIDE + { + return i_removeOption(aOption); + } + + HRESULT removeAllOptions() RT_OVERRIDE + { + return i_removeAllOptions(); + } + + HRESULT getOption(DhcpOpt_T aOption, DHCPOptionEncoding_T *aEncoding, com::Utf8Str &aValue) RT_OVERRIDE + { + return i_getOption(aOption, aEncoding, aValue); + } + + HRESULT getAllOptions(std::vector &aOptions, std::vector &aEncodings, + std::vector &aValues) RT_OVERRIDE + { + return i_getAllOptions(aOptions, aEncodings, aValues); + } + /** @} */ + + /** @name IDHCPIndividualConfig properties + * @{ */ + HRESULT getMACAddress(com::Utf8Str &aMacAddress) RT_OVERRIDE; + HRESULT getMachineId(com::Guid &aId) RT_OVERRIDE; + HRESULT getSlot(ULONG *aSlot) RT_OVERRIDE; + HRESULT getFixedAddress(com::Utf8Str &aFixedAddress) RT_OVERRIDE; + HRESULT setFixedAddress(const com::Utf8Str &aFixedAddress) RT_OVERRIDE; + /** @} */ +}; + +#endif /* !MAIN_INCLUDED_DHCPServerImpl_h */ + Index: /trunk/src/VBox/Main/include/DHCPServerImpl.h =================================================================== --- /trunk/src/VBox/Main/include/DHCPServerImpl.h (revision 79731) +++ /trunk/src/VBox/Main/include/DHCPServerImpl.h (revision 79732) @@ -32,6 +32,12 @@ } +class DHCPConfig; +class DHCPIndividualConfig; /** + * A DHCP server for internal host-only & NAT networks. + * + * Old notes: + * * for server configuration needs, it's perhaps better to use (VM,slot) pair * (vm-name, slot) <----> (MAC) @@ -49,76 +55,79 @@ { public: + /** @name Constructors and destructors + * @{ */ + DECLARE_EMPTY_CTOR_DTOR(DHCPServer) + HRESULT FinalConstruct(); + void FinalRelease(); - DECLARE_EMPTY_CTOR_DTOR(DHCPServer) + HRESULT init(VirtualBox *aVirtualBox, const com::Utf8Str &aName); + HRESULT init(VirtualBox *aVirtualBox, const settings::DHCPServer &data); + void uninit(); + /** @} */ - HRESULT FinalConstruct(); - void FinalRelease(); - - HRESULT init(VirtualBox *aVirtualBox, - const com::Utf8Str &aName); - HRESULT init(VirtualBox *aVirtualBox, - const settings::DHCPServer &data); - void uninit(); - - // Public internal methids. + /** @name Public internal methods. + * @{ */ HRESULT i_saveSettings(settings::DHCPServer &data); - settings::DhcpOptionMap &i_findOptMapByVmNameSlot(const com::Utf8Str &aVmName, LONG Slot); + /** @} */ private: - HRESULT encodeOption(com::Utf8Str &aEncoded, uint32_t aOptCode, const settings::DhcpOptValue &aOptValue); - int addOption(settings::DhcpOptionMap &aMap, DhcpOpt_T aOption, const com::Utf8Str &aValue); + /** @name IDHCPServer Properties + * @{ */ + HRESULT getEventSource(ComPtr &aEventSource) RT_OVERRIDE; + HRESULT getEnabled(BOOL *aEnabled) RT_OVERRIDE; + HRESULT setEnabled(BOOL aEnabled) RT_OVERRIDE; + HRESULT getIPAddress(com::Utf8Str &aIPAddress) RT_OVERRIDE; + HRESULT getNetworkMask(com::Utf8Str &aNetworkMask) RT_OVERRIDE; + HRESULT getNetworkName(com::Utf8Str &aName) RT_OVERRIDE; + HRESULT getLowerIP(com::Utf8Str &aIPAddress) RT_OVERRIDE; + HRESULT getUpperIP(com::Utf8Str &aIPAddress) RT_OVERRIDE; + HRESULT getGlobalOptions(std::vector &aGlobalOptions) RT_OVERRIDE; + HRESULT getVmConfigs(std::vector &aVmConfigs) RT_OVERRIDE; + HRESULT getMacOptions(const com::Utf8Str &aMAC, std::vector &aValues) RT_OVERRIDE; + HRESULT setConfiguration(const com::Utf8Str &aIPAddress, const com::Utf8Str &aNetworkMask, + const com::Utf8Str &aFromIPAddress, const com::Utf8Str &aToIPAddress) RT_OVERRIDE; + HRESULT getVmSlotOptions(const com::Utf8Str &aVmName, LONG aSlot, std::vector &aValues) RT_OVERRIDE; + HRESULT getGlobalConfig(ComPtr &aGlobalConfig) RT_OVERRIDE; + HRESULT getGroupConfigs(std::vector > &aGroupConfigs) RT_OVERRIDE; + HRESULT getIndividualConfigs(std::vector > &aIndividualConfigs) ; + /** @} */ - // wrapped IDHCPServer properties - HRESULT getEventSource(ComPtr &aEventSource); - HRESULT getEnabled(BOOL *aEnabled); - HRESULT setEnabled(BOOL aEnabled); - HRESULT getIPAddress(com::Utf8Str &aIPAddress); - HRESULT getNetworkMask(com::Utf8Str &aNetworkMask); - HRESULT getNetworkName(com::Utf8Str &aName); - HRESULT getLowerIP(com::Utf8Str &aIPAddress); - HRESULT getUpperIP(com::Utf8Str &aIPAddress); - HRESULT getGlobalOptions(std::vector &aGlobalOptions); - HRESULT getVmConfigs(std::vector &aVmConfigs); - HRESULT getMacOptions(const com::Utf8Str &aMAC, std::vector &aValues); - HRESULT setConfiguration(const com::Utf8Str &aIPAddress, - const com::Utf8Str &aNetworkMask, - const com::Utf8Str &aFromIPAddress, - const com::Utf8Str &aToIPAddress); - HRESULT getVmSlotOptions(const com::Utf8Str &aVmName, - LONG aSlot, - std::vector &aValues); - - // Wrapped IDHCPServer Methods - HRESULT addGlobalOption(DhcpOpt_T aOption, - const com::Utf8Str &aValue); - HRESULT removeGlobalOption(DhcpOpt_T aOption); - HRESULT removeGlobalOptions(); - HRESULT addVmSlotOption(const com::Utf8Str &aVmName, - LONG aSlot, - DhcpOpt_T aOption, - const com::Utf8Str &aValue); - HRESULT removeVmSlotOption(const com::Utf8Str &aVmName, - LONG aSlot, - DhcpOpt_T aOption); - HRESULT removeVmSlotOptions(const com::Utf8Str &aVmName, - LONG aSlot); - HRESULT start(const com::Utf8Str &aNetworkName, - const com::Utf8Str &aTrunkName, - const com::Utf8Str &aTrunkType); - HRESULT stop(); - HRESULT restart(); - HRESULT findLeaseByMAC(const com::Utf8Str &aMac, LONG aType, - com::Utf8Str &aAddress, com::Utf8Str &aState, LONG64 *aIssued, LONG64 *aExpire) RT_OVERRIDE; + /** @name IDHCPServer Methods + * @{ */ + HRESULT addGlobalOption(DhcpOpt_T aOption, const com::Utf8Str &aValue) RT_OVERRIDE; + HRESULT removeGlobalOption(DhcpOpt_T aOption) RT_OVERRIDE; + HRESULT removeGlobalOptions() RT_OVERRIDE; + HRESULT addVmSlotOption(const com::Utf8Str &aVmName, LONG aSlot, DhcpOpt_T aOption, const com::Utf8Str &aValue) RT_OVERRIDE; + HRESULT removeVmSlotOption(const com::Utf8Str &aVmName, LONG aSlot, DhcpOpt_T aOption) RT_OVERRIDE; + HRESULT removeVmSlotOptions(const com::Utf8Str &aVmName, LONG aSlot) RT_OVERRIDE; + HRESULT start(const com::Utf8Str &aNetworkName, const com::Utf8Str &aTrunkName, const com::Utf8Str &aTrunkType) RT_OVERRIDE; + HRESULT stop() RT_OVERRIDE; + HRESULT restart() RT_OVERRIDE; + HRESULT findLeaseByMAC(const com::Utf8Str &aMac, LONG aType, com::Utf8Str &aAddress, com::Utf8Str &aState, + LONG64 *aIssued, LONG64 *aExpire) RT_OVERRIDE; + HRESULT getConfig(DHCPConfigScope_T aScope, const com::Utf8Str &aName, ULONG aSlot, BOOL aMayAdd, + ComPtr &aConfig) RT_OVERRIDE; + /** @} */ /** @name Helpers * @{ */ + HRESULT i_doSaveSettings(); HRESULT i_calcLeasesFilename(const com::Utf8Str &aNetwork) RT_NOEXCEPT; + HRESULT i_writeDhcpdConfig(const char *pszFilename, uint32_t uMACAddressVersion) RT_NOEXCEPT; + + HRESULT i_vmNameToIdAndValidateSlot(const com::Utf8Str &aVmName, LONG aSlot, com::Guid &idMachine); + HRESULT i_vmNameAndSlotToConfig(const com::Utf8Str &a_strVmName, LONG a_uSlot, bool a_fCreateIfNeeded, + ComObjPtr &a_rPtrConfig); + + HRESULT i_encode60Option(com::Utf8Str &strEncoded, DhcpOpt_T enmOption, + DHCPOptionEncoding_T enmEncoding, const com::Utf8Str &strValue); + HRESULT i_getAllOptions60(DHCPConfig &aSourceConfig, std::vector &aValues); + HRESULT i_add60Option(DHCPConfig &aTargetConfig, DhcpOpt_T aOption, const com::Utf8Str &aValue); /** @} */ + /** Private data */ struct Data; + /** Private data. */ Data *m; - /** weak VirtualBox parent */ - VirtualBox *const mVirtualBox; - const Utf8Str mName; }; Index: /trunk/src/VBox/Main/src-server/DHCPConfigImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-server/DHCPConfigImpl.cpp (revision 79732) +++ /trunk/src/VBox/Main/src-server/DHCPConfigImpl.cpp (revision 79732) @@ -0,0 +1,671 @@ +/* $Id$ */ +/** @file + * VirtualBox Main - IDHCPConfig, IDHCPConfigGlobal, IDHCPConfigGroup, IDHCPConfigIndividual implementation. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP LOG_GROUP_MAIN_DHCPCONFIG +#include "DHCPConfigImpl.h" +#include "LoggingNew.h" + +#include +#include +#include +#include + +#include +#include + +#include "AutoCaller.h" +#include "MachineImpl.h" +#include "VirtualBoxImpl.h" + + + +/********************************************************************************************************************************* +* DHCPConfig Implementation * +*********************************************************************************************************************************/ + +HRESULT DHCPConfig::i_initWithDefaults(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent) +{ + unconst(m_pVirtualBox) = a_pVirtualBox; + unconst(m_pParent) = a_pParent; + return S_OK; +} + + +HRESULT DHCPConfig::i_initWithSettings(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, const settings::DHCPConfig &rConfig) +{ + unconst(m_pVirtualBox) = a_pVirtualBox; + unconst(m_pParent) = a_pParent; + + m_secMinLeaseTime = rConfig.secMinLeaseTime; + m_secDefaultLeaseTime = rConfig.secDefaultLeaseTime; + m_secMaxLeaseTime = rConfig.secMaxLeaseTime; + + for (settings::DhcpOptionMap::const_iterator it = rConfig.OptionMap.begin(); it != rConfig.OptionMap.end(); ++it) + { + try + { + m_OptionMap[it->first] = settings::DhcpOptValue(it->second.strValue, it->second.enmEncoding); + } + catch (std::bad_alloc &) + { + return E_OUTOFMEMORY; + } + } + + return S_OK; +} + + +HRESULT DHCPConfig::i_saveSettings(settings::DHCPConfig &a_rDst) +{ + /* lease times */ + a_rDst.secMinLeaseTime = m_secMinLeaseTime; + a_rDst.secDefaultLeaseTime = m_secDefaultLeaseTime; + a_rDst.secMaxLeaseTime = m_secMaxLeaseTime; + + /* Options: */ + try + { + a_rDst.OptionMap = m_OptionMap; + } + catch (std::bad_alloc &) + { + return E_OUTOFMEMORY; + } + return S_OK; +} + + +HRESULT DHCPConfig::i_getScope(DHCPConfigScope_T *aScope) +{ + /* No locking needed. */ + *aScope = m_enmScope; + return S_OK; +} + + +HRESULT DHCPConfig::i_getMinLeaseTime(ULONG *aMinLeaseTime) +{ + AutoReadLock alock(m_pHack COMMA_LOCKVAL_SRC_POS); + *aMinLeaseTime = m_secMinLeaseTime; + return S_OK; +} + + +HRESULT DHCPConfig::i_setMinLeaseTime(ULONG aMinLeaseTime) +{ + { + AutoWriteLock alock(m_pHack COMMA_LOCKVAL_SRC_POS); + m_secMinLeaseTime = aMinLeaseTime; + } + return i_doWriteConfig(); +} + + +HRESULT DHCPConfig::i_getDefaultLeaseTime(ULONG *aDefaultLeaseTime) +{ + AutoReadLock alock(m_pHack COMMA_LOCKVAL_SRC_POS); + *aDefaultLeaseTime = m_secDefaultLeaseTime; + return S_OK; +} + + +HRESULT DHCPConfig::i_setDefaultLeaseTime(ULONG aDefaultLeaseTime) +{ + { + AutoWriteLock alock(m_pHack COMMA_LOCKVAL_SRC_POS); + m_secDefaultLeaseTime = aDefaultLeaseTime; + } + return i_doWriteConfig(); +} + + +HRESULT DHCPConfig::i_getMaxLeaseTime(ULONG *aMaxLeaseTime) +{ + AutoReadLock alock(m_pHack COMMA_LOCKVAL_SRC_POS); + *aMaxLeaseTime = m_secMaxLeaseTime; + return S_OK; +} + + +HRESULT DHCPConfig::i_setMaxLeaseTime(ULONG aMaxLeaseTime) +{ + { + AutoWriteLock alock(m_pHack COMMA_LOCKVAL_SRC_POS); + m_secMaxLeaseTime = aMaxLeaseTime; + } + return i_doWriteConfig(); +} + + +HRESULT DHCPConfig::i_setOption(DhcpOpt_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue) +{ + /** @todo validate option value format. */ + { + AutoWriteLock alock(m_pHack COMMA_LOCKVAL_SRC_POS); + try + { + m_OptionMap[aOption] = settings::DhcpOptValue(aValue, aEncoding); + } + catch (std::bad_alloc &) + { + return E_OUTOFMEMORY; + } + } + i_doWriteConfig(); + return S_OK; +} + + +HRESULT DHCPConfig::i_removeOption(DhcpOpt_T aOption) +{ + { + AutoWriteLock alock(m_pHack COMMA_LOCKVAL_SRC_POS); + settings::DhcpOptionMap::iterator it = m_OptionMap.find(aOption); + if (it != m_OptionMap.end()) + m_OptionMap.erase(it); + else + return m_pHack->setError(VBOX_E_OBJECT_NOT_FOUND, m_pHack->tr("DHCP option %u was not found"), aOption); + } + return i_doWriteConfig(); +} + + +HRESULT DHCPConfig::i_removeAllOptions() +{ + { + AutoWriteLock alock(m_pHack COMMA_LOCKVAL_SRC_POS); + m_OptionMap.erase(m_OptionMap.begin(), m_OptionMap.end()); + } + return i_doWriteConfig(); +} + + +HRESULT DHCPConfig::i_getOption(DhcpOpt_T aOption, DHCPOptionEncoding_T *aEncoding, com::Utf8Str &aValue) +{ + AutoReadLock alock(m_pHack COMMA_LOCKVAL_SRC_POS); + settings::DhcpOptionMap::const_iterator it = m_OptionMap.find(aOption); + if (it != m_OptionMap.end()) + { + *aEncoding = it->second.enmEncoding; + return aValue.assignEx(it->second.strValue); + } + return m_pHack->setError(VBOX_E_OBJECT_NOT_FOUND, m_pHack->tr("DHCP option %u was not found"), aOption); +} + + +HRESULT DHCPConfig::i_getAllOptions(std::vector &aOptions, std::vector &aEncodings, + std::vector &aValues) +{ + AutoReadLock alock(m_pHack COMMA_LOCKVAL_SRC_POS); + try + { + aOptions.resize(m_OptionMap.size()); + aEncodings.resize(m_OptionMap.size()); + aValues.resize(m_OptionMap.size()); + size_t i = 0; + for (settings::DhcpOptionMap::iterator it = m_OptionMap.begin(); it != m_OptionMap.end(); ++it) + { + aOptions[i] = it->first; + aEncodings[i] = it->second.enmEncoding; + aValues[i] = it->second.strValue; + } + } + catch (std::bad_alloc &) + { + return E_OUTOFMEMORY; + } + return S_OK; +} + + +/** + * Causes the global VirtualBox configuration file to be written + * + * @returns COM status code. + * + * @note Must hold no locks when this is called! + */ +HRESULT DHCPConfig::i_doWriteConfig() +{ + AssertPtrReturn(m_pVirtualBox, E_FAIL); + + AutoWriteLock alock(m_pVirtualBox COMMA_LOCKVAL_SRC_POS); + return m_pVirtualBox->i_saveSettings(); +} + + +/** + * Produces the Dhcpd configuration. + * + * The base class only saves DHCP options. + * + * @param pElmConfig The element where to put the configuration. + * @throws std::bad_alloc + */ +void DHCPConfig::i_writeDhcpdConfig(xml::ElementNode *pElmConfig) +{ + if (m_secMinLeaseTime > 0 ) + pElmConfig->setAttribute("secMinLeaseTime", (uint32_t)m_secMinLeaseTime); + if (m_secDefaultLeaseTime > 0 ) + pElmConfig->setAttribute("secDefaultLeaseTime", (uint32_t)m_secDefaultLeaseTime); + if (m_secMaxLeaseTime > 0 ) + pElmConfig->setAttribute("secMaxLeaseTime", (uint32_t)m_secMaxLeaseTime); + + for (settings::DhcpOptionMap::const_iterator it = m_OptionMap.begin(); it != m_OptionMap.end(); ++it) + { + xml::ElementNode *pOption = pElmConfig->createChild("Option"); + pOption->setAttribute("name", (int)it->first); + pOption->setAttribute("encoding", it->second.enmEncoding); + pOption->setAttribute("value", it->second.strValue); + } +} + + + +/********************************************************************************************************************************* +* DHCPGlobalConfig Implementation * +*********************************************************************************************************************************/ +#undef LOG_GROUP +#define LOG_GROUP LOG_GROUP_MAIN_DHCPGLOBALCONFIG + +HRESULT DHCPGlobalConfig::initWithDefaults(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent) +{ + AutoInitSpan autoInitSpan(this); + AssertReturn(autoInitSpan.isOk(), E_FAIL); + + HRESULT hrc = DHCPConfig::i_initWithDefaults(a_pVirtualBox, a_pParent); + if (SUCCEEDED(hrc)) + hrc = i_setOption(DhcpOpt_SubnetMask, DHCPOptionEncoding_Legacy, "0.0.0.0"); + + if (SUCCEEDED(hrc)) + autoInitSpan.setSucceeded(); + return hrc; +} + + +HRESULT DHCPGlobalConfig::initWithSettings(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, const settings::DHCPConfig &rConfig) +{ + AutoInitSpan autoInitSpan(this); + AssertReturn(autoInitSpan.isOk(), E_FAIL); + + HRESULT hrc = DHCPConfig::i_initWithSettings(a_pVirtualBox, a_pParent, rConfig); + if (SUCCEEDED(hrc)) + autoInitSpan.setSucceeded(); + else + autoInitSpan.setFailed(hrc); + return hrc; +} + + +void DHCPGlobalConfig::uninit() +{ + AutoUninitSpan autoUninitSpan(this); + if (!autoUninitSpan.uninitDone()) + autoUninitSpan.setSucceeded(); +} + + +HRESULT DHCPGlobalConfig::i_saveSettings(settings::DHCPConfig &a_rDst) +{ + return DHCPConfig::i_saveSettings(a_rDst); +} + + +/** + * For getting the network mask option value (IDHCPServer::netmask attrib). + * + * @returns COM status code. + * @param a_rDst Where to return it. + * @throws nothing + */ +HRESULT DHCPGlobalConfig::i_getNetworkMask(com::Utf8Str &a_rDst) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + settings::DhcpOptionMap::const_iterator it = m_OptionMap.find(DhcpOpt_SubnetMask); + if (it != m_OptionMap.end()) + { + if (it->second.enmEncoding == DHCPOptionEncoding_Legacy) + return a_rDst.assignEx(it->second.strValue); + return setError(VBOX_E_OBJECT_NOT_FOUND, tr("DHCP option DhcpOpt_SubnetMask is not in a legacy encoding")); + } + return setError(VBOX_E_OBJECT_NOT_FOUND, tr("DHCP option DhcpOpt_SubnetMask was not found")); +} + + +/** + * For setting the network mask option value (IDHCPServer::netmask attrib). + * + * @returns COM status code. + * @param a_rSrc The new value. + * @throws nothing + */ +HRESULT DHCPGlobalConfig::i_setNetworkMask(const com::Utf8Str &a_rSrc) +{ + /* Validate it before setting it: */ + RTNETADDRIPV4 AddrIgnored; + int vrc = RTNetStrToIPv4Addr(a_rSrc.c_str(), &AddrIgnored); + if (RT_FAILURE(vrc)) + return setErrorBoth(E_INVALIDARG, vrc, tr("Invalid IPv4 netmask '%s': %Rrc"), a_rSrc.c_str(), vrc); + + return i_setOption(DhcpOpt_SubnetMask, DHCPOptionEncoding_Legacy, a_rSrc); +} + + +/** + * Overriden to ensure the sanity of the DhcpOpt_SubnetMask option. + */ +HRESULT DHCPGlobalConfig::i_setOption(DhcpOpt_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue) +{ + if (aOption != DhcpOpt_SubnetMask || aEncoding == DHCPOptionEncoding_Legacy) + return DHCPConfig::i_setOption(aOption, aEncoding, aValue); + return setError(E_FAIL, tr("DhcpOpt_SubnetMask must use DHCPOptionEncoding_Legacy as it is reflected by IDHCPServer::networkMask")); +} + + +/** + * Overriden to ensure the sanity of the DhcpOpt_SubnetMask option. + */ +HRESULT DHCPGlobalConfig::i_removeOption(DhcpOpt_T aOption) +{ + if (aOption != DhcpOpt_SubnetMask) + return DHCPConfig::i_removeOption(aOption); + return setError(E_FAIL, tr("DhcpOpt_SubnetMask cannot be removed as it reflects IDHCPServer::networkMask")); +} + + +/** + * Overriden to preserve the DhcpOpt_SubnetMask option. + */ +HRESULT DHCPGlobalConfig::i_removeAllOptions() +{ + { + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + settings::DhcpOptionMap::iterator it = m_OptionMap.find(DhcpOpt_SubnetMask); + m_OptionMap.erase(m_OptionMap.begin(), it); + if (it != m_OptionMap.end()) + { + ++it; + if (it != m_OptionMap.end()) + m_OptionMap.erase(it, m_OptionMap.end()); + } + } + + return i_doWriteConfig(); +} + + + +/********************************************************************************************************************************* +* DHCPIndividualConfig Implementation * +*********************************************************************************************************************************/ +#undef LOG_GROUP +#define LOG_GROUP LOG_GROUP_MAIN_DHCPINDIVIDUALCONFIG + +HRESULT DHCPIndividualConfig::initWithMachineIdAndSlot(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, + com::Guid const &a_idMachine, ULONG a_uSlot, uint32_t a_uMACAddressVersion) +{ + AutoInitSpan autoInitSpan(this); + AssertReturn(autoInitSpan.isOk(), E_FAIL); + + HRESULT hrc = DHCPConfig::i_initWithDefaults(a_pVirtualBox, a_pParent); + if (SUCCEEDED(hrc)) + { + unconst(m_enmScope) = DHCPConfigScope_MachineNIC; + unconst(m_idMachine) = a_idMachine; + unconst(m_uSlot) = a_uSlot; + m_uMACAddressResolvedVersion = a_uMACAddressVersion; + + autoInitSpan.setSucceeded(); + } + return hrc; +} + + +HRESULT DHCPIndividualConfig::initWithMACAddress(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, PCRTMAC a_pMACAddress) +{ + AutoInitSpan autoInitSpan(this); + AssertReturn(autoInitSpan.isOk(), E_FAIL); + + HRESULT hrc = DHCPConfig::i_initWithDefaults(a_pVirtualBox, a_pParent); + if (SUCCEEDED(hrc)) + { + unconst(m_enmScope) = DHCPConfigScope_MAC; + unconst(m_MACAddress) = *a_pMACAddress; + + autoInitSpan.setSucceeded(); + } + return hrc; +} + + +HRESULT DHCPIndividualConfig::initWithSettingsAndMachineIdAndSlot(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, + settings::DHCPIndividualConfig const &rConfig, + com::Guid const &a_idMachine, ULONG a_uSlot, + uint32_t a_uMACAddressVersion) +{ + AutoInitSpan autoInitSpan(this); + AssertReturn(autoInitSpan.isOk(), E_FAIL); + + HRESULT hrc = DHCPConfig::i_initWithSettings(a_pVirtualBox, a_pParent, rConfig); + if (SUCCEEDED(hrc)) + { + unconst(m_enmScope) = DHCPConfigScope_MachineNIC; + unconst(m_idMachine) = a_idMachine; + unconst(m_uSlot) = a_uSlot; + m_uMACAddressResolvedVersion = a_uMACAddressVersion; + m_strFixedAddress = rConfig.strFixedAddress; + + autoInitSpan.setSucceeded(); + } + return hrc; +} + + +HRESULT DHCPIndividualConfig::initWithSettingsAndMACAddress(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, + settings::DHCPIndividualConfig const &rConfig, PCRTMAC a_pMACAddress) +{ + AutoInitSpan autoInitSpan(this); + AssertReturn(autoInitSpan.isOk(), E_FAIL); + + HRESULT hrc = DHCPConfig::i_initWithSettings(a_pVirtualBox, a_pParent, rConfig); + if (SUCCEEDED(hrc)) + { + unconst(m_enmScope) = DHCPConfigScope_MAC; + unconst(m_MACAddress) = *a_pMACAddress; + m_strFixedAddress = rConfig.strFixedAddress; + + autoInitSpan.setSucceeded(); + } + return hrc; +} + + +void DHCPIndividualConfig::uninit() +{ + AutoUninitSpan autoUninitSpan(this); + if (!autoUninitSpan.uninitDone()) + autoUninitSpan.setSucceeded(); +} + + +HRESULT DHCPIndividualConfig::i_saveSettings(settings::DHCPIndividualConfig &a_rDst) +{ + a_rDst.uSlot = m_uSlot; + int vrc = a_rDst.strMACAddress.printfNoThrow("%RTmac", &m_MACAddress); + if (m_idMachine.isValid() && !m_idMachine.isZero() && RT_SUCCESS(vrc)) + vrc = a_rDst.strVMName.printfNoThrow("%RTuuid", m_idMachine.raw()); + if (RT_SUCCESS(vrc)) + vrc = a_rDst.strFixedAddress.assignNoThrow(m_strFixedAddress); + if (RT_SUCCESS(vrc)) + return DHCPConfig::i_saveSettings(a_rDst); + return E_OUTOFMEMORY;; +} + + +HRESULT DHCPIndividualConfig::getMACAddress(com::Utf8Str &aMACAddress) +{ + /* No locking needed here (the MAC address, machine UUID and NIC slot number cannot change). */ + RTMAC MACAddress; + if (m_enmScope == DHCPConfigScope_MAC) + MACAddress = m_MACAddress; + else + { + HRESULT hrc = i_getMachineMAC(&MACAddress); + if (FAILED(hrc)) + return hrc; + } + + /* Format the return string: */ + int vrc = aMACAddress.printfNoThrow("%RTmac", &m_MACAddress); + return RT_SUCCESS(vrc) ? S_OK : E_OUTOFMEMORY; +} + + +HRESULT DHCPIndividualConfig::getMachineId(com::Guid &aId) +{ + AutoReadLock(this COMMA_LOCKVAL_SRC_POS); + aId = m_idMachine; + return S_OK; +} + + +HRESULT DHCPIndividualConfig::getSlot(ULONG *aSlot) +{ + AutoReadLock(this COMMA_LOCKVAL_SRC_POS); + *aSlot = m_uSlot; + return S_OK; +} + +HRESULT DHCPIndividualConfig::getFixedAddress(com::Utf8Str &aFixedAddress) +{ + AutoReadLock(this COMMA_LOCKVAL_SRC_POS); + return aFixedAddress.assignEx(m_strFixedAddress); +} + + +HRESULT DHCPIndividualConfig::setFixedAddress(const com::Utf8Str &aFixedAddress) +{ + if (aFixedAddress.isNotEmpty()) + { + RTNETADDRIPV4 AddrIgnored; + int vrc = RTNetStrToIPv4Addr(aFixedAddress.c_str(), &AddrIgnored); + if (RT_FAILURE(vrc)) + return setErrorBoth(E_INVALIDARG, vrc, tr("Invalid IPv4 address '%s': %Rrc"), aFixedAddress.c_str(), vrc); + } + + { + AutoWriteLock(this COMMA_LOCKVAL_SRC_POS); + m_strFixedAddress = aFixedAddress; + } + return i_doWriteConfig(); +} + + +/** + * Gets the MAC address of m_idMachine + m_uSlot. + * + * @returns COM status code w/ setError. + * @param pMACAddress Where to return the address. + * + * @note Must be called without holding any DHCP related locks as that would + * be lock order violation. The m_idMachine and m_uSlot values are + * practically const, so we don't need any locks here anyway. + */ +HRESULT DHCPIndividualConfig::i_getMachineMAC(PRTMAC pMACAddress) +{ + ComObjPtr ptrMachine; + HRESULT hrc = m_pVirtualBox->i_findMachine(m_idMachine, false /*fPermitInaccessible*/, true /*aSetError*/, &ptrMachine); + if (SUCCEEDED(hrc)) + { + ComPtr ptrNetworkAdapter; + hrc = ptrMachine->GetNetworkAdapter(m_uSlot, ptrNetworkAdapter.asOutParam()); + if (SUCCEEDED(hrc)) + { + com::Bstr bstrMACAddress; + hrc = ptrNetworkAdapter->COMGETTER(MACAddress)(bstrMACAddress.asOutParam()); + if (SUCCEEDED(hrc)) + { + Utf8Str strMACAddress; + try + { + strMACAddress = bstrMACAddress; + } + catch (std::bad_alloc &) + { + return E_OUTOFMEMORY; + } + + int vrc = RTNetStrToMacAddr(strMACAddress.c_str(), pMACAddress); + if (RT_SUCCESS(vrc)) + hrc = S_OK; + else + hrc = setError(hrc, tr("INetworkAdapter returned bogus MAC address '%ls'"), bstrMACAddress.raw()); + } + } + } + return hrc; +} + + +HRESULT DHCPIndividualConfig::i_resolveMACAddress(uint32_t uVersion) +{ + HRESULT hrc; + if (m_enmScope == DHCPConfigScope_MachineNIC) + { + RTMAC MACAddress; + hrc = i_getMachineMAC(&MACAddress); + if (SUCCEEDED(hrc)) + { + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + if ((int32_t)(m_uMACAddressResolvedVersion - uVersion) >= 0) + { + m_uMACAddressResolvedVersion = uVersion; + m_MACAddress = MACAddress; + } + } + } + else + hrc = S_OK; + return hrc; +} + + +/** + * Overridden to write out additional config. + */ +void DHCPIndividualConfig::i_writeDhcpdConfig(xml::ElementNode *pElmConfig) +{ + char szTmp[RTUUID_STR_LENGTH + 32]; + RTStrPrintf(szTmp, sizeof(szTmp), "%RTmac", &m_MACAddress); + pElmConfig->setAttribute("MACAddress", szTmp); + + if (m_enmScope == DHCPConfigScope_MachineNIC) + { + RTStrPrintf(szTmp, sizeof(szTmp), "%RTuuid/%u", m_idMachine.raw(), m_uSlot); + pElmConfig->setAttribute("name", szTmp); + } + + pElmConfig->setAttribute("fixedAddress", m_strFixedAddress); + + DHCPConfig::i_writeDhcpdConfig(pElmConfig); +} + Index: /trunk/src/VBox/Main/src-server/DHCPServerImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-server/DHCPServerImpl.cpp (revision 79731) +++ /trunk/src/VBox/Main/src-server/DHCPServerImpl.cpp (revision 79732) @@ -21,7 +21,5 @@ *********************************************************************************************************************************/ #define LOG_GROUP LOG_GROUP_MAIN_DHCPSERVER -#include "NetworkServiceRunner.h" #include "DHCPServerImpl.h" -#include "AutoCaller.h" #include "LoggingNew.h" @@ -38,4 +36,8 @@ #include +#include "AutoCaller.h" +#include "DHCPConfigImpl.h" +#include "MachineImpl.h" +#include "NetworkServiceRunner.h" #include "VirtualBoxImpl.h" @@ -84,9 +86,18 @@ { Data() - : enabled(FALSE) - , router(false) + : pVirtualBox(NULL) + , strName() + , enabled(FALSE) +// , router(false) + , uIndividualMACAddressVersion(1) { szTempConfigFileName[0] = '\0'; } + + /** weak VirtualBox parent */ + VirtualBox * const pVirtualBox; + /** The DHCP server name (network). + * @todo Kind of duplicated by networkName, if I understand it correctly. */ + Utf8Str const strName; Utf8Str IPAddress; @@ -95,9 +106,14 @@ BOOL enabled; +#if 0 + /** Don't quit get WTF this is about, but the old addOption method contained the + * following hint: "Indirect way to understand that we're on NAT network." + * + * Apparently this is a busted with the new dhcpd implementation, so we don't + * maintain it with the API overhaul in 6.0.12. + */ bool router; +#endif DHCPServerRunner dhcp; - - settings::DhcpOptionMap GlobalDhcpOptions; - settings::VmSlot2OptionsMap VmSlot2Options; char szTempConfigFileName[RTPATH_MAX]; @@ -106,4 +122,21 @@ com::Utf8Str trunkName; com::Utf8Str trunkType; + + /** Global configuration. */ + ComObjPtr globalConfig; + + /** Group configuration indexed by name. */ + std::map> groupConfigs; + /** Iterator for groupConfigs. */ + typedef std::map>::iterator GroupConfigIterator; + + /** Individual (host) configuration indexed by MAC address or VM UUID. */ + std::map> individualConfigs; + /** Iterator for individualConfigs. */ + typedef std::map>::iterator IndividualConfigIterator; + + /** Part of a lock-avoidance hack to resolve the VM ID + slot into MAC + * addresses before writing out the Dhcpd configuration file. */ + uint32_t uIndividualMACAddressVersion; }; @@ -115,5 +148,4 @@ DHCPServer::DHCPServer() : m(NULL) - , mVirtualBox(NULL) { m = new DHCPServer::Data(); @@ -139,6 +171,5 @@ void DHCPServer::FinalRelease() { - uninit (); - + uninit(); BaseFinalRelease(); } @@ -155,5 +186,5 @@ stop(); - unconst(mVirtualBox) = NULL; + unconst(m->pVirtualBox) = NULL; } @@ -167,22 +198,27 @@ /* share VirtualBox weakly (parent remains NULL so far) */ - unconst(mVirtualBox) = aVirtualBox; - - unconst(mName) = aName; + unconst(m->pVirtualBox) = aVirtualBox; + + unconst(m->strName) = aName; m->IPAddress = "0.0.0.0"; - m->GlobalDhcpOptions[DhcpOpt_SubnetMask] = settings::DhcpOptValue("0.0.0.0"); - m->enabled = FALSE; - - m->lowerIP = "0.0.0.0"; - m->upperIP = "0.0.0.0"; - - /* Confirm a successful initialization */ - autoInitSpan.setSucceeded(); - - return S_OK; -} - - -HRESULT DHCPServer::init(VirtualBox *aVirtualBox, const settings::DHCPServer &data) + m->lowerIP = "0.0.0.0"; + m->upperIP = "0.0.0.0"; + m->enabled = FALSE; + + /* Global configuration: */ + HRESULT hrc = m->globalConfig.createObject(); + if (SUCCEEDED(hrc)) + hrc = m->globalConfig->initWithDefaults(aVirtualBox, this); + + /* Confirm a successful initialization or not: */ + if (SUCCEEDED(hrc)) + autoInitSpan.setSucceeded(); + else + autoInitSpan.setFailed(hrc); + return hrc; +} + + +HRESULT DHCPServer::init(VirtualBox *aVirtualBox, const settings::DHCPServer &rData) { /* Enclose the state transition NotReady->InInit->Ready */ @@ -191,25 +227,90 @@ /* share VirtualBox weakly (parent remains NULL so far) */ - unconst(mVirtualBox) = aVirtualBox; - - unconst(mName) = data.strNetworkName; - m->IPAddress = data.strIPAddress; - m->enabled = data.fEnabled; - m->lowerIP = data.strIPLower; - m->upperIP = data.strIPUpper; - - m->GlobalDhcpOptions.clear(); - m->GlobalDhcpOptions.insert(data.GlobalDhcpOptions.begin(), data.GlobalDhcpOptions.end()); - - m->VmSlot2Options.clear(); - m->VmSlot2Options.insert(data.VmSlot2OptionsM.begin(), data.VmSlot2OptionsM.end()); - - autoInitSpan.setSucceeded(); - - return S_OK; -} - - -HRESULT DHCPServer::i_saveSettings(settings::DHCPServer &data) + unconst(m->pVirtualBox) = aVirtualBox; + + unconst(m->strName) = rData.strNetworkName; + m->IPAddress = rData.strIPAddress; + m->enabled = rData.fEnabled; + m->lowerIP = rData.strIPLower; + m->upperIP = rData.strIPUpper; + + /* + * Global configuration: + */ + HRESULT hrc = m->globalConfig.createObject(); + if (SUCCEEDED(hrc)) + hrc = m->globalConfig->initWithSettings(aVirtualBox, this, rData.GlobalConfig); + + /* + * Group configurations: + */ + + /* + * Individual configuration: + */ + Assert(m->individualConfigs.size() == 0); + if (SUCCEEDED(hrc)) + { + for (settings::DHCPIndividualConfigMap::const_iterator it = rData.IndividualConfigs.begin(); + it != rData.IndividualConfigs.end() && SUCCEEDED(hrc); ++it) + { + ComObjPtr ptrIndiCfg; + com::Utf8Str strKey; + if (!it->second.strVMName.isNotEmpty()) + { + RTMAC MACAddress; + int vrc = RTNetStrToMacAddr(it->second.strMACAddress.c_str(), &MACAddress); + if (RT_FAILURE(vrc)) + { + LogRel(("Ignoring invalid MAC address for individual DHCP config: '%s' - %Rrc\n", it->second.strMACAddress.c_str(), vrc)); + continue; + } + + vrc = strKey.printfNoThrow("%RTmac", &MACAddress); + AssertRCReturn(vrc, E_OUTOFMEMORY); + + hrc = ptrIndiCfg.createObject(); + if (SUCCEEDED(hrc)) + hrc = ptrIndiCfg->initWithSettingsAndMACAddress(aVirtualBox, this, it->second, &MACAddress); + } + else + { + /* This ASSUMES that we're being called after the machines have been + loaded so we can resolve VM names into UUID for old settings. */ + com::Guid idMachine; + hrc = i_vmNameToIdAndValidateSlot(it->second.strVMName, it->second.uSlot, idMachine); + if (SUCCEEDED(hrc)) + { + hrc = ptrIndiCfg.createObject(); + if (SUCCEEDED(hrc)) + hrc = ptrIndiCfg->initWithSettingsAndMachineIdAndSlot(aVirtualBox, this, it->second, + idMachine, it->second.uSlot, + m->uIndividualMACAddressVersion - UINT32_MAX / 4); + } + } + if (SUCCEEDED(hrc)) + { + try + { + m->individualConfigs[strKey] = ptrIndiCfg; + } + catch (std::bad_alloc &) + { + return E_OUTOFMEMORY; + } + } + } + } + + /* Confirm a successful initialization or not: */ + if (SUCCEEDED(hrc)) + autoInitSpan.setSucceeded(); + else + autoInitSpan.setFailed(hrc); + return hrc; +} + + +HRESULT DHCPServer::i_saveSettings(settings::DHCPServer &rData) { AutoCaller autoCaller(this); @@ -218,20 +319,46 @@ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); - data.strNetworkName = mName; - data.strIPAddress = m->IPAddress; - - data.fEnabled = !!m->enabled; - data.strIPLower = m->lowerIP; - data.strIPUpper = m->upperIP; - - data.GlobalDhcpOptions.clear(); - data.GlobalDhcpOptions.insert(m->GlobalDhcpOptions.begin(), - m->GlobalDhcpOptions.end()); - - data.VmSlot2OptionsM.clear(); - data.VmSlot2OptionsM.insert(m->VmSlot2Options.begin(), - m->VmSlot2Options.end()); - - return S_OK; + rData.strNetworkName = m->strName; + rData.strIPAddress = m->IPAddress; + rData.fEnabled = m->enabled != FALSE; + rData.strIPLower = m->lowerIP; + rData.strIPUpper = m->upperIP; + + /* Global configuration: */ + HRESULT hrc = m->globalConfig->i_saveSettings(rData.GlobalConfig); + + /* Group configuration: */ + + /* Individual configuration: */ + for (Data::IndividualConfigIterator it = m->individualConfigs.begin(); + it != m->individualConfigs.end() && SUCCEEDED(hrc); ++it) + { + try + { + rData.IndividualConfigs[it->first] = settings::DHCPIndividualConfig(); + } + catch (std::bad_alloc &) + { + return E_OUTOFMEMORY; + } + hrc = it->second->i_saveSettings(rData.IndividualConfigs[it->first]); + } + + return hrc; +} + + +/** + * Internal worker that saves the settings after a modification was made. + * + * @returns COM status code. + * + * @note Caller must not hold any locks! + */ +HRESULT DHCPServer::i_doSaveSettings() +{ + // save the global settings; for that we should hold only the VirtualBox lock + AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS); + return m->pVirtualBox->i_saveSettings(); } @@ -239,15 +366,12 @@ HRESULT DHCPServer::getNetworkName(com::Utf8Str &aName) { + /* The name is const, so no need to for locking. */ + return aName.assignEx(m->strName); +} + + +HRESULT DHCPServer::getEnabled(BOOL *aEnabled) +{ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); - - aName = mName; - return S_OK; -} - - -HRESULT DHCPServer::getEnabled(BOOL *aEnabled) -{ - AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); - *aEnabled = m->enabled; return S_OK; @@ -257,13 +381,9 @@ HRESULT DHCPServer::setEnabled(BOOL aEnabled) { - AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); - m->enabled = aEnabled; - - // save the global settings; for that we should hold only the VirtualBox lock - alock.release(); - AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS); - HRESULT rc = mVirtualBox->i_saveSettings(); - - return rc; + { + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + m->enabled = aEnabled; + } + return i_doSaveSettings(); } @@ -272,7 +392,5 @@ { AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); - - aIPAddress = Utf8Str(m->IPAddress); - return S_OK; + return aIPAddress.assignEx(m->IPAddress); } @@ -280,26 +398,19 @@ HRESULT DHCPServer::getNetworkMask(com::Utf8Str &aNetworkMask) { + return m->globalConfig->i_getNetworkMask(aNetworkMask); +} + + +HRESULT DHCPServer::getLowerIP(com::Utf8Str &aIPAddress) +{ AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); - - aNetworkMask = m->GlobalDhcpOptions[DhcpOpt_SubnetMask].text; - return S_OK; -} - - -HRESULT DHCPServer::getLowerIP(com::Utf8Str &aIPAddress) + return aIPAddress.assignEx(m->lowerIP); +} + + +HRESULT DHCPServer::getUpperIP(com::Utf8Str &aIPAddress) { AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); - - aIPAddress = Utf8Str(m->lowerIP); - return S_OK; -} - - -HRESULT DHCPServer::getUpperIP(com::Utf8Str &aIPAddress) -{ - AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); - - aIPAddress = Utf8Str(m->upperIP); - return S_OK; + return aIPAddress.assignEx(m->upperIP); } @@ -314,17 +425,17 @@ int vrc = RTNetStrToIPv4Addr(aIPAddress.c_str(), &IPAddress); if (RT_FAILURE(vrc)) - return mVirtualBox->setErrorBoth(E_INVALIDARG, vrc, "Invalid server address"); + return setErrorBoth(E_INVALIDARG, vrc, tr("Invalid server address: %s"), aIPAddress.c_str()); vrc = RTNetStrToIPv4Addr(aNetworkMask.c_str(), &NetworkMask); if (RT_FAILURE(vrc)) - return mVirtualBox->setErrorBoth(E_INVALIDARG, vrc, "Invalid netmask"); + return setErrorBoth(E_INVALIDARG, vrc, tr("Invalid netmask: %s"), aNetworkMask.c_str()); vrc = RTNetStrToIPv4Addr(aLowerIP.c_str(), &LowerIP); if (RT_FAILURE(vrc)) - return mVirtualBox->setErrorBoth(E_INVALIDARG, vrc, "Invalid range lower address"); + return setErrorBoth(E_INVALIDARG, vrc, tr("Invalid range lower address: %s"), aLowerIP.c_str()); vrc = RTNetStrToIPv4Addr(aUpperIP.c_str(), &UpperIP); if (RT_FAILURE(vrc)) - return mVirtualBox->setErrorBoth(E_INVALIDARG, vrc, "Invalid range upper address"); + return setErrorBoth(E_INVALIDARG, vrc, tr("Invalid range upper address: %s"), aUpperIP.c_str()); /* @@ -334,11 +445,11 @@ vrc = RTNetMaskToPrefixIPv4(&NetworkMask, NULL); if (RT_FAILURE(vrc)) - return mVirtualBox->setErrorBoth(E_INVALIDARG, vrc, "Invalid netmask"); - - /* It's more convenient to convert to host order once */ - IPAddress.u = RT_N2H_U32(IPAddress.u); + return setErrorBoth(E_INVALIDARG, vrc, tr("Invalid netmask: %s"), aNetworkMask.c_str()); + + /* It's more convenient to convert to host order once: */ + IPAddress.u = RT_N2H_U32(IPAddress.u); NetworkMask.u = RT_N2H_U32(NetworkMask.u); - LowerIP.u = RT_N2H_U32(LowerIP.u); - UpperIP.u = RT_N2H_U32(UpperIP.u); + LowerIP.u = RT_N2H_U32(LowerIP.u); + UpperIP.u = RT_N2H_U32(UpperIP.u); /* @@ -348,5 +459,5 @@ || (IPAddress.u & ~NetworkMask.u) == 0 || ((IPAddress.u & ~NetworkMask.u) | NetworkMask.u) == UINT32_C(0xffffffff)) - return mVirtualBox->setError(E_INVALIDARG, "Invalid server address"); + return setError(E_INVALIDARG, tr("Invalid server address: %s (mask %s)"), aIPAddress.c_str(), aNetworkMask.c_str()); if ( (LowerIP.u & UINT32_C(0xe0000000)) == UINT32_C(0xe0000000) @@ -354,5 +465,5 @@ || (LowerIP.u & ~NetworkMask.u) == 0 || ((LowerIP.u & ~NetworkMask.u) | NetworkMask.u) == UINT32_C(0xffffffff)) - return mVirtualBox->setError(E_INVALIDARG, "Invalid range lower address"); + return setError(E_INVALIDARG, tr("Invalid range lower address: %s (mask %s)"), aLowerIP.c_str(), aNetworkMask.c_str()); if ( (UpperIP.u & UINT32_C(0xe0000000)) == UINT32_C(0xe0000000) @@ -360,35 +471,47 @@ || (UpperIP.u & ~NetworkMask.u) == 0 || ((UpperIP.u & ~NetworkMask.u) | NetworkMask.u) == UINT32_C(0xffffffff)) - return mVirtualBox->setError(E_INVALIDARG, "Invalid range upper address"); + return setError(E_INVALIDARG, tr("Invalid range upper address"), aUpperIP.c_str(), aNetworkMask.c_str()); /* The range should be valid ... */ if (LowerIP.u > UpperIP.u) - return mVirtualBox->setError(E_INVALIDARG, "Invalid range bounds"); + return setError(E_INVALIDARG, tr("Lower bound must be less or eqaul than the upper: %s vs %s"), + aLowerIP.c_str(), aUpperIP.c_str()); /* ... and shouldn't contain the server's address */ if (LowerIP.u <= IPAddress.u && IPAddress.u <= UpperIP.u) - return mVirtualBox->setError(E_INVALIDARG, "Server address within range bounds"); - - AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); - m->IPAddress = aIPAddress; - m->GlobalDhcpOptions[DhcpOpt_SubnetMask] = aNetworkMask; - - m->lowerIP = aLowerIP; - m->upperIP = aUpperIP; - - // save the global settings; for that we should hold only the VirtualBox lock - alock.release(); - AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS); - return mVirtualBox->i_saveSettings(); -} - - -HRESULT DHCPServer::encodeOption(com::Utf8Str &aEncoded, - uint32_t aOptCode, - const settings::DhcpOptValue &aOptValue) -{ - switch (aOptValue.encoding) - { - case DhcpOptEncoding_Legacy: + return setError(E_INVALIDARG, tr("Server address within range bounds: %s in %s - %s"), + aIPAddress.c_str(), aLowerIP.c_str(), aUpperIP.c_str()); + + /* + * Input is valid, effect the changes. + */ + HRESULT hrc; + { + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + m->IPAddress = aIPAddress; + m->lowerIP = aLowerIP; + m->upperIP = aUpperIP; + hrc = m->globalConfig->i_setNetworkMask(aNetworkMask); + } + if (SUCCEEDED(hrc)) + hrc = i_doSaveSettings(); + return hrc; +} + + +/** + * Used by the legacy 6.0 IDHCPServer::GetVmSlotOptions() and + * IDHCPServer::GetGlobalOptions() implementations. + * + * New interfaces have the option number and option encoding separate from the + * value. + */ +HRESULT DHCPServer::i_encode60Option(com::Utf8Str &strEncoded, DhcpOpt_T enmOption, + DHCPOptionEncoding_T enmEncoding, const com::Utf8Str &strValue) +{ + int vrc; + switch (enmEncoding) + { + case DHCPOptionEncoding_Legacy: { /* @@ -400,9 +523,9 @@ * "6:1.2.3.4 8.8.8.8" # array of ip-address */ - aEncoded = Utf8StrFmt("%d:%s", aOptCode, aOptValue.text.c_str()); + vrc = strEncoded.printfNoThrow("%d:%s", (int)enmOption, strValue.c_str()); break; } - case DhcpOptEncoding_Hex: + case DHCPOptionEncoding_Hex: { /* @@ -413,5 +536,5 @@ * 234=68:65:6c:6c:6f:2c:20:77:6f:72:6c:64 */ - aEncoded = Utf8StrFmt("%d=%s", aOptCode, aOptValue.text.c_str()); + vrc = strEncoded.printfNoThrow("%d=%s", (int)enmOption, strValue.c_str()); break; } @@ -424,171 +547,250 @@ * "254@42=i hope you know what this means" */ - aEncoded = Utf8StrFmt("%d@%d=%s", aOptCode, (int)aOptValue.encoding, - aOptValue.text.c_str()); + vrc = strEncoded.printfNoThrow("%d@%d=%s", (int)enmOption, (int)enmEncoding, strValue.c_str()); break; } } - - return S_OK; -} - - -int DHCPServer::addOption(settings::DhcpOptionMap &aMap, - DhcpOpt_T aOption, const com::Utf8Str &aValue) -{ - settings::DhcpOptValue OptValue; - + return RT_SUCCESS(vrc) ? S_OK : E_OUTOFMEMORY; +} + + +/** + * worker for IDHCPServer::GetGlobalOptions. + */ +HRESULT DHCPServer::i_getAllOptions60(DHCPConfig &aSourceConfig, std::vector &aValues) +{ + /* Get the values using the new getter: */ + std::vector Options; + std::vector Encodings; + std::vector Values; + HRESULT hrc = aSourceConfig.i_getAllOptions(Options, Encodings, Values); + if (SUCCEEDED(hrc)) + { + /* Encoding them using in the 6.0 style: */ + size_t const cValues = Values.size(); + aValues.resize(cValues); + for (size_t i = 0; i < cValues && SUCCEEDED(hrc); i++) + hrc = i_encode60Option(aValues[i], Options[i], Encodings[i], Values[i]); + } + return hrc; +} + + +/** + * Worker for legacy <=6.0 interfaces for adding options. + * + * @throws std::bad_alloc + */ +HRESULT DHCPServer::i_add60Option(DHCPConfig &aTargetConfig, DhcpOpt_T aOption, const com::Utf8Str &aValue) +{ if (aOption != 0) - { - OptValue = settings::DhcpOptValue(aValue, DhcpOptEncoding_Legacy); - } + return aTargetConfig.i_setOption(aOption, DHCPOptionEncoding_Legacy, aValue); + /* * This is a kludge to sneak in option encoding information * through existing API. We use option 0 and supply the real - * option/value in the same format that encodeOption() above + * option/value in the same format that i_encode60Option() above * produces for getter methods. */ - else - { - uint8_t u8Code; - char *pszNext; - int vrc = RTStrToUInt8Ex(aValue.c_str(), &pszNext, 10, &u8Code); - if (!RT_SUCCESS(vrc)) + uint8_t u8Code; + char *pszNext; + int vrc = RTStrToUInt8Ex(aValue.c_str(), &pszNext, 10, &u8Code); + if (RT_FAILURE(vrc)) + return setErrorBoth(E_INVALIDARG, VERR_PARSE_ERROR); + + DHCPOptionEncoding_T enmEncoding; + switch (*pszNext) + { + case ':': /* support legacy format too */ + { + enmEncoding = DHCPOptionEncoding_Legacy; + break; + } + + case '=': + { + enmEncoding = DHCPOptionEncoding_Hex; + break; + } + + case '@': + { + uint32_t u32Enc = 0; + vrc = RTStrToUInt32Ex(pszNext + 1, &pszNext, 10, &u32Enc); + if (RT_FAILURE(vrc)) + return setErrorBoth(E_INVALIDARG, VERR_PARSE_ERROR); + if (*pszNext != '=') + return setErrorBoth(E_INVALIDARG, VERR_PARSE_ERROR); + enmEncoding = (DHCPOptionEncoding_T)u32Enc; + break; + } + + default: return VERR_PARSE_ERROR; - - uint32_t u32Enc; - switch (*pszNext) - { - case ':': /* support legacy format too */ + } + + return aTargetConfig.i_setOption(aOption, enmEncoding, com::Utf8Str(pszNext + 1)); +} + + +HRESULT DHCPServer::addGlobalOption(DhcpOpt_T aOption, const com::Utf8Str &aValue) +{ + return i_add60Option(*m->globalConfig, aOption, aValue); +} + + +HRESULT DHCPServer::removeGlobalOption(DhcpOpt_T aOption) +{ + return m->globalConfig->i_removeOption(aOption); +} + + +HRESULT DHCPServer::removeGlobalOptions() +{ + return m->globalConfig->i_removeAllOptions(); +} + + +HRESULT DHCPServer::getGlobalOptions(std::vector &aValues) +{ + return i_getAllOptions60(*m->globalConfig, aValues); +} + + +HRESULT DHCPServer::getVmConfigs(std::vector &aValues) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + try + { + aValues.resize(m->individualConfigs.size()); + size_t i = 0; + for (Data::IndividualConfigIterator it = m->individualConfigs.begin(); it != m->individualConfigs.end(); ++it, i++) + if (it->second->i_getScope() != DHCPConfigScope_MAC) + aValues[i].printf("[%RTuuid]:%d", it->second->i_getMachineId().raw(), it->second->i_getSlot()); + else + aValues[i].printf("[%RTmac]", it->second->i_getMACAddress()); + } + catch (std::bad_alloc &) + { + return E_OUTOFMEMORY; + } + + return S_OK; +} + + +HRESULT DHCPServer::i_vmNameToIdAndValidateSlot(const com::Utf8Str &aVmName, LONG aSlot, com::Guid &idMachine) +{ + if ((ULONG)aSlot <= 32) + { + /* Is it a UUID? */ + idMachine = aVmName; + if (idMachine.isValid() && !idMachine.isZero()) + return S_OK; + + /* No, find the VM and get it's UUID. */ + ComObjPtr ptrMachine; + HRESULT hrc = m->pVirtualBox->i_findMachine(aVmName, false /*fPermitInaccessible*/, true /*aSetError*/, &ptrMachine); + if (SUCCEEDED(hrc)) + idMachine = ptrMachine->i_getId(); + return hrc; + } + return setError(E_INVALIDARG, tr("NIC slot number (%d) is out of range (0..32)"), aSlot); +} + + +/** + * Translates a VM name/id and slot to an individual configuration object. + * + * @returns COM status code. + * @param a_strVmName The VM name or ID. + * @param a_uSlot The NIC slot. + * @param a_fCreateIfNeeded Whether to create a new entry if not found. + * @param a_rPtrConfig Where to return the config object. It's + * implicitly referenced, so we don't be returning + * with any locks held. + * + * @note Caller must not be holding any locks! + */ +HRESULT DHCPServer::i_vmNameAndSlotToConfig(const com::Utf8Str &a_strVmName, LONG a_uSlot, bool a_fCreateIfNeeded, + ComObjPtr &a_rPtrConfig) +{ + /* + * Validate the slot and normalize the name into a UUID. + */ + com::Guid idMachine; + HRESULT hrc = i_vmNameToIdAndValidateSlot(a_strVmName, a_uSlot, idMachine); + if (SUCCEEDED(hrc)) + { + Utf8Str strKey; + int vrc = strKey.printfNoThrow("%RTuuid/%u", idMachine.raw(), a_uSlot); + if (RT_SUCCESS(vrc)) + { + /* + * Look it up. + */ { - u32Enc = DhcpOptEncoding_Legacy; - break; + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + Data::IndividualConfigIterator it = m->individualConfigs.find(strKey); + if (it != m->individualConfigs.end()) + { + a_rPtrConfig = it->second; + return S_OK; + } } - - case '=': + if (a_fCreateIfNeeded) { - u32Enc = DhcpOptEncoding_Hex; - break; + /* + * Create a new slot. + */ + /* Instantiate the object: */ + hrc = a_rPtrConfig.createObject(); + if (SUCCEEDED(hrc)) + hrc = a_rPtrConfig->initWithMachineIdAndSlot(m->pVirtualBox, this, idMachine, a_uSlot, + m->uIndividualMACAddressVersion - UINT32_MAX / 4); + if (SUCCEEDED(hrc)) + { + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + + /* Check for creation race: */ + Data::IndividualConfigIterator it = m->individualConfigs.find(strKey); + if (it != m->individualConfigs.end()) + { + a_rPtrConfig.setNull(); + a_rPtrConfig = it->second; + return S_OK; + } + + /* Add it. */ + try + { + m->individualConfigs[strKey] = a_rPtrConfig; + return S_OK; + } + catch (std::bad_alloc &) + { + hrc = E_OUTOFMEMORY; + } + a_rPtrConfig.setNull(); + } } - - case '@': - { - vrc = RTStrToUInt32Ex(pszNext + 1, &pszNext, 10, &u32Enc); - if (!RT_SUCCESS(vrc)) - return VERR_PARSE_ERROR; - if (*pszNext != '=') - return VERR_PARSE_ERROR; - break; - } - - default: - return VERR_PARSE_ERROR; - } - - aOption = (DhcpOpt_T)u8Code; - OptValue = settings::DhcpOptValue(pszNext + 1, (DhcpOptEncoding_T)u32Enc); - } - - aMap[aOption] = OptValue; - return VINF_SUCCESS; -} - - -HRESULT DHCPServer::addGlobalOption(DhcpOpt_T aOption, const com::Utf8Str &aValue) -{ - AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); - - int rc = addOption(m->GlobalDhcpOptions, aOption, aValue); - if (!RT_SUCCESS(rc)) - return E_INVALIDARG; - - /* Indirect way to understand that we're on NAT network */ - if (aOption == DhcpOpt_Router) - { - m->router = true; - } - - alock.release(); - - AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS); - return mVirtualBox->i_saveSettings(); -} - - -HRESULT DHCPServer::removeGlobalOption(DhcpOpt_T aOption) -{ - AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); - - settings::DhcpOptionMap::size_type cErased = m->GlobalDhcpOptions.erase(aOption); - if (!cErased) - return E_INVALIDARG; - - alock.release(); - - AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS); - return mVirtualBox->i_saveSettings(); -} - - -HRESULT DHCPServer::removeGlobalOptions() -{ - AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); - m->GlobalDhcpOptions.clear(); - - alock.release(); - - AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS); - return mVirtualBox->i_saveSettings(); -} - - -HRESULT DHCPServer::getGlobalOptions(std::vector &aValues) -{ - AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); - aValues.resize(m->GlobalDhcpOptions.size()); - settings::DhcpOptionMap::const_iterator it; - size_t i = 0; - for (it = m->GlobalDhcpOptions.begin(); it != m->GlobalDhcpOptions.end(); ++it, ++i) - { - uint32_t OptCode = (*it).first; - const settings::DhcpOptValue &OptValue = (*it).second; - - encodeOption(aValues[i], OptCode, OptValue); - } - - return S_OK; -} - -HRESULT DHCPServer::getVmConfigs(std::vector &aValues) -{ - AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); - aValues.resize(m->VmSlot2Options.size()); - settings::VmSlot2OptionsMap::const_iterator it; - size_t i = 0; - for (it = m->VmSlot2Options.begin(); it != m->VmSlot2Options.end(); ++it, ++i) - { - aValues[i] = Utf8StrFmt("[%s]:%d", it->first.VmName.c_str(), it->first.Slot); - } - - return S_OK; -} - - -HRESULT DHCPServer::addVmSlotOption(const com::Utf8Str &aVmName, - LONG aSlot, - DhcpOpt_T aOption, - const com::Utf8Str &aValue) -{ - AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); - - settings::DhcpOptionMap &map = m->VmSlot2Options[settings::VmNameSlotKey(aVmName, aSlot)]; - int rc = addOption(map, aOption, aValue); - if (!RT_SUCCESS(rc)) - return E_INVALIDARG; - - alock.release(); - - AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS); - return mVirtualBox->i_saveSettings(); + else + hrc = VBOX_E_OBJECT_NOT_FOUND; + } + else + hrc = E_OUTOFMEMORY; + } + return hrc; +} + + +HRESULT DHCPServer::addVmSlotOption(const com::Utf8Str &aVmName, LONG aSlot, DhcpOpt_T aOption, const com::Utf8Str &aValue) +{ + ComObjPtr ptrConfig; + HRESULT hrc = i_vmNameAndSlotToConfig(aVmName, aSlot, true, ptrConfig); + if (SUCCEEDED(hrc)) + hrc = i_add60Option(*ptrConfig, aOption, aValue); + return hrc; } @@ -596,14 +798,9 @@ HRESULT DHCPServer::removeVmSlotOption(const com::Utf8Str &aVmName, LONG aSlot, DhcpOpt_T aOption) { - AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); - settings::DhcpOptionMap &map = i_findOptMapByVmNameSlot(aVmName, aSlot); - settings::DhcpOptionMap::size_type cErased = map.erase(aOption); - if (!cErased) - return E_INVALIDARG; - - alock.release(); - - AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS); - return mVirtualBox->i_saveSettings(); + ComObjPtr ptrConfig; + HRESULT hrc = i_vmNameAndSlotToConfig(aVmName, aSlot, false, ptrConfig); + if (SUCCEEDED(hrc)) + hrc = ptrConfig->i_removeOption(aOption); + return hrc; } @@ -611,36 +808,24 @@ HRESULT DHCPServer::removeVmSlotOptions(const com::Utf8Str &aVmName, LONG aSlot) { - AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); - settings::DhcpOptionMap &map = i_findOptMapByVmNameSlot(aVmName, aSlot); - map.clear(); - - alock.release(); - - AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS); - return mVirtualBox->i_saveSettings(); -} - -/** - * this is mapping (vm, slot) - */ -HRESULT DHCPServer::getVmSlotOptions(const com::Utf8Str &aVmName, - LONG aSlot, - std::vector &aValues) -{ - - AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); - settings::DhcpOptionMap &map = i_findOptMapByVmNameSlot(aVmName, aSlot); - aValues.resize(map.size()); - size_t i = 0; - settings::DhcpOptionMap::const_iterator it; - for (it = map.begin(); it != map.end(); ++it, ++i) - { - uint32_t OptCode = (*it).first; - const settings::DhcpOptValue &OptValue = (*it).second; - - encodeOption(aValues[i], OptCode, OptValue); - } - - return S_OK; + ComObjPtr ptrConfig; + HRESULT hrc = i_vmNameAndSlotToConfig(aVmName, aSlot, false, ptrConfig); + if (SUCCEEDED(hrc)) + hrc = ptrConfig->i_removeAllOptions(); + return hrc; +} + + +HRESULT DHCPServer::getVmSlotOptions(const com::Utf8Str &aVmName, LONG aSlot, std::vector &aValues) +{ + ComObjPtr ptrConfig; + HRESULT hrc = i_vmNameAndSlotToConfig(aVmName, aSlot, false, ptrConfig); + if (SUCCEEDED(hrc)) + hrc = i_getAllOptions60(*ptrConfig, aValues); + else if (hrc == VBOX_E_OBJECT_NOT_FOUND) + { + aValues.resize(0); + hrc = S_OK; + } + return hrc; } @@ -648,41 +833,9 @@ HRESULT DHCPServer::getMacOptions(const com::Utf8Str &aMAC, std::vector &aOption) { - AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); - HRESULT hrc = S_OK; - ComPtr machine; - ComPtr nic; - settings::VmSlot2OptionsIterator it; - for(it = m->VmSlot2Options.begin(); it != m->VmSlot2Options.end(); ++it) - { - alock.release(); - hrc = mVirtualBox->FindMachine(Bstr(it->first.VmName).raw(), machine.asOutParam()); - alock.acquire(); - - if (FAILED(hrc)) - continue; - - alock.release(); - hrc = machine->GetNetworkAdapter(it->first.Slot, nic.asOutParam()); - alock.acquire(); - - if (FAILED(hrc)) - continue; - - com::Bstr mac; - - alock.release(); - hrc = nic->COMGETTER(MACAddress)(mac.asOutParam()); - alock.acquire(); - - if (FAILED(hrc)) /* no MAC address ??? */ - break; - if (!RTStrICmp(com::Utf8Str(mac).c_str(), aMAC.c_str())) - return getVmSlotOptions(it->first.VmName, - it->first.Slot, - aOption); - } /* end of for */ - - return hrc; -} + RT_NOREF(aMAC, aOption); + AssertFailed(); + return setError(E_NOTIMPL, tr("The GetMacOptions method has been discontinued as it was only supposed to be used by the DHCP server and it does not need it any more. sorry")); +} + HRESULT DHCPServer::getEventSource(ComPtr &aEventSource) @@ -693,10 +846,62 @@ -DECLINLINE(void) addOptionChild(xml::ElementNode *pParent, uint32_t OptCode, const settings::DhcpOptValue &OptValue) -{ - xml::ElementNode *pOption = pParent->createChild("Option"); - pOption->setAttribute("name", OptCode); - pOption->setAttribute("encoding", OptValue.encoding); - pOption->setAttribute("value", OptValue.text.c_str()); +HRESULT DHCPServer::getGlobalConfig(ComPtr &aGlobalConfig) +{ + /* The global configuration is immutable, so no need to lock anything here. */ + return m->globalConfig.queryInterfaceTo(aGlobalConfig.asOutParam()); +} + + +HRESULT DHCPServer::getGroupConfigs(std::vector > &aGroupConfigs) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); +#if 0 /** @todo implement group configs */ + + try + { + aGroupConfigs.resize(m->groupConfigs.size()); + } + catch (std::bad_alloc &) + { + return E_OUTOFMEMORY; + } + + size_t i = 0; + for (Data::GroupConfigIterator it = m->groupConfigs.begin(); it != m->groupConfigs.end(); ++it) + { + HRESULT hrc = it->second.queryInterfaceTo(aGroupConfigs[i].asOutParam()); + if (FAILED(hrc)) + return hrc; + } + +#else + aGroupConfigs.resize(0); +#endif + return S_OK; +} + + +HRESULT DHCPServer::getIndividualConfigs(std::vector > &aIndividualConfigs) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + try + { + aIndividualConfigs.resize(m->individualConfigs.size()); + } + catch (std::bad_alloc &) + { + return E_OUTOFMEMORY; + } + + size_t i = 0; + for (Data::IndividualConfigIterator it = m->individualConfigs.begin(); it != m->individualConfigs.end(); ++it) + { + HRESULT hrc = it->second.queryInterfaceTo(aIndividualConfigs[i].asOutParam()); + if (FAILED(hrc)) + return hrc; + } + + return S_OK; } @@ -718,15 +923,127 @@ -HRESULT DHCPServer::start(const com::Utf8Str &aNetworkName, - const com::Utf8Str &aTrunkName, - const com::Utf8Str &aTrunkType) -{ +/** + * @throws std::bad_alloc + */ +HRESULT DHCPServer::i_writeDhcpdConfig(const char *pszFilename, uint32_t uMACAddressVersion) +{ + /* + * Produce the DHCP server configuration. + */ + xml::Document doc; + try + { + xml::ElementNode *pElmRoot = doc.createRootElement("DHCPServer"); + pElmRoot->setAttribute("networkName", m->networkName); + if (m->trunkName.isNotEmpty()) + pElmRoot->setAttribute("trunkName", m->trunkName); + pElmRoot->setAttribute("trunkType", m->trunkType); + pElmRoot->setAttribute("IPAddress", m->IPAddress); + pElmRoot->setAttribute("lowerIP", m->lowerIP); + pElmRoot->setAttribute("upperIP", m->upperIP); + pElmRoot->setAttribute("leasesFilename", m->strLeasesFilename); + Utf8Str strNetworkMask; + HRESULT hrc = m->globalConfig->i_getNetworkMask(strNetworkMask); + if (FAILED(hrc)) + return hrc; + pElmRoot->setAttribute("networkMask", strNetworkMask); + + /* + * Process global options + */ + m->globalConfig->i_writeDhcpdConfig(pElmRoot->createChild("Options")); + + /* + * Groups. + */ + //for (Data::GroupConfigIterator it = m->groupConfigs.begin(); it != m->groupConfigs.end(); ++it) + // it->second->i_writeDhcpdConfig(pElmRoot->createChild("Config")); + + /* + * Individual NIC configurations. + */ + for (Data::IndividualConfigIterator it = m->individualConfigs.begin(); it != m->individualConfigs.end(); ++it) + if (it->second->i_isMACAddressResolved(uMACAddressVersion)) + it->second->i_writeDhcpdConfig(pElmRoot->createChild("Config")); + else + LogRelFunc(("Skipping %RTuuid/%u, no MAC address.\n", it->second->i_getMachineId().raw(), it->second->i_getSlot())); + } + catch (std::bad_alloc &) + { + return E_OUTOFMEMORY; + } + + /* + * Write out the document. + */ + try + { + xml::XmlFileWriter writer(doc); + writer.write(pszFilename, false); + } + catch (...) + { + return E_FAIL; + } + + return S_OK; +} + + +/** @todo r=bird: why do we get the network name passed in here? it's the same + * as m->strName, isn't it? */ +HRESULT DHCPServer::start(const com::Utf8Str &aNetworkName, const com::Utf8Str &aTrunkName, const com::Utf8Str &aTrunkType) +{ + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + /* Silently ignore attempts to run disabled servers. */ if (!m->enabled) return S_OK; - /** - * @todo: the existing code cannot handle concurrent attempts to start DHCP server. - * Note that technically it may receive different parameters from different callers. + /* + * Resolve the MAC addresses. This requires us to leave the lock. + */ + uint32_t uMACAddressVersion = m->uIndividualMACAddressVersion; + if (m->individualConfigs.size() > 0) + { + m->uIndividualMACAddressVersion = uMACAddressVersion + 1; + + /* Retain pointers to all the individual configuration objects so we + can safely access these after releaseing the lock: */ + std::vector< ComObjPtr > vecIndividualConfigs; + try + { + vecIndividualConfigs.resize(m->individualConfigs.size()); + } + catch (std::bad_alloc &) + { + return E_OUTOFMEMORY; + } + size_t i = 0; + for (Data::IndividualConfigIterator it = m->individualConfigs.begin(); it != m->individualConfigs.end(); ++it, i++) + vecIndividualConfigs[i] = it->second; + + /* Drop the lock and resolve the MAC addresses: */ + alock.release(); + + i = vecIndividualConfigs.size(); + while (i-- > 0) + vecIndividualConfigs[i]->i_resolveMACAddress(uMACAddressVersion); + + /* Reacquire the lock */ + alock.acquire(); + if (!m->enabled) + return S_OK; + } + + /* + * Refuse to start a 2nd DHCP server instance for the same network. + */ + if (m->dhcp.isRunning()) + return setErrorBoth(VBOX_E_OBJECT_IN_USE, VERR_PROCESS_RUNNING, + tr("Cannot start DHCP server because it is already running")); + + /* + * Copy the startup parameters. */ m->networkName = aNetworkName; @@ -734,143 +1051,62 @@ m->trunkType = aTrunkType; HRESULT hrc = i_calcLeasesFilename(aNetworkName); - if (FAILED(hrc)) - return hrc; - - m->dhcp.resetArguments(); - -#ifdef VBOX_WITH_DHCPD - - /* - * Create configuration file path. - */ - /** @todo put this next to the leases file. */ - int rc = RTPathTemp(m->szTempConfigFileName, sizeof(m->szTempConfigFileName)); - if (RT_SUCCESS(rc)) - rc = RTPathAppend(m->szTempConfigFileName, sizeof(m->szTempConfigFileName), "dhcp-config-XXXXX.xml"); - if (RT_SUCCESS(rc)) - rc = RTFileCreateTemp(m->szTempConfigFileName, 0600); - if (RT_FAILURE(rc)) - { + if (SUCCEEDED(hrc)) + { + /* + * Create configuration file path and write out the configuration. + */ + /** @todo put this next to the leases file. */ + int vrc = RTPathTemp(m->szTempConfigFileName, sizeof(m->szTempConfigFileName)); + if (RT_SUCCESS(vrc)) + vrc = RTPathAppend(m->szTempConfigFileName, sizeof(m->szTempConfigFileName), "dhcp-config-XXXXX.xml"); + if (RT_SUCCESS(vrc)) + vrc = RTFileCreateTemp(m->szTempConfigFileName, 0600); + if (RT_SUCCESS(vrc)) + { + hrc = i_writeDhcpdConfig(m->szTempConfigFileName, uMACAddressVersion); + if (SUCCEEDED(hrc)) + { + /* + * Setup the arguments and start the DHCP server. + */ + m->dhcp.resetArguments(); + vrc = m->dhcp.addArgPair(DHCPServerRunner::kDsrKeyConfig, m->szTempConfigFileName); + if (RT_SUCCESS(vrc)) + vrc = m->dhcp.addArgPair(DHCPServerRunner::kDsrKeyComment, m->networkName.c_str()); + if (RT_SUCCESS(vrc)) + vrc = m->dhcp.start(true /*aKillProcessOnStop*/); + if (RT_FAILURE(vrc)) + hrc = setErrorVrc(vrc, tr("Failed to start DHCP server for '%s': %Rrc"), m->strName.c_str(), vrc); + } + if (FAILED(hrc)) + { + RTFileDelete(m->szTempConfigFileName); + m->szTempConfigFileName[0] = '\0'; + } + } + else + { + m->szTempConfigFileName[0] = '\0'; + hrc = setErrorVrc(vrc); + } + } + return hrc; +} + + +HRESULT DHCPServer::stop(void) +{ + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + + if (m->szTempConfigFileName[0]) + { + RTFileDelete(m->szTempConfigFileName); m->szTempConfigFileName[0] = '\0'; - return E_FAIL; - } - - /* - * Produce the DHCP server configuration. - */ - xml::Document doc; - xml::ElementNode *pElmRoot = doc.createRootElement("DHCPServer"); - pElmRoot->setAttribute("networkName", m->networkName); - if (m->trunkName.isNotEmpty()) - pElmRoot->setAttribute("trunkName", m->trunkName); - pElmRoot->setAttribute("trunkType", m->trunkType); - pElmRoot->setAttribute("IPAddress", m->IPAddress); - pElmRoot->setAttribute("networkMask", m->GlobalDhcpOptions[DhcpOpt_SubnetMask].text); - pElmRoot->setAttribute("lowerIP", m->lowerIP); - pElmRoot->setAttribute("upperIP", m->upperIP); - pElmRoot->setAttribute("leasesFilename", m->strLeasesFilename); - - /* Process global options */ - xml::ElementNode *pOptions = pElmRoot->createChild("Options"); - for (settings::DhcpOptionMap::const_iterator it = m->GlobalDhcpOptions.begin(); it != m->GlobalDhcpOptions.end(); ++it) - addOptionChild(pOptions, (*it).first, (*it).second); - - /* Process network-adapter-specific options */ - AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); - hrc = S_OK; - ComPtr machine; - ComPtr nic; - settings::VmSlot2OptionsIterator it; - for (it = m->VmSlot2Options.begin(); it != m->VmSlot2Options.end(); ++it) - { - alock.release(); - hrc = mVirtualBox->FindMachine(Bstr(it->first.VmName).raw(), machine.asOutParam()); - alock.acquire(); - - if (FAILED(hrc)) - continue; - - alock.release(); - hrc = machine->GetNetworkAdapter(it->first.Slot, nic.asOutParam()); - alock.acquire(); - - if (FAILED(hrc)) - continue; - - com::Bstr mac; - - alock.release(); - hrc = nic->COMGETTER(MACAddress)(mac.asOutParam()); - alock.acquire(); - - if (FAILED(hrc)) /* no MAC address ??? */ - continue; - - /* Convert MAC address from XXXXXXXXXXXX to XX:XX:XX:XX:XX:XX */ - Utf8Str strMacWithoutColons(mac); - const char *pszSrc = strMacWithoutColons.c_str(); - RTMAC binaryMac; - if (RTStrConvertHexBytes(pszSrc, &binaryMac, sizeof(binaryMac), 0) != VINF_SUCCESS) - continue; - char szMac[18]; /* "XX:XX:XX:XX:XX:XX" */ - if (RTStrPrintHexBytes(szMac, sizeof(szMac), &binaryMac, sizeof(binaryMac), RTSTRPRINTHEXBYTES_F_SEP_COLON) != VINF_SUCCESS) - continue; - - xml::ElementNode *pMacConfig = pElmRoot->createChild("Config"); - pMacConfig->setAttribute("MACAddress", szMac); - - com::Utf8Str encodedOption; - settings::DhcpOptionMap &map = i_findOptMapByVmNameSlot(it->first.VmName, it->first.Slot); - settings::DhcpOptionMap::const_iterator itAdapterOption; - for (itAdapterOption = map.begin(); itAdapterOption != map.end(); ++itAdapterOption) - addOptionChild(pMacConfig, (*itAdapterOption).first, (*itAdapterOption).second); - } - - xml::XmlFileWriter writer(doc); - writer.write(m->szTempConfigFileName, false); - - m->dhcp.addArgPair(DHCPServerRunner::kDsrKeyConfig, m->szTempConfigFileName); - m->dhcp.addArgPair(DHCPServerRunner::kDsrKeyComment, m->networkName.c_str()); - -#else /* !VBOX_WITH_DHCPD */ - /* Main is needed for NATNetwork */ - if (m->router) - m->dhcp.addArgPair(NetworkServiceRunner::kpszKeyNeedMain, "on"); - - /* Commmon Network Settings */ - m->dhcp.addArgPair(NetworkServiceRunner::kpszKeyNetwork, aNetworkName.c_str()); - if (!aTrunkName.isEmpty()) - m->dhcp.addArgPair(NetworkServiceRunner::kpszTrunkName, aTrunkName.c_str()); - m->dhcp.addArgPair(NetworkServiceRunner::kpszKeyTrunkType, aTrunkType.c_str()); - - /* XXX: should this MAC default initialization moved to NetworkServiceRunner? */ - char strMAC[32]; - Guid guid; - guid.create(); - RTStrPrintf (strMAC, sizeof(strMAC), "08:00:27:%02X:%02X:%02X", - guid.raw()->au8[0], guid.raw()->au8[1], guid.raw()->au8[2]); - m->dhcp.addArgPair(NetworkServiceRunner::kpszMacAddress, strMAC); - m->dhcp.addArgPair(NetworkServiceRunner::kpszIpAddress, m->IPAddress.c_str()); - m->dhcp.addArgPair(NetworkServiceRunner::kpszIpNetmask, m->GlobalDhcpOptions[DhcpOpt_SubnetMask].text.c_str()); - m->dhcp.addArgPair(DHCPServerRunner::kDsrKeyLowerIp, m->lowerIP.c_str()); - m->dhcp.addArgPair(DHCPServerRunner::kDsrKeyUpperIp, m->upperIP.c_str()); -#endif /* !VBOX_WITH_DHCPD */ - - /* XXX: This parameters Dhcp Server will fetch via API */ - return RT_FAILURE(m->dhcp.start(!m->router /* KillProcOnExit */)) ? E_FAIL : S_OK; - //m->dhcp.detachFromServer(); /* need to do this to avoid server shutdown on runner destruction */ -} - - -HRESULT DHCPServer::stop(void) -{ -#ifdef VBOX_WITH_DHCPD - if (m->szTempConfigFileName[0]) - { - RTFileDelete(m->szTempConfigFileName); - m->szTempConfigFileName[0] = 0; - } -#endif /* VBOX_WITH_DHCPD */ - return RT_FAILURE(m->dhcp.stop()) ? E_FAIL : S_OK; + } + + int vrc = m->dhcp.stop(); + if (RT_SUCCESS(vrc)) + return S_OK; + return setErrorVrc(vrc); } @@ -901,5 +1137,5 @@ if (m->strLeasesFilename.isEmpty()) { - HRESULT hrc = i_calcLeasesFilename(m->networkName.isEmpty() ? mName : m->networkName); + HRESULT hrc = i_calcLeasesFilename(m->networkName.isEmpty() ? m->strName : m->networkName); if (FAILED(hrc)) return hrc; @@ -1020,4 +1256,90 @@ +HRESULT DHCPServer::getConfig(DHCPConfigScope_T aScope, const com::Utf8Str &aName, ULONG aSlot, BOOL aMayAdd, + ComPtr &aConfig) +{ + if (aSlot != 0 && aScope != DHCPConfigScope_MachineNIC) + return setError(E_INVALIDARG, tr("The 'slot' argument must be zero for all but the MachineNIC scope!")); + + switch (aScope) + { + case DHCPConfigScope_Global: + if (aName.isNotEmpty()) + return setError(E_INVALIDARG, tr("The name must be empty or NULL for the Global scope!")); + /* No locking required here. */ + return m->globalConfig.queryInterfaceTo(aConfig.asOutParam()); + + case DHCPConfigScope_Group: + return setError(E_NOTIMPL, tr("Groups are not yet implemented, sorry.")); + + case DHCPConfigScope_MachineNIC: + { + ComObjPtr ptrIndividualConfig; + HRESULT hrc = i_vmNameAndSlotToConfig(aName, aSlot, aMayAdd != FALSE, ptrIndividualConfig); + if (SUCCEEDED(hrc)) + hrc = ptrIndividualConfig.queryInterfaceTo(aConfig.asOutParam()); + return hrc; + } + + case DHCPConfigScope_MAC: + { + /* Check and Normalize the MAC address into a key: */ + RTMAC MACAddress; + int vrc = RTNetStrToMacAddr(aName.c_str(), &MACAddress); + if (RT_SUCCESS(vrc)) + { + Utf8Str strKey; + vrc = strKey.printfNoThrow("%RTmac", &MACAddress); + if (RT_SUCCESS(vrc)) + { + /* Look up the MAC address: */ + { + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + Data::IndividualConfigIterator it = m->individualConfigs.find(strKey); + if (it != m->individualConfigs.end()) + return it->second.queryInterfaceTo(aConfig.asOutParam()); + } + if (aMayAdd) + { + /* Create a new individiual configuration: */ + ComObjPtr ptrIndividualConfig; + HRESULT hrc = ptrIndividualConfig.createObject(); + if (SUCCEEDED(hrc)) + hrc = ptrIndividualConfig->initWithMACAddress(m->pVirtualBox, this, &MACAddress); + if (SUCCEEDED(hrc)) + { + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + + /* Check for insertion race: */ + Data::IndividualConfigIterator it = m->individualConfigs.find(strKey); + if (it != m->individualConfigs.end()) + return it->second.queryInterfaceTo(aConfig.asOutParam()); /* creation race*/ + + /* Try insert it: */ + try + { + m->individualConfigs[strKey] = ptrIndividualConfig; + } + catch (std::bad_alloc &) + { + return E_OUTOFMEMORY; + } + return ptrIndividualConfig.queryInterfaceTo(aConfig.asOutParam()); + } + } + else + return setError(VBOX_E_OBJECT_NOT_FOUND, tr("Found no configuration for MAC address %s"), strKey.c_str()); + } + return E_OUTOFMEMORY; + } + return setErrorBoth(E_INVALIDARG, vrc, tr("Invalid MAC address: %s"), aName.c_str()); + } + + default: + return E_FAIL; + } +} + + /** * Calculates and updates the value of strLeasesFilename given @a aNetwork. @@ -1028,5 +1350,5 @@ /* The lease file must be the same as we used the last time, so careful when changing this code. */ - int vrc = m->strLeasesFilename.assignNoThrow(mVirtualBox->i_homeDir()); + int vrc = m->strLeasesFilename.assignNoThrow(m->pVirtualBox->i_homeDir()); if (RT_SUCCESS(vrc)) vrc = RTPathAppendCxx(m->strLeasesFilename, aNetwork); @@ -1042,8 +1364,2 @@ } -settings::DhcpOptionMap &DHCPServer::i_findOptMapByVmNameSlot(const com::Utf8Str &aVmName, - LONG aSlot) -{ - return m->VmSlot2Options[settings::VmNameSlotKey(aVmName, aSlot)]; -} - Index: /trunk/src/VBox/Main/xml/Settings.cpp =================================================================== --- /trunk/src/VBox/Main/xml/Settings.cpp (revision 79731) +++ /trunk/src/VBox/Main/xml/Settings.cpp (revision 79732) @@ -1614,7 +1614,7 @@ * Constructor. Needs to set sane defaults which stand the test of time. */ -DhcpOptValue::DhcpOptValue() : - text(), - encoding(DhcpOptEncoding_Legacy) +DhcpOptValue::DhcpOptValue() + : strValue() + , enmEncoding(DHCPOptionEncoding_Legacy) { } @@ -1623,28 +1623,31 @@ * Non-standard constructor. */ -DhcpOptValue::DhcpOptValue(const com::Utf8Str &aText, DhcpOptEncoding_T aEncoding) : - text(aText), - encoding(aEncoding) -{ -} - -/** - * Non-standard constructor. - */ -VmNameSlotKey::VmNameSlotKey(const com::Utf8Str& aVmName, LONG aSlot) : - VmName(aVmName), - Slot(aSlot) -{ -} - -/** - * Non-standard comparison operator. - */ -bool VmNameSlotKey::operator< (const VmNameSlotKey& that) const -{ - if (VmName == that.VmName) - return Slot < that.Slot; - else - return VmName < that.VmName; +DhcpOptValue::DhcpOptValue(const com::Utf8Str &aText, DHCPOptionEncoding_T aEncoding) + : strValue(aText) + , enmEncoding(aEncoding) +{ +} + + +/** + * Default constructor. + */ +DHCPConfig::DHCPConfig() + : OptionMap() + , secMinLeaseTime(0) + , secDefaultLeaseTime(0) + , secMaxLeaseTime(0) +{ +} + +/** + * Default constructor. + */ +DHCPIndividualConfig::DHCPIndividualConfig() + : DHCPConfig() + , strMACAddress() + , strVMName() + , uSlot(0) +{ } @@ -1652,6 +1655,6 @@ * Constructor. Needs to set sane defaults which stand the test of time. */ -DHCPServer::DHCPServer() : - fEnabled(false) +DHCPServer::DHCPServer() + : fEnabled(false) { } @@ -1705,4 +1708,77 @@ /** + * Builds the XML tree for the DHCP servers. + */ +void MainConfigFile::buildDHCPServers(xml::ElementNode &elmDHCPServers, DHCPServersList const &ll) +{ + for (DHCPServersList::const_iterator it = ll.begin(); it != ll.end(); ++it) + { + const DHCPServer &srv = *it; + xml::ElementNode *pElmThis = elmDHCPServers.createChild("DHCPServer"); + + pElmThis->setAttribute("networkName", srv.strNetworkName); + pElmThis->setAttribute("IPAddress", srv.strIPAddress); + DhcpOptConstIterator itOpt = srv.GlobalConfig.OptionMap.find(DhcpOpt_SubnetMask); + if (itOpt != srv.GlobalConfig.OptionMap.end()) + pElmThis->setAttribute("networkMask", itOpt->second.strValue); + pElmThis->setAttribute("lowerIP", srv.strIPLower); + pElmThis->setAttribute("upperIP", srv.strIPUpper); + pElmThis->setAttribute("enabled", (srv.fEnabled) ? 1 : 0); // too bad we chose 1 vs. 0 here + + /* We don't want duplicate validation check of networkMask here*/ + if (srv.GlobalConfig.OptionMap.size() > (itOpt != srv.GlobalConfig.OptionMap.end() ? 1 : 0)) + { + xml::ElementNode *pElmOptions = pElmThis->createChild("Options"); + buildDHCPOptions(*pElmOptions, srv.GlobalConfig, true); + } + + if (srv.IndividualConfigs.size() > 0) + { + for (DHCPIndividualConfigMap::const_iterator itHost = srv.IndividualConfigs.begin(); + itHost != srv.IndividualConfigs.end(); ++itHost) + { + DHCPIndividualConfig const &rIndividualConfig = itHost->second; + + xml::ElementNode *pElmConfig = pElmThis->createChild("Config"); + if (rIndividualConfig.strMACAddress.isNotEmpty()) + pElmConfig->setAttribute("MACAddress", rIndividualConfig.strMACAddress); + if (rIndividualConfig.strVMName.isNotEmpty()) + pElmConfig->setAttribute("vm-name", rIndividualConfig.strVMName); + if (rIndividualConfig.uSlot != 0 || rIndividualConfig.strVMName.isNotEmpty()) + pElmConfig->setAttribute("slot", rIndividualConfig.strVMName); + if (rIndividualConfig.strFixedAddress.isNotEmpty()) + pElmConfig->setAttribute("fixedAddress", rIndividualConfig.strFixedAddress); + buildDHCPOptions(*pElmConfig, rIndividualConfig, false); + } + } + } +} + +/** + * Worker for buildDHCPServers() that builds Options or Config element trees. + */ +void MainConfigFile::buildDHCPOptions(xml::ElementNode &elmOptions, DHCPConfig const &rConfig, bool fSkipSubnetMask) +{ + /* Generic (and optional) attributes on the Options or Config element: */ + if (rConfig.secMinLeaseTime > 0) + elmOptions.setAttribute("secMinLeaseTime", rConfig.secMinLeaseTime); + if (rConfig.secDefaultLeaseTime > 0) + elmOptions.setAttribute("secDefaultLeaseTime", rConfig.secDefaultLeaseTime); + if (rConfig.secMaxLeaseTime > 0) + elmOptions.setAttribute("secMaxLeaseTime", rConfig.secMaxLeaseTime); + + /* The DHCP options are