1 | /* $Id: VBoxManageDHCPServer.cpp 82968 2020-02-04 10:35:17Z 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 'restart' subcommand.
|
---|
1030 | */
|
---|
1031 | static 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 | */
|
---|
1075 | static 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 | */
|
---|
1161 | RTEXITCODE 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 |
|
---|