VBoxManageDHCPServer.cpp@ 88079

Last change on this file since 88079 was 86820, checked in by vboxsync, 4 years ago
VBoxManage/dhcpserver: Added 'start' and 'stop' sub-commands since 'restart' it to braindead to restart a DHCP server that quit on its own (restart only works if the server is still running).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 54.8 KB

Line
1	/* $Id: VBoxManageDHCPServer.cpp 86820 2020-11-06 11:54:23Z vboxsync $ */
2	/** @file
3	* VBoxManage - Implementation of dhcpserver command.
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
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
44	using 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. */
77	typedef struct DHCPDCMDCTX *PDHCPDCMDCTX;
78
79	/**
80	* Definition of a dhcpserver command, with handler and various flags.
81	*/
82	typedef 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. */
98	typedef DHCPDCMDDEF const *PCDHCPDCMDDEF;
99
100	/**
101	* dhcpserver command context (mainly for carrying common options and such).
102	*/
103	typedef 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
115	typedef std::pair<DHCPOption_T, Utf8Str> DhcpOptSpec;
116	typedef std::vector<DhcpOptSpec> DhcpOpts;
117	typedef DhcpOpts::iterator DhcpOptIterator;
118
119	typedef std::vector<DHCPOption_T> DhcpOptIds;
120	typedef DhcpOptIds::iterator DhcpOptIdIterator;
121
122	struct 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
140	typedef std::map<VmNameSlotKey, DhcpOpts> VmSlot2OptionsM;
141	typedef VmSlot2OptionsM::iterator VmSlot2OptionsIterator;
142	typedef VmSlot2OptionsM::value_type VmSlot2OptionsPair;
143
144	typedef std::map<VmNameSlotKey, DhcpOptIds> VmSlot2OptionIdsM;
145	typedef 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	*/
155	static 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	*/
206	class 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
216	public:
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
305	private:
306	void resetPointers()
307	{
308	m_ptrConfig.setNull();
309	m_ptrGlobalConfig.setNull();
310	m_ptrIndividualConfig.setNull();
311	m_ptrGroupConfig.setNull();
312	}
313	};
314
315	enum
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	*/
347	static 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	*/
987	static 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 'start' subcommand.
1030	*/
1031	static DECLCALLBACK(RTEXITCODE) dhcpdHandleStart(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.
1058	*/
1059	ComPtr<IDHCPServer> ptrDHCPServer = dhcpdFindServer(pCtx);
1060	if (ptrDHCPServer.isNotNull())
1061	{
1062	/*
1063	* We have to figure out the trunk name and type here, which is silly to
1064	* leave to the API client as it's a pain to get right. But here we go...
1065	*/
1066	static char const s_szHostOnlyPrefix[] = "HostInterfaceNetworking-";
1067	bool fHostOnly = true;
1068	Bstr strTrunkName;
1069	if (pCtx->pszInterface)
1070	strTrunkName = pCtx->pszInterface;
1071	else if (RTStrStartsWith(pCtx->pszNetwork, s_szHostOnlyPrefix))
1072	strTrunkName = &pCtx->pszNetwork[sizeof(s_szHostOnlyPrefix) - 1];
1073	else
1074	fHostOnly = false;
1075
1076	Bstr strTrunkType;
1077	if (fHostOnly)
1078	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_DARWIN)
1079	strTrunkType = "netadp";
1080	#else /* lazy implementations: */
1081	strTrunkType = "netflt";
1082	#endif
1083	else
1084	strTrunkType = "whatever";
1085
1086	HRESULT hrc = ptrDHCPServer->Start(strTrunkName.raw(), strTrunkType.raw());
1087	if (SUCCEEDED(hrc))
1088	return RTEXITCODE_SUCCESS;
1089	errorArgument("Failed to start the server");
1090	GlueHandleComErrorNoCtx(ptrDHCPServer, hrc);
1091	}
1092	return RTEXITCODE_FAILURE;
1093	}
1094
1095
1096	/**
1097	* Handles the 'restart' subcommand.
1098	*/
1099	static DECLCALLBACK(RTEXITCODE) dhcpdHandleRestart(PDHCPDCMDCTX pCtx, int argc, char **argv)
1100	{
1101	/*
1102	* Parse the command line.
1103	*/
1104	static const RTGETOPTDEF s_aOptions[] =
1105	{
1106	DHCPD_CMD_COMMON_OPTION_DEFS(),
1107	};
1108
1109	RTGETOPTSTATE GetState;
1110	int vrc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
1111	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1112
1113	RTGETOPTUNION ValueUnion;
1114	while ((vrc = RTGetOpt(&GetState, &ValueUnion)))
1115	{
1116	switch (vrc)
1117	{
1118	DHCPD_CMD_COMMON_OPTION_CASES(pCtx, vrc, &ValueUnion);
1119	default:
1120	return errorGetOpt(vrc, &ValueUnion);
1121	}
1122	}
1123
1124	/*
1125	* Locate the server and perform the requested operation.
1126	*/
1127	ComPtr<IDHCPServer> ptrDHCPServer = dhcpdFindServer(pCtx);
1128	if (ptrDHCPServer.isNotNull())
1129	{
1130	HRESULT hrc = ptrDHCPServer->Restart();
1131	if (SUCCEEDED(hrc))
1132	return RTEXITCODE_SUCCESS;
1133	errorArgument("Failed to restart the server");
1134	GlueHandleComErrorNoCtx(ptrDHCPServer, hrc);
1135	}
1136	return RTEXITCODE_FAILURE;
1137	}
1138
1139
1140	/**
1141	* Handles the 'stop' subcommand.
1142	*/
1143	static DECLCALLBACK(RTEXITCODE) dhcpdHandleStop(PDHCPDCMDCTX pCtx, int argc, char **argv)
1144	{
1145	/*
1146	* Parse the command line.
1147	*/
1148	static const RTGETOPTDEF s_aOptions[] =
1149	{
1150	DHCPD_CMD_COMMON_OPTION_DEFS(),
1151	};
1152
1153	RTGETOPTSTATE GetState;
1154	int vrc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
1155	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1156
1157	RTGETOPTUNION ValueUnion;
1158	while ((vrc = RTGetOpt(&GetState, &ValueUnion)))
1159	{
1160	switch (vrc)
1161	{
1162	DHCPD_CMD_COMMON_OPTION_CASES(pCtx, vrc, &ValueUnion);
1163	default:
1164	return errorGetOpt(vrc, &ValueUnion);
1165	}
1166	}
1167
1168	/*
1169	* Locate the server and perform the requested operation.
1170	*/
1171	ComPtr<IDHCPServer> ptrDHCPServer = dhcpdFindServer(pCtx);
1172	if (ptrDHCPServer.isNotNull())
1173	{
1174	HRESULT hrc = ptrDHCPServer->Stop();
1175	if (SUCCEEDED(hrc))
1176	return RTEXITCODE_SUCCESS;
1177	errorArgument("Failed to stop the server");
1178	GlueHandleComErrorNoCtx(ptrDHCPServer, hrc);
1179	}
1180	return RTEXITCODE_FAILURE;
1181	}
1182
1183
1184	/**
1185	* Handles the 'findlease' subcommand.
1186	*/
1187	static DECLCALLBACK(RTEXITCODE) dhcpdHandleFindLease(PDHCPDCMDCTX pCtx, int argc, char **argv)
1188	{
1189	/*
1190	* Parse the command line.
1191	*/
1192	static const RTGETOPTDEF s_aOptions[] =
1193	{
1194	DHCPD_CMD_COMMON_OPTION_DEFS(),
1195	{ "--mac-address", 'm', RTGETOPT_REQ_MACADDR },
1196
1197	};
1198
1199	bool fHaveMacAddress = false;
1200	RTMAC MacAddress = { { 0, 0, 0, 0, 0, 0 } };
1201
1202	RTGETOPTSTATE GetState;
1203	int vrc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
1204	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1205
1206	RTGETOPTUNION ValueUnion;
1207	while ((vrc = RTGetOpt(&GetState, &ValueUnion)))
1208	{
1209	switch (vrc)
1210	{
1211	DHCPD_CMD_COMMON_OPTION_CASES(pCtx, vrc, &ValueUnion);
1212
1213	case 'm': // --mac-address
1214	fHaveMacAddress = true;
1215	MacAddress = ValueUnion.MacAddr;
1216	break;
1217
1218	default:
1219	return errorGetOpt(vrc, &ValueUnion);
1220	}
1221	}
1222
1223	if (!fHaveMacAddress)
1224	return errorSyntax("You need to specify a MAC address too look for");
1225
1226	/*
1227	* Locate the server and perform the requested operation.
1228	*/
1229	ComPtr<IDHCPServer> ptrDHCPServer = dhcpdFindServer(pCtx);
1230	if (ptrDHCPServer.isNull())
1231	return RTEXITCODE_FAILURE;
1232
1233	char szMac[32];
1234	RTStrPrintf(szMac, sizeof(szMac), "%RTmac", &MacAddress);
1235	Bstr bstrAddress;
1236	Bstr bstrState;
1237	LONG64 secIssued = 0;
1238	LONG64 secExpire = 0;
1239	HRESULT hrc;
1240	CHECK_ERROR2(hrc, ptrDHCPServer, FindLeaseByMAC(Bstr(szMac).raw(), 0 /type/,
1241	bstrAddress.asOutParam(), bstrState.asOutParam(), &secIssued, &secExpire));
1242	if (SUCCEEDED(hrc))
1243	{
1244	RTTIMESPEC TimeSpec;
1245	int64_t cSecLeftToLive = secExpire - RTTimeSpecGetSeconds(RTTimeNow(&TimeSpec));
1246	RTTIME Time;
1247	char szIssued[RTTIME_STR_LEN];
1248	RTTimeToStringEx(RTTimeExplode(&Time, RTTimeSpecSetSeconds(&TimeSpec, secIssued)), szIssued, sizeof(szIssued), 0);
1249	char szExpire[RTTIME_STR_LEN];
1250	RTTimeToStringEx(RTTimeExplode(&Time, RTTimeSpecSetSeconds(&TimeSpec, secExpire)), szExpire, sizeof(szExpire), 0);
1251
1252	RTPrintf("IP Address: %ls\n"
1253	"MAC Address: %RTmac\n"
1254	"State: %ls\n"
1255	"Issued: %s (%RU64)\n"
1256	"Expire: %s (%RU64)\n"
1257	"TTL: %RU64 sec, currently %RU64 sec left\n",
1258	bstrAddress.raw(),
1259	&MacAddress,
1260	bstrState.raw(),
1261	szIssued, secIssued,
1262	szExpire, secExpire,
1263	secExpire >= secIssued ? secExpire - secIssued : 0, cSecLeftToLive > 0 ? cSecLeftToLive : 0);
1264	return RTEXITCODE_SUCCESS;
1265	}
1266	return RTEXITCODE_FAILURE;
1267	}
1268
1269
1270	/**
1271	* Handles the 'dhcpserver' command.
1272	*/
1273	RTEXITCODE handleDHCPServer(HandlerArg *pArg)
1274	{
1275	/*
1276	* Command definitions.
1277	*/
1278	static const DHCPDCMDDEF s_aCmdDefs[] =
1279	{
1280	{ "add", dhcpdHandleAddAndModify, HELP_SCOPE_DHCPSERVER_ADD },
1281	{ "modify", dhcpdHandleAddAndModify, HELP_SCOPE_DHCPSERVER_MODIFY },
1282	{ "remove", dhcpdHandleRemove, HELP_SCOPE_DHCPSERVER_REMOVE },
1283	{ "start", dhcpdHandleStart, HELP_SCOPE_DHCPSERVER_START },
1284	{ "restart", dhcpdHandleRestart, HELP_SCOPE_DHCPSERVER_RESTART },
1285	{ "stop", dhcpdHandleStop, HELP_SCOPE_DHCPSERVER_STOP },
1286	{ "findlease", dhcpdHandleFindLease, HELP_SCOPE_DHCPSERVER_FINDLEASE },
1287	};
1288
1289	/*
1290	* VBoxManage dhcpserver [common-options] subcommand ...
1291	*/
1292	DHCPDCMDCTX CmdCtx;
1293	CmdCtx.pArg = pArg;
1294	CmdCtx.pCmdDef = NULL;
1295	CmdCtx.pszInterface = NULL;
1296	CmdCtx.pszNetwork = NULL;
1297
1298	static const RTGETOPTDEF s_CommonOptions[] = { DHCPD_CMD_COMMON_OPTION_DEFS() };
1299	RTGETOPTSTATE GetState;
1300	int vrc = RTGetOptInit(&GetState, pArg->argc, pArg->argv, s_CommonOptions, RT_ELEMENTS(s_CommonOptions), 0,
1301	0 /* No sorting! */);
1302	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1303
1304	RTGETOPTUNION ValueUnion;
1305	while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
1306	{
1307	switch (vrc)
1308	{
1309	DHCPD_CMD_COMMON_OPTION_CASES(&CmdCtx, vrc, &ValueUnion);
1310
1311	case VINF_GETOPT_NOT_OPTION:
1312	{
1313	const char *pszCmd = ValueUnion.psz;
1314	uint32_t iCmd;
1315	for (iCmd = 0; iCmd < RT_ELEMENTS(s_aCmdDefs); iCmd++)
1316	if (strcmp(s_aCmdDefs[iCmd].pszName, pszCmd) == 0)
1317	{
1318	CmdCtx.pCmdDef = &s_aCmdDefs[iCmd];
1319	setCurrentSubcommand(s_aCmdDefs[iCmd].fSubcommandScope);
1320	return s_aCmdDefs[iCmd].pfnHandler(&CmdCtx, pArg->argc - GetState.iNext + 1,
1321	&pArg->argv[GetState.iNext - 1]);
1322	}
1323	return errorUnknownSubcommand(pszCmd);
1324	}
1325
1326	default:
1327	return errorGetOpt(vrc, &ValueUnion);
1328	}
1329	}
1330	return errorNoSubcommand();
1331	}
1332

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

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

Download in other formats: