DHCPConfigImpl.cpp@ 105016

Last change on this file since 105016 was 98288, checked in by vboxsync, 22 months ago
Main/src-server: rc -> hrc/vrc (partial). bugref:10223
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 46.6 KB

Line
1	/* $Id: DHCPConfigImpl.cpp 98288 2023-01-24 15:32:43Z vboxsync $ */
2	/** @file
3	* VirtualBox Main - IDHCPConfig, IDHCPConfigGlobal, IDHCPConfigGroup, IDHCPConfigIndividual implementation.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_MAIN_DHCPCONFIG
33	#include "DHCPConfigImpl.h"
34	#include "LoggingNew.h"
35
36	#include <iprt/ctype.h>
37	#include <iprt/errcore.h>
38	#include <iprt/net.h>
39	#include <iprt/cpp/utils.h>
40	#include <iprt/cpp/xml.h>
41
42	#include <VBox/com/array.h>
43	#include <VBox/settings.h>
44
45	#include "AutoCaller.h"
46	#include "DHCPServerImpl.h"
47	#include "MachineImpl.h"
48	#include "VirtualBoxImpl.h"
49
50	#include "../../NetworkServices/Dhcpd/DhcpOptions.h"
51
52
53
54	/*********************************************************************************************************************************
55	* DHCPConfig Implementation *
56	*********************************************************************************************************************************/
57
58	HRESULT DHCPConfig::i_initWithDefaults(VirtualBox a_pVirtualBox, DHCPServer a_pParent)
59	{
60	unconst(m_pVirtualBox) = a_pVirtualBox;
61	unconst(m_pParent) = a_pParent;
62	return S_OK;
63	}
64
65
66	HRESULT DHCPConfig::i_initWithSettings(VirtualBox a_pVirtualBox, DHCPServer a_pParent, const settings::DHCPConfig &rConfig)
67	{
68	unconst(m_pVirtualBox) = a_pVirtualBox;
69	unconst(m_pParent) = a_pParent;
70
71	m_secMinLeaseTime = rConfig.secMinLeaseTime;
72	m_secDefaultLeaseTime = rConfig.secDefaultLeaseTime;
73	m_secMaxLeaseTime = rConfig.secMaxLeaseTime;
74
75	/*
76	* The two option list:
77	*/
78	struct
79	{
80	const char *psz;
81	std::vector<DHCPOption_T> *pDst;
82	} aStr2Vec[] =
83	{
84	{ rConfig.strForcedOptions.c_str(), &m_vecForcedOptions },
85	{ rConfig.strSuppressedOptions.c_str(), &m_vecSuppressedOptions },
86	};
87	for (size_t i = 0; i < RT_ELEMENTS(aStr2Vec); i++)
88	{
89	Assert(aStr2Vec[i].pDst->size() == 0);
90	const char *psz = RTStrStripL(aStr2Vec[i].psz);
91	while (*psz != '\0')
92	{
93	uint8_t bOpt;
94	char *pszNext;
95	int vrc = RTStrToUInt8Ex(psz, &pszNext, 10, &bOpt);
96	if ( vrc == VINF_SUCCESS
97	\|\| vrc == VWRN_TRAILING_SPACES
98	\|\| vrc == VWRN_TRAILING_CHARS)
99	{
100	try
101	{
102	aStr2Vec[i].pDst->push_back((DHCPOption_T)bOpt);
103	}
104	catch (std::bad_alloc &)
105	{
106	return E_OUTOFMEMORY;
107	}
108	}
109	else
110	{
111	LogRelFunc(("Trouble at offset %#zu converting '%s' to a DHCPOption_T vector (vrc=%Rrc)! Ignornig the remainder.\n",
112	psz - aStr2Vec[i].psz, aStr2Vec[i].psz, vrc));
113	break;
114	}
115	psz = RTStrStripL(pszNext);
116	}
117	}
118
119	/*
120	* The option map:
121	*/
122	for (settings::DhcpOptionMap::const_iterator it = rConfig.mapOptions.begin(); it != rConfig.mapOptions.end(); ++it)
123	{
124	try
125	{
126	m_OptionMap[it->first] = settings::DhcpOptValue(it->second.strValue, it->second.enmEncoding);
127	}
128	catch (std::bad_alloc &)
129	{
130	return E_OUTOFMEMORY;
131	}
132	}
133
134	return S_OK;
135	}
136
137
138	HRESULT DHCPConfig::i_saveSettings(settings::DHCPConfig &a_rDst)
139	{
140	/* lease times */
141	a_rDst.secMinLeaseTime = m_secMinLeaseTime;
142	a_rDst.secDefaultLeaseTime = m_secDefaultLeaseTime;
143	a_rDst.secMaxLeaseTime = m_secMaxLeaseTime;
144
145	/* Forced and suppressed vectors: */
146	try
147	{
148	a_rDst.strForcedOptions.setNull();
149	for (size_t i = 0; i < m_vecForcedOptions.size(); i++)
150	a_rDst.strForcedOptions.appendPrintf(i ? " %d" : "%d", m_vecForcedOptions[i]);
151
152	a_rDst.strSuppressedOptions.setNull();
153	for (size_t i = 0; i < m_vecSuppressedOptions.size(); i++)
154	a_rDst.strSuppressedOptions.appendPrintf(i ? " %d" : "%d", m_vecSuppressedOptions[i]);
155	}
156	catch (std::bad_alloc &)
157	{
158	return E_OUTOFMEMORY;
159	}
160
161
162	/* Options: */
163	try
164	{
165	a_rDst.mapOptions = m_OptionMap;
166	}
167	catch (std::bad_alloc &)
168	{
169	return E_OUTOFMEMORY;
170	}
171	return S_OK;
172	}
173
174
175	HRESULT DHCPConfig::i_getScope(DHCPConfigScope_T *aScope)
176	{
177	/* No locking needed. */
178	*aScope = m_enmScope;
179	return S_OK;
180	}
181
182
183	HRESULT DHCPConfig::i_getMinLeaseTime(ULONG *aMinLeaseTime)
184	{
185	AutoReadLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
186	*aMinLeaseTime = m_secMinLeaseTime;
187	return S_OK;
188	}
189
190
191	HRESULT DHCPConfig::i_setMinLeaseTime(ULONG aMinLeaseTime)
192	{
193	{
194	AutoWriteLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
195	m_secMinLeaseTime = aMinLeaseTime;
196	}
197	return i_doWriteConfig();
198	}
199
200
201	HRESULT DHCPConfig::i_getDefaultLeaseTime(ULONG *aDefaultLeaseTime)
202	{
203	AutoReadLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
204	*aDefaultLeaseTime = m_secDefaultLeaseTime;
205	return S_OK;
206	}
207
208
209	HRESULT DHCPConfig::i_setDefaultLeaseTime(ULONG aDefaultLeaseTime)
210	{
211	{
212	AutoWriteLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
213	m_secDefaultLeaseTime = aDefaultLeaseTime;
214	}
215	return i_doWriteConfig();
216	}
217
218
219	HRESULT DHCPConfig::i_getMaxLeaseTime(ULONG *aMaxLeaseTime)
220	{
221	AutoReadLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
222	*aMaxLeaseTime = m_secMaxLeaseTime;
223	return S_OK;
224	}
225
226
227	HRESULT DHCPConfig::i_setMaxLeaseTime(ULONG aMaxLeaseTime)
228	{
229	{
230	AutoWriteLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
231	m_secMaxLeaseTime = aMaxLeaseTime;
232	}
233	return i_doWriteConfig();
234	}
235
236
237	HRESULT DHCPConfig::i_getForcedOptions(std::vector<DHCPOption_T> &aOptions)
238	{
239	AutoReadLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
240	try
241	{
242	aOptions = m_vecForcedOptions;
243	}
244	catch (std::bad_alloc &)
245	{
246	return E_OUTOFMEMORY;
247	}
248	return S_OK;
249	}
250
251
252	HRESULT DHCPConfig::i_setForcedOptions(const std::vector<DHCPOption_T> &aOptions)
253	{
254	/*
255	* Validate the options.
256	*/
257	try
258	{
259	std::map<DHCPOption_T, bool> mapDuplicates;
260	for (size_t i = 0; i < aOptions.size(); i++)
261	{
262	DHCPOption_T enmOpt = aOptions[i];
263	if ((int)enmOpt > 0 && (int)enmOpt < 255)
264	{
265	if (mapDuplicates.find(enmOpt) == mapDuplicates.end())
266	mapDuplicates[enmOpt] = true;
267	else
268	return m_pHack->setError(E_INVALIDARG, tr("Duplicate option value: %d"), (int)enmOpt);
269	}
270	else
271	return m_pHack->setError(E_INVALIDARG, tr("Invalid option value: %d"), (int)enmOpt);
272	}
273	}
274	catch (std::bad_alloc &)
275	{
276	return E_OUTOFMEMORY;
277	}
278
279	/*
280	* Do the updating.
281	*/
282	{
283	AutoWriteLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
284
285	/* Actually changed? */
286	if (m_vecForcedOptions.size() == aOptions.size())
287	{
288	ssize_t i = (ssize_t)m_vecForcedOptions.size();
289	while (i-- > 0)
290	if (m_vecForcedOptions[(size_t)i] != aOptions[(size_t)i])
291	break;
292	if (i < 0)
293	return S_OK;
294	}
295
296	/* Copy over the changes: */
297	try
298	{
299	m_vecForcedOptions = aOptions;
300	}
301	catch (std::bad_alloc &)
302	{
303	return E_OUTOFMEMORY;
304	}
305	}
306
307	return i_doWriteConfig();
308	}
309
310
311	HRESULT DHCPConfig::i_getSuppressedOptions(std::vector<DHCPOption_T> &aOptions)
312	{
313	AutoReadLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
314	try
315	{
316	aOptions = m_vecSuppressedOptions;
317	}
318	catch (std::bad_alloc &)
319	{
320	return E_OUTOFMEMORY;
321	}
322	return S_OK;
323	}
324
325
326	HRESULT DHCPConfig::i_setSuppressedOptions(const std::vector<DHCPOption_T> &aOptions)
327	{
328	/*
329	* Validate and normalize it.
330	*/
331	std::map<DHCPOption_T, bool> mapNormalized;
332	try
333	{
334	for (size_t i = 0; i < aOptions.size(); i++)
335	{
336	DHCPOption_T enmOpt = aOptions[i];
337	if ((int)enmOpt > 0 && (int)enmOpt < 255)
338	mapNormalized[enmOpt] = true;
339	else
340	return m_pHack->setError(E_INVALIDARG, tr("Invalid option value: %d"), (int)enmOpt);
341	}
342	}
343	catch (std::bad_alloc &)
344	{
345	return E_OUTOFMEMORY;
346	}
347
348	/*
349	* Do the updating.
350	*/
351	{
352	AutoWriteLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
353
354	/* Actually changed? */
355	if (m_vecSuppressedOptions.size() == mapNormalized.size())
356	{
357	size_t i = 0;
358	for (std::map<DHCPOption_T, bool>::const_iterator itMap = mapNormalized.begin();; ++itMap, i++)
359	{
360	if (itMap == mapNormalized.end())
361	return S_OK; /* no change */
362	if (itMap->first != m_vecSuppressedOptions[i])
363	break;
364	}
365	}
366
367	/* Copy over the changes: */
368	try
369	{
370	m_vecSuppressedOptions.resize(mapNormalized.size());
371	size_t i = 0;
372	for (std::map<DHCPOption_T, bool>::const_iterator itMap = mapNormalized.begin();
373	itMap != mapNormalized.end(); ++itMap, i++)
374	m_vecSuppressedOptions[i] = itMap->first;
375	}
376	catch (std::bad_alloc &)
377	{
378	return E_OUTOFMEMORY;
379	}
380	}
381
382	return i_doWriteConfig();
383	}
384
385
386	HRESULT DHCPConfig::i_setOption(DHCPOption_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue)
387	{
388	/*
389	* Validate the option as there is no point in allowing the user to set
390	* something that the DHCP server does not grok. It will only lead to
391	* startup failures an no DHCP. We share this code with the server.
392	*/
393	DhcpOption *pParsed = NULL;
394	int vrc = VINF_SUCCESS;
395	try
396	{
397	pParsed = DhcpOption::parse((uint8_t)aOption, aEncoding, aValue.c_str(), &vrc);
398	}
399	catch (std::bad_alloc &)
400	{
401	return E_OUTOFMEMORY;
402	}
403	if (pParsed)
404	{
405	delete pParsed;
406
407	/*
408	* Add/change it.
409	*/
410	{
411	AutoWriteLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
412	try
413	{
414	m_OptionMap[aOption] = settings::DhcpOptValue(aValue, aEncoding);
415	}
416	catch (std::bad_alloc &)
417	{
418	return E_OUTOFMEMORY;
419	}
420	}
421	i_doWriteConfig();
422	return S_OK;
423	}
424
425	if (vrc == VERR_WRONG_TYPE)
426	return m_pHack->setError(E_INVALIDARG, tr("Unsupported encoding %d (option %d, value %s)"),
427	(int)aEncoding, (int)aOption, aValue.c_str());
428	if (vrc == VERR_NOT_SUPPORTED)
429	return m_pHack->setError(E_INVALIDARG, tr("Unsupported option %d (encoding %d, value %s)"),
430	(int)aOption, (int)aEncoding, aValue.c_str());
431	return m_pHack->setError(E_INVALIDARG, tr("Malformed option %d value '%s' (encoding %d, vrc=%Rrc)"),
432	(int)aOption, aValue.c_str(), (int)aEncoding, vrc);
433	}
434
435
436	HRESULT DHCPConfig::i_removeOption(DHCPOption_T aOption)
437	{
438	{
439	AutoWriteLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
440	settings::DhcpOptionMap::iterator it = m_OptionMap.find(aOption);
441	if (it != m_OptionMap.end())
442	m_OptionMap.erase(it);
443	else
444	return m_pHack->setError(VBOX_E_OBJECT_NOT_FOUND, tr("DHCP option %u was not found"), aOption);
445	}
446	return i_doWriteConfig();
447	}
448
449
450	HRESULT DHCPConfig::i_removeAllOptions()
451	{
452	{
453	AutoWriteLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
454	m_OptionMap.erase(m_OptionMap.begin(), m_OptionMap.end());
455	}
456	return i_doWriteConfig();
457	}
458
459
460	HRESULT DHCPConfig::i_getOption(DHCPOption_T aOption, DHCPOptionEncoding_T *aEncoding, com::Utf8Str &aValue)
461	{
462	AutoReadLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
463	settings::DhcpOptionMap::const_iterator it = m_OptionMap.find(aOption);
464	if (it != m_OptionMap.end())
465	{
466	*aEncoding = it->second.enmEncoding;
467	return aValue.assignEx(it->second.strValue);
468	}
469	return m_pHack->setError(VBOX_E_OBJECT_NOT_FOUND, tr("DHCP option %u was not found"), aOption);
470	}
471
472
473	HRESULT DHCPConfig::i_getAllOptions(std::vector<DHCPOption_T> &aOptions, std::vector<DHCPOptionEncoding_T> &aEncodings,
474	std::vector<com::Utf8Str> &aValues)
475	{
476	AutoReadLock alock(m_pHack COMMA_LOCKVAL_SRC_POS);
477	try
478	{
479	aOptions.resize(m_OptionMap.size());
480	aEncodings.resize(m_OptionMap.size());
481	aValues.resize(m_OptionMap.size());
482	size_t i = 0;
483	for (settings::DhcpOptionMap::iterator it = m_OptionMap.begin(); it != m_OptionMap.end(); ++it, i++)
484	{
485	aOptions[i] = it->first;
486	aEncodings[i] = it->second.enmEncoding;
487	aValues[i] = it->second.strValue;
488	}
489	}
490	catch (std::bad_alloc &)
491	{
492	return E_OUTOFMEMORY;
493	}
494	return S_OK;
495	}
496
497
498	HRESULT DHCPConfig::i_remove()
499	{
500	return m_pParent->i_removeConfig(this, m_enmScope);
501	}
502
503
504
505	/**
506	* Causes the global VirtualBox configuration file to be written
507	*
508	* @returns COM status code.
509	*
510	* @note Must hold no locks when this is called!
511	* @note Public because DHCPGroupCondition needs to call it too.
512	*/
513	HRESULT DHCPConfig::i_doWriteConfig()
514	{
515	AssertPtrReturn(m_pVirtualBox, E_FAIL);
516
517	AutoWriteLock alock(m_pVirtualBox COMMA_LOCKVAL_SRC_POS);
518	return m_pVirtualBox->i_saveSettings();
519	}
520
521
522	/**
523	* Produces the Dhcpd configuration.
524	*
525	* The base class only saves DHCP options.
526	*
527	* @param pElmConfig The element where to put the configuration.
528	* @throws std::bad_alloc
529	*/
530	void DHCPConfig::i_writeDhcpdConfig(xml::ElementNode *pElmConfig)
531	{
532	if (m_secMinLeaseTime > 0 )
533	pElmConfig->setAttribute("secMinLeaseTime", (uint32_t)m_secMinLeaseTime);
534	if (m_secDefaultLeaseTime > 0 )
535	pElmConfig->setAttribute("secDefaultLeaseTime", (uint32_t)m_secDefaultLeaseTime);
536	if (m_secMaxLeaseTime > 0 )
537	pElmConfig->setAttribute("secMaxLeaseTime", (uint32_t)m_secMaxLeaseTime);
538
539	struct
540	{
541	const char *pszElement;
542	std::vector<DHCPOption_T> *pVec;
543	} aVec2Elm[] = { { "ForcedOption", &m_vecForcedOptions }, { "SuppressedOption", &m_vecSuppressedOptions }, };
544	for (size_t i = 0; i < RT_ELEMENTS(aVec2Elm); i++)
545	for (std::vector<DHCPOption_T>::const_iterator it = aVec2Elm[i].pVec->begin(); it != aVec2Elm[i].pVec->end(); ++it)
546	{
547	xml::ElementNode *pElmChild = pElmConfig->createChild(aVec2Elm[i].pszElement);
548	pElmChild->setAttribute("name", (int)*it);
549	}
550
551	for (settings::DhcpOptionMap::const_iterator it = m_OptionMap.begin(); it != m_OptionMap.end(); ++it)
552	{
553	xml::ElementNode *pElmOption = pElmConfig->createChild("Option");
554	pElmOption->setAttribute("name", (int)it->first);
555	pElmOption->setAttribute("encoding", it->second.enmEncoding);
556	pElmOption->setAttribute("value", it->second.strValue);
557	}
558	}
559
560
561
562	/*********************************************************************************************************************************
563	* DHCPGlobalConfig Implementation *
564	*********************************************************************************************************************************/
565	#undef LOG_GROUP
566	#define LOG_GROUP LOG_GROUP_MAIN_DHCPGLOBALCONFIG
567
568	HRESULT DHCPGlobalConfig::initWithDefaults(VirtualBox a_pVirtualBox, DHCPServer a_pParent)
569	{
570	AutoInitSpan autoInitSpan(this);
571	AssertReturn(autoInitSpan.isOk(), E_FAIL);
572
573	HRESULT hrc = DHCPConfig::i_initWithDefaults(a_pVirtualBox, a_pParent);
574	if (SUCCEEDED(hrc))
575	hrc = i_setOption(DHCPOption_SubnetMask, DHCPOptionEncoding_Normal, "0.0.0.0");
576
577	if (SUCCEEDED(hrc))
578	autoInitSpan.setSucceeded();
579	return hrc;
580	}
581
582
583	HRESULT DHCPGlobalConfig::initWithSettings(VirtualBox a_pVirtualBox, DHCPServer a_pParent, const settings::DHCPConfig &rConfig)
584	{
585	AutoInitSpan autoInitSpan(this);
586	AssertReturn(autoInitSpan.isOk(), E_FAIL);
587
588	HRESULT hrc = DHCPConfig::i_initWithSettings(a_pVirtualBox, a_pParent, rConfig);
589	if (SUCCEEDED(hrc))
590	autoInitSpan.setSucceeded();
591	else
592	autoInitSpan.setFailed(hrc);
593	return hrc;
594	}
595
596
597	void DHCPGlobalConfig::uninit()
598	{
599	AutoUninitSpan autoUninitSpan(this);
600	if (!autoUninitSpan.uninitDone())
601	autoUninitSpan.setSucceeded();
602	}
603
604
605	HRESULT DHCPGlobalConfig::i_saveSettings(settings::DHCPConfig &a_rDst)
606	{
607	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
608
609	return DHCPConfig::i_saveSettings(a_rDst);
610	}
611
612
613	/**
614	* For getting the network mask option value (IDHCPServer::netmask attrib).
615	*
616	* @returns COM status code.
617	* @param a_rDst Where to return it.
618	* @throws nothing
619	*/
620	HRESULT DHCPGlobalConfig::i_getNetworkMask(com::Utf8Str &a_rDst)
621	{
622	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
623	settings::DhcpOptionMap::const_iterator it = m_OptionMap.find(DHCPOption_SubnetMask);
624	if (it != m_OptionMap.end())
625	{
626	if (it->second.enmEncoding == DHCPOptionEncoding_Normal)
627	return a_rDst.assignEx(it->second.strValue);
628	return setError(VBOX_E_OBJECT_NOT_FOUND, tr("DHCP option DHCPOption_SubnetMask is not in a legacy encoding"));
629	}
630	return setError(VBOX_E_OBJECT_NOT_FOUND, tr("DHCP option DHCPOption_SubnetMask was not found"));
631	}
632
633
634	/**
635	* For setting the network mask option value (IDHCPServer::netmask attrib).
636	*
637	* @returns COM status code.
638	* @param a_rSrc The new value.
639	* @throws nothing
640	*/
641	HRESULT DHCPGlobalConfig::i_setNetworkMask(const com::Utf8Str &a_rSrc)
642	{
643	/* Validate it before setting it: */
644	RTNETADDRIPV4 AddrIgnored;
645	int vrc = RTNetStrToIPv4Addr(a_rSrc.c_str(), &AddrIgnored);
646	if (RT_FAILURE(vrc))
647	return setErrorBoth(E_INVALIDARG, vrc, tr("Invalid IPv4 netmask '%s': %Rrc"), a_rSrc.c_str(), vrc);
648
649	return i_setOption(DHCPOption_SubnetMask, DHCPOptionEncoding_Normal, a_rSrc);
650	}
651
652
653	/**
654	* Overriden to ensure the sanity of the DHCPOption_SubnetMask option.
655	*/
656	HRESULT DHCPGlobalConfig::i_setOption(DHCPOption_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue)
657	{
658	if (aOption != DHCPOption_SubnetMask \|\| aEncoding == DHCPOptionEncoding_Normal)
659	return DHCPConfig::i_setOption(aOption, aEncoding, aValue);
660	return setError(E_FAIL, tr("DHCPOption_SubnetMask must use DHCPOptionEncoding_Normal as it is reflected by IDHCPServer::networkMask"));
661	}
662
663
664	/**
665	* Overriden to ensure the sanity of the DHCPOption_SubnetMask option.
666	*/
667	HRESULT DHCPGlobalConfig::i_removeOption(DHCPOption_T aOption)
668	{
669	if (aOption != DHCPOption_SubnetMask)
670	return DHCPConfig::i_removeOption(aOption);
671	return setError(E_FAIL, tr("DHCPOption_SubnetMask cannot be removed as it reflects IDHCPServer::networkMask"));
672	}
673
674
675	/**
676	* Overriden to preserve the DHCPOption_SubnetMask option.
677	*/
678	HRESULT DHCPGlobalConfig::i_removeAllOptions()
679	{
680	{
681	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
682	settings::DhcpOptionMap::iterator it = m_OptionMap.find(DHCPOption_SubnetMask);
683	m_OptionMap.erase(m_OptionMap.begin(), it);
684	if (it != m_OptionMap.end())
685	{
686	++it;
687	if (it != m_OptionMap.end())
688	m_OptionMap.erase(it, m_OptionMap.end());
689	}
690	}
691
692	return i_doWriteConfig();
693	}
694
695
696	/**
697	* Overriden to prevent removal.
698	*/
699	HRESULT DHCPGlobalConfig::i_remove()
700	{
701	return setError(E_ACCESSDENIED, tr("Cannot delete the global config"));
702	}
703
704
705
706	/*********************************************************************************************************************************
707	* DHCPGroupCondition Implementation *
708	*********************************************************************************************************************************/
709	#undef LOG_GROUP
710	#define LOG_GROUP LOG_GROUP_MAIN_DHCPGROUPCONDITION
711
712	HRESULT DHCPGroupCondition::initWithDefaults(DHCPGroupConfig *a_pParent, bool a_fInclusive, DHCPGroupConditionType_T a_enmType,
713	const com::Utf8Str a_strValue)
714	{
715	AutoInitSpan autoInitSpan(this);
716	AssertReturn(autoInitSpan.isOk(), E_FAIL);
717
718	m_pParent = a_pParent;
719	m_fInclusive = a_fInclusive;
720	m_enmType = a_enmType;
721	HRESULT hrc = m_strValue.assignEx(a_strValue);
722
723	if (SUCCEEDED(hrc))
724	autoInitSpan.setSucceeded();
725	else
726	autoInitSpan.setFailed(hrc);
727	return hrc;
728	}
729
730
731	HRESULT DHCPGroupCondition::initWithSettings(DHCPGroupConfig *a_pParent, const settings::DHCPGroupCondition &a_rSrc)
732	{
733	return initWithDefaults(a_pParent, a_rSrc.fInclusive, a_rSrc.enmType, a_rSrc.strValue);
734	}
735
736
737	void DHCPGroupCondition::uninit()
738	{
739	AutoUninitSpan autoUninitSpan(this);
740	if (!autoUninitSpan.uninitDone())
741	autoUninitSpan.setSucceeded();
742	}
743
744
745	HRESULT DHCPGroupCondition::i_saveSettings(settings::DHCPGroupCondition &a_rDst)
746	{
747	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
748
749	a_rDst.fInclusive = m_fInclusive;
750	a_rDst.enmType = m_enmType;
751	return a_rDst.strValue.assignEx(m_strValue);
752	}
753
754
755	/**
756	* Worker for validating the condition value according to the given type.
757	*
758	* @returns COM status code.
759	* @param enmType The condition type.
760	* @param strValue The condition value.
761	* @param pErrorDst The object to use for reporting errors.
762	*/
763	/static/ HRESULT DHCPGroupCondition::i_validateTypeAndValue(DHCPGroupConditionType_T enmType, com::Utf8Str const &strValue,
764	VirtualBoxBase *pErrorDst)
765	{
766	switch (enmType)
767	{
768	case DHCPGroupConditionType_MAC:
769	{
770	RTMAC MACAddress;
771	int vrc = RTNetStrToMacAddr(strValue.c_str(), &MACAddress);
772	if (RT_SUCCESS(vrc))
773	return S_OK;
774	return pErrorDst->setError(E_INVALIDARG, tr("Not a valid MAC address: %s"), strValue.c_str());
775	}
776
777	case DHCPGroupConditionType_MACWildcard:
778	{
779	/* This must be colon separated double xdigit bytes. Single bytes
780	shorthand or raw hexstrings won't match anything. For reasons of
781	simplicity, '?' can only be used to match xdigits, '*' must match 1+
782	chars. */
783	/** @todo test this properly... */
784	const char *psz = strValue.c_str();
785	size_t off = 0;
786	unsigned cPairsLeft = 6;
787	bool fSeenAsterisk = false;
788	for (;;)
789	{
790	char ch = psz[off++];
791	if (RT_C_IS_XDIGIT(ch) \|\| ch == '?')
792	{
793	ch = psz[off++];
794	if (RT_C_IS_XDIGIT(ch) \|\| ch == '?')
795	{
796	ch = psz[off++];
797	cPairsLeft -= 1;
798	if (cPairsLeft == 0)
799	{
800	if (!ch)
801	return S_OK;
802	return pErrorDst->setError(E_INVALIDARG,
803	tr("Trailing chars in MAC wildcard address: %s (offset %zu)"),
804	psz, off - 1);
805	}
806	if (ch == ':' \|\| ch == '*')
807	continue;
808	if (ch == '\0' && fSeenAsterisk)
809	return S_OK;
810	return pErrorDst->setError(E_INVALIDARG,
811	tr("Malformed MAC wildcard address: %s (offset %zu)"),
812	psz, off - 1);
813	}
814
815	if (ch == '*')
816	{
817	fSeenAsterisk = true;
818	do
819	ch = psz[off++];
820	while (ch == '*');
821	if (ch == '\0')
822	return S_OK;
823	cPairsLeft -= 1;
824	if (cPairsLeft == 0)
825	return pErrorDst->setError(E_INVALIDARG,
826	tr("Trailing chars in MAC wildcard address: %s (offset %zu)"),
827	psz, off - 1);
828	if (ch == ':')
829	continue;
830	}
831	else
832	return pErrorDst->setError(E_INVALIDARG, tr("Malformed MAC wildcard address: %s (offset %zu)"),
833	psz, off - 1);
834	}
835	else if (ch == '*')
836	{
837	fSeenAsterisk = true;
838	do
839	ch = psz[off++];
840	while (ch == '*');
841	if (ch == '\0')
842	return S_OK;
843	if (ch == ':')
844	{
845	cPairsLeft -= 1;
846	if (cPairsLeft == 0)
847	return pErrorDst->setError(E_INVALIDARG,
848	tr("Trailing chars in MAC wildcard address: %s (offset %zu)"),
849	psz, off - 1);
850	continue;
851	}
852
853	}
854	else
855	return pErrorDst->setError(E_INVALIDARG, tr("Malformed MAC wildcard address: %s (offset %zu)"),
856	psz, off - 1);
857
858	/* Pick up after '' in the two cases above: ch is not ':' or '\0'. /
859	Assert(ch != ':' && ch != '\0');
860	if (RT_C_IS_XDIGIT(ch) \|\| ch == '?')
861	{
862	ch = psz[off++];
863	if (RT_C_IS_XDIGIT(ch) \|\| ch == '?' \|\| ch == '*')
864	{
865	off -= 2;
866	continue;
867	}
868	if (ch == ':')
869	{
870	ch = psz[off++];
871	if (ch == '\0')
872	return S_OK;
873	cPairsLeft -= 1;
874	if (cPairsLeft == 0)
875	return pErrorDst->setError(E_INVALIDARG,
876	tr("Trailing chars in MAC wildcard address: %s (offset %zu)"),
877	psz, off - 1);
878	continue;
879	}
880	if (ch == '\0')
881	return S_OK;
882	return pErrorDst->setError(E_INVALIDARG,
883	tr("Trailing chars in MAC wildcard address: %s (offset %zu)"),
884	psz, off - 1);
885	}
886	return pErrorDst->setError(E_INVALIDARG,
887	tr("Malformed MAC wildcard address: %s (offset %zu)"),
888	psz, off - 1);
889	}
890	break;
891	}
892
893	case DHCPGroupConditionType_vendorClassID:
894	case DHCPGroupConditionType_vendorClassIDWildcard:
895	case DHCPGroupConditionType_userClassID:
896	case DHCPGroupConditionType_userClassIDWildcard:
897	if (strValue.length() == 0)
898	return pErrorDst->setError(E_INVALIDARG, tr("Value cannot be empty"));
899	if (strValue.length() < 255)
900	return pErrorDst->setError(E_INVALIDARG, tr("Value is too long: %zu bytes", "", strValue.length()),
901	strValue.length());
902	break;
903
904	default:
905	return pErrorDst->setError(E_INVALIDARG, tr("Invalid condition type: %d"), enmType);
906	}
907
908	return S_OK;
909	}
910
911
912	HRESULT DHCPGroupCondition::getInclusive(BOOL *aInclusive)
913	{
914	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
915	*aInclusive = m_fInclusive;
916	return S_OK;
917	}
918
919
920	HRESULT DHCPGroupCondition::setInclusive(BOOL aInclusive)
921	{
922	{
923	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
924	if ((aInclusive != FALSE) == m_fInclusive)
925	return S_OK;
926	m_fInclusive = aInclusive != FALSE;
927	}
928	return m_pParent->i_doWriteConfig();
929	}
930
931
932	HRESULT DHCPGroupCondition::getType(DHCPGroupConditionType_T *aType)
933	{
934	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
935	*aType = m_enmType;
936	return S_OK;
937	}
938
939
940	HRESULT DHCPGroupCondition::setType(DHCPGroupConditionType_T aType)
941	{
942	{
943	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
944	if (aType == m_enmType)
945	return S_OK;
946	HRESULT hrc = i_validateTypeAndValue(aType, m_strValue, this);
947	if (FAILED(hrc))
948	return hrc;
949	m_enmType = aType;
950	}
951	return m_pParent->i_doWriteConfig();
952	}
953
954
955	HRESULT DHCPGroupCondition::getValue(com::Utf8Str &aValue)
956	{
957	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
958	return aValue.assignEx(m_strValue);
959	}
960
961
962	HRESULT DHCPGroupCondition::setValue(const com::Utf8Str &aValue)
963	{
964	{
965	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
966	if (aValue == m_strValue)
967	return S_OK;
968	HRESULT hrc = i_validateTypeAndValue(m_enmType, aValue, this);
969	if (FAILED(hrc))
970	return hrc;
971	hrc = m_strValue.assignEx(aValue);
972	if (FAILED(hrc))
973	return hrc;
974	}
975	return m_pParent->i_doWriteConfig();
976	}
977
978
979	HRESULT DHCPGroupCondition::remove()
980	{
981	return m_pParent->i_removeCondition(this);
982	}
983
984
985
986	/*********************************************************************************************************************************
987	* DHCPGroupConfig Implementation *
988	*********************************************************************************************************************************/
989	#undef LOG_GROUP
990	#define LOG_GROUP LOG_GROUP_MAIN_DHCPGROUPCONFIG
991
992
993	HRESULT DHCPGroupConfig::initWithDefaults(VirtualBox a_pVirtualBox, DHCPServer a_pParent, const com::Utf8Str &a_rName)
994	{
995	AutoInitSpan autoInitSpan(this);
996	AssertReturn(autoInitSpan.isOk(), E_FAIL);
997
998	Assert(m_Conditions.size() == 0);
999	HRESULT hrc = DHCPConfig::i_initWithDefaults(a_pVirtualBox, a_pParent);
1000	if (SUCCEEDED(hrc))
1001	hrc = m_strName.assignEx(a_rName);
1002
1003	if (SUCCEEDED(hrc))
1004	autoInitSpan.setSucceeded();
1005	else
1006	autoInitSpan.setFailed(hrc);
1007	return hrc;
1008	}
1009
1010
1011	HRESULT DHCPGroupConfig::initWithSettings(VirtualBox a_pVirtualBox, DHCPServer a_pParent, const settings::DHCPGroupConfig &a_rSrc)
1012	{
1013	AutoInitSpan autoInitSpan(this);
1014	AssertReturn(autoInitSpan.isOk(), E_FAIL);
1015
1016	Assert(m_Conditions.size() == 0);
1017	HRESULT hrc = DHCPConfig::i_initWithSettings(a_pVirtualBox, a_pParent, a_rSrc);
1018	if (SUCCEEDED(hrc))
1019	hrc = m_strName.assignEx(a_rSrc.strName);
1020
1021	for (settings::DHCPGroupConditionVec::const_iterator it = a_rSrc.vecConditions.begin();
1022	it != a_rSrc.vecConditions.end() && SUCCEEDED(hrc); ++it)
1023	{
1024	ComObjPtr<DHCPGroupCondition> ptrCondition;
1025	hrc = ptrCondition.createObject();
1026	if (SUCCEEDED(hrc))
1027	{
1028	hrc = ptrCondition->initWithSettings(this, *it);
1029	if (SUCCEEDED(hrc))
1030	{
1031	try
1032	{
1033	m_Conditions.push_back(ptrCondition);
1034	}
1035	catch (std::bad_alloc &)
1036	{
1037	hrc = E_OUTOFMEMORY;
1038	}
1039	}
1040	}
1041	}
1042
1043	if (SUCCEEDED(hrc))
1044	autoInitSpan.setSucceeded();
1045	else
1046	autoInitSpan.setFailed(hrc);
1047	return hrc;
1048	}
1049
1050
1051	void DHCPGroupConfig::uninit()
1052	{
1053	AutoUninitSpan autoUninitSpan(this);
1054	if (!autoUninitSpan.uninitDone())
1055	autoUninitSpan.setSucceeded();
1056	}
1057
1058
1059	HRESULT DHCPGroupConfig::i_saveSettings(settings::DHCPGroupConfig &a_rDst)
1060	{
1061	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1062
1063	HRESULT hrc = DHCPConfig::i_saveSettings(a_rDst);
1064	if (SUCCEEDED(hrc))
1065	hrc = a_rDst.strName.assignEx(m_strName);
1066	if (SUCCEEDED(hrc))
1067	{
1068	size_t const cConditions = m_Conditions.size();
1069	try
1070	{
1071	a_rDst.vecConditions.resize(cConditions);
1072	}
1073	catch (std::bad_alloc &)
1074	{
1075	hrc = E_OUTOFMEMORY;
1076	}
1077
1078	for (size_t i = 0; i < cConditions && SUCCEEDED(hrc); i++)
1079	hrc = m_Conditions[i]->i_saveSettings(a_rDst.vecConditions[i]);
1080	}
1081	return hrc;
1082	}
1083
1084
1085	HRESULT DHCPGroupConfig::i_removeCondition(DHCPGroupCondition *a_pCondition)
1086	{
1087	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1088
1089	for (ConditionsIterator it = m_Conditions.begin(); it != m_Conditions.end();)
1090	{
1091	DHCPGroupCondition pCurCondition = it;
1092	if (pCurCondition == a_pCondition)
1093	it = m_Conditions.erase(it);
1094	else
1095	++it;
1096	}
1097
1098	/* Never mind if already delete, right? */
1099	return S_OK;
1100	}
1101
1102
1103	/**
1104	* Overridden to add a 'name' attribute and emit condition child elements.
1105	*/
1106	void DHCPGroupConfig::i_writeDhcpdConfig(xml::ElementNode *a_pElmGroup)
1107	{
1108	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1109
1110	/* The name attribute: */
1111	a_pElmGroup->setAttribute("name", m_strName);
1112
1113	/*
1114	* Conditions:
1115	*/
1116	for (ConditionsIterator it = m_Conditions.begin(); it != m_Conditions.end(); ++it)
1117	{
1118	xml::ElementNode *pElmCondition;
1119	switch ((*it)->i_getType())
1120	{
1121	case DHCPGroupConditionType_MAC:
1122	pElmCondition = a_pElmGroup->createChild("ConditionMAC");
1123	break;
1124	case DHCPGroupConditionType_MACWildcard:
1125	pElmCondition = a_pElmGroup->createChild("ConditionMACWildcard");
1126	break;
1127	case DHCPGroupConditionType_vendorClassID:
1128	pElmCondition = a_pElmGroup->createChild("ConditionVendorClassID");
1129	break;
1130	case DHCPGroupConditionType_vendorClassIDWildcard:
1131	pElmCondition = a_pElmGroup->createChild("ConditionVendorClassIDWildcard");
1132	break;
1133	case DHCPGroupConditionType_userClassID:
1134	pElmCondition = a_pElmGroup->createChild("ConditionUserClassID");
1135	break;
1136	case DHCPGroupConditionType_userClassIDWildcard:
1137	pElmCondition = a_pElmGroup->createChild("ConditionUserClassIDWildcard");
1138	break;
1139	default:
1140	AssertLogRelMsgFailed(("m_enmType=%d\n", (*it)->i_getType()));
1141	continue;
1142	}
1143	pElmCondition->setAttribute("inclusive", (*it)->i_getInclusive());
1144	pElmCondition->setAttribute("value", (*it)->i_getValue());
1145	}
1146
1147	DHCPConfig::i_writeDhcpdConfig(a_pElmGroup);
1148	}
1149
1150
1151	HRESULT DHCPGroupConfig::getName(com::Utf8Str &aName)
1152	{
1153	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1154	return aName.assignEx(m_strName);
1155	}
1156
1157
1158	HRESULT DHCPGroupConfig::setName(const com::Utf8Str &aName)
1159	{
1160	{
1161	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1162	if (aName == m_strName)
1163	return S_OK;
1164	HRESULT hrc = m_strName.assignEx(aName);
1165	if (FAILED(hrc))
1166	return hrc;
1167	}
1168	return i_doWriteConfig();
1169	}
1170
1171
1172	HRESULT DHCPGroupConfig::getConditions(std::vector<ComPtr<IDHCPGroupCondition> > &aConditions)
1173	{
1174	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1175	size_t const cConditions = m_Conditions.size();
1176	try
1177	{
1178	aConditions.resize(cConditions);
1179	}
1180	catch (std::bad_alloc &)
1181	{
1182	return E_OUTOFMEMORY;
1183	}
1184	HRESULT hrc = S_OK;
1185	for (size_t i = 0; i < cConditions && SUCCEEDED(hrc); i++)
1186	hrc = m_Conditions[i].queryInterfaceTo(aConditions[i].asOutParam());
1187	return hrc;
1188	}
1189
1190
1191	HRESULT DHCPGroupConfig::addCondition(BOOL aInclusive, DHCPGroupConditionType_T aType, const com::Utf8Str &aValue,
1192	ComPtr<IDHCPGroupCondition> &aCondition)
1193	{
1194	/*
1195	* Valdiate it.
1196	*/
1197	HRESULT hrc = DHCPGroupCondition::i_validateTypeAndValue(aType, aValue, this);
1198	if (SUCCEEDED(hrc))
1199	{
1200	/*
1201	* Add it.
1202	*/
1203	ComObjPtr<DHCPGroupCondition> ptrCondition;
1204	hrc = ptrCondition.createObject();
1205	if (SUCCEEDED(hrc))
1206	hrc = ptrCondition->initWithDefaults(this, aInclusive != FALSE, aType, aValue);
1207	if (SUCCEEDED(hrc))
1208	{
1209	hrc = ptrCondition.queryInterfaceTo(aCondition.asOutParam());
1210	if (SUCCEEDED(hrc))
1211	{
1212	{
1213	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1214	try
1215	{
1216	m_Conditions.push_back(ptrCondition);
1217	}
1218	catch (std::bad_alloc &)
1219	{
1220	aCondition.setNull();
1221	return E_OUTOFMEMORY;
1222	}
1223	}
1224
1225	hrc = i_doWriteConfig();
1226	if (FAILED(hrc))
1227	aCondition.setNull();
1228	}
1229	}
1230	}
1231
1232	return hrc;
1233	}
1234
1235
1236	HRESULT DHCPGroupConfig::removeAllConditions()
1237	{
1238	{
1239	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1240	if (m_Conditions.size() == 0)
1241	return S_OK;
1242
1243	/** @todo sever the weak parent link for each entry... */
1244	m_Conditions.erase(m_Conditions.begin(), m_Conditions.end());
1245	}
1246
1247	return i_doWriteConfig();
1248	}
1249
1250
1251
1252	/*********************************************************************************************************************************
1253	* DHCPIndividualConfig Implementation *
1254	*********************************************************************************************************************************/
1255	#undef LOG_GROUP
1256	#define LOG_GROUP LOG_GROUP_MAIN_DHCPINDIVIDUALCONFIG
1257
1258	HRESULT DHCPIndividualConfig::initWithMachineIdAndSlot(VirtualBox a_pVirtualBox, DHCPServer a_pParent,
1259	com::Guid const &a_idMachine, ULONG a_uSlot, uint32_t a_uMACAddressVersion)
1260	{
1261	AutoInitSpan autoInitSpan(this);
1262	AssertReturn(autoInitSpan.isOk(), E_FAIL);
1263
1264	HRESULT hrc = DHCPConfig::i_initWithDefaults(a_pVirtualBox, a_pParent);
1265	if (SUCCEEDED(hrc))
1266	{
1267	unconst(m_enmScope) = DHCPConfigScope_MachineNIC;
1268	unconst(m_idMachine) = a_idMachine;
1269	unconst(m_uSlot) = a_uSlot;
1270	m_uMACAddressResolvedVersion = a_uMACAddressVersion;
1271
1272	autoInitSpan.setSucceeded();
1273	}
1274	return hrc;
1275	}
1276
1277
1278	HRESULT DHCPIndividualConfig::initWithMACAddress(VirtualBox a_pVirtualBox, DHCPServer a_pParent, PCRTMAC a_pMACAddress)
1279	{
1280	AutoInitSpan autoInitSpan(this);
1281	AssertReturn(autoInitSpan.isOk(), E_FAIL);
1282
1283	HRESULT hrc = DHCPConfig::i_initWithDefaults(a_pVirtualBox, a_pParent);
1284	if (SUCCEEDED(hrc))
1285	{
1286	unconst(m_enmScope) = DHCPConfigScope_MAC;
1287	unconst(m_MACAddress) = *a_pMACAddress;
1288
1289	autoInitSpan.setSucceeded();
1290	}
1291	return hrc;
1292	}
1293
1294
1295	HRESULT DHCPIndividualConfig::initWithSettingsAndMachineIdAndSlot(VirtualBox a_pVirtualBox, DHCPServer a_pParent,
1296	settings::DHCPIndividualConfig const &rConfig,
1297	com::Guid const &a_idMachine, ULONG a_uSlot,
1298	uint32_t a_uMACAddressVersion)
1299	{
1300	AutoInitSpan autoInitSpan(this);
1301	AssertReturn(autoInitSpan.isOk(), E_FAIL);
1302
1303	HRESULT hrc = DHCPConfig::i_initWithSettings(a_pVirtualBox, a_pParent, rConfig);
1304	if (SUCCEEDED(hrc))
1305	{
1306	unconst(m_enmScope) = DHCPConfigScope_MachineNIC;
1307	unconst(m_idMachine) = a_idMachine;
1308	unconst(m_uSlot) = a_uSlot;
1309	m_uMACAddressResolvedVersion = a_uMACAddressVersion;
1310	m_strFixedAddress = rConfig.strFixedAddress;
1311
1312	autoInitSpan.setSucceeded();
1313	}
1314	return hrc;
1315	}
1316
1317
1318	HRESULT DHCPIndividualConfig::initWithSettingsAndMACAddress(VirtualBox a_pVirtualBox, DHCPServer a_pParent,
1319	settings::DHCPIndividualConfig const &rConfig, PCRTMAC a_pMACAddress)
1320	{
1321	AutoInitSpan autoInitSpan(this);
1322	AssertReturn(autoInitSpan.isOk(), E_FAIL);
1323
1324	HRESULT hrc = DHCPConfig::i_initWithSettings(a_pVirtualBox, a_pParent, rConfig);
1325	if (SUCCEEDED(hrc))
1326	{
1327	unconst(m_enmScope) = DHCPConfigScope_MAC;
1328	unconst(m_MACAddress) = *a_pMACAddress;
1329	m_strFixedAddress = rConfig.strFixedAddress;
1330
1331	autoInitSpan.setSucceeded();
1332	}
1333	return hrc;
1334	}
1335
1336
1337	void DHCPIndividualConfig::uninit()
1338	{
1339	AutoUninitSpan autoUninitSpan(this);
1340	if (!autoUninitSpan.uninitDone())
1341	autoUninitSpan.setSucceeded();
1342	}
1343
1344
1345	HRESULT DHCPIndividualConfig::i_saveSettings(settings::DHCPIndividualConfig &a_rDst)
1346	{
1347	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1348
1349	a_rDst.uSlot = m_uSlot;
1350	int vrc = a_rDst.strMACAddress.printfNoThrow("%RTmac", &m_MACAddress);
1351	if (m_idMachine.isValid() && !m_idMachine.isZero() && RT_SUCCESS(vrc))
1352	vrc = a_rDst.strVMName.printfNoThrow("%RTuuid", m_idMachine.raw());
1353	if (RT_SUCCESS(vrc))
1354	vrc = a_rDst.strFixedAddress.assignNoThrow(m_strFixedAddress);
1355	if (RT_SUCCESS(vrc))
1356	return DHCPConfig::i_saveSettings(a_rDst);
1357	return E_OUTOFMEMORY;;
1358	}
1359
1360
1361	HRESULT DHCPIndividualConfig::getMACAddress(com::Utf8Str &aMACAddress)
1362	{
1363	/* No locking needed here (the MAC address, machine UUID and NIC slot number cannot change). */
1364	RTMAC MACAddress;
1365	if (m_enmScope == DHCPConfigScope_MAC)
1366	MACAddress = m_MACAddress;
1367	else
1368	{
1369	HRESULT hrc = i_getMachineMAC(&MACAddress);
1370	if (FAILED(hrc))
1371	return hrc;
1372	}
1373
1374	/* Format the return string: */
1375	int vrc = aMACAddress.printfNoThrow("%RTmac", &MACAddress);
1376	return RT_SUCCESS(vrc) ? S_OK : E_OUTOFMEMORY;
1377	}
1378
1379
1380	HRESULT DHCPIndividualConfig::getMachineId(com::Guid &aId)
1381	{
1382	AutoReadLock(this COMMA_LOCKVAL_SRC_POS);
1383	aId = m_idMachine;
1384	return S_OK;
1385	}
1386
1387
1388	HRESULT DHCPIndividualConfig::getSlot(ULONG *aSlot)
1389	{
1390	AutoReadLock(this COMMA_LOCKVAL_SRC_POS);
1391	*aSlot = m_uSlot;
1392	return S_OK;
1393	}
1394
1395	HRESULT DHCPIndividualConfig::getFixedAddress(com::Utf8Str &aFixedAddress)
1396	{
1397	AutoReadLock(this COMMA_LOCKVAL_SRC_POS);
1398	return aFixedAddress.assignEx(m_strFixedAddress);
1399	}
1400
1401
1402	HRESULT DHCPIndividualConfig::setFixedAddress(const com::Utf8Str &aFixedAddress)
1403	{
1404	if (aFixedAddress.isNotEmpty())
1405	{
1406	RTNETADDRIPV4 AddrIgnored;
1407	int vrc = RTNetStrToIPv4Addr(aFixedAddress.c_str(), &AddrIgnored);
1408	if (RT_FAILURE(vrc))
1409	return setErrorBoth(E_INVALIDARG, vrc, tr("Invalid IPv4 address '%s': %Rrc"), aFixedAddress.c_str(), vrc);
1410	}
1411
1412	{
1413	AutoWriteLock(this COMMA_LOCKVAL_SRC_POS);
1414	m_strFixedAddress = aFixedAddress;
1415	}
1416	return i_doWriteConfig();
1417	}
1418
1419
1420	/**
1421	* Gets the MAC address of m_idMachine + m_uSlot.
1422	*
1423	* @returns COM status code w/ setError.
1424	* @param pMACAddress Where to return the address.
1425	*
1426	* @note Must be called without holding any DHCP related locks as that would
1427	* be lock order violation. The m_idMachine and m_uSlot values are
1428	* practically const, so we don't need any locks here anyway.
1429	*/
1430	HRESULT DHCPIndividualConfig::i_getMachineMAC(PRTMAC pMACAddress)
1431	{
1432	ComObjPtr<Machine> ptrMachine;
1433	HRESULT hrc = m_pVirtualBox->i_findMachine(m_idMachine, false /fPermitInaccessible/, true /aSetError/, &ptrMachine);
1434	if (SUCCEEDED(hrc))
1435	{
1436	ComPtr<INetworkAdapter> ptrNetworkAdapter;
1437	hrc = ptrMachine->GetNetworkAdapter(m_uSlot, ptrNetworkAdapter.asOutParam());
1438	if (SUCCEEDED(hrc))
1439	{
1440	com::Bstr bstrMACAddress;
1441	hrc = ptrNetworkAdapter->COMGETTER(MACAddress)(bstrMACAddress.asOutParam());
1442	if (SUCCEEDED(hrc))
1443	{
1444	Utf8Str strMACAddress;
1445	try
1446	{
1447	strMACAddress = bstrMACAddress;
1448	}
1449	catch (std::bad_alloc &)
1450	{
1451	return E_OUTOFMEMORY;
1452	}
1453
1454	int vrc = RTNetStrToMacAddr(strMACAddress.c_str(), pMACAddress);
1455	if (RT_SUCCESS(vrc))
1456	hrc = S_OK;
1457	else
1458	hrc = setErrorBoth(E_FAIL, vrc, tr("INetworkAdapter returned bogus MAC address '%ls': %Rrc"),
1459	bstrMACAddress.raw(), vrc);
1460	}
1461	}
1462	}
1463	return hrc;
1464	}
1465
1466
1467	HRESULT DHCPIndividualConfig::i_resolveMACAddress(uint32_t uVersion)
1468	{
1469	HRESULT hrc;
1470	if (m_enmScope == DHCPConfigScope_MachineNIC)
1471	{
1472	RTMAC MACAddress;
1473	hrc = i_getMachineMAC(&MACAddress);
1474	if (SUCCEEDED(hrc))
1475	{
1476	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1477	if ((int32_t)(uVersion - m_uMACAddressResolvedVersion) >= 0)
1478	{
1479	m_uMACAddressResolvedVersion = uVersion;
1480	m_MACAddress = MACAddress;
1481	}
1482	}
1483	}
1484	else
1485	hrc = S_OK;
1486	return hrc;
1487	}
1488
1489
1490	/**
1491	* Overridden to write out additional config.
1492	*/
1493	void DHCPIndividualConfig::i_writeDhcpdConfig(xml::ElementNode *pElmConfig)
1494	{
1495	char szTmp[RTUUID_STR_LENGTH + 32];
1496	RTStrPrintf(szTmp, sizeof(szTmp), "%RTmac", &m_MACAddress);
1497	pElmConfig->setAttribute("MACAddress", szTmp);
1498
1499	if (m_enmScope == DHCPConfigScope_MachineNIC)
1500	{
1501	RTStrPrintf(szTmp, sizeof(szTmp), "%RTuuid/%u", m_idMachine.raw(), m_uSlot);
1502	pElmConfig->setAttribute("name", szTmp);
1503	}
1504
1505	pElmConfig->setAttribute("fixedAddress", m_strFixedAddress);
1506
1507	DHCPConfig::i_writeDhcpdConfig(pElmConfig);
1508	}
1509

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/src-server/DHCPConfigImpl.cpp@ 105016

Download in other formats: