VBoxNetDhcpd.cpp@ 70836

Last change on this file since 70836 was 70836, checked in by vboxsync, 7 years ago
NetworkServices/Dhcpd: export fix
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 19.7 KB

Line
1	/* $Id: VBoxNetDhcpd.cpp 70836 2018-01-31 14:55:44Z vboxsync $ */
2	/** @file
3	* VBoxNetDhcpd - DHCP server for host-only and NAT networks.
4	*/
5
6	/*
7	* Copyright (C) 2009-2018 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 <iprt/cdefs.h>
19	#include <iprt/param.h>
20	#include <iprt/err.h>
21
22	#include <iprt/initterm.h>
23	#include <iprt/message.h>
24
25	#include <iprt/net.h>
26	#include <iprt/path.h>
27	#include <iprt/stream.h>
28
29	#include <VBox/sup.h>
30	#include <VBox/vmm/vmm.h>
31	#include <VBox/vmm/pdmnetinline.h>
32	#include <VBox/intnet.h>
33	#include <VBox/intnetinline.h>
34
35	#include <VBox/com/com.h>
36
37	#include "VBoxLwipCore.h"
38	#include "Config.h"
39	#include "DHCPD.h"
40	#include "DhcpMessage.h"
41
42	extern "C"
43	{
44	#include "lwip/sys.h"
45	#include "lwip/pbuf.h"
46	#include "lwip/netif.h"
47	#include "lwip/tcpip.h"
48	#include "lwip/udp.h"
49	#include "netif/etharp.h"
50	}
51
52	#include <string>
53	#include <vector>
54	#include <memory>
55
56
57	struct delete_pbuf
58	{
59	delete_pbuf() {}
60	void operator()(struct pbuf *p) const { pbuf_free(p); }
61	};
62
63	typedef std::unique_ptr<pbuf, delete_pbuf> unique_ptr_pbuf;
64
65
66	#define CALL_VMMR0(op, req) \
67	(SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, (op), 0, &(req).Hdr))
68
69
70	class VBoxNetDhcpd
71	{
72	DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(VBoxNetDhcpd);
73
74	private:
75	/* intnet plumbing */
76	PSUPDRVSESSION m_pSession;
77	INTNETIFHANDLE m_hIf;
78	PINTNETBUF m_pIfBuf;
79
80	/* lwip stack connected to the intnet */
81	struct netif m_LwipNetif;
82
83	/* path of ~/.VirtualBox or equivalent */
84	std::string m_strHome;
85
86	Config *m_Config;
87
88	/* listening pcb */
89	struct udp_pcb *m_Dhcp4Pcb;
90
91	DHCPD m_server;
92
93	public:
94	VBoxNetDhcpd();
95	~VBoxNetDhcpd();
96
97	int main(int argc, char **argv);
98
99	private:
100	void homeInit();
101	int logInit(const std::string &strBaseName);
102
103	/*
104	* Boilerplate code.
105	*/
106	int r3Init();
107	void r3Fini();
108
109	int vmmInit();
110
111	int ifInit(const std::string &strNetwork,
112	const std::string &strTrunk = std::string(),
113	INTNETTRUNKTYPE enmTrunkType = kIntNetTrunkType_WhateverNone);
114	int ifOpen(const std::string &strNetwork,
115	const std::string &strTrunk,
116	INTNETTRUNKTYPE enmTrunkType);
117	int ifGetBuf();
118	int ifActivate();
119
120	int ifWait(uint32_t cMillies = RT_INDEFINITE_WAIT);
121	int ifProcessInput();
122	int ifFlush();
123
124	int ifClose();
125
126	void ifPump();
127	int ifInput(void *pvSegFrame, uint32_t cbSegFrame);
128
129	int ifOutput(PCINTNETSEG paSegs, size_t cSegs, size_t cbFrame);
130
131
132	/*
133	* lwIP callbacks
134	*/
135	static DECLCALLBACK(void) lwipInitCB(void *pvArg);
136	void lwipInit();
137
138	static err_t netifInitCB(netif *pNetif);
139	err_t netifInit(netif *pNetif);
140
141	static err_t netifLinkOutputCB(netif pNetif, pbuf pPBuf);
142	err_t netifLinkOutput(pbuf *pPBuf);
143
144	static void dhcp4RecvCB(void arg, struct udp_pcb pcb, struct pbuf *p,
145	ip_addr_t *addr, u16_t port);
146	void dhcp4Recv(struct udp_pcb pcb, struct pbuf p, ip_addr_t *addr, u16_t port);
147	};
148
149
150	VBoxNetDhcpd::VBoxNetDhcpd()
151	: m_pSession(NIL_RTR0PTR),
152	m_hIf(INTNET_HANDLE_INVALID),
153	m_pIfBuf(NULL),
154	m_LwipNetif(),
155	m_Config(NULL),
156	m_Dhcp4Pcb(NULL)
157	{
158	int rc;
159
160	rc = r3Init();
161	if (RT_FAILURE(rc))
162	return;
163
164	vmmInit();
165	}
166
167
168	VBoxNetDhcpd::~VBoxNetDhcpd()
169	{
170	ifClose();
171	r3Fini();
172	}
173
174
175	int VBoxNetDhcpd::r3Init()
176	{
177	AssertReturn(m_pSession == NIL_RTR0PTR, VERR_GENERAL_FAILURE);
178
179	int rc = SUPR3Init(&m_pSession);
180	return rc;
181	}
182
183
184	void VBoxNetDhcpd::r3Fini()
185	{
186	if (m_pSession == NIL_RTR0PTR)
187	return;
188
189	SUPR3Term();
190	m_pSession = NIL_RTR0PTR;
191	}
192
193
194	int VBoxNetDhcpd::vmmInit()
195	{
196	int rc;
197	try {
198	std::vector<char> vExecDir(RTPATH_MAX);
199	rc = RTPathExecDir(&vExecDir.front(), vExecDir.size());
200	if (RT_FAILURE(rc))
201	return rc;
202	std::string strPath(&vExecDir.front());
203	strPath.append("/VMMR0.r0");
204
205	rc = SUPR3LoadVMM(strPath.c_str());
206	if (RT_FAILURE(rc))
207	return rc;
208
209	rc = VINF_SUCCESS;
210	}
211	catch (...)
212	{
213	rc = VERR_GENERAL_FAILURE;
214	}
215
216	return rc;
217	}
218
219
220	int VBoxNetDhcpd::ifInit(const std::string &strNetwork,
221	const std::string &strTrunk,
222	INTNETTRUNKTYPE enmTrunkType)
223	{
224	int rc;
225
226	rc = ifOpen(strNetwork, strTrunk, enmTrunkType);
227	if (RT_FAILURE(rc))
228	return rc;
229
230	rc = ifGetBuf();
231	if (RT_FAILURE(rc))
232	return rc;
233
234	rc = ifActivate();
235	if (RT_FAILURE(rc))
236	return rc;
237
238	return VINF_SUCCESS;
239	}
240
241
242	int VBoxNetDhcpd::ifOpen(const std::string &strNetwork,
243	const std::string &strTrunk,
244	INTNETTRUNKTYPE enmTrunkType)
245	{
246	AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
247	AssertReturn(m_hIf == INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
248
249	INTNETOPENREQ OpenReq;
250	int rc;
251
252	OpenReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
253	OpenReq.Hdr.cbReq = sizeof(OpenReq);
254	OpenReq.pSession = m_pSession;
255
256	strncpy(OpenReq.szNetwork, strNetwork.c_str(), sizeof(OpenReq.szNetwork));
257	OpenReq.szNetwork[sizeof(OpenReq.szNetwork) - 1] = '\0';
258
259	strncpy(OpenReq.szTrunk, strTrunk.c_str(), sizeof(OpenReq.szTrunk));
260	OpenReq.szTrunk[sizeof(OpenReq.szTrunk) - 1] = '\0';
261
262	OpenReq.enmTrunkType = enmTrunkType;
263
264	OpenReq.fFlags = 0;
265	OpenReq.cbSend = 128 * _1K;
266	OpenReq.cbRecv = 256 * _1K;
267
268	OpenReq.hIf = INTNET_HANDLE_INVALID;
269
270	rc = CALL_VMMR0(VMMR0_DO_INTNET_OPEN, OpenReq);
271	if (RT_FAILURE(rc))
272	return rc;
273
274	m_hIf = OpenReq.hIf;
275	AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
276
277	return VINF_SUCCESS;
278	}
279
280
281	int VBoxNetDhcpd::ifGetBuf()
282	{
283	AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
284	AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
285	AssertReturn(m_pIfBuf == NULL, VERR_GENERAL_FAILURE);
286
287	INTNETIFGETBUFFERPTRSREQ GetBufferPtrsReq;
288	int rc;
289
290	GetBufferPtrsReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
291	GetBufferPtrsReq.Hdr.cbReq = sizeof(GetBufferPtrsReq);
292	GetBufferPtrsReq.pSession = m_pSession;
293	GetBufferPtrsReq.hIf = m_hIf;
294
295	GetBufferPtrsReq.pRing0Buf = NIL_RTR0PTR;
296	GetBufferPtrsReq.pRing3Buf = NULL;
297
298	rc = CALL_VMMR0(VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS, GetBufferPtrsReq);
299	if (RT_FAILURE(rc))
300	return rc;
301
302	m_pIfBuf = GetBufferPtrsReq.pRing3Buf;
303	AssertReturn(m_pIfBuf != NULL, VERR_GENERAL_FAILURE);
304
305	return VINF_SUCCESS;
306	}
307
308
309	int VBoxNetDhcpd::ifActivate()
310	{
311	AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
312	AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
313	AssertReturn(m_pIfBuf != NULL, VERR_GENERAL_FAILURE);
314
315	INTNETIFSETACTIVEREQ ActiveReq;
316	int rc;
317
318	ActiveReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
319	ActiveReq.Hdr.cbReq = sizeof(ActiveReq);
320	ActiveReq.pSession = m_pSession;
321	ActiveReq.hIf = m_hIf;
322
323	ActiveReq.fActive = 1;
324
325	rc = CALL_VMMR0(VMMR0_DO_INTNET_IF_SET_ACTIVE, ActiveReq);
326	return rc;
327	}
328
329
330	void VBoxNetDhcpd::ifPump()
331	{
332	for (;;)
333	{
334	int rc = ifWait();
335
336	if (RT_UNLIKELY(rc == VERR_INTERRUPTED))
337	continue;
338
339	#if 0 /* we wait indefinitely */
340	if (rc == VERR_TIMEOUT)
341	...;
342	#endif
343
344	if (RT_FAILURE(rc))
345	return;
346
347	ifProcessInput();
348	}
349	}
350
351
352	int VBoxNetDhcpd::ifWait(uint32_t cMillies)
353	{
354	AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
355	AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
356
357	INTNETIFWAITREQ WaitReq;
358	int rc;
359
360	WaitReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
361	WaitReq.Hdr.cbReq = sizeof(WaitReq);
362	WaitReq.pSession = m_pSession;
363	WaitReq.hIf = m_hIf;
364
365	WaitReq.cMillies = cMillies;
366
367	rc = CALL_VMMR0(VMMR0_DO_INTNET_IF_WAIT, WaitReq);
368	return rc;
369	}
370
371
372	int VBoxNetDhcpd::ifProcessInput()
373	{
374	AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
375	AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
376	AssertReturn(m_pIfBuf != NULL, VERR_GENERAL_FAILURE);
377
378	for (PCINTNETHDR pHdr;
379	(pHdr = IntNetRingGetNextFrameToRead(&m_pIfBuf->Recv)) != NULL;
380	IntNetRingSkipFrame(&m_pIfBuf->Recv))
381	{
382	const uint8_t u8Type = pHdr->u8Type;
383	void *pvSegFrame;
384	uint32_t cbSegFrame;
385
386	if (u8Type == INTNETHDR_TYPE_FRAME)
387	{
388	pvSegFrame = IntNetHdrGetFramePtr(pHdr, m_pIfBuf);
389	cbSegFrame = pHdr->cbFrame;
390
391	ifInput(pvSegFrame, cbSegFrame);
392	}
393	else if (u8Type == INTNETHDR_TYPE_GSO)
394	{
395	PCPDMNETWORKGSO pGso;
396	size_t cbGso = pHdr->cbFrame;
397	size_t cbFrame = cbGso - sizeof(PDMNETWORKGSO);
398
399	pGso = IntNetHdrGetGsoContext(pHdr, m_pIfBuf);
400	if (!PDMNetGsoIsValid(pGso, cbGso, cbFrame))
401	continue;
402
403	const uint32_t cSegs = PDMNetGsoCalcSegmentCount(pGso, cbFrame);
404	for (uint32_t i = 0; i < cSegs; ++i)
405	{
406	uint8_t abHdrScratch[256];
407	pvSegFrame = PDMNetGsoCarveSegmentQD(pGso, (uint8_t *)(pGso + 1), cbFrame,
408	abHdrScratch,
409	i, cSegs,
410	&cbSegFrame);
411	ifInput(pvSegFrame, cbFrame);
412	}
413	}
414	}
415
416	return VINF_SUCCESS;
417	}
418
419
420	/*
421	* Got a frame from the internal network, feed it to the lwIP stack.
422	*/
423	int VBoxNetDhcpd::ifInput(void *pvFrame, uint32_t cbFrame)
424	{
425	if (pvFrame == NULL)
426	return VERR_INVALID_PARAMETER;
427
428	if ( cbFrame <= sizeof(RTNETETHERHDR)
429	\|\| cbFrame > UINT16_MAX - ETH_PAD_SIZE)
430	return VERR_INVALID_PARAMETER;
431
432	struct pbuf *p = pbuf_alloc(PBUF_RAW, (u16_t)cbFrame + ETH_PAD_SIZE, PBUF_POOL);
433	if (RT_UNLIKELY(p == NULL))
434	return VERR_NO_MEMORY;
435
436	/*
437	* The code below is inlined version of:
438	*
439	* pbuf_header(p, -ETH_PAD_SIZE); // hide padding
440	* pbuf_take(p, pvFrame, cbFrame);
441	* pbuf_header(p, ETH_PAD_SIZE); // reveal padding
442	*/
443	struct pbuf *q = p;
444	uint8_t pu8Chunk = (uint8_t )pvFrame;
445	do {
446	uint8_t payload = (uint8_t )q->payload;
447	size_t len = q->len;
448
449	#if ETH_PAD_SIZE
450	if (RT_LIKELY(q == p)) /* single pbuf is large enough */
451	{
452	payload += ETH_PAD_SIZE;
453	len -= ETH_PAD_SIZE;
454	}
455	#endif
456	memcpy(payload, pu8Chunk, len);
457	pu8Chunk += len;
458	q = q->next;
459	} while (RT_UNLIKELY(q != NULL));
460
461	m_LwipNetif.input(p, &m_LwipNetif);
462	return VINF_SUCCESS;
463	}
464
465
466	/*
467	* Got a frame from the lwIP stack, feed it to the internal network.
468	*/
469	err_t VBoxNetDhcpd::netifLinkOutput(pbuf *pPBuf)
470	{
471	PINTNETHDR pHdr;
472	void *pvFrame;
473	u16_t cbFrame;
474	int rc;
475
476	if (pPBuf->tot_len < sizeof(struct eth_hdr)) /* includes ETH_PAD_SIZE */
477	return ERR_ARG;
478
479	cbFrame = pPBuf->tot_len - ETH_PAD_SIZE;
480	rc = IntNetRingAllocateFrame(&m_pIfBuf->Send, cbFrame, &pHdr, &pvFrame);
481	if (RT_FAILURE(rc))
482	return ERR_MEM;
483
484	pbuf_copy_partial(pPBuf, pvFrame, cbFrame, ETH_PAD_SIZE);
485	IntNetRingCommitFrameEx(&m_pIfBuf->Send, pHdr, cbFrame);
486
487	ifFlush();
488	return ERR_OK;
489	}
490
491
492	int VBoxNetDhcpd::ifFlush()
493	{
494	INTNETIFSENDREQ SendReq;
495	int rc;
496
497	SendReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
498	SendReq.Hdr.cbReq = sizeof(SendReq);
499	SendReq.pSession = m_pSession;
500
501	SendReq.hIf = m_hIf;
502
503	rc = CALL_VMMR0(VMMR0_DO_INTNET_IF_SEND, SendReq);
504	return rc;
505	}
506
507
508	int VBoxNetDhcpd::ifClose()
509	{
510	if (m_hIf == INTNET_HANDLE_INVALID)
511	return VINF_SUCCESS;
512
513	INTNETIFCLOSEREQ CloseReq;
514
515	CloseReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
516	CloseReq.Hdr.cbReq = sizeof(CloseReq);
517	CloseReq.pSession = m_pSession;
518
519	CloseReq.hIf = m_hIf;
520
521	m_hIf = INTNET_HANDLE_INVALID;
522	m_pIfBuf = NULL;
523
524	CALL_VMMR0(VMMR0_DO_INTNET_IF_CLOSE, CloseReq);
525	return VINF_SUCCESS;
526	}
527
528
529	/* static / DECLCALLBACK(void) VBoxNetDhcpd::lwipInitCB(void pvArg)
530	{
531	AssertPtrReturnVoid(pvArg);
532
533	VBoxNetDhcpd self = static_cast<VBoxNetDhcpd >(pvArg);
534	self->lwipInit();
535	}
536
537
538	/* static / err_t VBoxNetDhcpd::netifInitCB(netif pNetif)
539	{
540	AssertPtrReturn(pNetif, ERR_ARG);
541
542	VBoxNetDhcpd self = static_cast<VBoxNetDhcpd >(pNetif->state);
543	return self->netifInit(pNetif);
544	}
545
546
547	/* static / err_t VBoxNetDhcpd::netifLinkOutputCB(netif pNetif, pbuf *pPBuf)
548	{
549	AssertPtrReturn(pNetif, ERR_ARG);
550	AssertPtrReturn(pPBuf, ERR_ARG);
551
552	VBoxNetDhcpd self = static_cast<VBoxNetDhcpd >(pNetif->state);
553	AssertPtrReturn(self, ERR_IF);
554
555	return self->netifLinkOutput(pPBuf);
556	}
557
558
559	/* static / void VBoxNetDhcpd::dhcp4RecvCB(void arg, struct udp_pcb *pcb,
560	struct pbuf *p,
561	ip_addr_t *addr, u16_t port)
562	{
563	AssertPtrReturnVoid(arg);
564
565	VBoxNetDhcpd self = static_cast<VBoxNetDhcpd >(arg);
566	self->dhcp4Recv(pcb, p, addr, port);
567	pbuf_free(p);
568	}
569
570
571
572
573
574	int VBoxNetDhcpd::main(int argc, char **argv)
575	{
576	int rc;
577
578	ClientId::registerFormat();
579
580	if (argc < 2)
581	m_Config = Config::hardcoded();
582	else
583	m_Config = Config::compat(argc, argv);
584
585	if (m_Config == NULL)
586	return RTEXITCODE_FAILURE;
587
588	homeInit();
589	m_Config->setHome(m_strHome);
590
591	logInit(m_Config->getBaseName());
592
593	rc = m_server.init(m_Config);
594
595	/* connect to the intnet */
596	rc = ifInit(m_Config->getNetwork(),
597	m_Config->getTrunk(),
598	m_Config->getTrunkType());
599	if (RT_FAILURE(rc))
600	return rc;
601
602	/* setup lwip */
603	rc = vboxLwipCoreInitialize(lwipInitCB, this);
604	if (RT_FAILURE(rc))
605	return rc;
606
607	ifPump();
608	return VINF_SUCCESS;
609	}
610
611
612	void VBoxNetDhcpd::homeInit()
613	{
614	int rc;
615
616	/* pathname of ~/.VirtualBox or equivalent */
617	char szHome[RTPATH_MAX];
618	rc = com::GetVBoxUserHomeDirectory(szHome, sizeof(szHome), false);
619	if (RT_FAILURE(rc))
620	return;
621
622	m_strHome.assign(szHome);
623	}
624
625
626	int VBoxNetDhcpd::logInit(const std::string &strBaseName)
627	{
628	int rc;
629	size_t cch;
630
631	/* default log file name */
632	char szLogFile[RTPATH_MAX];
633	cch = RTStrPrintf(szLogFile, sizeof(szLogFile),
634	"%s%c%s-Dhcpd.log",
635	m_strHome.c_str(), RTPATH_DELIMITER, strBaseName.c_str());
636	if (cch >= sizeof(szLogFile))
637	return VERR_BUFFER_OVERFLOW;
638
639
640	/* get a writable copy of the base name */
641	char szBaseName[RTPATH_MAX];
642	rc = RTStrCopy(szBaseName, sizeof(szBaseName), strBaseName.c_str());
643	if (RT_FAILURE(rc))
644	return rc;
645
646	/* sanitize base name some more to be usable in an environment variable name */
647	for (char p = szBaseName; p != '\0'; ++p)
648	{
649	if ( *p != '_'
650	&& (p < '0' \|\| '9' < p)
651	&& (p < 'a' \|\| 'z' < p)
652	&& (p < 'A' \|\| 'Z' < p))
653	{
654	*p = '_';
655	}
656	}
657
658
659	/* name of the environment variable to control logging */
660	char szEnvVarBase[128];
661	cch = RTStrPrintf(szEnvVarBase, sizeof(szEnvVarBase),
662	"VBOXDHCP_%s_RELEASE_LOG", szBaseName);
663	if (cch >= sizeof(szEnvVarBase))
664	return VERR_BUFFER_OVERFLOW;
665
666
667	rc = com::VBoxLogRelCreate("DHCP Server",
668	szLogFile,
669	RTLOGFLAGS_PREFIX_TIME_PROG,
670	"all all.restrict -default.restrict",
671	szEnvVarBase,
672	RTLOGDEST_FILE
673	#ifdef DEBUG
674	\| RTLOGDEST_STDERR
675	#endif
676	,
677	32768 /* cMaxEntriesPerGroup */,
678	0 /* cHistory */,
679	0 /* uHistoryFileTime */,
680	0 /* uHistoryFileSize */,
681	NULL /* pErrInfo */);
682
683	return rc;
684	}
685
686
687	void VBoxNetDhcpd::lwipInit()
688	{
689	err_t error;
690
691	ip_addr_t addr, mask;
692	ip4_addr_set_u32(&addr, m_Config->getIPv4Address().u);
693	ip4_addr_set_u32(&mask, m_Config->getIPv4Netmask().u);
694
695	netif *pNetif = netif_add(&m_LwipNetif,
696	&addr, &mask,
697	IP_ADDR_ANY, /* gateway */
698	this, /* state */
699	VBoxNetDhcpd::netifInitCB, /* netif_init_fn */
700	tcpip_input); /* netif_input_fn */
701	if (pNetif == NULL)
702	return;
703
704	netif_set_up(pNetif);
705	netif_set_link_up(pNetif);
706
707	m_Dhcp4Pcb = udp_new();
708	if (RT_UNLIKELY(m_Dhcp4Pcb == NULL))
709	return; /* XXX? */
710
711	ip_set_option(m_Dhcp4Pcb, SOF_BROADCAST);
712	udp_recv(m_Dhcp4Pcb, dhcp4RecvCB, this);
713
714	error = udp_bind(m_Dhcp4Pcb, IP_ADDR_ANY, RTNETIPV4_PORT_BOOTPS);
715	if (error != ERR_OK)
716	{
717	udp_remove(m_Dhcp4Pcb);
718	m_Dhcp4Pcb = NULL;
719	return; /* XXX? */
720	}
721	}
722
723
724	err_t VBoxNetDhcpd::netifInit(netif *pNetif)
725	{
726	pNetif->hwaddr_len = sizeof(RTMAC);
727	memcpy(pNetif->hwaddr, &m_Config->getMacAddress(), sizeof(RTMAC));
728
729	pNetif->mtu = 1500;
730
731	pNetif->flags = NETIF_FLAG_BROADCAST
732	\| NETIF_FLAG_ETHARP
733	\| NETIF_FLAG_ETHERNET;
734
735	pNetif->linkoutput = netifLinkOutputCB;
736	pNetif->output = etharp_output;
737
738	netif_set_default(pNetif);
739	return ERR_OK;
740	}
741
742
743	void VBoxNetDhcpd::dhcp4Recv(struct udp_pcb pcb, struct pbuf p,
744	ip_addr_t *addr, u16_t port)
745	{
746	err_t error;
747	int rc;
748
749	RT_NOREF(pcb, addr, port);
750
751	if (RT_UNLIKELY(p->next != NULL))
752	return; /* XXX: we want it in one chunk */
753
754	bool broadcasted = ip_addr_cmp(ip_current_dest_addr(), &ip_addr_broadcast)
755	\|\| ip_addr_cmp(ip_current_dest_addr(), &ip_addr_any);
756
757	DhcpClientMessage *msgIn = DhcpClientMessage::parse(broadcasted, p->payload, p->len);
758	if (msgIn == NULL)
759	return;
760
761	std::unique_ptr<DhcpClientMessage> autoFreeMsgIn(msgIn);
762
763	DhcpServerMessage msgOut = m_server.process(msgIn);
764	if (msgOut == NULL)
765	return;
766
767	std::unique_ptr<DhcpServerMessage> autoFreeMsgOut(msgOut);
768
769	ip_addr_t dst = { msgOut->dst().u };
770	if (ip_addr_isany(&dst))
771	ip_addr_copy(dst, ip_addr_broadcast);
772
773	octets_t data;
774	rc = msgOut->encode(data);
775	if (RT_FAILURE(rc))
776	return;
777
778	unique_ptr_pbuf q ( pbuf_alloc(PBUF_RAW, (u16_t)data.size(), PBUF_RAM) );
779	if (q == NULL)
780	return;
781
782	error = pbuf_take(q.get(), &data.front(), data.size());
783	if (error != ERR_OK)
784	return;
785
786	error = udp_sendto(pcb, q.get(), &dst, RTNETIPV4_PORT_BOOTPC);
787	if (error != ERR_OK)
788	return;
789	}
790
791
792
793
794	/*
795	* Entry point.
796	*/
797	extern "C" DECLEXPORT(int) TrustedMain(int argc, char **argv)
798	{
799	VBoxNetDhcpd Dhcpd;
800	int rc = Dhcpd.main(argc, argv);
801
802	return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
803	}
804
805
806	#ifndef VBOX_WITH_HARDENING
807
808	int main(int argc, char **argv)
809	{
810	int rc = RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_SUPLIB);
811	if (RT_FAILURE(rc))
812	return RTMsgInitFailure(rc);
813
814	return TrustedMain(argc, argv);
815	}
816
817
818	# ifdef RT_OS_WINDOWS
819	/** (We don't want a console usually.) */
820	int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
821	{
822	RT_NOREF(hInstance, hPrevInstance, lpCmdLine, nCmdShow);
823
824	return main(__argc, __argv);
825	}
826	# endif /* RT_OS_WINDOWS */
827
828	#endif /* !VBOX_WITH_HARDENING */

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

source: vbox/trunk/src/VBox/NetworkServices/Dhcpd/VBoxNetDhcpd.cpp@ 70836

Download in other formats: