VirtualBox

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageDHCPServer.cpp@ 82781

Last change on this file since 82781 was 79886, checked in by vboxsync, 5 years ago

VBoxManage/dhcpserver: Adding support for option forcing & suppression. [build fix[ bugref:9288
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 51.5 KB
Line 
1/* $Id: VBoxManageDHCPServer.cpp 79886 2019-07-19 12:38:52Z vboxsync $ */
2/** @file
3 * VBoxManage - Implementation of dhcpserver command.
4 */
5
6/*
7 * Copyright (C) 2006-2019 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
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#include <VBox/com/com.h>
23#include <VBox/com/array.h>
24#include <VBox/com/ErrorInfo.h>
25#include <VBox/com/errorprint.h>
26#include <VBox/com/VirtualBox.h>
27
28#include <iprt/cidr.h>
29#include <iprt/param.h>
30#include <iprt/path.h>
31#include <iprt/stream.h>
32#include <iprt/string.h>
33#include <iprt/net.h>
34#include <iprt/getopt.h>
35#include <iprt/ctype.h>
36
37#include <VBox/log.h>
38
39#include "VBoxManage.h"
40
41#include <vector>
42#include <map>
43
44using namespace com;
45
46
47/*********************************************************************************************************************************
48* Defined Constants And Macros *
49*********************************************************************************************************************************/
50#define DHCPD_CMD_COMMON_OPT_NETWORK 999 /**< The --network / --netname option number. */
51#define DHCPD_CMD_COMMON_OPT_INTERFACE 998 /**< The --interface / --ifname option number. */
52/** Common option definitions. */
53#define DHCPD_CMD_COMMON_OPTION_DEFS() \
54 { "--network", DHCPD_CMD_COMMON_OPT_NETWORK, RTGETOPT_REQ_STRING }, \
55 { "--netname", DHCPD_CMD_COMMON_OPT_NETWORK, RTGETOPT_REQ_STRING }, /* legacy */ \
56 { "--interface", DHCPD_CMD_COMMON_OPT_INTERFACE, RTGETOPT_REQ_STRING }, \
57 { "--ifname", DHCPD_CMD_COMMON_OPT_INTERFACE, RTGETOPT_REQ_STRING } /* legacy */
58
59/** Handles common options in the typical option parsing switch. */
60#define DHCPD_CMD_COMMON_OPTION_CASES(a_pCtx, a_ch, a_pValueUnion) \
61 case DHCPD_CMD_COMMON_OPT_NETWORK: \
62 if ((a_pCtx)->pszInterface != NULL) \
63 return errorSyntax("Either --network or --interface, not both"); \
64 (a_pCtx)->pszNetwork = ValueUnion.psz; \
65 break; \
66 case DHCPD_CMD_COMMON_OPT_INTERFACE: \
67 if ((a_pCtx)->pszNetwork != NULL) \
68 return errorSyntax("Either --interface or --network, not both"); \
69 (a_pCtx)->pszInterface = ValueUnion.psz; \
70 break
71
72
73/*********************************************************************************************************************************
74* Structures and Typedefs *
75*********************************************************************************************************************************/
76/** Pointer to a dhcpserver command context. */
77typedef struct DHCPDCMDCTX *PDHCPDCMDCTX;
78
79/**
80 * Definition of a dhcpserver command, with handler and various flags.
81 */
82typedef struct DHCPDCMDDEF
83{
84 /** The command name. */
85 const char *pszName;
86
87 /**
88 * Actual command handler callback.
89 *
90 * @param pCtx Pointer to command context to use.
91 */
92 DECLR3CALLBACKMEMBER(RTEXITCODE, pfnHandler, (PDHCPDCMDCTX pCtx, int argc, char **argv));
93
94 /** The sub-command scope flags. */
95 uint64_t fSubcommandScope;
96} DHCPDCMDDEF;
97/** Pointer to a const dhcpserver command definition. */
98typedef DHCPDCMDDEF const *PCDHCPDCMDDEF;
99
100/**
101 * dhcpserver command context (mainly for carrying common options and such).
102 */
103typedef struct DHCPDCMDCTX
104{
105 /** The handler arguments from the main() function. */
106 HandlerArg *pArg;
107 /** Pointer to the command definition. */
108 PCDHCPDCMDDEF pCmdDef;
109 /** The network name. */
110 const char *pszNetwork;
111 /** The (trunk) interface name. */
112 const char *pszInterface;
113} DHCPDCMDCTX;
114
115typedef std::pair<DHCPOption_T, Utf8Str> DhcpOptSpec;
116typedef std::vector<DhcpOptSpec> DhcpOpts;
117typedef DhcpOpts::iterator DhcpOptIterator;
118
119typedef std::vector<DHCPOption_T> DhcpOptIds;
120typedef DhcpOptIds::iterator DhcpOptIdIterator;
121
122struct VmNameSlotKey
123{
124 const Utf8Str VmName;
125 uint8_t u8Slot;
126
127 VmNameSlotKey(const Utf8Str &aVmName, uint8_t aSlot)
128 : VmName(aVmName)
129 , u8Slot(aSlot)
130 {}
131
132 bool operator<(const VmNameSlotKey& that) const
133 {
134 if (VmName == that.VmName)
135 return u8Slot < that.u8Slot;
136 return VmName < that.VmName;
137 }
138};
139
140typedef std::map<VmNameSlotKey, DhcpOpts> VmSlot2OptionsM;
141typedef VmSlot2OptionsM::iterator VmSlot2OptionsIterator;
142typedef VmSlot2OptionsM::value_type VmSlot2OptionsPair;
143
144typedef std::map<VmNameSlotKey, DhcpOptIds> VmSlot2OptionIdsM;
145typedef VmSlot2OptionIdsM::iterator VmSlot2OptionIdsIterator;
146
147
148
149/**
150 * Helper that find the DHCP server instance.
151 *
152 * @returns The DHCP server instance. NULL if failed (complaining done).
153 * @param pCtx The DHCP server command context.
154 */
155static ComPtr<IDHCPServer> dhcpdFindServer(PDHCPDCMDCTX pCtx)
156{
157 ComPtr<IDHCPServer> ptrRet;
158 if (pCtx->pszNetwork || pCtx->pszInterface)
159 {
160 Assert(pCtx->pszNetwork == NULL || pCtx->pszInterface == NULL);
161
162 /*
163 * We need a network name to find the DHCP server. So, if interface is
164 * given we have to look it up.
165 */
166 HRESULT hrc;
167 Bstr bstrNetName(pCtx->pszNetwork);
168 if (!pCtx->pszNetwork)
169 {
170 ComPtr<IHost> ptrIHost;
171 CHECK_ERROR2_RET(hrc, pCtx->pArg->virtualBox, COMGETTER(Host)(ptrIHost.asOutParam()), ptrRet);
172
173 Bstr bstrInterface(pCtx->pszInterface);
174 ComPtr<IHostNetworkInterface> ptrIHostIf;
175 CHECK_ERROR2(hrc, ptrIHost, FindHostNetworkInterfaceByName(bstrInterface.raw(), ptrIHostIf.asOutParam()));
176 if (FAILED(hrc))
177 {
178 errorArgument("Failed to locate host-only interface '%s'", pCtx->pszInterface);
179 return ptrRet;
180 }
181
182 CHECK_ERROR2_RET(hrc, ptrIHostIf, COMGETTER(NetworkName)(bstrNetName.asOutParam()), ptrRet);
183 }
184
185 /*
186 * Now, try locate the server
187 */
188 hrc = pCtx->pArg->virtualBox->FindDHCPServerByNetworkName(bstrNetName.raw(), ptrRet.asOutParam());
189 if (SUCCEEDED(hrc))
190 return ptrRet;
191 if (pCtx->pszNetwork)
192 errorArgument("Failed to find DHCP server for network '%s'", pCtx->pszNetwork);
193 else
194 errorArgument("Failed to find DHCP server for host-only interface '%s' (network '%ls')",
195 pCtx->pszInterface, bstrNetName.raw());
196 }
197 else
198 errorSyntax("You need to specify either --network or --interface to identify the DHCP server");
199 return ptrRet;
200}
201
202
203/**
204 * Helper class for dhcpdHandleAddAndModify
205 */
206class DHCPCmdScope
207{
208 DHCPConfigScope_T m_enmScope;
209 const char *m_pszName;
210 uint8_t m_uSlot;
211 ComPtr<IDHCPConfig> m_ptrConfig;
212 ComPtr<IDHCPGlobalConfig> m_ptrGlobalConfig;
213 ComPtr<IDHCPGroupConfig> m_ptrGroupConfig;
214 ComPtr<IDHCPIndividualConfig> m_ptrIndividualConfig;
215
216public:
217 DHCPCmdScope()
218 : m_enmScope(DHCPConfigScope_Global)
219 , m_pszName(NULL)
220 , m_uSlot(0)
221 {
222 }
223
224 void setGlobal()
225 {
226 m_enmScope = DHCPConfigScope_Global;
227 m_pszName = NULL;
228 m_uSlot = 0;
229 resetPointers();
230 }
231
232 void setGroup(const char *pszGroup)
233 {
234 m_enmScope = DHCPConfigScope_Group;
235 m_pszName = pszGroup;
236 m_uSlot = 0;
237 resetPointers();
238 }
239
240 void setMachineNIC(const char *pszMachine)
241 {
242 m_enmScope = DHCPConfigScope_MachineNIC;
243 m_pszName = pszMachine;
244 m_uSlot = 0;
245 resetPointers();
246 }
247
248 void setMachineSlot(uint8_t uSlot)
249 {
250 Assert(m_enmScope == DHCPConfigScope_MachineNIC);
251 m_uSlot = uSlot;
252 resetPointers();
253 }
254
255 void setMACAddress(const char *pszMACAddress)
256 {
257 m_enmScope = DHCPConfigScope_MAC;
258 m_pszName = pszMACAddress;
259 m_uSlot = 0;
260 resetPointers();
261 }
262
263 ComPtr<IDHCPConfig> &getConfig(ComPtr<IDHCPServer> const &ptrDHCPServer)
264 {
265 if (m_ptrConfig.isNull())
266 {
267 CHECK_ERROR2I_STMT(ptrDHCPServer, GetConfig(m_enmScope, Bstr(m_pszName).raw(), m_uSlot, TRUE /*mayAdd*/,
268 m_ptrConfig.asOutParam()), m_ptrConfig.setNull());
269 }
270 return m_ptrConfig;
271 }
272
273 ComPtr<IDHCPIndividualConfig> &getIndividual(ComPtr<IDHCPServer> const &ptrDHCPServer)
274 {
275 getConfig(ptrDHCPServer);
276 if (m_ptrIndividualConfig.isNull() && m_ptrConfig.isNotNull())
277 {
278 HRESULT hrc = m_ptrConfig.queryInterfaceTo(m_ptrIndividualConfig.asOutParam());
279 if (FAILED(hrc))
280 {
281 com::GlueHandleComError(m_ptrConfig, "queryInterface", hrc, __FILE__, __LINE__);
282 m_ptrIndividualConfig.setNull();
283 }
284 }
285 return m_ptrIndividualConfig;
286 }
287
288 ComPtr<IDHCPGroupConfig> &getGroup(ComPtr<IDHCPServer> const &ptrDHCPServer)
289 {
290 getConfig(ptrDHCPServer);
291 if (m_ptrGroupConfig.isNull() && m_ptrConfig.isNotNull())
292 {
293 HRESULT hrc = m_ptrConfig.queryInterfaceTo(m_ptrGroupConfig.asOutParam());
294 if (FAILED(hrc))
295 {
296 com::GlueHandleComError(m_ptrConfig, "queryInterface", hrc, __FILE__, __LINE__);
297 m_ptrGroupConfig.setNull();
298 }
299 }
300 return m_ptrGroupConfig;
301 }
302
303 DHCPConfigScope_T getScope() const { return m_enmScope; }
304
305private:
306 void resetPointers()
307 {
308 m_ptrConfig.setNull();
309 m_ptrGlobalConfig.setNull();
310 m_ptrIndividualConfig.setNull();
311 m_ptrGroupConfig.setNull();
312 }
313};
314
315enum
316{
317 DHCP_ADDMOD = 1000,
318 DHCP_ADDMOD_FORCE_OPTION,
319 DHCP_ADDMOD_UNFORCE_OPTION,
320 DHCP_ADDMOD_SUPPRESS_OPTION,
321 DHCP_ADDMOD_UNSUPPRESS_OPTION,
322 DHCP_ADDMOD_ZAP_OPTIONS,
323 DHCP_ADDMOD_INCL_MAC,
324 DHCP_ADDMOD_EXCL_MAC,
325 DHCP_ADDMOD_DEL_MAC,
326 DHCP_ADDMOD_INCL_MAC_WILD,
327 DHCP_ADDMOD_EXCL_MAC_WILD,
328 DHCP_ADDMOD_DEL_MAC_WILD,
329 DHCP_ADDMOD_INCL_VENDOR,
330 DHCP_ADDMOD_EXCL_VENDOR,
331 DHCP_ADDMOD_DEL_VENDOR,
332 DHCP_ADDMOD_INCL_VENDOR_WILD,
333 DHCP_ADDMOD_EXCL_VENDOR_WILD,
334 DHCP_ADDMOD_DEL_VENDOR_WILD,
335 DHCP_ADDMOD_INCL_USER,
336 DHCP_ADDMOD_EXCL_USER,
337 DHCP_ADDMOD_DEL_USER,
338 DHCP_ADDMOD_INCL_USER_WILD,
339 DHCP_ADDMOD_EXCL_USER_WILD,
340 DHCP_ADDMOD_DEL_USER_WILD,
341 DHCP_ADDMOD_ZAP_CONDITIONS
342};
343
344/**
345 * Handles the 'add' and 'modify' subcommands.
346 */
347static DECLCALLBACK(RTEXITCODE) dhcpdHandleAddAndModify(PDHCPDCMDCTX pCtx, int argc, char **argv)
348{
349 static const RTGETOPTDEF s_aOptions[] =
350 {
351 DHCPD_CMD_COMMON_OPTION_DEFS(),
352 { "--server-ip", 'a', RTGETOPT_REQ_STRING },
353 { "--ip", 'a', RTGETOPT_REQ_STRING }, // deprecated
354 { "-ip", 'a', RTGETOPT_REQ_STRING }, // deprecated
355 { "--netmask", 'm', RTGETOPT_REQ_STRING },
356 { "-netmask", 'm', RTGETOPT_REQ_STRING }, // deprecated
357 { "--lower-ip", 'l', RTGETOPT_REQ_STRING },
358 { "--lowerip", 'l', RTGETOPT_REQ_STRING },
359 { "-lowerip", 'l', RTGETOPT_REQ_STRING }, // deprecated
360 { "--upper-ip", 'u', RTGETOPT_REQ_STRING },
361 { "--upperip", 'u', RTGETOPT_REQ_STRING },
362 { "-upperip", 'u', RTGETOPT_REQ_STRING }, // deprecated
363 { "--enable", 'e', RTGETOPT_REQ_NOTHING },
364 { "-enable", 'e', RTGETOPT_REQ_NOTHING }, // deprecated
365 { "--disable", 'd', RTGETOPT_REQ_NOTHING },
366 { "-disable", 'd', RTGETOPT_REQ_NOTHING }, // deprecated
367 { "--global", 'g', RTGETOPT_REQ_NOTHING },
368 { "--group", 'G', RTGETOPT_REQ_STRING },
369 { "--mac-address", 'E', RTGETOPT_REQ_MACADDR },
370 { "--vm", 'M', RTGETOPT_REQ_STRING },
371 { "--nic", 'n', RTGETOPT_REQ_UINT8 },
372 { "--set-opt", 's', RTGETOPT_REQ_UINT8 },
373 { "--set-opt-hex", 'x', RTGETOPT_REQ_UINT8 },
374 { "--del-opt", 'D', RTGETOPT_REQ_UINT8 },
375 { "--force-opt", DHCP_ADDMOD_FORCE_OPTION, RTGETOPT_REQ_UINT8 },
376 { "--unforce-opt", DHCP_ADDMOD_UNFORCE_OPTION, RTGETOPT_REQ_UINT8 },
377 { "--suppress-opt", DHCP_ADDMOD_SUPPRESS_OPTION, RTGETOPT_REQ_UINT8 },
378 { "--unsuppress-opt", DHCP_ADDMOD_UNSUPPRESS_OPTION, RTGETOPT_REQ_UINT8 },
379 { "--zap-options", DHCP_ADDMOD_ZAP_OPTIONS, RTGETOPT_REQ_NOTHING },
380 { "--min-lease-time", 'q' , RTGETOPT_REQ_UINT32 },
381 { "--default-lease-time", 'L' , RTGETOPT_REQ_UINT32 },
382 { "--max-lease-time", 'Q' , RTGETOPT_REQ_UINT32 },
383 { "--remove-config", 'R', RTGETOPT_REQ_NOTHING },
384 { "--fixed-address", 'f', RTGETOPT_REQ_STRING },
385 /* group conditions: */
386 { "--incl-mac", DHCP_ADDMOD_INCL_MAC, RTGETOPT_REQ_STRING },
387 { "--excl-mac", DHCP_ADDMOD_EXCL_MAC, RTGETOPT_REQ_STRING },
388 { "--del-mac", DHCP_ADDMOD_DEL_MAC, RTGETOPT_REQ_STRING },
389 { "--incl-mac-wild", DHCP_ADDMOD_INCL_MAC_WILD, RTGETOPT_REQ_STRING },
390 { "--excl-mac-wild", DHCP_ADDMOD_EXCL_MAC_WILD, RTGETOPT_REQ_STRING },
391 { "--del-mac-wild", DHCP_ADDMOD_DEL_MAC_WILD, RTGETOPT_REQ_STRING },
392 { "--incl-vendor", DHCP_ADDMOD_INCL_VENDOR, RTGETOPT_REQ_STRING },
393 { "--excl-vendor", DHCP_ADDMOD_EXCL_VENDOR, RTGETOPT_REQ_STRING },
394 { "--del-vendor", DHCP_ADDMOD_DEL_VENDOR, RTGETOPT_REQ_STRING },
395 { "--incl-vendor-wild", DHCP_ADDMOD_INCL_VENDOR_WILD, RTGETOPT_REQ_STRING },
396 { "--excl-vendor-wild", DHCP_ADDMOD_EXCL_VENDOR_WILD, RTGETOPT_REQ_STRING },
397 { "--del-vendor-wild", DHCP_ADDMOD_DEL_VENDOR_WILD, RTGETOPT_REQ_STRING },
398 { "--incl-user", DHCP_ADDMOD_INCL_USER, RTGETOPT_REQ_STRING },
399 { "--excl-user", DHCP_ADDMOD_EXCL_USER, RTGETOPT_REQ_STRING },
400 { "--del-user", DHCP_ADDMOD_DEL_USER, RTGETOPT_REQ_STRING },
401 { "--incl-user-wild", DHCP_ADDMOD_INCL_USER_WILD, RTGETOPT_REQ_STRING },
402 { "--excl-user-wild", DHCP_ADDMOD_EXCL_USER_WILD, RTGETOPT_REQ_STRING },
403 { "--del-user-wild", DHCP_ADDMOD_DEL_USER_WILD, RTGETOPT_REQ_STRING },
404 { "--zap-conditions", DHCP_ADDMOD_ZAP_CONDITIONS, RTGETOPT_REQ_NOTHING },
405 /* obsolete, to be removed: */
406 { "--id", 'i', RTGETOPT_REQ_UINT8 }, // obsolete, backwards compatibility only.
407 { "--value", 'p', RTGETOPT_REQ_STRING }, // obsolete, backwards compatibility only.
408 { "--remove", 'r', RTGETOPT_REQ_NOTHING }, // obsolete, backwards compatibility only.
409 { "--options", 'o', RTGETOPT_REQ_NOTHING }, // obsolete legacy, ignored
410
411 };
412
413 /*
414 * Parse the arguments in two passes:
415 *
416 * 1. Validate the command line and establish the IDHCPServer settings.
417 * 2. Execute the various IDHCPConfig settings changes.
418 *
419 * This is considered simpler than duplicating the command line instructions
420 * into elaborate structures and executing these.
421 */
422 RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
423 ComPtr<IDHCPServer> ptrDHCPServer;
424 for (size_t iPass = 0; iPass < 2; iPass++)
425 {
426 const char *pszServerIp = NULL;
427 const char *pszNetmask = NULL;
428 const char *pszLowerIp = NULL;
429 const char *pszUpperIp = NULL;
430 int fEnabled = -1;
431
432 DHCPCmdScope Scope;
433 char szMACAddress[32];
434
435 bool fNeedValueOrRemove = false; /* Only used with --id; remove in 6.1+ */
436 uint8_t u8OptId = 0; /* Only used too keep --id for following --value/--remove. remove in 6.1+ */
437
438 RTGETOPTSTATE GetState;
439 int vrc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
440 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
441
442 RTGETOPTUNION ValueUnion;
443 while ((vrc = RTGetOpt(&GetState, &ValueUnion)))
444 {
445 switch (vrc)
446 {
447 DHCPD_CMD_COMMON_OPTION_CASES(pCtx, vrc, &ValueUnion);
448 case 'a': // --server-ip
449 pszServerIp = ValueUnion.psz;
450 break;
451 case 'm': // --netmask
452 pszNetmask = ValueUnion.psz;
453 break;
454 case 'l': // --lower-ip
455 pszLowerIp = ValueUnion.psz;
456 break;
457 case 'u': // --upper-ip
458 pszUpperIp = ValueUnion.psz;
459 break;
460 case 'e': // --enable
461 fEnabled = 1;
462 break;
463 case 'd': // --disable
464 fEnabled = 0;
465 break;
466
467 /*
468 * Configuration selection:
469 */
470 case 'g': // --global Sets the option scope to 'global'.
471 if (fNeedValueOrRemove)
472 return errorSyntax("Incomplete option sequence preseeding '--global'");
473 Scope.setGlobal();
474 break;
475
476 case 'G': // --group
477 if (fNeedValueOrRemove)
478 return errorSyntax("Incomplete option sequence preseeding '--group'");
479 if (!*ValueUnion.psz)
480 return errorSyntax("Group name cannot be empty");
481 Scope.setGroup(ValueUnion.psz);
482 break;
483
484 case 'E': // --mac-address
485 if (fNeedValueOrRemove)
486 return errorSyntax("Incomplete option sequence preseeding '--mac-address'");
487 RTStrPrintf(szMACAddress, sizeof(szMACAddress), "%RTmac", &ValueUnion.MacAddr);
488 Scope.setMACAddress(szMACAddress);
489 break;
490
491 case 'M': // --vm Sets the option scope to ValueUnion.psz + 0.
492 if (fNeedValueOrRemove)
493 return errorSyntax("Incomplete option sequence preseeding '--vm'");
494 Scope.setMachineNIC(ValueUnion.psz);
495 break;
496
497 case 'n': // --nic Sets the option scope to pszVmName + (ValueUnion.u8 - 1).
498 if (Scope.getScope() != DHCPConfigScope_MachineNIC)
499 return errorSyntax("--nic option requires a --vm preceeding selecting the VM it should apply to");
500 if (fNeedValueOrRemove)
501 return errorSyntax("Incomplete option sequence preseeding '--nic=%u", ValueUnion.u8);
502 if (ValueUnion.u8 < 1)
503 return errorSyntax("invalid NIC number: %u", ValueUnion.u8);
504 Scope.setMachineSlot(ValueUnion.u8 - 1);
505 break;
506
507 /*
508 * Modify configuration:
509 */
510 case 's': // --set-opt num stringvalue
511 {
512 uint8_t const idAddOpt = ValueUnion.u8;
513 vrc = RTGetOptFetchValue(&GetState, &ValueUnion, RTGETOPT_REQ_STRING);
514 if (RT_FAILURE(vrc))
515 return errorFetchValue(1, "--set-opt", vrc, &ValueUnion);
516 if (iPass == 1)
517 {
518 ComPtr<IDHCPConfig> &ptrConfig = Scope.getConfig(ptrDHCPServer);
519 if (ptrConfig.isNull())
520 return RTEXITCODE_FAILURE;
521 CHECK_ERROR2I_STMT(ptrConfig, SetOption((DHCPOption_T)idAddOpt, DHCPOptionEncoding_Normal,
522 Bstr(ValueUnion.psz).raw()), rcExit = RTEXITCODE_FAILURE);
523 }
524 break;
525 }
526
527 case 'x': // --set-opt-hex num hex-string
528 {
529 uint8_t const idAddOpt = ValueUnion.u8;
530 vrc = RTGetOptFetchValue(&GetState, &ValueUnion, RTGETOPT_REQ_STRING);
531 if (RT_FAILURE(vrc))
532 return errorFetchValue(1, "--set-opt-hex", vrc, &ValueUnion);
533 uint8_t abBuf[256];
534 size_t cbRet;
535 vrc = RTStrConvertHexBytesEx(ValueUnion.psz, abBuf, sizeof(abBuf), RTSTRCONVERTHEXBYTES_F_SEP_COLON,
536 NULL, &cbRet);
537 if (RT_FAILURE(vrc))
538 return errorArgument("Malformed hex string given to --set-opt-hex %u: %s\n", idAddOpt, ValueUnion.psz);
539 if (iPass == 1)
540 {
541 ComPtr<IDHCPConfig> &ptrConfig = Scope.getConfig(ptrDHCPServer);
542 if (ptrConfig.isNull())
543 return RTEXITCODE_FAILURE;
544 CHECK_ERROR2I_STMT(ptrConfig, SetOption((DHCPOption_T)idAddOpt, DHCPOptionEncoding_Hex,
545 Bstr(ValueUnion.psz).raw()), rcExit = RTEXITCODE_FAILURE);
546 }
547 break;
548 }
549
550 case 'D': // --del-opt num
551 if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
552 return errorSyntax("--del-opt does not apply to the 'add' subcommand");
553 if (iPass == 1)
554 {
555 ComPtr<IDHCPConfig> &ptrConfig = Scope.getConfig(ptrDHCPServer);
556 if (ptrConfig.isNull())
557 return RTEXITCODE_FAILURE;
558 CHECK_ERROR2I_STMT(ptrConfig, RemoveOption((DHCPOption_T)ValueUnion.u8), rcExit = RTEXITCODE_FAILURE);
559 }
560 break;
561
562 case DHCP_ADDMOD_UNFORCE_OPTION: // --unforce-opt
563 if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
564 return errorSyntax("--unforce-opt does not apply to the 'add' subcommand");
565 RT_FALL_THROUGH();
566 case DHCP_ADDMOD_UNSUPPRESS_OPTION: // --unsupress-opt
567 if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
568 return errorSyntax("--unsuppress-opt does not apply to the 'add' subcommand");
569 RT_FALL_THROUGH();
570 case DHCP_ADDMOD_FORCE_OPTION: // --force-opt
571 case DHCP_ADDMOD_SUPPRESS_OPTION: // --suppress-opt
572 if (iPass == 1)
573 {
574 DHCPOption_T const enmOption = (DHCPOption_T)ValueUnion.u8;
575 bool const fForced = vrc == DHCP_ADDMOD_FORCE_OPTION || vrc == DHCP_ADDMOD_UNFORCE_OPTION;
576
577 /* Get the current option list: */
578 ComPtr<IDHCPConfig> &ptrConfig = Scope.getConfig(ptrDHCPServer);
579 if (ptrConfig.isNull())
580 return RTEXITCODE_FAILURE;
581 com::SafeArray<DHCPOption_T> Options;
582 if (fForced)
583 CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(ForcedOptions)(ComSafeArrayAsOutParam(Options)),
584 rcExit = RTEXITCODE_FAILURE; break);
585 else
586 CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(SuppressedOptions)(ComSafeArrayAsOutParam(Options)),
587 rcExit = RTEXITCODE_FAILURE; break);
588 if (vrc == DHCP_ADDMOD_FORCE_OPTION || vrc == DHCP_ADDMOD_SUPPRESS_OPTION)
589 {
590 /* Add if not present. */
591 size_t iSrc;
592 for (iSrc = 0; iSrc < Options.size(); iSrc++)
593 if (Options[iSrc] == enmOption)
594 break;
595 if (iSrc < Options.size())
596 break; /* already present */
597 Options.push_back(enmOption);
598 }
599 else
600 {
601 /* Remove */
602 size_t iDst = 0;
603 for (size_t iSrc = 0; iSrc < Options.size(); iSrc++)
604 {
605 DHCPOption_T enmCurOpt = Options[iSrc];
606 if (enmCurOpt != enmOption)
607 Options[iDst++] = enmCurOpt;
608 }
609 if (iDst == Options.size())
610 break; /* Not found. */
611 Options.resize(iDst);
612 }
613
614 /* Update the option list: */
615 if (fForced)
616 CHECK_ERROR2I_STMT(ptrConfig, COMSETTER(ForcedOptions)(ComSafeArrayAsInParam(Options)),
617 rcExit = RTEXITCODE_FAILURE);
618 else
619 CHECK_ERROR2I_STMT(ptrConfig, COMSETTER(SuppressedOptions)(ComSafeArrayAsInParam(Options)),
620 rcExit = RTEXITCODE_FAILURE);
621 }
622 break;
623
624 case DHCP_ADDMOD_ZAP_OPTIONS:
625 if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
626 return errorSyntax("--zap-options does not apply to the 'add' subcommand");
627 if (iPass == 1)
628 {
629 ComPtr<IDHCPConfig> &ptrConfig = Scope.getConfig(ptrDHCPServer);
630 if (ptrConfig.isNull())
631 return RTEXITCODE_FAILURE;
632 CHECK_ERROR2I_STMT(ptrConfig, RemoveAllOptions(), rcExit = RTEXITCODE_FAILURE);
633 }
634 break;
635
636 case 'q': // --min-lease-time
637 if (iPass == 1)
638 {
639 ComPtr<IDHCPConfig> &ptrConfig = Scope.getConfig(ptrDHCPServer);
640 if (ptrConfig.isNull())
641 return RTEXITCODE_FAILURE;
642 CHECK_ERROR2I_STMT(ptrConfig, COMSETTER(MinLeaseTime)(ValueUnion.u32), rcExit = RTEXITCODE_FAILURE);
643 }
644 break;
645
646 case 'L': // --default-lease-time
647 if (iPass == 1)
648 {
649 ComPtr<IDHCPConfig> &ptrConfig = Scope.getConfig(ptrDHCPServer);
650 if (ptrConfig.isNull())
651 return RTEXITCODE_FAILURE;
652 CHECK_ERROR2I_STMT(ptrConfig, COMSETTER(DefaultLeaseTime)(ValueUnion.u32), rcExit = RTEXITCODE_FAILURE);
653 }
654 break;
655
656 case 'Q': // --max-lease-time
657 if (iPass == 1)
658 {
659 ComPtr<IDHCPConfig> &ptrConfig = Scope.getConfig(ptrDHCPServer);
660 if (ptrConfig.isNull())
661 return RTEXITCODE_FAILURE;
662 CHECK_ERROR2I_STMT(ptrConfig, COMSETTER(MaxLeaseTime)(ValueUnion.u32), rcExit = RTEXITCODE_FAILURE);
663 }
664 break;
665
666 case 'R': // --remove-config
667 if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
668 return errorSyntax("--remove-config does not apply to the 'add' subcommand");
669 if (Scope.getScope() == DHCPConfigScope_Global)
670 return errorSyntax("--remove-config cannot be applied to the global config");
671 if (iPass == 1)
672 {
673 ComPtr<IDHCPConfig> &ptrConfig = Scope.getConfig(ptrDHCPServer);
674 if (ptrConfig.isNull())
675 return RTEXITCODE_FAILURE;
676 CHECK_ERROR2I_STMT(ptrConfig, Remove(), rcExit = RTEXITCODE_FAILURE);
677 }
678 Scope.setGlobal();
679 break;
680
681 case 'f': // --fixed-address
682 if (Scope.getScope() != DHCPConfigScope_MachineNIC && Scope.getScope() != DHCPConfigScope_MAC)
683 return errorSyntax("--fixed-address can only be applied to a VM NIC or an MAC address");
684 if (iPass == 1)
685 {
686 ComPtr<IDHCPIndividualConfig> &ptrIndividualConfig = Scope.getIndividual(ptrDHCPServer);
687 if (ptrIndividualConfig.isNull())
688 return RTEXITCODE_FAILURE;
689 CHECK_ERROR2I_STMT(ptrIndividualConfig, COMSETTER(FixedAddress)(Bstr(ValueUnion.psz).raw()),
690 rcExit = RTEXITCODE_FAILURE);
691 }
692 break;
693
694 /*
695 * Group conditions:
696 */
697 case DHCP_ADDMOD_INCL_MAC:
698 case DHCP_ADDMOD_EXCL_MAC:
699 case DHCP_ADDMOD_DEL_MAC:
700 case DHCP_ADDMOD_INCL_MAC_WILD:
701 case DHCP_ADDMOD_EXCL_MAC_WILD:
702 case DHCP_ADDMOD_DEL_MAC_WILD:
703 case DHCP_ADDMOD_INCL_VENDOR:
704 case DHCP_ADDMOD_EXCL_VENDOR:
705 case DHCP_ADDMOD_DEL_VENDOR:
706 case DHCP_ADDMOD_INCL_VENDOR_WILD:
707 case DHCP_ADDMOD_EXCL_VENDOR_WILD:
708 case DHCP_ADDMOD_DEL_VENDOR_WILD:
709 case DHCP_ADDMOD_INCL_USER:
710 case DHCP_ADDMOD_EXCL_USER:
711 case DHCP_ADDMOD_DEL_USER:
712 case DHCP_ADDMOD_INCL_USER_WILD:
713 case DHCP_ADDMOD_EXCL_USER_WILD:
714 case DHCP_ADDMOD_DEL_USER_WILD:
715 {
716 if (Scope.getScope() != DHCPConfigScope_Group)
717 return errorSyntax("A group must be selected to perform condition alterations.");
718 if (!*ValueUnion.psz)
719 return errorSyntax("Condition value cannot be empty"); /* or can it? */
720 if (iPass != 1)
721 break;
722
723 DHCPGroupConditionType_T enmType;
724 switch (vrc)
725 {
726 case DHCP_ADDMOD_INCL_MAC: case DHCP_ADDMOD_EXCL_MAC: case DHCP_ADDMOD_DEL_MAC:
727 enmType = DHCPGroupConditionType_MAC;
728 break;
729 case DHCP_ADDMOD_INCL_MAC_WILD: case DHCP_ADDMOD_EXCL_MAC_WILD: case DHCP_ADDMOD_DEL_MAC_WILD:
730 enmType = DHCPGroupConditionType_MACWildcard;
731 break;
732 case DHCP_ADDMOD_INCL_VENDOR: case DHCP_ADDMOD_EXCL_VENDOR: case DHCP_ADDMOD_DEL_VENDOR:
733 enmType = DHCPGroupConditionType_vendorClassID;
734 break;
735 case DHCP_ADDMOD_INCL_VENDOR_WILD: case DHCP_ADDMOD_EXCL_VENDOR_WILD: case DHCP_ADDMOD_DEL_VENDOR_WILD:
736 enmType = DHCPGroupConditionType_vendorClassIDWildcard;
737 break;
738 case DHCP_ADDMOD_INCL_USER: case DHCP_ADDMOD_EXCL_USER: case DHCP_ADDMOD_DEL_USER:
739 enmType = DHCPGroupConditionType_userClassID;
740 break;
741 case DHCP_ADDMOD_INCL_USER_WILD: case DHCP_ADDMOD_EXCL_USER_WILD: case DHCP_ADDMOD_DEL_USER_WILD:
742 enmType = DHCPGroupConditionType_userClassIDWildcard;
743 break;
744 default:
745 AssertFailedReturn(RTEXITCODE_FAILURE);
746 }
747
748 int fInclusive;
749 switch (vrc)
750 {
751 case DHCP_ADDMOD_DEL_MAC:
752 case DHCP_ADDMOD_DEL_MAC_WILD:
753 case DHCP_ADDMOD_DEL_USER:
754 case DHCP_ADDMOD_DEL_USER_WILD:
755 case DHCP_ADDMOD_DEL_VENDOR:
756 case DHCP_ADDMOD_DEL_VENDOR_WILD:
757 fInclusive = -1;
758 break;
759 case DHCP_ADDMOD_EXCL_MAC:
760 case DHCP_ADDMOD_EXCL_MAC_WILD:
761 case DHCP_ADDMOD_EXCL_USER:
762 case DHCP_ADDMOD_EXCL_USER_WILD:
763 case DHCP_ADDMOD_EXCL_VENDOR:
764 case DHCP_ADDMOD_EXCL_VENDOR_WILD:
765 fInclusive = 0;
766 break;
767 case DHCP_ADDMOD_INCL_MAC:
768 case DHCP_ADDMOD_INCL_MAC_WILD:
769 case DHCP_ADDMOD_INCL_USER:
770 case DHCP_ADDMOD_INCL_USER_WILD:
771 case DHCP_ADDMOD_INCL_VENDOR:
772 case DHCP_ADDMOD_INCL_VENDOR_WILD:
773 fInclusive = 1;
774 break;
775 default:
776 AssertFailedReturn(RTEXITCODE_FAILURE);
777 }
778
779 ComPtr<IDHCPGroupConfig> &ptrGroupConfig = Scope.getGroup(ptrDHCPServer);
780 if (ptrGroupConfig.isNull())
781 return RTEXITCODE_FAILURE;
782 if (fInclusive >= 0)
783 {
784 ComPtr<IDHCPGroupCondition> ptrCondition;
785 CHECK_ERROR2I_STMT(ptrGroupConfig, AddCondition((BOOL)fInclusive, enmType, Bstr(ValueUnion.psz).raw(),
786 ptrCondition.asOutParam()), rcExit = RTEXITCODE_FAILURE);
787 }
788 else
789 {
790 com::SafeIfaceArray<IDHCPGroupCondition> Conditions;
791 CHECK_ERROR2I_STMT(ptrGroupConfig, COMGETTER(Conditions)(ComSafeArrayAsOutParam(Conditions)),
792 rcExit = RTEXITCODE_FAILURE; break);
793 bool fFound = false;
794 for (size_t iCond = 0; iCond < Conditions.size(); iCond++)
795 {
796 DHCPGroupConditionType_T enmCurType = DHCPGroupConditionType_MAC;
797 CHECK_ERROR2I_STMT(Conditions[iCond], COMGETTER(Type)(&enmCurType),
798 rcExit = RTEXITCODE_FAILURE; continue);
799 if (enmCurType == enmType)
800 {
801 Bstr bstrValue;
802 CHECK_ERROR2I_STMT(Conditions[iCond], COMGETTER(Value)(bstrValue.asOutParam()),
803 rcExit = RTEXITCODE_FAILURE; continue);
804 if (RTUtf16CmpUtf8(bstrValue.raw(), ValueUnion.psz) == 0)
805 {
806 CHECK_ERROR2I_STMT(Conditions[iCond], Remove(), rcExit = RTEXITCODE_FAILURE);
807 fFound = true;
808 }
809 }
810 }
811 if (!fFound)
812 rcExit = RTMsgErrorExitFailure("Could not find any condition of type %d with value '%s' to delete",
813 enmType, ValueUnion.psz);
814 }
815 break;
816 }
817
818 case DHCP_ADDMOD_ZAP_CONDITIONS:
819 if (Scope.getScope() != DHCPConfigScope_Group)
820 return errorSyntax("--zap-conditions can only be with a group selected");
821 if (iPass == 1)
822 {
823 ComPtr<IDHCPGroupConfig> &ptrGroupConfig = Scope.getGroup(ptrDHCPServer);
824 if (ptrGroupConfig.isNull())
825 return RTEXITCODE_FAILURE;
826 CHECK_ERROR2I_STMT(ptrGroupConfig, RemoveAllConditions(), rcExit = RTEXITCODE_FAILURE);
827 }
828 break;
829
830 /*
831 * For backwards compatibility. Remove in 6.1 or later.
832 */
833
834 case 'o': // --options - obsolete, ignored.
835 break;
836
837 case 'i': // --id
838 if (fNeedValueOrRemove)
839 return errorSyntax("Incomplete option sequence preseeding '--id=%u", ValueUnion.u8);
840 u8OptId = ValueUnion.u8;
841 fNeedValueOrRemove = true;
842 break;
843
844 case 'p': // --value
845 if (!fNeedValueOrRemove)
846 return errorSyntax("--value without --id=dhcp-opt-no");
847 if (iPass == 1)
848 {
849 ComPtr<IDHCPConfig> &ptrConfig = Scope.getConfig(ptrDHCPServer);
850 if (ptrConfig.isNull())
851 return RTEXITCODE_FAILURE;
852 CHECK_ERROR2I_STMT(ptrConfig, SetOption((DHCPOption_T)u8OptId, DHCPOptionEncoding_Normal,
853 Bstr(ValueUnion.psz).raw()), rcExit = RTEXITCODE_FAILURE);
854 }
855 fNeedValueOrRemove = false;
856 break;
857
858 case 'r': // --remove
859 if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
860 return errorSyntax("--remove does not apply to the 'add' subcommand");
861 if (!fNeedValueOrRemove)
862 return errorSyntax("--remove without --id=dhcp-opt-no");
863
864 if (iPass == 1)
865 {
866 ComPtr<IDHCPConfig> &ptrConfig = Scope.getConfig(ptrDHCPServer);
867 if (ptrConfig.isNull())
868 return RTEXITCODE_FAILURE;
869 CHECK_ERROR2I_STMT(ptrConfig, RemoveOption((DHCPOption_T)u8OptId), rcExit = RTEXITCODE_FAILURE);
870 }
871 fNeedValueOrRemove = false;
872 break;
873
874 default:
875 return errorGetOpt(vrc, &ValueUnion);
876 }
877 }
878
879 if (iPass != 0)
880 break;
881
882 /*
883 * Ensure we've got mandatory options and supply defaults
884 * where needed (modify case)
885 */
886 if (!pCtx->pszNetwork && !pCtx->pszInterface)
887 return errorSyntax("You need to specify either --network or --interface to identify the DHCP server");
888
889 if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
890 {
891 if (!pszServerIp)
892 rcExit = errorSyntax("Missing required option: --ip");
893 if (!pszNetmask)
894 rcExit = errorSyntax("Missing required option: --netmask");
895 if (!pszLowerIp)
896 rcExit = errorSyntax("Missing required option: --lowerip");
897 if (!pszUpperIp)
898 rcExit = errorSyntax("Missing required option: --upperip");
899 if (rcExit != RTEXITCODE_SUCCESS)
900 return rcExit;
901 }
902
903 /*
904 * Find or create the server.
905 */
906 HRESULT rc;
907 Bstr NetName;
908 if (!pCtx->pszNetwork)
909 {
910 ComPtr<IHost> host;
911 CHECK_ERROR(pCtx->pArg->virtualBox, COMGETTER(Host)(host.asOutParam()));
912
913 ComPtr<IHostNetworkInterface> hif;
914 CHECK_ERROR(host, FindHostNetworkInterfaceByName(Bstr(pCtx->pszInterface).mutableRaw(), hif.asOutParam()));
915 if (FAILED(rc))
916 return errorArgument("Could not find interface '%s'", pCtx->pszInterface);
917
918 CHECK_ERROR(hif, COMGETTER(NetworkName) (NetName.asOutParam()));
919 if (FAILED(rc))
920 return errorArgument("Could not get network name for the interface '%s'", pCtx->pszInterface);
921 }
922 else
923 {
924 NetName = Bstr(pCtx->pszNetwork);
925 }
926
927 rc = pCtx->pArg->virtualBox->FindDHCPServerByNetworkName(NetName.mutableRaw(), ptrDHCPServer.asOutParam());
928 if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
929 {
930 if (SUCCEEDED(rc))
931 return errorArgument("DHCP server already exists");
932
933 CHECK_ERROR(pCtx->pArg->virtualBox, CreateDHCPServer(NetName.mutableRaw(), ptrDHCPServer.asOutParam()));
934 if (FAILED(rc))
935 return errorArgument("Failed to create the DHCP server");
936 }
937 else if (FAILED(rc))
938 return errorArgument("DHCP server does not exist");
939
940 /*
941 * Apply IDHCPServer settings:
942 */
943 HRESULT hrc;
944 if (pszServerIp || pszNetmask || pszLowerIp || pszUpperIp)
945 {
946 Bstr bstrServerIp(pszServerIp);
947 Bstr bstrNetmask(pszNetmask);
948 Bstr bstrLowerIp(pszLowerIp);
949 Bstr bstrUpperIp(pszUpperIp);
950
951 if (!pszServerIp)
952 {
953 CHECK_ERROR2_RET(hrc, ptrDHCPServer, COMGETTER(IPAddress)(bstrServerIp.asOutParam()), RTEXITCODE_FAILURE);
954 }
955 if (!pszNetmask)
956 {
957 CHECK_ERROR2_RET(hrc, ptrDHCPServer, COMGETTER(NetworkMask)(bstrNetmask.asOutParam()), RTEXITCODE_FAILURE);
958 }
959 if (!pszLowerIp)
960 {
961 CHECK_ERROR2_RET(hrc, ptrDHCPServer, COMGETTER(LowerIP)(bstrLowerIp.asOutParam()), RTEXITCODE_FAILURE);
962 }
963 if (!pszUpperIp)
964 {
965 CHECK_ERROR2_RET(hrc, ptrDHCPServer, COMGETTER(UpperIP)(bstrUpperIp.asOutParam()), RTEXITCODE_FAILURE);
966 }
967
968 CHECK_ERROR2_STMT(hrc, ptrDHCPServer, SetConfiguration(bstrServerIp.raw(), bstrNetmask.raw(),
969 bstrLowerIp.raw(), bstrUpperIp.raw()),
970 rcExit = errorArgument("Failed to set configuration (%ls, %ls, %ls, %ls)", bstrServerIp.raw(),
971 bstrNetmask.raw(), bstrLowerIp.raw(), bstrUpperIp.raw()));
972 }
973
974 if (fEnabled >= 0)
975 {
976 CHECK_ERROR2_STMT(hrc, ptrDHCPServer, COMSETTER(Enabled)((BOOL)fEnabled), rcExit = RTEXITCODE_FAILURE);
977 }
978 }
979
980 return rcExit;
981}
982
983
984/**
985 * Handles the 'remove' subcommand.
986 */
987static DECLCALLBACK(RTEXITCODE) dhcpdHandleRemove(PDHCPDCMDCTX pCtx, int argc, char **argv)
988{
989 /*
990 * Parse the command line.
991 */
992 static const RTGETOPTDEF s_aOptions[] =
993 {
994 DHCPD_CMD_COMMON_OPTION_DEFS(),
995 };
996
997 RTGETOPTSTATE GetState;
998 int vrc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
999 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1000
1001 RTGETOPTUNION ValueUnion;
1002 while ((vrc = RTGetOpt(&GetState, &ValueUnion)))
1003 {
1004 switch (vrc)
1005 {
1006 DHCPD_CMD_COMMON_OPTION_CASES(pCtx, vrc, &ValueUnion);
1007 default:
1008 return errorGetOpt(vrc, &ValueUnion);
1009 }
1010 }
1011
1012 /*
1013 * Locate the server and perform the requested operation.
1014 */
1015 ComPtr<IDHCPServer> ptrDHCPServer = dhcpdFindServer(pCtx);
1016 if (ptrDHCPServer.isNotNull())
1017 {
1018 HRESULT hrc;
1019 CHECK_ERROR2(hrc, pCtx->pArg->virtualBox, RemoveDHCPServer(ptrDHCPServer));
1020 if (SUCCEEDED(hrc))
1021 return RTEXITCODE_SUCCESS;
1022 errorArgument("Failed to remove server");
1023 }
1024 return RTEXITCODE_FAILURE;
1025}
1026
1027
1028/**
1029 * Handles the 'restart' subcommand.
1030 */
1031static DECLCALLBACK(RTEXITCODE) dhcpdHandleRestart(PDHCPDCMDCTX pCtx, int argc, char **argv)
1032{
1033 /*
1034 * Parse the command line.
1035 */
1036 static const RTGETOPTDEF s_aOptions[] =
1037 {
1038 DHCPD_CMD_COMMON_OPTION_DEFS(),
1039 };
1040
1041 RTGETOPTSTATE GetState;
1042 int vrc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
1043 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1044
1045 RTGETOPTUNION ValueUnion;
1046 while ((vrc = RTGetOpt(&GetState, &ValueUnion)))
1047 {
1048 switch (vrc)
1049 {
1050 DHCPD_CMD_COMMON_OPTION_CASES(pCtx, vrc, &ValueUnion);
1051 default:
1052 return errorGetOpt(vrc, &ValueUnion);
1053 }
1054 }
1055
1056 /*
1057 * Locate the server and perform the requested operation.
1058 */
1059 ComPtr<IDHCPServer> ptrDHCPServer = dhcpdFindServer(pCtx);
1060 if (ptrDHCPServer.isNotNull())
1061 {
1062 HRESULT hrc;
1063 CHECK_ERROR2(hrc, ptrDHCPServer, Restart());
1064 if (SUCCEEDED(hrc))
1065 return RTEXITCODE_SUCCESS;
1066 errorArgument("Failed to restart server");
1067 }
1068 return RTEXITCODE_FAILURE;
1069}
1070
1071
1072/**
1073 * Handles the 'findlease' subcommand.
1074 */
1075static DECLCALLBACK(RTEXITCODE) dhcpdHandleFindLease(PDHCPDCMDCTX pCtx, int argc, char **argv)
1076{
1077 /*
1078 * Parse the command line.
1079 */
1080 static const RTGETOPTDEF s_aOptions[] =
1081 {
1082 DHCPD_CMD_COMMON_OPTION_DEFS(),
1083 { "--mac-address", 'm', RTGETOPT_REQ_MACADDR },
1084
1085 };
1086
1087 bool fHaveMacAddress = false;
1088 RTMAC MacAddress = { { 0, 0, 0, 0, 0, 0 } };
1089
1090 RTGETOPTSTATE GetState;
1091 int vrc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
1092 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1093
1094 RTGETOPTUNION ValueUnion;
1095 while ((vrc = RTGetOpt(&GetState, &ValueUnion)))
1096 {
1097 switch (vrc)
1098 {
1099 DHCPD_CMD_COMMON_OPTION_CASES(pCtx, vrc, &ValueUnion);
1100
1101 case 'm': // --mac-address
1102 fHaveMacAddress = true;
1103 MacAddress = ValueUnion.MacAddr;
1104 break;
1105
1106 default:
1107 return errorGetOpt(vrc, &ValueUnion);
1108 }
1109 }
1110
1111 if (!fHaveMacAddress)
1112 return errorSyntax("You need to specify a MAC address too look for");
1113
1114 /*
1115 * Locate the server and perform the requested operation.
1116 */
1117 ComPtr<IDHCPServer> ptrDHCPServer = dhcpdFindServer(pCtx);
1118 if (ptrDHCPServer.isNull())
1119 return RTEXITCODE_FAILURE;
1120
1121 char szMac[32];
1122 RTStrPrintf(szMac, sizeof(szMac), "%RTmac", &MacAddress);
1123 Bstr bstrAddress;
1124 Bstr bstrState;
1125 LONG64 secIssued = 0;
1126 LONG64 secExpire = 0;
1127 HRESULT hrc;
1128 CHECK_ERROR2(hrc, ptrDHCPServer, FindLeaseByMAC(Bstr(szMac).raw(), 0 /*type*/,
1129 bstrAddress.asOutParam(), bstrState.asOutParam(), &secIssued, &secExpire));
1130 if (SUCCEEDED(hrc))
1131 {
1132 RTTIMESPEC TimeSpec;
1133 int64_t cSecLeftToLive = secExpire - RTTimeSpecGetSeconds(RTTimeNow(&TimeSpec));
1134 RTTIME Time;
1135 char szIssued[RTTIME_STR_LEN];
1136 RTTimeToStringEx(RTTimeExplode(&Time, RTTimeSpecSetSeconds(&TimeSpec, secIssued)), szIssued, sizeof(szIssued), 0);
1137 char szExpire[RTTIME_STR_LEN];
1138 RTTimeToStringEx(RTTimeExplode(&Time, RTTimeSpecSetSeconds(&TimeSpec, secExpire)), szExpire, sizeof(szExpire), 0);
1139
1140 RTPrintf("IP Address: %ls\n"
1141 "MAC Address: %RTmac\n"
1142 "State: %ls\n"
1143 "Issued: %s (%RU64)\n"
1144 "Expire: %s (%RU64)\n"
1145 "TTL: %RU64 sec, currently %RU64 sec left\n",
1146 bstrAddress.raw(),
1147 &MacAddress,
1148 bstrState.raw(),
1149 szIssued, secIssued,
1150 szExpire, secExpire,
1151 secExpire >= secIssued ? secExpire - secIssued : 0, cSecLeftToLive > 0 ? cSecLeftToLive : 0);
1152 return RTEXITCODE_SUCCESS;
1153 }
1154 return RTEXITCODE_FAILURE;
1155}
1156
1157
1158/**
1159 * Handles the 'dhcpserver' command.
1160 */
1161RTEXITCODE handleDHCPServer(HandlerArg *pArg)
1162{
1163 /*
1164 * Command definitions.
1165 */
1166 static const DHCPDCMDDEF s_aCmdDefs[] =
1167 {
1168 { "add", dhcpdHandleAddAndModify, HELP_SCOPE_DHCPSERVER_ADD },
1169 { "modify", dhcpdHandleAddAndModify, HELP_SCOPE_DHCPSERVER_MODIFY },
1170 { "remove", dhcpdHandleRemove, HELP_SCOPE_DHCPSERVER_REMOVE },
1171 { "restart", dhcpdHandleRestart, HELP_SCOPE_DHCPSERVER_RESTART },
1172 { "findlease", dhcpdHandleFindLease, HELP_SCOPE_DHCPSERVER_FINDLEASE },
1173 };
1174
1175 /*
1176 * VBoxManage dhcpserver [common-options] subcommand ...
1177 */
1178 DHCPDCMDCTX CmdCtx;
1179 CmdCtx.pArg = pArg;
1180 CmdCtx.pCmdDef = NULL;
1181 CmdCtx.pszInterface = NULL;
1182 CmdCtx.pszNetwork = NULL;
1183
1184 static const RTGETOPTDEF s_CommonOptions[] = { DHCPD_CMD_COMMON_OPTION_DEFS() };
1185 RTGETOPTSTATE GetState;
1186 int vrc = RTGetOptInit(&GetState, pArg->argc, pArg->argv, s_CommonOptions, RT_ELEMENTS(s_CommonOptions), 0,
1187 0 /* No sorting! */);
1188 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1189
1190 RTGETOPTUNION ValueUnion;
1191 while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
1192 {
1193 switch (vrc)
1194 {
1195 DHCPD_CMD_COMMON_OPTION_CASES(&CmdCtx, vrc, &ValueUnion);
1196
1197 case VINF_GETOPT_NOT_OPTION:
1198 {
1199 const char *pszCmd = ValueUnion.psz;
1200 uint32_t iCmd;
1201 for (iCmd = 0; iCmd < RT_ELEMENTS(s_aCmdDefs); iCmd++)
1202 if (strcmp(s_aCmdDefs[iCmd].pszName, pszCmd) == 0)
1203 {
1204 CmdCtx.pCmdDef = &s_aCmdDefs[iCmd];
1205 setCurrentSubcommand(s_aCmdDefs[iCmd].fSubcommandScope);
1206 return s_aCmdDefs[iCmd].pfnHandler(&CmdCtx, pArg->argc - GetState.iNext + 1,
1207 &pArg->argv[GetState.iNext - 1]);
1208 }
1209 return errorUnknownSubcommand(pszCmd);
1210 }
1211
1212 default:
1213 return errorGetOpt(vrc, &ValueUnion);
1214 }
1215 }
1216 return errorNoSubcommand();
1217}
1218
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use