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