Db.cpp@ 103075

Last change on this file since 103075 was 98103, checked in by vboxsync, 2 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 31.6 KB

Line
1	/* $Id: Db.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* DHCP server - address database
4	*/
5
6	/*
7	* Copyright (C) 2017-2023 Oracle and/or its affiliates.
8	*
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
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include "DhcpdInternal.h"
33	#include <iprt/errcore.h>
34
35	#include "Db.h"
36
37
38	/*********************************************************************************************************************************
39	* Global Variables *
40	*********************************************************************************************************************************/
41	/** Indicates whether has been called successfully yet. */
42	bool Binding::g_fFormatRegistered = false;
43
44
45	/**
46	* Registers the ClientId format type callback ("%R[binding]").
47	*/
48	void Binding::registerFormat() RT_NOEXCEPT
49	{
50	if (!g_fFormatRegistered)
51	{
52	int rc = RTStrFormatTypeRegister("binding", rtStrFormat, NULL);
53	AssertRC(rc);
54	g_fFormatRegistered = true;
55	}
56	}
57
58
59	/**
60	* @callback_method_impl{FNRTSTRFORMATTYPE, Formats ClientId via "%R[binding]".}
61	*/
62	DECLCALLBACK(size_t)
63	Binding::rtStrFormat(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
64	const char pszType, void const pvValue,
65	int cchWidth, int cchPrecision, unsigned fFlags,
66	void *pvUser)
67	{
68
69	AssertReturn(strcmp(pszType, "binding") == 0, 0);
70	RT_NOREF(pszType);
71
72	RT_NOREF(cchWidth, cchPrecision, fFlags);
73	RT_NOREF(pvUser);
74
75	const Binding b = static_cast<const Binding >(pvValue);
76	if (b == NULL)
77	return pfnOutput(pvArgOutput, RT_STR_TUPLE("<NULL>"));
78
79	size_t cb = RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%RTnaipv4", b->m_addr.u);
80	if (b->m_state == Binding::FREE)
81	cb += pfnOutput(pvArgOutput, RT_STR_TUPLE(" free"));
82	else if (b->m_fFixed)
83	cb += pfnOutput(pvArgOutput, RT_STR_TUPLE(" fixed"));
84	else
85	{
86	cb += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, " to %R[id], %s, valid from ", &b->m_id, b->stateName());
87
88	Timestamp tsIssued = b->issued();
89	cb += tsIssued.strFormatHelper(pfnOutput, pvArgOutput);
90
91	cb += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, " for %ds until ", b->leaseTime());
92
93	Timestamp tsValid = b->issued();
94	tsValid.addSeconds(b->leaseTime());
95	cb += tsValid.strFormatHelper(pfnOutput, pvArgOutput);
96	}
97
98	return cb;
99	}
100
101
102	/**
103	* Used to update the client ID of a fixed address assignment.
104	*
105	* We only have the MAC address when prepraring the binding, so the full client
106	* ID must be supplied when the client requests it.
107	*
108	* @param a_ridClient The client ID.
109	* @throws std::bad_alloc
110	*/
111	void Binding::idUpdate(const ClientId &a_ridClient)
112	{
113	AssertReturnVoid(isFixed());
114	m_id = a_ridClient;
115	}
116
117
118	/**
119	* Get the state as a string for the XML lease database.
120	*/
121	const char *Binding::stateName() const RT_NOEXCEPT
122	{
123	switch (m_state)
124	{
125	case FREE:
126	return "free";
127	case RELEASED:
128	return "released";
129	case EXPIRED:
130	return "expired";
131	case OFFERED:
132	return "offered";
133	case ACKED:
134	return "acked";
135	default:
136	AssertMsgFailed(("%d\n", m_state));
137	return "released";
138	}
139	}
140
141
142	/**
143	* Sets the state by name (reverse of Binding::stateName()).
144	*/
145	Binding &Binding::setState(const char *pszStateName) RT_NOEXCEPT
146	{
147	if (strcmp(pszStateName, "free") == 0)
148	m_state = Binding::FREE;
149	else if (strcmp(pszStateName, "released") == 0)
150	m_state = Binding::RELEASED;
151	else if (strcmp(pszStateName, "expired") == 0)
152	m_state = Binding::EXPIRED;
153	else if (strcmp(pszStateName, "offered") == 0)
154	m_state = Binding::OFFERED;
155	else if (strcmp(pszStateName, "acked") == 0)
156	m_state = Binding::ACKED;
157	else
158	{
159	AssertMsgFailed(("%d\n", m_state));
160	m_state = Binding::RELEASED;
161	}
162
163	return *this;
164	}
165
166
167	/**
168	* Expires the binding if it's past the specified deadline.
169	*
170	* @returns False if already expired, released or freed, otherwise true (i.e.
171	* does not indicate whether action was taken or not).
172	* @param tsDeadline The expiry deadline to use.
173	*/
174	bool Binding::expire(Timestamp tsDeadline) RT_NOEXCEPT
175	{
176	if (m_state <= Binding::EXPIRED \|\| m_fFixed)
177	return false;
178
179	Timestamp tsExpire = m_issued;
180	tsExpire.addSeconds(m_secLease);
181
182	if (tsExpire < tsDeadline)
183	{
184	if (m_state == Binding::OFFERED)
185	setState(Binding::FREE);
186	else
187	setState(Binding::EXPIRED);
188	}
189	return true;
190	}
191
192
193	/**
194	* Serializes the binding to XML for the lease database.
195	*
196	* @throw std::bad_alloc
197	* @note DHCPServerImpl.cpp contains a reader, keep it in sync.
198	*/
199	void Binding::toXML(xml::ElementNode *pElmParent) const
200	{
201	/*
202	* Lease
203	*/
204	xml::ElementNode *pElmLease = pElmParent->createChild("Lease");
205
206	pElmLease->setAttribute("mac", RTCStringFmt("%RTmac", &m_id.mac()));
207	if (m_id.id().present())
208	{
209	/* I'd prefer RTSTRPRINTHEXBYTES_F_SEP_COLON but there's no decoder */
210	size_t cbStrId = m_id.id().value().size() * 2 + 1;
211	char *pszId = new char[cbStrId];
212	int rc = RTStrPrintHexBytes(pszId, cbStrId,
213	&m_id.id().value().front(), m_id.id().value().size(),
214	0);
215	AssertRC(rc);
216	pElmLease->setAttribute("id", pszId);
217	delete[] pszId;
218	}
219
220	/* unused but we need it to keep the old code happy */
221	pElmLease->setAttribute("network", "0.0.0.0");
222	pElmLease->setAttribute("state", stateName());
223
224	/*
225	* Lease/Address
226	*/
227	xml::ElementNode *pElmAddr = pElmLease->createChild("Address");
228	pElmAddr->setAttribute("value", RTCStringFmt("%RTnaipv4", m_addr.u));
229
230	/*
231	* Lease/Time
232	*/
233	xml::ElementNode *pElmTime = pElmLease->createChild("Time");
234	pElmTime->setAttribute("issued", m_issued.getAbsSeconds());
235	pElmTime->setAttribute("expiration", m_secLease);
236	}
237
238
239	/**
240	* Deserializes the binding from the XML lease database.
241	*
242	* @param pElmLease The "Lease" element to serialize into.
243	* @return Pointer to the resulting binding, NULL on failure.
244	* @throw std::bad_alloc
245	* @note DHCPServerImpl.cpp contains a similar reader, keep it in sync.
246	*/
247	Binding Binding::fromXML(const xml::ElementNode pElmLease)
248	{
249	/* Note! Lease/@network seems to always have bogus value, ignore it. */
250	/* Note! We parse the mandatory attributes and elements first, then
251	the optional ones. This means things appear a little jumbled. */
252
253	/*
254	* Lease/@mac - mandatory.
255	*/
256	const char *pszMacAddress = pElmLease->findAttributeValue("mac");
257	if (!pszMacAddress)
258	DHCP_LOG_RET_NULL(("Binding::fromXML: <Lease> element without 'mac' attribute! Skipping lease.\n"));
259
260	RTMAC mac;
261	int rc = RTNetStrToMacAddr(pszMacAddress, &mac);
262	if (RT_FAILURE(rc))
263	DHCP_LOG_RET_NULL(("Binding::fromXML: Malformed mac address attribute value '%s': %Rrc - Skipping lease.\n",
264	pszMacAddress, rc));
265
266	/*
267	* Lease/Address/@value - mandatory.
268	*/
269	const char *pszAddress = pElmLease->findChildElementAttributeValue("Address", "value");
270	if (!pszAddress)
271	DHCP_LOG_RET_NULL(("Binding::fromXML: Could not find <Address> with a 'value' attribute! Skipping lease.\n"));
272
273	RTNETADDRIPV4 addr;
274	rc = RTNetStrToIPv4Addr(pszAddress, &addr);
275	if (RT_FAILURE(rc))
276	DHCP_LOG_RET_NULL(("Binding::fromXML: Malformed IPv4 address value '%s': %Rrc - Skipping lease.\n", pszAddress, rc));
277
278	/*
279	* Lease/Time - mandatory.
280	*/
281	const xml::ElementNode *pElmTime = pElmLease->findChildElement("Time");
282	if (pElmTime == NULL)
283	DHCP_LOG_RET_NULL(("Binding::fromXML: No <Time> element under <Lease mac=%RTmac>! Skipping lease.\n", &mac));
284
285	/*
286	* Lease/Time/@issued - mandatory.
287	*/
288	int64_t secIssued;
289	if (!pElmTime->getAttributeValue("issued", &secIssued))
290	DHCP_LOG_RET_NULL(("Binding::fromXML: <Time> element for %RTmac has no valid 'issued' attribute! Skipping lease.\n", &mac));
291
292	/*
293	* Lease/Time/@expiration - mandatory.
294	*/
295	uint32_t cSecToLive;
296	if (!pElmTime->getAttributeValue("expiration", &cSecToLive))
297	DHCP_LOG_RET_NULL(("Binding::fromXML: <Time> element for %RTmac has no valid 'expiration' attribute! Skipping lease.\n", &mac));
298
299	std::unique_ptr<Binding> b(new Binding(addr));
300
301	/*
302	* Lease/@state - mandatory but not present in old leases file, so pretent
303	* we're loading an expired one if absent.
304	*/
305	const char *pszState = pElmLease->findAttributeValue("state");
306	if (pszState)
307	{
308	b->m_issued = Timestamp::absSeconds(secIssued);
309	b->setState(pszState);
310	}
311	else
312	{ /** @todo XXX: old code wrote timestamps instead of absolute time. */
313	/* pretend that lease has just ended */
314	LogRel(("Binding::fromXML: No 'state' attribute for <Lease mac=%RTmac> (ts=%RI64 ttl=%RU32)! Assuming EXPIRED.\n",
315	&mac, secIssued, cSecToLive));
316	b->m_issued = Timestamp::now().subSeconds(cSecToLive);
317	b->m_state = Binding::EXPIRED;
318	}
319	b->m_secLease = cSecToLive;
320
321
322	/*
323	* Lease/@id - optional, ignore if bad.
324	* Value format: "deadbeef..." or "de:ad:be:ef...".
325	*/
326	const char *pszClientId = pElmLease->findAttributeValue("id");
327	if (pszClientId)
328	{
329	uint8_t abBytes[255];
330	size_t cbActual;
331	rc = RTStrConvertHexBytesEx(pszClientId, abBytes, sizeof(abBytes), RTSTRCONVERTHEXBYTES_F_SEP_COLON, NULL, &cbActual);
332	if (RT_SUCCESS(rc))
333	{
334	b->m_id = ClientId(mac, OptClientId(std::vector<uint8_t>(&abBytes[0], &abBytes[cbActual]))); /* throws bad_alloc */
335	if (rc != VINF_BUFFER_UNDERFLOW && rc != VINF_SUCCESS)
336	LogRel(("Binding::fromXML: imperfect 'id' attribute: rc=%Rrc, cbActual=%u, '%s'\n", rc, cbActual, pszClientId));
337	}
338	else
339	{
340	LogRel(("Binding::fromXML: ignoring malformed 'id' attribute: rc=%Rrc, cbActual=%u, '%s'\n",
341	rc, cbActual, pszClientId));
342	b->m_id = ClientId(mac, OptClientId());
343	}
344	}
345	else
346	b->m_id = ClientId(mac, OptClientId());
347
348	return b.release();
349	}
350
351
352
353	/*********************************************************************************************************************************
354	* Class Db Implementation *
355	*********************************************************************************************************************************/
356
357	Db::Db()
358	: m_pConfig(NULL)
359	{
360	}
361
362
363	Db::~Db()
364	{
365	/** @todo free bindings */
366	}
367
368
369	int Db::init(const Config *pConfig)
370	{
371	Binding::registerFormat();
372
373	m_pConfig = pConfig;
374
375	int rc = m_pool.init(pConfig->getIPv4PoolFirst(), pConfig->getIPv4PoolLast());
376	if (RT_SUCCESS(rc))
377	{
378	/*
379	* If the server IP is in the dynamic range, preallocate it like a fixed assignment.
380	*/
381	rc = i_enterFixedAddressAssignment(pConfig->getIPv4Address(), pConfig->getMacAddress());
382	if (RT_SUCCESS(rc))
383	{
384	/*
385	* Preallocate any fixed address assignments:
386	*/
387	Config::HostConfigVec vecHostConfigs;
388	rc = pConfig->getFixedAddressConfigs(vecHostConfigs);
389	for (Config::HostConfigVec::const_iterator it = vecHostConfigs.begin();
390	it != vecHostConfigs.end() && RT_SUCCESS(rc); ++it)
391	rc = i_enterFixedAddressAssignment((it)->getFixedAddress(), (it)->getMACAddress());
392	}
393	}
394
395	return rc;
396	}
397
398
399	/**
400	* Used by Db::init() to register a fixed address assignment.
401	*
402	* @returns IPRT status code.
403	* @param a_rAddress The IPv4 address assignment.
404	* @param a_rMACAddress The MAC address.
405	*/
406	int Db::i_enterFixedAddressAssignment(RTNETADDRIPV4 const &a_rAddress, RTMAC const &a_rMACAddress) RT_NOEXCEPT
407	{
408	LogRelFunc(("%RTmac: %RTnaipv4\n", &a_rMACAddress, a_rAddress));
409	Assert(m_pConfig->isInIPv4Network(a_rAddress)); /* should've been checked elsewhere already */
410
411	/*
412	* If the address is part of the pool, we have to allocate it to
413	* prevent it from being used again.
414	*/
415	if (m_pool.contains(a_rAddress))
416	{
417	if (!m_pool.allocate(a_rAddress))
418	{
419	LogRelFunc(("%RTnaipv4 already allocated?\n", a_rAddress));
420	return VERR_ADDRESS_CONFLICT;
421	}
422	}
423
424	/*
425	* Create the binding.
426	*/
427	Binding *pBinding = NULL;
428	try
429	{
430	pBinding = new Binding(a_rAddress, a_rMACAddress, true /fFixed/);
431	m_bindings.push_front(pBinding);
432	}
433	catch (std::bad_alloc &)
434	{
435	if (pBinding)
436	delete pBinding;
437	return VERR_NO_MEMORY;
438	}
439	return VINF_SUCCESS;
440	}
441
442
443	/**
444	* Expire old binding (leases).
445	*/
446	void Db::expire() RT_NOEXCEPT
447	{
448	const Timestamp now = Timestamp::now();
449	for (bindings_t::iterator it = m_bindings.begin(); it != m_bindings.end(); ++it)
450	{
451	Binding b = it;
452	b->expire(now);
453	}
454	}
455
456
457	/**
458	* Internal worker that creates a binding for the given client, allocating new
459	* IPv4 address for it.
460	*
461	* @returns Pointer to the binding.
462	* @param id The client ID.
463	*/
464	Binding *Db::i_createBinding(const ClientId &id)
465	{
466	Binding *pBinding = NULL;
467	RTNETADDRIPV4 addr = m_pool.allocate();
468	if (addr.u != 0)
469	{
470	try
471	{
472	pBinding = new Binding(addr, id);
473	m_bindings.push_front(pBinding);
474	}
475	catch (std::bad_alloc &)
476	{
477	if (pBinding)
478	delete pBinding;
479	/** @todo free address (no pool method for that) */
480	}
481	}
482	return pBinding;
483	}
484
485
486	/**
487	* Internal worker that creates a binding to the specified IPv4 address for the
488	* given client.
489	*
490	* @returns Pointer to the binding.
491	* NULL if the address is in use or we ran out of memory.
492	* @param addr The IPv4 address.
493	* @param id The client.
494	*/
495	Binding *Db::i_createBinding(RTNETADDRIPV4 addr, const ClientId &id)
496	{
497	bool fAvailable = m_pool.allocate(addr);
498	if (!fAvailable)
499	{
500	/** @todo
501	* XXX: this should not happen. If the address is from the
502	* pool, which we have verified before, then either it's in
503	* the free pool or there's an binding (possibly free) for it.
504	*/
505	return NULL;
506	}
507
508	Binding *b = new Binding(addr, id);
509	m_bindings.push_front(b);
510	return b;
511	}
512
513
514	/**
515	* Internal worker that allocates an IPv4 address for the given client, taking
516	* the preferred address (@a addr) into account when possible and if non-zero.
517	*/
518	Binding *Db::i_allocateAddress(const ClientId &id, RTNETADDRIPV4 addr)
519	{
520	Assert(addr.u == 0 \|\| addressBelongs(addr));
521
522	if (addr.u != 0)
523	LogRel(("> allocateAddress %RTnaipv4 to client %R[id]\n", addr.u, &id));
524	else
525	LogRel(("> allocateAddress to client %R[id]\n", &id));
526
527	/*
528	* Allocate existing address if client has one. Ignore requested
529	* address in that case. While here, look for free addresses and
530	* addresses that can be reused.
531	*/
532	Binding *addrBinding = NULL;
533	Binding *freeBinding = NULL;
534	Binding *reuseBinding = NULL;
535	const Timestamp now = Timestamp::now();
536	for (bindings_t::iterator it = m_bindings.begin(); it != m_bindings.end(); ++it)
537	{
538	Binding b = it;
539	b->expire(now);
540
541	/*
542	* We've already seen this client, give it its old binding.
543	*
544	* If the client's MAC address is configured with a fixed
545	* address, give its preconfigured binding. Fixed bindings
546	* are always at the head of the m_bindings list, so we
547	* won't be confused by any old leases of the client.
548	*/
549	if (b->m_id == id)
550	{
551	LogRel(("> ... found existing binding %R[binding]\n", b));
552	return b;
553	}
554	if (b->isFixed() && b->id().mac() == id.mac())
555	{
556	b->idUpdate(id);
557	LogRel(("> ... found fixed binding %R[binding]\n", b));
558	return b;
559	}
560
561	if (addr.u != 0 && b->m_addr.u == addr.u)
562	{
563	Assert(addrBinding == NULL);
564	addrBinding = b;
565	LogRel(("> .... noted existing binding %R[binding]\n", addrBinding));
566	}
567
568	/* if we haven't found a free binding yet, keep looking */
569	if (freeBinding == NULL)
570	{
571	if (b->m_state == Binding::FREE)
572	{
573	freeBinding = b;
574	LogRel(("> .... noted free binding %R[binding]\n", freeBinding));
575	continue;
576	}
577
578	/* still no free binding, can this one be reused? */
579	if (b->m_state == Binding::RELEASED)
580	{
581	if ( reuseBinding == NULL
582	/* released binding is better than an expired one */
583	\|\| reuseBinding->m_state == Binding::EXPIRED)
584	{
585	reuseBinding = b;
586	LogRel(("> .... noted released binding %R[binding]\n", reuseBinding));
587	}
588	}
589	else if (b->m_state == Binding::EXPIRED)
590	{
591	if ( reuseBinding == NULL
592	/* long expired binding is bettern than a recent one */
593	/* \|\| (reuseBinding->m_state == Binding::EXPIRED && b->olderThan(reuseBinding)) */)
594	{
595	reuseBinding = b;
596	LogRel(("> .... noted expired binding %R[binding]\n", reuseBinding));
597	}
598	}
599	}
600	}
601
602	/*
603	* Allocate requested address if we can.
604	*/
605	if (addr.u != 0)
606	{
607	if (addrBinding == NULL)
608	{
609	addrBinding = i_createBinding(addr, id);
610	Assert(addrBinding != NULL);
611	LogRel(("> .... creating new binding for this address %R[binding]\n", addrBinding));
612	return addrBinding;
613	}
614
615	if (addrBinding->m_state <= Binding::EXPIRED) /* not in use */
616	{
617	LogRel(("> .... reusing %s binding for this address\n", addrBinding->stateName()));
618	addrBinding->giveTo(id);
619	return addrBinding;
620	}
621	LogRel(("> .... cannot reuse %s binding for this address\n", addrBinding->stateName()));
622	}
623
624	/*
625	* Allocate new (or reuse).
626	*/
627	Binding *idBinding = NULL;
628	if (freeBinding != NULL)
629	{
630	idBinding = freeBinding;
631	LogRel(("> .... reusing free binding\n"));
632	}
633	else
634	{
635	idBinding = i_createBinding();
636	if (idBinding != NULL)
637	LogRel(("> .... creating new binding\n"));
638	else
639	{
640	idBinding = reuseBinding;
641	if (idBinding != NULL)
642	LogRel(("> .... reusing %s binding %R[binding]\n", reuseBinding->stateName(), reuseBinding));
643	else
644	DHCP_LOG_RET_NULL(("> .... failed to allocate binding\n"));
645	}
646	}
647
648	idBinding->giveTo(id);
649	LogRel(("> .... allocated %R[binding]\n", idBinding));
650
651	return idBinding;
652	}
653
654
655
656	/**
657	* Called by DHCPD to allocate a binding for the specified request.
658	*
659	* @returns Pointer to the binding, NULL on failure.
660	* @param req The DHCP request being served.
661	* @param rConfigVec The configurations that applies to the client.
662	* Used for lease time calculation.
663	*/
664	Binding *Db::allocateBinding(const DhcpClientMessage &req, Config::ConfigVec const &rConfigVec)
665	{
666	const ClientId &id(req.clientId());
667
668	/*
669	* Get and validate the requested address (if present).
670	*
671	* Fixed assignments are often outside the dynamic range, so we much detect
672	* those to make sure they aren't rejected based on IP range. ASSUMES fixed
673	* assignments are at the head of the binding list.
674	*/
675	OptRequestedAddress reqAddr(req);
676	if (reqAddr.present() && !addressBelongs(reqAddr.value()))
677	{
678	bool fIsFixed = false;
679	for (bindings_t::iterator it = m_bindings.begin(); it != m_bindings.end() && (*it)->isFixed(); ++it)
680	if (reqAddr.value().u == (*it)->addr().u)
681	{
682	if ( (*it)->id() == id
683	\|\| (*it)->id().mac() == id.mac())
684	{
685	fIsFixed = true;
686	break;
687	}
688	}
689	if (fIsFixed)
690	reqAddr = OptRequestedAddress();
691	else if (req.messageType() == RTNET_DHCP_MT_DISCOVER)
692	{
693	LogRel(("DISCOVER: ignoring invalid requested address\n"));
694	reqAddr = OptRequestedAddress();
695	}
696	else
697	DHCP_LOG_RET_NULL(("rejecting invalid requested address\n"));
698	}
699
700	/*
701	* Allocate the address.
702	*/
703	Binding *b = i_allocateAddress(id, reqAddr.value());
704	if (b != NULL)
705	{
706	Assert(b->id() == id);
707
708	/*
709	* Figure out the lease time.
710	*/
711	uint32_t secMin = 0;
712	uint32_t secDfl = 0;
713	uint32_t secMax = 0;
714	for (Config::ConfigVec::const_iterator it = rConfigVec.begin(); it != rConfigVec.end(); ++it)
715	{
716	ConfigLevelBase const pConfig = it;
717	if (secMin == 0)
718	secMin = pConfig->getMinLeaseTime();
719	if (secDfl == 0)
720	secDfl = pConfig->getDefaultLeaseTime();
721	if (secMax == 0)
722	secMax = pConfig->getMaxLeaseTime();
723	}
724	Assert(secMin); Assert(secMax); Assert(secDfl); /* global config always have non-defaults set */
725	if (secMin > secMax)
726	secMin = secMax;
727
728	OptLeaseTime reqLeaseTime(req);
729	if (!reqLeaseTime.present())
730	{
731	b->setLeaseTime(secDfl);
732	LogRel2(("Lease time %u secs (default)\n", b->leaseTime()));
733	}
734	else if (reqLeaseTime.value() < secMin)
735	{
736	b->setLeaseTime(secMin);
737	LogRel2(("Lease time %u secs (min)\n", b->leaseTime()));
738	}
739	else if (reqLeaseTime.value() > secMax)
740	{
741	b->setLeaseTime(secMax);
742	LogRel2(("Lease time %u secs (max)\n", b->leaseTime()));
743	}
744	else
745	{
746	b->setLeaseTime(reqLeaseTime.value());
747	LogRel2(("Lease time %u secs (requested)\n", b->leaseTime()));
748	}
749	}
750	return b;
751	}
752
753
754	/**
755	* Internal worker used by loadLease().
756	*
757	* @returns IPRT status code.
758	* @param pNewBinding The new binding to add.
759	*/
760	int Db::i_addBinding(Binding *pNewBinding) RT_NOEXCEPT
761	{
762	/*
763	* Validate the binding against the range and existing bindings.
764	*/
765	if (!addressBelongs(pNewBinding->m_addr))
766	{
767	LogRel(("Binding for out of range address %RTnaipv4 ignored\n", pNewBinding->m_addr.u));
768	return VERR_OUT_OF_RANGE;
769	}
770
771	for (bindings_t::iterator it = m_bindings.begin(); it != m_bindings.end(); ++it)
772	{
773	Binding b = it;
774
775	if (pNewBinding->m_addr.u == b->m_addr.u)
776	{
777	LogRel(("> ADD: %R[binding]\n", pNewBinding));
778	LogRel(("> .... duplicate ip: %R[binding]\n", b));
779	return VERR_DUPLICATE;
780	}
781
782	if (pNewBinding->m_id == b->m_id)
783	{
784	LogRel(("> ADD: %R[binding]\n", pNewBinding));
785	LogRel(("> .... duplicate id: %R[binding]\n", b));
786	return VERR_DUPLICATE;
787	}
788	}
789
790	/*
791	* Allocate the address and add the binding to the list.
792	*/
793	AssertLogRelMsgReturn(m_pool.allocate(pNewBinding->m_addr),
794	("> ADD: failed to claim IP %R[binding]\n", pNewBinding),
795	VERR_INTERNAL_ERROR);
796	try
797	{
798	m_bindings.push_back(pNewBinding);
799	}
800	catch (std::bad_alloc &)
801	{
802	return VERR_NO_MEMORY;
803	}
804	return VINF_SUCCESS;
805	}
806
807
808	/**
809	* Called by DHCP to cancel an offset.
810	*
811	* @param req The DHCP request.
812	*/
813	void Db::cancelOffer(const DhcpClientMessage &req) RT_NOEXCEPT
814	{
815	const OptRequestedAddress reqAddr(req);
816	if (!reqAddr.present())
817	return;
818
819	const RTNETADDRIPV4 addr = reqAddr.value();
820	const ClientId &id(req.clientId());
821
822	for (bindings_t::iterator it = m_bindings.begin(); it != m_bindings.end(); ++it)
823	{
824	Binding b = it;
825
826	if (b->addr().u == addr.u && b->id() == id)
827	{
828	if (b->state() == Binding::OFFERED)
829	{
830	LogRel2(("Db::cancelOffer: cancelling %R[binding]\n", b));
831	if (!b->isFixed())
832	{
833	b->setLeaseTime(0);
834	b->setState(Binding::RELEASED);
835	}
836	else
837	b->setState(Binding::ACKED);
838	}
839	else
840	LogRel2(("Db::cancelOffer: not offered state: %R[binding]\n", b));
841	return;
842	}
843	}
844	LogRel2(("Db::cancelOffer: not found (%RTnaipv4, %R[id])\n", addr.u, &id));
845	}
846
847
848	/**
849	* Called by DHCP to cancel an offset.
850	*
851	* @param req The DHCP request.
852	* @returns true if found and released, otherwise false.
853	* @throws nothing
854	*/
855	bool Db::releaseBinding(const DhcpClientMessage &req) RT_NOEXCEPT
856	{
857	const RTNETADDRIPV4 addr = req.ciaddr();
858	const ClientId &id(req.clientId());
859
860	for (bindings_t::iterator it = m_bindings.begin(); it != m_bindings.end(); ++it)
861	{
862	Binding b = it;
863
864	if (b->addr().u == addr.u && b->id() == id)
865	{
866	LogRel2(("Db::releaseBinding: releasing %R[binding]\n", b));
867	if (!b->isFixed())
868	{
869	b->setState(Binding::RELEASED);
870	return true;
871	}
872	b->setState(Binding::ACKED);
873	return false;
874	}
875	}
876
877	LogRel2(("Db::releaseBinding: not found (%RTnaipv4, %R[id])\n", addr.u, &id));
878	return false;
879	}
880
881
882	/**
883	* Called by DHCPD to write out the lease database to @a strFilename.
884	*
885	* @returns IPRT status code.
886	* @param strFilename The file to write it to.
887	*/
888	int Db::writeLeases(const RTCString &strFilename) const RT_NOEXCEPT
889	{
890	LogRel(("writing leases to %s\n", strFilename.c_str()));
891
892	/** @todo This could easily be written directly to the file w/o going thru
893	* a xml::Document, xml::XmlFileWriter, hammering the heap and being
894	* required to catch a lot of different exceptions at various points.
895	* (RTStrmOpen, bunch of RTStrmPrintf using \%RMas and \%RMes.,
896	* RTStrmClose closely followed by a couple of renames.)
897	*/
898
899	/*
900	* Create the document and root element.
901	*/
902	xml::Document doc;
903	try
904	{
905	xml::ElementNode *pElmRoot = doc.createRootElement("Leases");
906	pElmRoot->setAttribute("version", "1.0");
907
908	/*
909	* Add the leases.
910	*/
911	for (bindings_t::const_iterator it = m_bindings.begin(); it != m_bindings.end(); ++it)
912	{
913	const Binding b = it;
914	if (!b->isFixed())
915	b->toXML(pElmRoot);
916	}
917	}
918	catch (std::bad_alloc &)
919	{
920	return VERR_NO_MEMORY;
921	}
922
923	/*
924	* Write the document to the specified file in a safe manner (written to temporary
925	* file, renamed to destination on success)
926	*/
927	try
928	{
929	xml::XmlFileWriter writer(doc);
930	writer.write(strFilename.c_str(), true /fSafe/);
931	}
932	catch (const xml::EIPRTFailure &e)
933	{
934	LogRel(("%s\n", e.what()));
935	return e.rc();
936	}
937	catch (const RTCError &e)
938	{
939	LogRel(("%s\n", e.what()));
940	return VERR_GENERAL_FAILURE;
941	}
942	catch (...)
943	{
944	LogRel(("Unknown exception while writing '%s'\n", strFilename.c_str()));
945	return VERR_UNEXPECTED_EXCEPTION;
946	}
947
948	return VINF_SUCCESS;
949	}
950
951
952	/**
953	* Called by DHCPD to load the lease database to @a strFilename.
954	*
955	* @note Does not clear the database state before doing the load.
956	*
957	* @returns IPRT status code.
958	* @param strFilename The file to load it from.
959	* @throws nothing
960	*/
961	int Db::loadLeases(const RTCString &strFilename) RT_NOEXCEPT
962	{
963	LogRel(("loading leases from %s\n", strFilename.c_str()));
964
965	/*
966	* Load the file into an XML document.
967	*/
968	xml::Document doc;
969	try
970	{
971	xml::XmlFileParser parser;
972	parser.read(strFilename.c_str(), doc);
973	}
974	catch (const xml::EIPRTFailure &e)
975	{
976	LogRel(("%s\n", e.what()));
977	return e.rc();
978	}
979	catch (const RTCError &e)
980	{
981	LogRel(("%s\n", e.what()));
982	return VERR_GENERAL_FAILURE;
983	}
984	catch (...)
985	{
986	LogRel(("Unknown exception while reading and parsing '%s'\n", strFilename.c_str()));
987	return VERR_UNEXPECTED_EXCEPTION;
988	}
989
990	/*
991	* Check that the root element is "Leases" and process its children.
992	*/
993	xml::ElementNode *pElmRoot = doc.getRootElement();
994	if (!pElmRoot)
995	{
996	LogRel(("No root element in '%s'\n", strFilename.c_str()));
997	return VERR_NOT_FOUND;
998	}
999	if (!pElmRoot->nameEquals("Leases"))
1000	{
1001	LogRel(("No root element is not 'Leases' in '%s', but '%s'\n", strFilename.c_str(), pElmRoot->getName()));
1002	return VERR_NOT_FOUND;
1003	}
1004
1005	int rc = VINF_SUCCESS;
1006	xml::NodesLoop it(*pElmRoot);
1007	const xml::ElementNode *pElmLease;
1008	while ((pElmLease = it.forAllNodes()) != NULL)
1009	{
1010	if (pElmLease->nameEquals("Lease"))
1011	{
1012	int rc2 = i_loadLease(pElmLease);
1013	if (RT_SUCCESS(rc2))
1014	{ /* likely */ }
1015	else if (rc2 == VERR_NO_MEMORY)
1016	return rc2;
1017	else
1018	rc = -rc2;
1019	}
1020	else
1021	LogRel(("Ignoring unexpected element '%s' under 'Leases'...\n", pElmLease->getName()));
1022	}
1023
1024	return rc;
1025	}
1026
1027
1028	/**
1029	* Internal worker for loadLeases() that handles one 'Lease' element.
1030	*
1031	* @param pElmLease The 'Lease' element to handle.
1032	* @return IPRT status code.
1033	*/
1034	int Db::i_loadLease(const xml::ElementNode *pElmLease) RT_NOEXCEPT
1035	{
1036	Binding *pBinding = NULL;
1037	try
1038	{
1039	pBinding = Binding::fromXML(pElmLease);
1040	}
1041	catch (std::bad_alloc &)
1042	{
1043	return VERR_NO_MEMORY;
1044	}
1045	if (pBinding)
1046	{
1047	bool fExpired = pBinding->expire();
1048	if (!fExpired)
1049	LogRel(("> LOAD: lease %R[binding]\n", pBinding));
1050	else
1051	LogRel(("> LOAD: EXPIRED lease %R[binding]\n", pBinding));
1052
1053	int rc = i_addBinding(pBinding);
1054	if (RT_FAILURE(rc))
1055	delete pBinding;
1056	return rc;
1057	}
1058	LogRel(("> LOAD: failed to load lease!\n"));
1059	return VERR_PARSE_ERROR;
1060	}

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

source: vbox/trunk/src/VBox/NetworkServices/Dhcpd/Db.cpp@ 103075

Download in other formats: