VirtualBox

source: vbox/trunk/src/VBox/Main/include/DHCPConfigImpl.h@ 85240

Last change on this file since 85240 was 82968, checked in by vboxsync, 5 years ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 20.2 KB
Line 
1/* $Id: DHCPConfigImpl.h 82968 2020-02-04 10:35:17Z vboxsync $ */
2/** @file
3 * VirtualBox Main - IDHCPConfig, IDHCPConfigGlobal, IDHCPConfigGroup, IDHCPConfigIndividual header.
4 */
5
6/*
7 * Copyright (C) 2006-2020 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#ifndef MAIN_INCLUDED_DHCPConfigImpl_h
19#define MAIN_INCLUDED_DHCPConfigImpl_h
20#ifndef RT_WITHOUT_PRAGMA_ONCE
21# pragma once
22#endif
23
24#include "DHCPGlobalConfigWrap.h"
25#include "DHCPGroupConditionWrap.h"
26#include "DHCPGroupConfigWrap.h"
27#include "DHCPIndividualConfigWrap.h"
28#include <VBox/settings.h>
29
30
31class DHCPServer;
32class DHCPGroupConfig;
33
34
35/**
36 * Base class for the a DHCP configration layer.
37 *
38 * This does not inherit from DHCPConfigWrap because its children need to
39 * inherit from children of DHCPConfigWrap, which smells like trouble and thus
40 * wasn't even attempted. Instead, we have a hack for passing a pointer that we
41 * can call setError and such on.
42 */
43class DHCPConfig
44{
45protected:
46 /** Config scope (global, group, vm+nic, mac). */
47 DHCPConfigScope_T const m_enmScope;
48 /** Minimum lease time. */
49 ULONG m_secMinLeaseTime;
50 /** Default lease time. */
51 ULONG m_secDefaultLeaseTime;
52 /** Maximum lease time. */
53 ULONG m_secMaxLeaseTime;
54 /** List of options which are forced upon the client when available, whether
55 * requested by it or not. */
56 std::vector<DHCPOption_T> m_vecForcedOptions;
57 /** List of options which should be suppressed and not returned the the client
58 * when available and requested. */
59 std::vector<DHCPOption_T> m_vecSuppressedOptions;
60 /** DHCP option map. */
61 settings::DhcpOptionMap m_OptionMap;
62 /** The DHCP server parent (weak). */
63 DHCPServer * const m_pParent;
64 /** The DHCP server parent (weak). */
65 VirtualBox * const m_pVirtualBox;
66private:
67 /** For setError and such. */
68 VirtualBoxBase * const m_pHack;
69
70protected:
71 /** @name Constructors and destructors.
72 * @{ */
73 DHCPConfig(DHCPConfigScope_T a_enmScope, VirtualBoxBase *a_pHack)
74 : m_enmScope(a_enmScope), m_secMinLeaseTime(0), m_secDefaultLeaseTime(0), m_secMaxLeaseTime(0), m_OptionMap()
75 , m_pParent(NULL), m_pVirtualBox(NULL), m_pHack(a_pHack)
76 {}
77 DHCPConfig();
78 virtual ~DHCPConfig()
79 {}
80 HRESULT i_initWithDefaults(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent);
81 HRESULT i_initWithSettings(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, const settings::DHCPConfig &rConfig);
82 /** @} */
83
84 /** @name IDHCPConfig properties
85 * @{ */
86 HRESULT i_getScope(DHCPConfigScope_T *aScope);
87 HRESULT i_getMinLeaseTime(ULONG *aMinLeaseTime);
88 HRESULT i_setMinLeaseTime(ULONG aMinLeaseTime);
89 HRESULT i_getDefaultLeaseTime(ULONG *aDefaultLeaseTime);
90 HRESULT i_setDefaultLeaseTime(ULONG aDefaultLeaseTime);
91 HRESULT i_getMaxLeaseTime(ULONG *aMaxLeaseTime);
92 HRESULT i_setMaxLeaseTime(ULONG aMaxLeaseTime);
93 HRESULT i_getForcedOptions(std::vector<DHCPOption_T> &aOptions);
94 HRESULT i_setForcedOptions(const std::vector<DHCPOption_T> &aOptions);
95 HRESULT i_getSuppressedOptions(std::vector<DHCPOption_T> &aOptions);
96 HRESULT i_setSuppressedOptions(const std::vector<DHCPOption_T> &aOptions);
97 /** @} */
98
99public:
100 /** @name IDHCPConfig methods
101 * @note public because the DHCPServer needs them for 6.0 interfaces.
102 * @todo Make protected again when IDHCPServer is cleaned up.
103 * @{ */
104 virtual HRESULT i_setOption(DHCPOption_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue);
105
106 virtual HRESULT i_removeOption(DHCPOption_T aOption);
107 virtual HRESULT i_removeAllOptions();
108 HRESULT i_getOption(DHCPOption_T aOption, DHCPOptionEncoding_T *aEncoding, com::Utf8Str &aValue);
109 HRESULT i_getAllOptions(std::vector<DHCPOption_T> &aOptions, std::vector<DHCPOptionEncoding_T> &aEncodings,
110 std::vector<com::Utf8Str> &aValues);
111 virtual HRESULT i_remove();
112 /** @} */
113
114
115public:
116 HRESULT i_doWriteConfig();
117 HRESULT i_saveSettings(settings::DHCPConfig &a_rDst);
118 DHCPConfigScope_T i_getScope() const RT_NOEXCEPT { return m_enmScope; }
119 virtual void i_writeDhcpdConfig(xml::ElementNode *pElm);
120};
121
122
123/**
124 * Global DHCP configuration.
125 */
126class DHCPGlobalConfig : public DHCPGlobalConfigWrap, public DHCPConfig
127{
128public:
129 /** @name Constructors and destructors.
130 * @{ */
131 DHCPGlobalConfig()
132 : DHCPConfig(DHCPConfigScope_Global, this)
133 { }
134 HRESULT FinalConstruct()
135 {
136 return BaseFinalConstruct();
137 }
138 void FinalRelease()
139 {
140 uninit();
141 BaseFinalRelease();
142 }
143 HRESULT initWithDefaults(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent);
144 HRESULT initWithSettings(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, const settings::DHCPConfig &rConfig);
145 void uninit();
146 /** @} */
147
148 HRESULT i_saveSettings(settings::DHCPConfig &a_rDst);
149 HRESULT i_getNetworkMask(com::Utf8Str &a_rDst);
150 HRESULT i_setNetworkMask(const com::Utf8Str &a_rSrc);
151
152protected:
153 /** @name wrapped IDHCPConfig properties
154 * @{ */
155 HRESULT getScope(DHCPConfigScope_T *aScope) RT_OVERRIDE { return i_getScope(aScope); }
156 HRESULT getMinLeaseTime(ULONG *aMinLeaseTime) RT_OVERRIDE { return i_getMinLeaseTime(aMinLeaseTime); }
157 HRESULT setMinLeaseTime(ULONG aMinLeaseTime) RT_OVERRIDE { return i_setMinLeaseTime(aMinLeaseTime); }
158 HRESULT getDefaultLeaseTime(ULONG *aDefaultLeaseTime) RT_OVERRIDE { return i_getDefaultLeaseTime(aDefaultLeaseTime); }
159 HRESULT setDefaultLeaseTime(ULONG aDefaultLeaseTime) RT_OVERRIDE { return i_setDefaultLeaseTime(aDefaultLeaseTime); }
160 HRESULT getMaxLeaseTime(ULONG *aMaxLeaseTime) RT_OVERRIDE { return i_getMaxLeaseTime(aMaxLeaseTime); }
161 HRESULT setMaxLeaseTime(ULONG aMaxLeaseTime) RT_OVERRIDE { return i_setMaxLeaseTime(aMaxLeaseTime); }
162 HRESULT getForcedOptions(std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_getForcedOptions(aOptions); }
163 HRESULT setForcedOptions(const std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_setForcedOptions(aOptions); }
164 HRESULT getSuppressedOptions(std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_getSuppressedOptions(aOptions); }
165 HRESULT setSuppressedOptions(const std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_setSuppressedOptions(aOptions); }
166 /** @} */
167
168 /** @name wrapped IDHCPConfig methods
169 * @{ */
170 HRESULT setOption(DHCPOption_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue) RT_OVERRIDE
171 {
172 return i_setOption(aOption, aEncoding, aValue);
173 }
174
175 HRESULT removeOption(DHCPOption_T aOption) RT_OVERRIDE
176 {
177 return i_removeOption(aOption);
178 }
179
180 HRESULT removeAllOptions() RT_OVERRIDE
181 {
182 return i_removeAllOptions();
183 }
184
185 HRESULT getOption(DHCPOption_T aOption, DHCPOptionEncoding_T *aEncoding, com::Utf8Str &aValue) RT_OVERRIDE
186 {
187 return i_getOption(aOption, aEncoding, aValue);
188 }
189
190 HRESULT getAllOptions(std::vector<DHCPOption_T> &aOptions, std::vector<DHCPOptionEncoding_T> &aEncodings,
191 std::vector<com::Utf8Str> &aValues) RT_OVERRIDE
192 {
193 return i_getAllOptions(aOptions, aEncodings, aValues);
194 }
195
196 HRESULT remove() RT_OVERRIDE
197 {
198 return i_remove();
199 }
200 /** @} */
201
202public:
203 HRESULT i_setOption(DHCPOption_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue) RT_OVERRIDE;
204 HRESULT i_removeOption(DHCPOption_T aOption) RT_OVERRIDE;
205 HRESULT i_removeAllOptions() RT_OVERRIDE;
206 HRESULT i_remove() RT_OVERRIDE;
207};
208
209
210/**
211 * DHCP Group inclusion/exclusion condition.
212 */
213class DHCPGroupCondition : public DHCPGroupConditionWrap
214{
215private:
216 /** Inclusive or exclusive condition. */
217 bool m_fInclusive;
218 /** The condition type (or how m_strValue should be interpreted). */
219 DHCPGroupConditionType_T m_enmType;
220 /** The value. Interpreted according to m_enmType. */
221 com::Utf8Str m_strValue;
222 /** Pointer to the parent (weak). */
223 DHCPGroupConfig *m_pParent;
224
225public:
226 /** @name Constructors and destructors.
227 * @{ */
228 DHCPGroupCondition()
229 : m_enmType(DHCPGroupConditionType_MAC)
230 , m_pParent(NULL)
231 {}
232 HRESULT FinalConstruct()
233 {
234 return BaseFinalConstruct();
235 }
236 void FinalRelease()
237 {
238 uninit();
239 BaseFinalRelease();
240 }
241 HRESULT initWithDefaults(DHCPGroupConfig *a_pParent, bool a_fInclusive, DHCPGroupConditionType_T a_enmType,
242 const com::Utf8Str a_strValue);
243 HRESULT initWithSettings(DHCPGroupConfig *a_pParent, const settings::DHCPGroupCondition &a_rSrc);
244 void uninit();
245 /** @} */
246
247 HRESULT i_saveSettings(settings::DHCPGroupCondition &a_rDst);
248 static HRESULT i_validateTypeAndValue(DHCPGroupConditionType_T enmType, com::Utf8Str const &strValue,
249 VirtualBoxBase *pErrorDst);
250
251 /** @name Internal accessors
252 * @{ */
253 bool i_getInclusive() const RT_NOEXCEPT { return m_fInclusive; }
254 DHCPGroupConditionType_T i_getType() const RT_NOEXCEPT { return m_enmType; }
255 com::Utf8Str const &i_getValue() const RT_NOEXCEPT { return m_strValue; }
256 /** @} */
257
258protected:
259 /** @name Wrapped IDHCPGroupCondition properties
260 * @{ */
261 HRESULT getInclusive(BOOL *aInclusive) RT_OVERRIDE;
262 HRESULT setInclusive(BOOL aInclusive) RT_OVERRIDE;
263 HRESULT getType(DHCPGroupConditionType_T *aType) RT_OVERRIDE;
264 HRESULT setType(DHCPGroupConditionType_T aType) RT_OVERRIDE;
265 HRESULT getValue(com::Utf8Str &aValue) RT_OVERRIDE;
266 HRESULT setValue(const com::Utf8Str &aValue) RT_OVERRIDE;
267 /** @} */
268
269 /** @name Wrapped IDHCPGroupCondition methods
270 * @{ */
271 HRESULT remove() RT_OVERRIDE;
272 /** @} */
273};
274
275
276/**
277 * Group configuration.
278 */
279class DHCPGroupConfig : public DHCPGroupConfigWrap, public DHCPConfig
280{
281private:
282 /** Group name. */
283 com::Utf8Str m_strName;
284 /** Group membership conditions. */
285 std::vector<ComObjPtr<DHCPGroupCondition> > m_Conditions;
286 /** Iterator for m_Conditions. */
287 typedef std::vector<ComObjPtr<DHCPGroupCondition> >::iterator ConditionsIterator;
288
289public:
290 /** @name Constructors and destructors.
291 * @{ */
292 DHCPGroupConfig()
293 : DHCPConfig(DHCPConfigScope_Group, this)
294 { }
295 HRESULT FinalConstruct()
296 {
297 return BaseFinalConstruct();
298 }
299 void FinalRelease()
300 {
301 uninit();
302 BaseFinalRelease();
303 }
304 HRESULT initWithDefaults(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, const com::Utf8Str &a_rName);
305 HRESULT initWithSettings(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, const settings::DHCPGroupConfig &a_rSrc);
306 void uninit();
307 /** @} */
308
309 HRESULT i_saveSettings(settings::DHCPGroupConfig &a_rDst);
310 HRESULT i_removeCondition(DHCPGroupCondition *a_pCondition);
311 void i_writeDhcpdConfig(xml::ElementNode *a_pElmGroup) RT_OVERRIDE;
312
313protected:
314 /** @name Wrapped IDHCPConfig properties
315 * @{ */
316 HRESULT getScope(DHCPConfigScope_T *aScope) RT_OVERRIDE { return i_getScope(aScope); }
317 HRESULT getMinLeaseTime(ULONG *aMinLeaseTime) RT_OVERRIDE { return i_getMinLeaseTime(aMinLeaseTime); }
318 HRESULT setMinLeaseTime(ULONG aMinLeaseTime) RT_OVERRIDE { return i_setMinLeaseTime(aMinLeaseTime); }
319 HRESULT getDefaultLeaseTime(ULONG *aDefaultLeaseTime) RT_OVERRIDE { return i_getDefaultLeaseTime(aDefaultLeaseTime); }
320 HRESULT setDefaultLeaseTime(ULONG aDefaultLeaseTime) RT_OVERRIDE { return i_setDefaultLeaseTime(aDefaultLeaseTime); }
321 HRESULT getMaxLeaseTime(ULONG *aMaxLeaseTime) RT_OVERRIDE { return i_getMaxLeaseTime(aMaxLeaseTime); }
322 HRESULT setMaxLeaseTime(ULONG aMaxLeaseTime) RT_OVERRIDE { return i_setMaxLeaseTime(aMaxLeaseTime); }
323 HRESULT getForcedOptions(std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_getForcedOptions(aOptions); }
324 HRESULT setForcedOptions(const std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_setForcedOptions(aOptions); }
325 HRESULT getSuppressedOptions(std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_getSuppressedOptions(aOptions); }
326 HRESULT setSuppressedOptions(const std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_setSuppressedOptions(aOptions); }
327 /** @} */
328
329 /** @name Wrapped IDHCPGroupConfig properties
330 * @{ */
331 HRESULT getName(com::Utf8Str &aName) RT_OVERRIDE;
332 HRESULT setName(const com::Utf8Str &aName) RT_OVERRIDE;
333 HRESULT getConditions(std::vector<ComPtr<IDHCPGroupCondition> > &aConditions) RT_OVERRIDE;
334 /** @} */
335
336 /** @name Wrapped IDHCPConfig methods
337 * @{ */
338 HRESULT setOption(DHCPOption_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue) RT_OVERRIDE
339 {
340 return i_setOption(aOption, aEncoding, aValue);
341 }
342
343 HRESULT removeOption(DHCPOption_T aOption) RT_OVERRIDE
344 {
345 return i_removeOption(aOption);
346 }
347
348 HRESULT removeAllOptions() RT_OVERRIDE
349 {
350 return i_removeAllOptions();
351 }
352
353 HRESULT getOption(DHCPOption_T aOption, DHCPOptionEncoding_T *aEncoding, com::Utf8Str &aValue) RT_OVERRIDE
354 {
355 return i_getOption(aOption, aEncoding, aValue);
356 }
357
358 HRESULT getAllOptions(std::vector<DHCPOption_T> &aOptions, std::vector<DHCPOptionEncoding_T> &aEncodings,
359 std::vector<com::Utf8Str> &aValues) RT_OVERRIDE
360 {
361 return i_getAllOptions(aOptions, aEncodings, aValues);
362 }
363
364 HRESULT remove() RT_OVERRIDE
365 {
366 return i_remove();
367 }
368 /** @} */
369
370 /** @name Wrapped IDHCPGroupConfig methods
371 * @{ */
372 HRESULT addCondition(BOOL aInclusive, DHCPGroupConditionType_T aType, const com::Utf8Str &aValue,
373 ComPtr<IDHCPGroupCondition> &aCondition) RT_OVERRIDE;
374 HRESULT removeAllConditions() RT_OVERRIDE;
375 /** @} */
376};
377
378
379/**
380 * Individual DHCP configuration.
381 */
382class DHCPIndividualConfig : public DHCPIndividualConfigWrap, public DHCPConfig
383{
384private:
385 /** The MAC address or all zeros. */
386 RTMAC m_MACAddress;
387 /** The VM ID or all zeros. */
388 com::Guid const m_idMachine;
389 /** The VM NIC slot number, or ~(ULONG)0. */
390 ULONG const m_uSlot;
391 /** This is part of a hack to resolve the MAC address for
392 * DHCPConfigScope_MachineNIC instances. If non-zero, we m_MACAddress is valid.
393 * To deal with the impossibly theoretical scenario that the DHCP server is
394 * being started by more than one thread, this is a version number and not just
395 * a boolean indicator. */
396 uint32_t volatile m_uMACAddressResolvedVersion;
397
398 /** The fixed IPv4 address, empty if dynamic. */
399 com::Utf8Str m_strFixedAddress;
400
401public:
402 /** @name Constructors and destructors.
403 * @{ */
404 DHCPIndividualConfig()
405 : DHCPConfig(DHCPConfigScope_MAC, this)
406 , m_uSlot(~(ULONG)0)
407 , m_uMACAddressResolvedVersion(0)
408 {
409 RT_ZERO(m_MACAddress);
410 }
411 HRESULT FinalConstruct()
412 {
413 return BaseFinalConstruct();
414 }
415 void FinalRelease()
416 {
417 uninit();
418 BaseFinalRelease();
419 }
420 HRESULT initWithMachineIdAndSlot(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, com::Guid const &a_idMachine,
421 ULONG a_uSlot, uint32_t a_uMACAddressVersion);
422 HRESULT initWithMACAddress(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, PCRTMAC a_pMACAddress);
423 HRESULT initWithSettingsAndMachineIdAndSlot(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent,
424 const settings::DHCPIndividualConfig &rData, com::Guid const &a_idMachine,
425 ULONG a_uSlot, uint32_t a_uMACAddressVersion);
426 HRESULT initWithSettingsAndMACAddress(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent,
427 const settings::DHCPIndividualConfig &rData, PCRTMAC a_pMACAddress);
428 void uninit();
429 /** @} */
430
431 /** @name Internal methods that are public for various reasons
432 * @{ */
433 HRESULT i_saveSettings(settings::DHCPIndividualConfig &a_rDst);
434 RTMAC const &i_getMACAddress() const RT_NOEXCEPT { return m_MACAddress; }
435 com::Guid const &i_getMachineId() const RT_NOEXCEPT { return m_idMachine; }
436 ULONG i_getSlot() const RT_NOEXCEPT { return m_uSlot; }
437 HRESULT i_getMachineMAC(PRTMAC pMACAddress);
438
439 HRESULT i_resolveMACAddress(uint32_t uVersion);
440 /** This is used to avoid producing bogus Dhcpd configuration elements. */
441 bool i_isMACAddressResolved(uint32_t uVersion) const
442 {
443 return m_enmScope != DHCPConfigScope_MachineNIC || (int32_t)(m_uMACAddressResolvedVersion - uVersion) >= 0;
444 }
445 void i_writeDhcpdConfig(xml::ElementNode *pElm) RT_OVERRIDE;
446 /** @} */
447
448protected:
449 /** @name wrapped IDHCPConfig properties
450 * @{ */
451 HRESULT getScope(DHCPConfigScope_T *aScope) RT_OVERRIDE { return i_getScope(aScope); }
452 HRESULT getMinLeaseTime(ULONG *aMinLeaseTime) RT_OVERRIDE { return i_getMinLeaseTime(aMinLeaseTime); }
453 HRESULT setMinLeaseTime(ULONG aMinLeaseTime) RT_OVERRIDE { return i_setMinLeaseTime(aMinLeaseTime); }
454 HRESULT getDefaultLeaseTime(ULONG *aDefaultLeaseTime) RT_OVERRIDE { return i_getDefaultLeaseTime(aDefaultLeaseTime); }
455 HRESULT setDefaultLeaseTime(ULONG aDefaultLeaseTime) RT_OVERRIDE { return i_setDefaultLeaseTime(aDefaultLeaseTime); }
456 HRESULT getMaxLeaseTime(ULONG *aMaxLeaseTime) RT_OVERRIDE { return i_getMaxLeaseTime(aMaxLeaseTime); }
457 HRESULT setMaxLeaseTime(ULONG aMaxLeaseTime) RT_OVERRIDE { return i_setMaxLeaseTime(aMaxLeaseTime); }
458 HRESULT getForcedOptions(std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_getForcedOptions(aOptions); }
459 HRESULT setForcedOptions(const std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_setForcedOptions(aOptions); }
460 HRESULT getSuppressedOptions(std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_getSuppressedOptions(aOptions); }
461 HRESULT setSuppressedOptions(const std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_setSuppressedOptions(aOptions); }
462 /** @} */
463
464 /** @name wrapped IDHCPConfig methods
465 * @{ */
466 HRESULT setOption(DHCPOption_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue) RT_OVERRIDE
467 {
468 return i_setOption(aOption, aEncoding, aValue);
469 }
470
471 HRESULT removeOption(DHCPOption_T aOption) RT_OVERRIDE
472 {
473 return i_removeOption(aOption);
474 }
475
476 HRESULT removeAllOptions() RT_OVERRIDE
477 {
478 return i_removeAllOptions();
479 }
480
481 HRESULT getOption(DHCPOption_T aOption, DHCPOptionEncoding_T *aEncoding, com::Utf8Str &aValue) RT_OVERRIDE
482 {
483 return i_getOption(aOption, aEncoding, aValue);
484 }
485
486 HRESULT getAllOptions(std::vector<DHCPOption_T> &aOptions, std::vector<DHCPOptionEncoding_T> &aEncodings,
487 std::vector<com::Utf8Str> &aValues) RT_OVERRIDE
488 {
489 return i_getAllOptions(aOptions, aEncodings, aValues);
490 }
491
492 HRESULT remove() RT_OVERRIDE
493 {
494 return i_remove();
495 }
496 /** @} */
497
498 /** @name IDHCPIndividualConfig properties
499 * @{ */
500 HRESULT getMACAddress(com::Utf8Str &aMacAddress) RT_OVERRIDE;
501 HRESULT getMachineId(com::Guid &aId) RT_OVERRIDE;
502 HRESULT getSlot(ULONG *aSlot) RT_OVERRIDE;
503 HRESULT getFixedAddress(com::Utf8Str &aFixedAddress) RT_OVERRIDE;
504 HRESULT setFixedAddress(const com::Utf8Str &aFixedAddress) RT_OVERRIDE;
505 /** @} */
506};
507
508#endif /* !MAIN_INCLUDED_DHCPConfigImpl_h */
509
Note: See TracBrowser for help on using the repository browser.

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