Config.cpp@ 79530

Last change on this file since 79530 was 79524, checked in by vboxsync, 6 years ago
Dhcpd: s/Defs.h/DhcpdInternal.h/, s/TimeStamp/Timestamp/g, started adding comments and stuff. bugref:9288
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 26.2 KB

Line
1	/* $Id: Config.cpp 79524 2019-07-04 10:14:02Z vboxsync $ */
2	/** @file
3	* DHCP server - server configuration
4	*/
5
6	/*
7	* Copyright (C) 2017-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#include "DhcpdInternal.h"
19	#include "Config.h"
20
21	#include <iprt/ctype.h>
22	#include <iprt/net.h> /* NB: must come before getopt.h */
23	#include <iprt/getopt.h>
24	#include <iprt/path.h>
25	#include <iprt/message.h>
26	#include <iprt/string.h>
27	#include <iprt/uuid.h>
28
29	#include <VBox/com/com.h>
30
31	#include <iostream>
32
33	class ConfigFileError
34	: public RTCError
35	{
36	public:
37	ConfigFileError(const char *pszMessage)
38	: RTCError(pszMessage) {}
39
40	ConfigFileError(const RTCString &a_rstrMessage)
41	: RTCError(a_rstrMessage) {}
42	};
43
44
45	Config::Config()
46	: m_strHome(),
47	m_strNetwork(),
48	m_strBaseName(),
49	m_strTrunk(),
50	m_enmTrunkType(kIntNetTrunkType_Invalid),
51	m_MacAddress(),
52	m_IPv4Address(),
53	m_IPv4Netmask(),
54	m_IPv4PoolFirst(),
55	m_IPv4PoolLast(),
56	m_GlobalOptions(),
57	m_VMMap()
58	{
59	return;
60	}
61
62
63	int Config::init()
64	{
65	int rc;
66
67	rc = homeInit();
68	if (RT_FAILURE(rc))
69	return rc;
70
71	return VINF_SUCCESS;
72	}
73
74
75	int Config::homeInit()
76	{
77	/* pathname of ~/.VirtualBox or equivalent */
78	char szHome[RTPATH_MAX];
79	int rc = com::GetVBoxUserHomeDirectory(szHome, sizeof(szHome), false);
80	if (RT_FAILURE(rc))
81	{
82	LogDHCP(("unable to find VirtualBox home directory: %Rrs", rc));
83	return rc;
84	}
85
86	m_strHome.assign(szHome);
87	return VINF_SUCCESS;
88	}
89
90
91	void Config::setNetwork(const RTCString &aStrNetwork)
92	{
93	AssertReturnVoid(m_strNetwork.isEmpty());
94
95	m_strNetwork = aStrNetwork;
96	sanitizeBaseName();
97	}
98
99
100	/*
101	* Requires network name to be known as the log file name depends on
102	* it. Alternatively, consider passing the log file name via the
103	* command line?
104	*/
105	int Config::logInit()
106	{
107	if (m_strHome.isEmpty() \|\| m_strBaseName.isEmpty())
108	return VERR_PATH_ZERO_LENGTH;
109
110	/* default log file name */
111	char szLogFile[RTPATH_MAX];
112	ssize_t cch = RTStrPrintf2(szLogFile, sizeof(szLogFile),
113	"%s%c%s-Dhcpd.log",
114	m_strHome.c_str(), RTPATH_DELIMITER, m_strBaseName.c_str());
115	if (cch <= 0)
116	return VERR_BUFFER_OVERFLOW;
117
118	/* Sanitize base name some more to be usable in an environment variable name: */
119	char szEnvVarBase[128];
120	cch = RTStrPrintf(szEnvVarBase, sizeof(szEnvVarBase), "VBOXDHCP_%s_RELEASE_LOG", m_strBaseName.c_str());
121	if (cch <= 0)
122	return VERR_BUFFER_OVERFLOW;
123	for (char p = szEnvVarBase; p != '\0'; ++p)
124	if (p != '_' && !RT_C_IS_ALNUM(p))
125	*p = '_';
126
127
128	int rc = com::VBoxLogRelCreate("DHCP Server",
129	szLogFile,
130	RTLOGFLAGS_PREFIX_TIME_PROG,
131	"all all.restrict -default.restrict",
132	szEnvVarBase,
133	RTLOGDEST_FILE
134	#ifdef DEBUG
135	\| RTLOGDEST_STDERR
136	#endif
137	,
138	32768 /* cMaxEntriesPerGroup */,
139	0 /* cHistory */,
140	0 /* uHistoryFileTime */,
141	0 /* uHistoryFileSize */,
142	NULL /* pErrInfo */);
143
144	return rc;
145	}
146
147
148	int Config::complete()
149	{
150	int rc;
151
152	if (m_strNetwork.isEmpty())
153	{
154	LogDHCP(("network name is not specified\n"));
155	return false;
156	}
157
158	logInit();
159
160	bool fMACGenerated = false;
161	if ( m_MacAddress.au16[0] == 0
162	&& m_MacAddress.au16[1] == 0
163	&& m_MacAddress.au16[2] == 0)
164	{
165	RTUUID Uuid;
166	RTUuidCreate(&Uuid);
167
168	m_MacAddress.au8[0] = 0x08;
169	m_MacAddress.au8[1] = 0x00;
170	m_MacAddress.au8[2] = 0x27;
171	m_MacAddress.au8[3] = Uuid.Gen.au8Node[3];
172	m_MacAddress.au8[4] = Uuid.Gen.au8Node[4];
173	m_MacAddress.au8[5] = Uuid.Gen.au8Node[5];
174
175	LogDHCP(("MAC address is not specified: will use generated MAC %RTmac\n", &m_MacAddress));
176	fMACGenerated = true;
177	}
178
179	/* unicast MAC address */
180	if (m_MacAddress.au8[0] & 0x01)
181	{
182	LogDHCP(("MAC address is not unicast: %RTmac\n", &m_MacAddress));
183	return VERR_GENERAL_FAILURE;
184	}
185
186	/* unicast IP address */
187	if ((m_IPv4Address.au8[0] & 0xe0) == 0xe0)
188	{
189	LogDHCP(("IP address is not unicast: %RTnaipv4\n", m_IPv4Address.u));
190	return VERR_GENERAL_FAILURE;
191	}
192
193	/* valid netmask */
194	int cPrefixBits;
195	rc = RTNetMaskToPrefixIPv4(&m_IPv4Netmask, &cPrefixBits);
196	if (RT_FAILURE(rc) \|\| cPrefixBits == 0)
197	{
198	LogDHCP(("IP mask is not valid: %RTnaipv4\n", m_IPv4Netmask.u));
199	return VERR_GENERAL_FAILURE;
200	}
201
202	/* first IP is from the same network */
203	if ((m_IPv4PoolFirst.u & m_IPv4Netmask.u) != (m_IPv4Address.u & m_IPv4Netmask.u))
204	{
205	LogDHCP(("first pool address is outside the network %RTnaipv4/%d: %RTnaipv4\n",
206	(m_IPv4Address.u & m_IPv4Netmask.u), cPrefixBits, m_IPv4PoolFirst.u));
207	return VERR_GENERAL_FAILURE;
208	}
209
210	/* last IP is from the same network */
211	if ((m_IPv4PoolLast.u & m_IPv4Netmask.u) != (m_IPv4Address.u & m_IPv4Netmask.u))
212	{
213	LogDHCP(("last pool address is outside the network %RTnaipv4/%d: %RTnaipv4\n",
214	(m_IPv4Address.u & m_IPv4Netmask.u), cPrefixBits, m_IPv4PoolLast.u));
215	return VERR_GENERAL_FAILURE;
216	}
217
218	/* the pool is valid */
219	if (RT_N2H_U32(m_IPv4PoolLast.u) < RT_N2H_U32(m_IPv4PoolFirst.u))
220	{
221	LogDHCP(("pool range is invalid: %RTnaipv4 - %RTnaipv4\n",
222	m_IPv4PoolFirst.u, m_IPv4PoolLast.u));
223	return VERR_GENERAL_FAILURE;
224	}
225
226	/* our own address is not inside the pool */
227	if ( RT_N2H_U32(m_IPv4PoolFirst.u) <= RT_N2H_U32(m_IPv4Address.u)
228	&& RT_N2H_U32(m_IPv4Address.u) <= RT_N2H_U32(m_IPv4PoolLast.u))
229	{
230	LogDHCP(("server address inside the pool range %RTnaipv4 - %RTnaipv4: %RTnaipv4\n",
231	m_IPv4PoolFirst.u, m_IPv4PoolLast.u, m_IPv4Address.u));
232	return VERR_GENERAL_FAILURE;
233	}
234
235	if (!fMACGenerated)
236	LogDHCP(("MAC address %RTmac\n", &m_MacAddress));
237	LogDHCP(("IP address %RTnaipv4/%d\n", m_IPv4Address.u, cPrefixBits));
238	LogDHCP(("address pool %RTnaipv4 - %RTnaipv4\n", m_IPv4PoolFirst.u, m_IPv4PoolLast.u));
239
240	return VINF_SUCCESS;
241	}
242
243
244	Config *Config::hardcoded()
245	{
246	int rc;
247
248	std::unique_ptr<Config> config(new Config());
249	rc = config->init();
250	if (RT_FAILURE(rc))
251	return NULL;
252
253	config->setNetwork("HostInterfaceNetworking-vboxnet0");
254	config->m_strTrunk.assign("vboxnet0");
255	config->m_enmTrunkType = kIntNetTrunkType_NetFlt;
256
257	config->m_MacAddress.au8[0] = 0x08;
258	config->m_MacAddress.au8[1] = 0x00;
259	config->m_MacAddress.au8[2] = 0x27;
260	config->m_MacAddress.au8[3] = 0xa9;
261	config->m_MacAddress.au8[4] = 0xcf;
262	config->m_MacAddress.au8[5] = 0xef;
263
264
265	config->m_IPv4Address.u = RT_H2N_U32_C(0xc0a838fe); /* 192.168.56.254 */
266	config->m_IPv4Netmask.u = RT_H2N_U32_C(0xffffff00); /* 255.255.255.0 */
267
268	/* flip to test naks */
269	#if 1
270	config->m_IPv4PoolFirst.u = RT_H2N_U32_C(0xc0a8385a); /* 192.168.56.90 */
271	config->m_IPv4PoolLast.u = RT_H2N_U32_C(0xc0a83863); /* 192.168.56.99 */
272	#else
273	config->m_IPv4PoolFirst.u = RT_H2N_U32_C(0xc0a838c9); /* 192.168.56.201 */
274	config->m_IPv4PoolLast.u = RT_H2N_U32_C(0xc0a838dc); /* 192.168.56.220 */
275	#endif
276
277	rc = config->complete();
278	AssertRCReturn(rc, NULL);
279
280	return config.release();
281	}
282
283
284	/* compatibility with old VBoxNetDHCP */
285	static const RTGETOPTDEF g_aCompatOptions[] =
286	{
287	{ "--ip-address", 'i', RTGETOPT_REQ_IPV4ADDR },
288	{ "--lower-ip", 'l', RTGETOPT_REQ_IPV4ADDR },
289	{ "--mac-address", 'a', RTGETOPT_REQ_MACADDR },
290	{ "--need-main", 'M', RTGETOPT_REQ_BOOL },
291	{ "--netmask", 'm', RTGETOPT_REQ_IPV4ADDR },
292	{ "--network", 'n', RTGETOPT_REQ_STRING },
293	{ "--trunk-name", 't', RTGETOPT_REQ_STRING },
294	{ "--trunk-type", 'T', RTGETOPT_REQ_STRING },
295	{ "--upper-ip", 'u', RTGETOPT_REQ_IPV4ADDR },
296	};
297
298
299	Config Config::compat(int argc, char *argv)
300	{
301	RTGETOPTSTATE State;
302	int rc;
303
304	rc = RTGetOptInit(&State, argc, argv,
305	g_aCompatOptions, RT_ELEMENTS(g_aCompatOptions), 1,
306	RTGETOPTINIT_FLAGS_NO_STD_OPTS);
307	AssertRCReturn(rc, NULL);
308
309	std::unique_ptr<Config> config(new Config());
310	rc = config->init();
311	if (RT_FAILURE(rc))
312	return NULL;
313
314	for (;;)
315	{
316	RTGETOPTUNION Val;
317
318	rc = RTGetOpt(&State, &Val);
319	if (rc == 0) /* done */
320	break;
321
322	switch (rc)
323	{
324	case 'a': /* --mac-address */
325	if ( config->m_MacAddress.au16[0] != 0
326	\|\| config->m_MacAddress.au16[1] != 0
327	\|\| config->m_MacAddress.au16[2] != 0)
328	{
329	RTMsgError("Duplicate --mac-address option");
330	return NULL;
331	}
332	config->m_MacAddress = Val.MacAddr;
333	break;
334
335	case 'i': /* --ip-address */
336	if (config->m_IPv4Address.u != 0)
337	{
338	RTMsgError("Duplicate --ip-address option");
339	return NULL;
340	}
341	config->m_IPv4Address = Val.IPv4Addr;
342	break;
343
344	case 'l': /* --lower-ip */
345	if (config->m_IPv4PoolFirst.u != 0)
346	{
347	RTMsgError("Duplicate --lower-ip option");
348	return NULL;
349	}
350	config->m_IPv4PoolFirst = Val.IPv4Addr;
351	break;
352
353	case 'M': /* --need-main */
354	/* for backward compatibility, ignored */
355	break;
356
357	case 'm': /* --netmask */
358	if (config->m_IPv4Netmask.u != 0)
359	{
360	RTMsgError("Duplicate --netmask option");
361	return NULL;
362	}
363	config->m_IPv4Netmask = Val.IPv4Addr;
364	break;
365
366	case 'n': /* --network */
367	if (!config->m_strNetwork.isEmpty())
368	{
369	RTMsgError("Duplicate --network option");
370	return NULL;
371	}
372	config->setNetwork(Val.psz);
373	break;
374
375	case 't': /* --trunk-name */
376	if (!config->m_strTrunk.isEmpty())
377	{
378	RTMsgError("Duplicate --trunk-name option");
379	return NULL;
380	}
381	config->m_strTrunk.assign(Val.psz);
382	break;
383
384	case 'T': /* --trunk-type */
385	if (config->m_enmTrunkType != kIntNetTrunkType_Invalid)
386	{
387	RTMsgError("Duplicate --trunk-type option");
388	return NULL;
389	}
390	else if (strcmp(Val.psz, "none") == 0)
391	config->m_enmTrunkType = kIntNetTrunkType_None;
392	else if (strcmp(Val.psz, "whatever") == 0)
393	config->m_enmTrunkType = kIntNetTrunkType_WhateverNone;
394	else if (strcmp(Val.psz, "netflt") == 0)
395	config->m_enmTrunkType = kIntNetTrunkType_NetFlt;
396	else if (strcmp(Val.psz, "netadp") == 0)
397	config->m_enmTrunkType = kIntNetTrunkType_NetAdp;
398	else
399	{
400	RTMsgError("Unknown trunk type '%s'", Val.psz);
401	return NULL;
402	}
403	break;
404
405	case 'u': /* --upper-ip */
406	if (config->m_IPv4PoolLast.u != 0)
407	{
408	RTMsgError("Duplicate --upper-ip option");
409	return NULL;
410	}
411	config->m_IPv4PoolLast = Val.IPv4Addr;
412	break;
413
414	case VINF_GETOPT_NOT_OPTION:
415	RTMsgError("%s: Unexpected command line argument", Val.psz);
416	return NULL;
417
418	default:
419	RTGetOptPrintError(rc, &Val);
420	return NULL;
421	}
422	}
423
424	rc = config->complete();
425	if (RT_FAILURE(rc))
426	return NULL;
427
428	return config.release();
429	}
430
431
432	#define DHCPD_GETOPT_COMMENT 256 /* No short option for --comment */
433	static const RTGETOPTDEF g_aOptions[] =
434	{
435	{ "--config", 'c', RTGETOPT_REQ_STRING },
436	{ "--comment", DHCPD_GETOPT_COMMENT, RTGETOPT_REQ_STRING }
437	};
438
439
440	Config Config::create(int argc, char *argv)
441	{
442	RTGETOPTSTATE State;
443	int rc;
444
445	rc = RTGetOptInit(&State, argc, argv,
446	g_aOptions, RT_ELEMENTS(g_aOptions), 1,
447	RTGETOPTINIT_FLAGS_NO_STD_OPTS);
448	AssertRCReturn(rc, NULL);
449
450	std::unique_ptr<Config> config;
451	for (;;)
452	{
453	RTGETOPTUNION Val;
454
455	rc = RTGetOpt(&State, &Val);
456	if (rc == 0) /* done */
457	break;
458
459	switch (rc)
460	{
461	case 'c': /* --config */
462	if (config.get() != NULL)
463	{
464	printf("Duplicate option: --config '%s'\n", Val.psz);
465	return NULL;
466	}
467
468	printf("reading config from %s\n", Val.psz);
469	config.reset(Config::read(Val.psz));
470	if (config.get() == NULL)
471	return NULL;
472
473	break;
474
475	case DHCPD_GETOPT_COMMENT: /* --comment */
476	/* The sole purpose of this option is to allow identification of DHCP
477	* server instances in the process list. We ignore the required string
478	* argument of this option.
479	*/
480	continue;
481
482	case VINF_GETOPT_NOT_OPTION:
483	RTMsgError("Unexpected command line argument: '%s'", Val.psz);
484	return NULL;
485
486	default:
487	RTGetOptPrintError(rc, &Val);
488	return NULL;
489	}
490	}
491
492	if (config.get() == NULL)
493	return NULL;
494
495	rc = config->complete();
496	if (RT_FAILURE(rc))
497	return NULL;
498
499	return config.release();
500	}
501
502
503	Config Config::read(const char pszFileName)
504	{
505	int rc;
506
507	if (pszFileName == NULL \|\| pszFileName[0] == '\0')
508	return NULL;
509
510	xml::Document doc;
511	try
512	{
513	xml::XmlFileParser parser;
514	parser.read(pszFileName, doc);
515	}
516	catch (const xml::EIPRTFailure &e)
517	{
518	LogDHCP(("%s\n", e.what()));
519	return NULL;
520	}
521	catch (const RTCError &e)
522	{
523	LogDHCP(("%s\n", e.what()));
524	return NULL;
525	}
526	catch (...)
527	{
528	LogDHCP(("Unknown exception while reading and parsing '%s'\n",
529	pszFileName));
530	return NULL;
531	}
532
533	std::unique_ptr<Config> config(new Config());
534	rc = config->init();
535	if (RT_FAILURE(rc))
536	return NULL;
537
538	try
539	{
540	config->parseConfig(doc.getRootElement());
541	}
542	catch (const RTCError &e)
543	{
544	LogDHCP(("%s\n", e.what()));
545	return NULL;
546	}
547	catch (...)
548	{
549	LogDHCP(("Unexpected exception\n"));
550	return NULL;
551	}
552
553	return config.release();
554	}
555
556
557	void Config::parseConfig(const xml::ElementNode *root)
558	{
559	if (root == NULL)
560	throw ConfigFileError("Empty config file");
561
562	/*
563	* XXX: NAMESPACE API IS COMPLETELY BROKEN, SO IGNORE IT FOR NOW
564	*/
565	if (!root->nameEquals("DHCPServer"))
566	{
567	const char *name = root->getName();
568	throw ConfigFileError(RTCStringFmt("Unexpected root element \"%s\"",
569	name ? name : "(null)"));
570	}
571
572	parseServer(root);
573
574	// XXX: debug
575	for (optmap_t::const_iterator it = m_GlobalOptions.begin(); it != m_GlobalOptions.end(); ++it) {
576	std::shared_ptr<DhcpOption> opt(it->second);
577
578	octets_t data;
579	opt->encode(data);
580
581	bool space = false;
582	for (octets_t::const_iterator itData = data.begin(); itData != data.end(); ++itData) {
583	uint8_t c = *itData;
584	if (space)
585	std::cout << " ";
586	else
587	space = true;
588	std::cout << (int)c;
589	}
590	std::cout << std::endl;
591	}
592	}
593
594
595	static void getIPv4AddrAttribute(const xml::ElementNode pNode, const char pcszAttrName,
596	RTNETADDRIPV4 *pAddr)
597	{
598	RTCString strAddr;
599	bool fHasAttr = pNode->getAttributeValue(pcszAttrName, &strAddr);
600	if (!fHasAttr)
601	throw ConfigFileError(RTCStringFmt("%s attribute missing",
602	pcszAttrName));
603
604	int rc = RTNetStrToIPv4Addr(strAddr.c_str(), pAddr);
605	if (RT_FAILURE(rc))
606	throw ConfigFileError(RTCStringFmt("%s attribute invalid",
607	pcszAttrName));
608	}
609
610
611	void Config::parseServer(const xml::ElementNode *server)
612	{
613	/*
614	* DHCPServer attributes
615	*/
616	RTCString strNetworkName;
617	bool fHasNetworkName = server->getAttributeValue("networkName", &strNetworkName);
618	if (!fHasNetworkName)
619	throw ConfigFileError("DHCPServer/@networkName missing");
620
621	setNetwork(strNetworkName);
622
623	RTCString strTrunkType;
624	if (!server->getAttributeValue("trunkType", &strTrunkType))
625	throw ConfigFileError("DHCPServer/@trunkType missing");
626	if (strTrunkType == "none")
627	m_enmTrunkType = kIntNetTrunkType_None;
628	else if (strTrunkType == "whatever")
629	m_enmTrunkType = kIntNetTrunkType_WhateverNone;
630	else if (strTrunkType == "netflt")
631	m_enmTrunkType = kIntNetTrunkType_NetFlt;
632	else if (strTrunkType == "netadp")
633	m_enmTrunkType = kIntNetTrunkType_NetAdp;
634	else
635	throw ConfigFileError(RTCStringFmt("Invalid DHCPServer/@trunkType value: %s", strTrunkType.c_str()));
636
637	if ( m_enmTrunkType == kIntNetTrunkType_NetFlt
638	\|\| m_enmTrunkType == kIntNetTrunkType_NetAdp)
639	{
640	RTCString strTrunk;
641	if (!server->getAttributeValue("trunkName", &strTrunk))
642	throw ConfigFileError("DHCPServer/@trunkName missing");
643	m_strTrunk = strTrunk;
644	}
645	else
646	m_strTrunk = "";
647
648	getIPv4AddrAttribute(server, "IPAddress", &m_IPv4Address);
649	getIPv4AddrAttribute(server, "networkMask", &m_IPv4Netmask);
650	getIPv4AddrAttribute(server, "lowerIP", &m_IPv4PoolFirst);
651	getIPv4AddrAttribute(server, "upperIP", &m_IPv4PoolLast);
652
653	/*
654	* DHCPServer children
655	*/
656	xml::NodesLoop it(*server);
657	const xml::ElementNode *node;
658	while ((node = it.forAllNodes()) != NULL)
659	{
660	/*
661	* Global options
662	*/
663	if (node->nameEquals("Options"))
664	{
665	parseGlobalOptions(node);
666	}
667
668	/*
669	* Per-VM configuration
670	*/
671	else if (node->nameEquals("Config"))
672	{
673	parseVMConfig(node);
674	}
675	}
676	}
677
678
679	void Config::parseGlobalOptions(const xml::ElementNode *options)
680	{
681	xml::NodesLoop it(*options);
682	const xml::ElementNode *node;
683	while ((node = it.forAllNodes()) != NULL)
684	{
685	if (node->nameEquals("Option"))
686	{
687	parseOption(node, m_GlobalOptions);
688	}
689	else
690	{
691	throw ConfigFileError(RTCStringFmt("Unexpected element \"%s\"",
692	node->getName()));
693	}
694	}
695	}
696
697
698	/**
699	* VM Config entries are generated automatically from VirtualBox.xml
700	* with the MAC fetched from the VM config. The client id is nowhere
701	* in the picture there, so VM config is indexed with plain RTMAC, not
702	* ClientId (also see getOptions below).
703	*/
704	void Config::parseVMConfig(const xml::ElementNode *config)
705	{
706	RTMAC mac;
707	int rc;
708
709	RTCString strMac;
710	bool fHasMac = config->getAttributeValue("MACAddress", &strMac);
711	if (!fHasMac)
712	throw ConfigFileError(RTCStringFmt("Config missing MACAddress attribute"));
713
714	rc = parseMACAddress(mac, strMac);
715	if (RT_FAILURE(rc))
716	{
717	throw ConfigFileError(RTCStringFmt("Malformed MACAddress attribute \"%s\"",
718	strMac.c_str()));
719	}
720
721	vmmap_t::iterator vmit( m_VMMap.find(mac) );
722	if (vmit != m_VMMap.end())
723	{
724	throw ConfigFileError(RTCStringFmt("Duplicate Config for MACAddress \"%s\"",
725	strMac.c_str()));
726	}
727
728	optmap_t &vmopts = m_VMMap[mac];
729
730	xml::NodesLoop it(*config);
731	const xml::ElementNode *node;
732	while ((node = it.forAllNodes()) != NULL)
733	if (node->nameEquals("Option"))
734	parseOption(node, vmopts);
735	else
736	throw ConfigFileError(RTCStringFmt("Unexpected element \"%s\"",
737	node->getName()));
738	}
739
740
741	int Config::parseMACAddress(RTMAC &aMac, const RTCString &aStr)
742	{
743	RTMAC mac;
744	int rc;
745
746	rc = RTNetStrToMacAddr(aStr.c_str(), &mac);
747	if (RT_FAILURE(rc))
748	return rc;
749	if (rc == VWRN_TRAILING_CHARS)
750	return VERR_INVALID_PARAMETER;
751
752	aMac = mac;
753	return VINF_SUCCESS;
754	}
755
756
757	int Config::parseClientId(OptClientId &aId, const RTCString &aStr)
758	{
759	RT_NOREF(aId, aStr);
760	return VERR_GENERAL_FAILURE;
761	}
762
763
764	/**
765	* Parse <Option/> element and add the option to the specified optmap.
766	*/
767	void Config::parseOption(const xml::ElementNode *option, optmap_t &optmap)
768	{
769	int rc;
770
771	uint8_t u8Opt;
772	RTCString strName;
773	bool fHasName = option->getAttributeValue("name", &strName);
774	if (fHasName)
775	{
776	const char *pcszName = strName.c_str();
777
778	rc = RTStrToUInt8Full(pcszName, 10, &u8Opt);
779	if (rc != VINF_SUCCESS) /* no warnings either */
780	throw ConfigFileError(RTCStringFmt("Bad option \"%s\"", pcszName));
781
782	}
783	else
784	throw ConfigFileError("missing option name");
785
786
787	uint32_t u32Enc = 0; /* XXX: DhcpOptEncoding_Legacy */
788	RTCString strEncoding;
789	bool fHasEncoding = option->getAttributeValue("encoding", &strEncoding);
790	if (fHasEncoding)
791	{
792	const char *pcszEnc = strEncoding.c_str();
793
794	rc = RTStrToUInt32Full(pcszEnc, 10, &u32Enc);
795	if (rc != VINF_SUCCESS) /* no warnings either */
796	throw ConfigFileError(RTCStringFmt("Bad encoding \"%s\"", pcszEnc));
797
798	switch (u32Enc)
799	{
800	case 0: /* XXX: DhcpOptEncoding_Legacy */
801	case 1: /* XXX: DhcpOptEncoding_Hex */
802	break;
803	default:
804	throw ConfigFileError(RTCStringFmt("Unknown encoding \"%s\"", pcszEnc));
805	}
806	}
807
808
809	/* value may be omitted for OptNoValue options like rapid commit */
810	RTCString strValue;
811	option->getAttributeValue("value", &strValue);
812
813	/* XXX: TODO: encoding, handle hex */
814	DhcpOption *opt = DhcpOption::parse(u8Opt, u32Enc, strValue.c_str());
815	if (opt == NULL)
816	throw ConfigFileError(RTCStringFmt("Bad option \"%s\"", strName.c_str()));
817
818	optmap << opt;
819	}
820
821
822	/**
823	* Set m_strBaseName to sanitized version of m_strNetwork that can be
824	* used in a path component.
825	*/
826	void Config::sanitizeBaseName()
827	{
828	if (m_strNetwork.isNotEmpty())
829	{
830	m_strBaseName = m_strNetwork;
831
832	char ch;
833	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
834	static const char s_szIllegals[] = "/\\\":<>?\|\t\v\n\r\f\a\b"; /* @todo all control chars... */
835	for (char psz = m_strBaseName.mutableRaw(); (ch = psz) != '\0'; ++psz)
836	if (strchr(s_szIllegals, ch))
837	*psz = '_';
838	#else
839	for (char psz = m_strBaseName.mutableRaw(); (ch = psz) != '\0'; ++psz)
840	if (RTPATH_IS_SEP(ch))
841	*psz = '_';
842	#endif
843	m_strBaseName.jolt(); /* Not really necessary, but it's protocol. */
844	}
845	else
846	m_strBaseName.setNull();
847	}
848
849
850	optmap_t Config::getOptions(const OptParameterRequest &reqOpts,
851	const ClientId &id,
852	const OptVendorClassId &vendor) const
853	{
854	optmap_t optmap;
855
856	const optmap_t *vmopts = NULL;
857	vmmap_t::const_iterator vmit( m_VMMap.find(id.mac()) );
858	if (vmit != m_VMMap.end())
859	vmopts = &vmit->second;
860
861	RT_NOREF(vendor); /* not yet */
862
863
864	optmap << new OptSubnetMask(m_IPv4Netmask);
865
866	const OptParameterRequest::value_t& reqValue = reqOpts.value();
867	for (octets_t::const_iterator itOptReq = reqValue.begin(); itOptReq != reqValue.end(); ++itOptReq)
868	{
869	uint8_t optreq = *itOptReq;
870	std::cout << ">>> requested option " << (int)optreq << std::endl;
871
872	if (optreq == OptSubnetMask::optcode)
873	{
874	std::cout << "... always supplied" << std::endl;
875	continue;
876	}
877
878	if (vmopts != NULL)
879	{
880	optmap_t::const_iterator it( vmopts->find(optreq) );
881	if (it != vmopts->end())
882	{
883	optmap << it->second;
884	std::cout << "... found in VM options" << std::endl;
885	continue;
886	}
887	}
888
889	optmap_t::const_iterator it( m_GlobalOptions.find(optreq) );
890	if (it != m_GlobalOptions.end())
891	{
892	optmap << it->second;
893	std::cout << "... found in global options" << std::endl;
894	continue;
895	}
896
897	// std::cout << "... not found" << std::endl;
898	}
899
900
901	/* XXX: testing ... */
902	if (vmopts != NULL)
903	{
904	for (optmap_t::const_iterator it = vmopts->begin(); it != vmopts->end(); ++it) {
905	std::shared_ptr<DhcpOption> opt(it->second);
906	if (optmap.count(opt->optcode()) == 0 && opt->optcode() > 127)
907	{
908	optmap << opt;
909	std::cout << "... forcing VM option " << (int)opt->optcode() << std::endl;
910	}
911	}
912	}
913
914	for (optmap_t::const_iterator it = m_GlobalOptions.begin(); it != m_GlobalOptions.end(); ++it) {
915	std::shared_ptr<DhcpOption> opt(it->second);
916	if (optmap.count(opt->optcode()) == 0 && opt->optcode() > 127)
917	{
918	optmap << opt;
919	std::cout << "... forcing global option " << (int)opt->optcode() << std::endl;
920	}
921	}
922
923	return optmap;
924	}

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

source: vbox/trunk/src/VBox/NetworkServices/Dhcpd/Config.cpp@ 79530

Download in other formats: