tstIntNet-1.cpp@ 57358

Last change on this file since 57358 was 57358, checked in by vboxsync, 9 years ago
*: scm cleanup run.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 36.5 KB

Line
1	/* $Id: tstIntNet-1.cpp 57358 2015-08-14 15:16:38Z vboxsync $ */
2	/** @file
3	* VBox - Testcase for internal networking, simple NetFlt trunk creation.
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#include <VBox/intnet.h>
23	#include <VBox/intnetinline.h>
24	#include <VBox/vmm/pdmnetinline.h>
25	#include <VBox/sup.h>
26	#include <VBox/vmm/vmm.h>
27	#include <VBox/err.h>
28	#include <iprt/initterm.h>
29	#include <iprt/alloc.h>
30	#include <iprt/path.h>
31	#include <iprt/stream.h>
32	#include <iprt/string.h>
33	#include <iprt/thread.h>
34	#include <iprt/param.h>
35	#include <iprt/getopt.h>
36	#include <iprt/rand.h>
37	#include <iprt/log.h>
38	#include <iprt/crc.h>
39	#include <iprt/net.h>
40
41	#include "../Pcap.h"
42
43
44	/*********************************************************************************************************************************
45	* Global Variables *
46	*********************************************************************************************************************************/
47	static int g_cErrors = 0;
48	static uint64_t g_StartTS = 0;
49	static uint32_t g_DhcpXID = 0;
50	static bool g_fDhcpReply = false;
51	static bool g_fPingReply = false;
52	static uint32_t g_cOtherPkts = 0;
53	static uint32_t g_cArpPkts = 0;
54	static uint32_t g_cIpv4Pkts = 0;
55	static uint32_t g_cUdpPkts = 0;
56	static uint32_t g_cDhcpPkts = 0;
57	static uint32_t g_cTcpPkts = 0;
58
59
60	/**
61	* Error reporting wrapper.
62	*
63	* @param pErrStrm The stream to write the error message to. Can be NULL.
64	* @param pszFormat The message format string.
65	* @param ... Format arguments.
66	*/
67	static void tstIntNetError(PRTSTREAM pErrStrm, const char *pszFormat, ...)
68	{
69	if (!pErrStrm)
70	pErrStrm = g_pStdOut;
71
72	va_list va;
73	va_start(va, pszFormat);
74	RTStrmPrintf(pErrStrm, "tstIntNet-1: ERROR - ");
75	RTStrmPrintfV(pErrStrm, pszFormat, va);
76	va_end(va);
77
78	g_cErrors++;
79	}
80
81
82	/**
83	* Parses a frame an runs in thru the RTNet validation code so it gets
84	* some exercise.
85	*
86	* @param pvFrame Pointer to the ethernet frame.
87	* @param cbFrame The size of the ethernet frame.
88	* @param pErrStrm The error stream.
89	*/
90	static void tstIntNetTestFrame(void const *pvFrame, size_t cbFrame, PRTSTREAM pErrStrm, bool fGso)
91	{
92	/*
93	* Ethernet header.
94	*/
95	PCRTNETETHERHDR pEtherHdr = (PCRTNETETHERHDR)pvFrame;
96	if (cbFrame <= sizeof(*pEtherHdr))
97	return tstIntNetError(pErrStrm, "cbFrame=%#x <= %#x (ether)\n", cbFrame, sizeof(*pEtherHdr));
98	ssize_t cbLeft = cbFrame - sizeof(*pEtherHdr);
99	uint8_t const pbCur = (uint8_t const )(pEtherHdr + 1);
100
101	switch (RT_BE2H_U16(pEtherHdr->EtherType))
102	{
103	case RTNET_ETHERTYPE_ARP:
104	{
105	g_cArpPkts++;
106	break;
107	}
108
109	case RTNET_ETHERTYPE_IPV4:
110	{
111	g_cIpv4Pkts++;
112
113	PCRTNETIPV4 pIpHdr = (PCRTNETIPV4)pbCur;
114	if (!RTNetIPv4IsHdrValid(pIpHdr, cbLeft, cbLeft, !fGso /fChecksum/))
115	return tstIntNetError(pErrStrm, "RTNetIPv4IsHdrValid failed\n");
116	pbCur += pIpHdr->ip_hl * 4;
117	cbLeft -= pIpHdr->ip_hl * 4;
118	AssertFatal(cbLeft >= 0);
119
120	switch (pIpHdr->ip_p)
121	{
122	case RTNETIPV4_PROT_ICMP:
123	{
124	/** @todo ICMP? */
125	break;
126	}
127
128	case RTNETIPV4_PROT_UDP:
129	{
130	g_cUdpPkts++;
131	PCRTNETUDP pUdpHdr = (PCRTNETUDP)pbCur;
132	if (!RTNetIPv4IsUDPValid(pIpHdr, pUdpHdr, pUdpHdr + 1, cbLeft, !fGso /fChecksum/))
133	return tstIntNetError(pErrStrm, "RTNetIPv4IsUDPValid failed\n");
134	pbCur += sizeof(*pUdpHdr);
135	cbLeft -= sizeof(*pUdpHdr);
136
137	if (RT_BE2H_U16(pUdpHdr->uh_dport) == RTNETIPV4_PORT_BOOTPS)
138	{
139	g_cDhcpPkts++;
140	PCRTNETBOOTP pDhcp = (PCRTNETBOOTP)pbCur;
141	if (!RTNetIPv4IsDHCPValid(pUdpHdr, pDhcp, cbLeft, NULL))
142	return tstIntNetError(pErrStrm, "RTNetIPv4IsDHCPValid failed\n");
143	}
144	break;
145	}
146
147	case RTNETIPV4_PROT_TCP:
148	{
149	g_cTcpPkts++;
150	PCRTNETTCP pTcpHdr = (PCRTNETTCP)pbCur;
151	if (!RTNetIPv4IsTCPValid(pIpHdr, pTcpHdr, cbLeft, NULL, cbLeft, !fGso /fChecksum/))
152	return tstIntNetError(pErrStrm, "RTNetIPv4IsTCPValid failed\n");
153	break;
154	}
155	}
156	break;
157	}
158
159	//case RTNET_ETHERTYPE_IPV6:
160	default:
161	g_cOtherPkts++;
162	break;
163	}
164	}
165
166
167	/**
168	* Transmits one frame after appending the CRC.
169	*
170	* @param hIf The interface handle.
171	* @param pSession The session.
172	* @param pBuf The shared interface buffer.
173	* @param pvFrame The frame without a crc.
174	* @param cbFrame The size of it.
175	* @param pFileRaw The file to write the raw data to (optional).
176	* @param pFileText The file to write a textual packet summary to (optional).
177	*/
178	static void doXmitFrame(INTNETIFHANDLE hIf, PSUPDRVSESSION pSession, PINTNETBUF pBuf, void *pvFrame, size_t cbFrame, PRTSTREAM pFileRaw, PRTSTREAM pFileText)
179	{
180	/*
181	* Log it.
182	*/
183	if (pFileText)
184	{
185	PCRTNETETHERHDR pEthHdr = (PCRTNETETHERHDR)pvFrame;
186	uint64_t NanoTS = RTTimeNanoTS() - g_StartTS;
187	RTStrmPrintf(pFileText, "%3RU64.%09u: cb=%04x dst=%.6Rhxs src=%.6Rhxs type=%04x Send!\n",
188	NanoTS / 1000000000, (uint32_t)(NanoTS % 1000000000),
189	cbFrame, &pEthHdr->SrcMac, &pEthHdr->DstMac, RT_BE2H_U16(pEthHdr->EtherType));
190	}
191
192	/*
193	* Run in thru the frame validator to test the RTNet code.
194	*/
195	tstIntNetTestFrame(pvFrame, cbFrame, pFileText, false /fGso/);
196
197	/*
198	* Write the frame and push the queue.
199	*
200	* Don't bother with dealing with overflows like DrvIntNet does, because
201	* it's not supposed to happen here in this testcase.
202	*/
203	int rc = IntNetRingWriteFrame(&pBuf->Send, pvFrame, cbFrame);
204	if (RT_SUCCESS(rc))
205	{
206	if (pFileRaw)
207	PcapStreamFrame(pFileRaw, g_StartTS, pvFrame, cbFrame, 0xffff);
208	}
209	else
210	{
211	RTPrintf("tstIntNet-1: IntNetRingWriteFrame failed, %Rrc; cbFrame=%d pBuf->cbSend=%d\n", rc, cbFrame, pBuf->cbSend);
212	g_cErrors++;
213	}
214
215	INTNETIFSENDREQ SendReq;
216	SendReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
217	SendReq.Hdr.cbReq = sizeof(SendReq);
218	SendReq.pSession = pSession;
219	SendReq.hIf = hIf;
220	rc = SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, VMMR0_DO_INTNET_IF_SEND, 0, &SendReq.Hdr);
221	if (RT_FAILURE(rc))
222	{
223	RTPrintf("tstIntNet-1: SUPR3CallVMMR0Ex(,VMMR0_DO_INTNET_IF_SEND,) failed, rc=%Rrc\n", rc);
224	g_cErrors++;
225	}
226
227	}
228
229
230	/**
231	* Does the transmit test.
232	*
233	* @param hIf The interface handle.
234	* @param pSession The session.
235	* @param pBuf The shared interface buffer.
236	* @param pSrcMac The mac address to use as source.
237	* @param pFileRaw The file to write the raw data to (optional).
238	* @param pFileText The file to write a textual packet summary to (optional).
239	*/
240	static void doXmitTest(INTNETIFHANDLE hIf, PSUPDRVSESSION pSession, PINTNETBUF pBuf, PCRTMAC pSrcMac, PRTSTREAM pFileRaw, PRTSTREAM pFileText)
241	{
242	uint8_t abFrame[4096];
243	PRTNETETHERHDR pEthHdr = (PRTNETETHERHDR)&abFrame[0];
244	PRTNETIPV4 pIpHdr = (PRTNETIPV4) (pEthHdr + 1);
245	PRTNETUDP pUdpHdr = (PRTNETUDP) (pIpHdr + 1);
246	PRTNETDHCP pDhcpMsg = (PRTNETDHCP) (pUdpHdr + 1);
247
248	/*
249	* Create a simple DHCP broadcast request.
250	*/
251	memset(&abFrame, 0, sizeof(abFrame));
252
253	pDhcpMsg->Op = 1; /* request */
254	pDhcpMsg->HType = 1; /* ethernet */
255	pDhcpMsg->HLen = sizeof(RTMAC);
256	pDhcpMsg->Hops = 0;
257	pDhcpMsg->XID = g_DhcpXID = RTRandU32();
258	pDhcpMsg->Secs = 0;
259	pDhcpMsg->Flags = 0; /* unicast / //RT_H2BE_U16(0x8000); / broadcast */
260	pDhcpMsg->CIAddr.u = 0;
261	pDhcpMsg->YIAddr.u = 0;
262	pDhcpMsg->SIAddr.u = 0;
263	pDhcpMsg->GIAddr.u = 0;
264	memset(&pDhcpMsg->CHAddr[0], '\0', sizeof(pDhcpMsg->CHAddr));
265	memcpy(&pDhcpMsg->CHAddr[0], pSrcMac, sizeof(*pSrcMac));
266	memset(&pDhcpMsg->SName[0], '\0', sizeof(pDhcpMsg->SName));
267	memset(&pDhcpMsg->File[0], '\0', sizeof(pDhcpMsg->File));
268	pDhcpMsg->abMagic[0] = 99;
269	pDhcpMsg->abMagic[1] = 130;
270	pDhcpMsg->abMagic[2] = 83;
271	pDhcpMsg->abMagic[3] = 99;
272
273	pDhcpMsg->DhcpOpt = 53; /* DHCP Msssage Type option */
274	pDhcpMsg->DhcpLen = 1;
275	pDhcpMsg->DhcpReq = 1; /* DHCPDISCOVER */
276
277	memset(&pDhcpMsg->abOptions[0], '\0', sizeof(pDhcpMsg->abOptions));
278	uint8_t *pbOpt = &pDhcpMsg->abOptions[0];
279
280	pbOpt++ = 116; / DHCP Auto-Configure */
281	*pbOpt++ = 1;
282	*pbOpt++ = 1;
283
284	pbOpt++ = 61; / Client identifier */
285	pbOpt++ = 1 + sizeof(pSrcMac);
286	pbOpt++ = 1; / hw type: ethernet */
287	memcpy(pbOpt, pSrcMac, sizeof(*pSrcMac));
288	pbOpt += sizeof(*pSrcMac);
289
290	pbOpt++ = 12; / Host name */
291	*pbOpt++ = sizeof("tstIntNet-1") - 1;
292	memcpy(pbOpt, "tstIntNet-1", sizeof("tstIntNet-1") - 1);
293	pbOpt += sizeof("tstIntNet-1") - 1;
294
295	pbOpt = 0xff; / the end */
296
297	/* UDP */
298	pUdpHdr->uh_sport = RT_H2BE_U16(68); /* bootp */
299	pUdpHdr->uh_dport = RT_H2BE_U16(67); /* bootps */
300	pUdpHdr->uh_ulen = RT_H2BE_U16(sizeof(pDhcpMsg) + sizeof(pUdpHdr));
301	pUdpHdr->uh_sum = 0; /* pretend checksumming is disabled */
302
303	/* IP */
304	pIpHdr->ip_v = 4;
305	pIpHdr->ip_hl = sizeof(*pIpHdr) / sizeof(uint32_t);
306	pIpHdr->ip_tos = 0;
307	pIpHdr->ip_len = RT_H2BE_U16(sizeof(pDhcpMsg) + sizeof(pUdpHdr) + sizeof(*pIpHdr));
308	pIpHdr->ip_id = (uint16_t)RTRandU32();
309	pIpHdr->ip_off = 0;
310	pIpHdr->ip_ttl = 255;
311	pIpHdr->ip_p = 0x11; /* UDP */
312	pIpHdr->ip_sum = 0;
313	pIpHdr->ip_src.u = 0;
314	pIpHdr->ip_dst.u = UINT32_C(0xffffffff); /* broadcast */
315	pIpHdr->ip_sum = RTNetIPv4HdrChecksum(pIpHdr);
316
317	/* calc the UDP checksum. */
318	pUdpHdr->uh_sum = RTNetIPv4UDPChecksum(pIpHdr, pUdpHdr, pUdpHdr + 1);
319
320	/* Ethernet */
321	memset(&pEthHdr->DstMac, 0xff, sizeof(pEthHdr->DstMac)); /* broadcast */
322	pEthHdr->SrcMac = *pSrcMac;
323	pEthHdr->EtherType = RT_H2BE_U16(RTNET_ETHERTYPE_IPV4); /* IP */
324
325	doXmitFrame(hIf, pSession, pBuf, &abFrame[0], (uint8_t )(pDhcpMsg + 1) - (uint8_t )&abFrame[0], pFileRaw, pFileText);
326	}
327
328
329	static uint16_t icmpChecksum(PRTNETICMPV4HDR pHdr, size_t cbHdr)
330	{
331	size_t cbLeft = cbHdr;
332	uint16_t pbSrc = (uint16_t )pHdr;
333	uint16_t oddByte = 0;
334	int cSum = 0;
335
336	while (cbLeft > 1)
337	{
338	cSum += *pbSrc++;
339	cbLeft -= 2;
340	}
341
342	if (cbLeft == 1)
343	{
344	(uint16_t )(&oddByte) = (uint16_t )pbSrc;
345	cSum += oddByte;
346	}
347
348	cSum = (cSum >> 16) + (cSum & 0xffff);
349	cSum += (cSum >> 16);
350	uint16_t Result = ~cSum;
351	return Result;
352	}
353
354
355	/**
356	* Does the rudimentary ping test with fixed destination and source IPs.
357	*
358	* @param hIf The interface handle.
359	* @param pSession The session.
360	* @param pBuf The shared interface buffer.
361	* @param pSrcMac The mac address to use as source.
362	* @param pFileRaw The file to write the raw data to (optional).
363	* @param pFileText The file to write a textual packet summary to (optional).
364	*/
365	static void doPingTest(INTNETIFHANDLE hIf, PSUPDRVSESSION pSession, PINTNETBUF pBuf, PCRTMAC pSrcMac, PRTSTREAM pFileRaw, PRTSTREAM pFileText)
366	{
367	uint8_t abFrame[4096];
368	PRTNETETHERHDR pEthHdr = (PRTNETETHERHDR)&abFrame[0];
369	PRTNETIPV4 pIpHdr = (PRTNETIPV4) (pEthHdr + 1);
370	PRTNETICMPV4ECHO pIcmpEcho = (PRTNETICMPV4ECHO) (pIpHdr + 1);
371
372	/*
373	* Create a simple ping request.
374	*/
375	memset(&abFrame, 0, sizeof(abFrame));
376
377	pIcmpEcho->Hdr.icmp_type = RTNETICMPV4_TYPE_ECHO_REQUEST;
378	pIcmpEcho->Hdr.icmp_code = 0;
379	pIcmpEcho->icmp_id = 0x06;
380	pIcmpEcho->icmp_seq = 0x05;
381	size_t cbPad = 56;
382	memset(&pIcmpEcho->icmp_data, '\0', cbPad);
383	pIcmpEcho->Hdr.icmp_cksum = icmpChecksum(&pIcmpEcho->Hdr, cbPad + 8);
384
385	/* IP */
386	pIpHdr->ip_v = 4;
387	pIpHdr->ip_hl = sizeof(*pIpHdr) / sizeof(uint32_t);
388	pIpHdr->ip_tos = 0;
389	pIpHdr->ip_len = RT_H2BE_U16((uint16_t)(sizeof(pIcmpEcho) + cbPad + sizeof(pIpHdr)));
390	pIpHdr->ip_id = (uint16_t)RTRandU32();
391	pIpHdr->ip_off = 0;
392	pIpHdr->ip_ttl = 255;
393	pIpHdr->ip_p = 0x01; /ICMP /
394	pIpHdr->ip_sum = 0;
395	pIpHdr->ip_src.u = UINT32_C(0x9701A8C0); /* 192.168.1.151 */
396	pIpHdr->ip_dst.u = UINT32_C(0xF9A344D0); /* 208.68.163.249 */
397	pIpHdr->ip_sum = RTNetIPv4HdrChecksum(pIpHdr);
398
399	/* Ethernet */
400	memset(&pEthHdr->DstMac, 0xff, sizeof(pEthHdr->DstMac)); /* broadcast */
401
402	pEthHdr->SrcMac = *pSrcMac;
403	#if 0 /* Enable with host's real Mac address for testing of the testcase. */
404	pEthHdr->SrcMac.au8[0] = 0x00;
405	pEthHdr->SrcMac.au8[1] = 0x1b;
406	pEthHdr->SrcMac.au8[2] = 0x24;
407	pEthHdr->SrcMac.au8[3] = 0xa0;
408	pEthHdr->SrcMac.au8[4] = 0x2f;
409	pEthHdr->SrcMac.au8[5] = 0xce;
410	#endif
411
412	pEthHdr->EtherType = RT_H2BE_U16(RTNET_ETHERTYPE_IPV4); /* IP */
413
414	doXmitFrame(hIf, pSession, pBuf, &abFrame[0], (uint8_t )(pIcmpEcho + 1) + cbPad - (uint8_t )&abFrame[0], pFileRaw, pFileText);
415	}
416
417
418	/**
419	* Does packet sniffing for a given period of time.
420	*
421	* @param hIf The interface handle.
422	* @param pSession The session.
423	* @param pBuf The shared interface buffer.
424	* @param cMillies The time period, ms.
425	* @param pFileRaw The file to write the raw data to (optional).
426	* @param pFileText The file to write a textual packet summary to (optional).
427	* @param pSrcMac Out MAC address.
428	*/
429	static void doPacketSniffing(INTNETIFHANDLE hIf, PSUPDRVSESSION pSession, PINTNETBUF pBuf, uint32_t cMillies,
430	PRTSTREAM pFileRaw, PRTSTREAM pFileText, PCRTMAC pSrcMac)
431	{
432	/*
433	* The loop.
434	*/
435	PINTNETRINGBUF pRingBuf = &pBuf->Recv;
436	for (;;)
437	{
438	/*
439	* Wait for a packet to become available.
440	*/
441	uint64_t cElapsedMillies = (RTTimeNanoTS() - g_StartTS) / 1000000;
442	if (cElapsedMillies >= cMillies)
443	break;
444	INTNETIFWAITREQ WaitReq;
445	WaitReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
446	WaitReq.Hdr.cbReq = sizeof(WaitReq);
447	WaitReq.pSession = pSession;
448	WaitReq.hIf = hIf;
449	WaitReq.cMillies = cMillies - (uint32_t)cElapsedMillies;
450	int rc = SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, VMMR0_DO_INTNET_IF_WAIT, 0, &WaitReq.Hdr);
451	if (rc == VERR_TIMEOUT \|\| rc == VERR_INTERRUPTED)
452	break;
453	if (RT_FAILURE(rc))
454	{
455	g_cErrors++;
456	RTPrintf("tstIntNet-1: VMMR0_DO_INTNET_IF_WAIT returned %Rrc\n", rc);
457	break;
458	}
459
460	/*
461	* Process the receive buffer.
462	*/
463	PINTNETHDR pHdr;
464	while ((pHdr = IntNetRingGetNextFrameToRead(pRingBuf)))
465	{
466	if (pHdr->u8Type == INTNETHDR_TYPE_FRAME)
467	{
468	size_t cbFrame = pHdr->cbFrame;
469	const void *pvFrame = IntNetHdrGetFramePtr(pHdr, pBuf);
470	uint64_t NanoTS = RTTimeNanoTS() - g_StartTS;
471
472	if (pFileRaw)
473	PcapStreamFrame(pFileRaw, g_StartTS, pvFrame, cbFrame, 0xffff);
474
475	PCRTNETETHERHDR pEthHdr = (PCRTNETETHERHDR)pvFrame;
476	if (pFileText)
477	RTStrmPrintf(pFileText, "%3RU64.%09u: cb=%04x dst=%.6Rhxs src=%.6Rhxs type=%04x%s\n",
478	NanoTS / 1000000000, (uint32_t)(NanoTS % 1000000000),
479	cbFrame, &pEthHdr->DstMac, &pEthHdr->SrcMac, RT_BE2H_U16(pEthHdr->EtherType),
480	!memcmp(&pEthHdr->DstMac, pSrcMac, sizeof(*pSrcMac)) ? " Mine!" : "");
481	tstIntNetTestFrame(pvFrame, cbFrame, pFileText, false /fGso/);
482
483	/* Loop for the DHCP reply. */
484	if ( cbFrame > 64
485	&& RT_BE2H_U16(pEthHdr->EtherType) == 0x0800 /* EtherType == IP */)
486	{
487	PCRTNETIPV4 pIpHdr = (PCRTNETIPV4)(pEthHdr + 1);
488	PCRTNETUDP pUdpHdr = (PCRTNETUDP)((uint32_t *)pIpHdr + pIpHdr->ip_hl);
489	if ( pIpHdr->ip_p == 0x11 /UDP/
490	&& RT_BE2H_U16(pUdpHdr->uh_dport) == 68 /* bootp */
491	&& RT_BE2H_U16(pUdpHdr->uh_sport) == 67 /* bootps */)
492	{
493	PCRTNETDHCP pDhcpMsg = (PCRTNETDHCP)(pUdpHdr + 1);
494	if ( pDhcpMsg->Op == 2 /* boot reply */
495	&& pDhcpMsg->HType == 1 /* ethernet */
496	&& pDhcpMsg->HLen == sizeof(RTMAC)
497	&& (pDhcpMsg->XID == g_DhcpXID \|\| !g_DhcpXID)
498	&& !memcmp(&pDhcpMsg->CHAddr[0], pSrcMac, sizeof(*pSrcMac)))
499	{
500	g_fDhcpReply = true;
501	RTPrintf("tstIntNet-1: DHCP server reply! My IP: %d.%d.%d.%d\n",
502	pDhcpMsg->YIAddr.au8[0],
503	pDhcpMsg->YIAddr.au8[1],
504	pDhcpMsg->YIAddr.au8[2],
505	pDhcpMsg->YIAddr.au8[3]);
506	}
507	}
508	else if (pIpHdr->ip_p == 0x01) /* ICMP */
509	{
510	PRTNETICMPV4HDR pIcmpHdr = (PRTNETICMPV4HDR)(pIpHdr + 1);
511	PRTNETICMPV4ECHO pIcmpEcho = (PRTNETICMPV4ECHO)(pIpHdr + 1);
512	if ( pIcmpHdr->icmp_type == RTNETICMPV4_TYPE_ECHO_REPLY
513	&& pIcmpEcho->icmp_seq == 0x05
514	&& pIpHdr->ip_dst.u == UINT32_C(0x9701A8C0)
515	#if 0
516	/** Enable with the host's real Mac address for testing of the testcase.*/
517	&& pEthHdr->DstMac.au8[0] == 0x00
518	&& pEthHdr->DstMac.au8[1] == 0x1b
519	&& pEthHdr->DstMac.au8[2] == 0x24
520	&& pEthHdr->DstMac.au8[3] == 0xa0
521	&& pEthHdr->DstMac.au8[4] == 0x2f
522	&& pEthHdr->DstMac.au8[5] == 0xce
523	#else
524	&& pEthHdr->DstMac.au16[0] == pSrcMac->au16[0]
525	&& pEthHdr->DstMac.au16[1] == pSrcMac->au16[1]
526	&& pEthHdr->DstMac.au16[2] == pSrcMac->au16[2]
527	#endif
528	)
529	{
530	g_fPingReply = true;
531	RTPrintf("tstIntNet-1: Ping reply! From %d.%d.%d.%d\n",
532	pIpHdr->ip_src.au8[0],
533	pIpHdr->ip_src.au8[1],
534	pIpHdr->ip_src.au8[2],
535	pIpHdr->ip_src.au8[3]);
536	}
537	else
538	RTPrintf("type=%d seq=%d dstmac=%.6Rhxs ip=%d.%d.%d.%d\n", pIcmpHdr->icmp_type, pIcmpEcho->icmp_seq,
539	&pEthHdr->DstMac, pIpHdr->ip_dst.au8[0], pIpHdr->ip_dst.au8[1], pIpHdr->ip_dst.au8[2], pIpHdr->ip_dst.au8[3]);
540	}
541	}
542	}
543	else if (pHdr->u8Type == INTNETHDR_TYPE_GSO)
544	{
545	PCPDMNETWORKGSO pGso = IntNetHdrGetGsoContext(pHdr, pBuf);
546	size_t cbFrame = pHdr->cbFrame;
547	if (PDMNetGsoIsValid(pGso, cbFrame, cbFrame - sizeof(*pGso)))
548	{
549	const void *pvFrame = pGso + 1;
550	uint64_t NanoTS = RTTimeNanoTS() - g_StartTS;
551	cbFrame -= sizeof(pGso);
552
553	if (pFileRaw)
554	PcapStreamGsoFrame(pFileRaw, g_StartTS, pGso, pvFrame, cbFrame, 0xffff);
555
556	PCRTNETETHERHDR pEthHdr = (PCRTNETETHERHDR)pvFrame;
557	if (pFileText)
558	RTStrmPrintf(pFileText, "%3RU64.%09u: cb=%04x dst=%.6Rhxs src=%.6Rhxs type=%04x%s [GSO]\n",
559	NanoTS / 1000000000, (uint32_t)(NanoTS % 1000000000),
560	cbFrame, &pEthHdr->DstMac, &pEthHdr->SrcMac, RT_BE2H_U16(pEthHdr->EtherType),
561	!memcmp(&pEthHdr->DstMac, pSrcMac, sizeof(*pSrcMac)) ? " Mine!" : "");
562	tstIntNetTestFrame(pvFrame, cbFrame, pFileText, true /fGso/);
563	}
564	else
565	{
566	RTPrintf("tstIntNet-1: Bad GSO frame: %.Rhxs\n", sizeof(pGso), pGso);
567	STAM_REL_COUNTER_INC(&pBuf->cStatBadFrames);
568	g_cErrors++;
569	}
570	}
571	else if (pHdr->u8Type != INTNETHDR_TYPE_PADDING)
572	{
573	RTPrintf("tstIntNet-1: Unknown frame type %d\n", pHdr->u8Type);
574	STAM_REL_COUNTER_INC(&pBuf->cStatBadFrames);
575	g_cErrors++;
576	}
577
578	/* Advance to the next frame. */
579	IntNetRingSkipFrame(pRingBuf);
580	}
581	}
582
583	uint64_t NanoTS = RTTimeNanoTS() - g_StartTS;
584	RTStrmPrintf(pFileText ? pFileText : g_pStdOut,
585	"%3RU64.%09u: stopped. cRecvs=%RU64 cbRecv=%RU64 cLost=%RU64 cOYs=%RU64 cNYs=%RU64\n",
586	NanoTS / 1000000000, (uint32_t)(NanoTS % 1000000000),
587	pBuf->Recv.cStatFrames.c,
588	pBuf->Recv.cbStatWritten.c,
589	pBuf->cStatLost.c,
590	pBuf->cStatYieldsOk.c,
591	pBuf->cStatYieldsNok.c
592	);
593	RTStrmPrintf(pFileText ? pFileText : g_pStdOut,
594	"%3RU64.%09u: cOtherPkts=%RU32 cArpPkts=%RU32 cIpv4Pkts=%RU32 cTcpPkts=%RU32 cUdpPkts=%RU32 cDhcpPkts=%RU32\n",
595	NanoTS / 1000000000, (uint32_t)(NanoTS % 1000000000),
596	g_cOtherPkts, g_cArpPkts, g_cIpv4Pkts, g_cTcpPkts, g_cUdpPkts, g_cDhcpPkts);
597	}
598
599	#ifdef RT_OS_LINUX
600	#include <stdio.h>
601	#include <net/if.h>
602	#include <net/route.h>
603	/**
604	* Obtain the name of the interface used for default routing.
605	*
606	* NOTE: Copied from Main/src-server/linux/NetIf-linux.cpp
607	*
608	* @returns VBox status code.
609	*
610	* @param pszName The buffer of IFNAMSIZ+1 length where to put the name.
611	*/
612	static int getDefaultIfaceName(char *pszName)
613	{
614	FILE *fp = fopen("/proc/net/route", "r");
615	char szBuf[1024];
616	char szIfName[17];
617	uint32_t uAddr;
618	uint32_t uGateway;
619	uint32_t uMask;
620	int iTmp;
621	unsigned uFlags;
622
623	if (fp)
624	{
625	while (fgets(szBuf, sizeof(szBuf)-1, fp))
626	{
627	int n = sscanf(szBuf, "%16s %x %x %x %d %d %d %x %d %d %d\n",
628	szIfName, &uAddr, &uGateway, &uFlags, &iTmp, &iTmp, &iTmp,
629	&uMask, &iTmp, &iTmp, &iTmp);
630	if (n < 10 \|\| !(uFlags & RTF_UP))
631	continue;
632
633	if (uAddr == 0 && uMask == 0)
634	{
635	fclose(fp);
636	strncpy(pszName, szIfName, 16);
637	pszName[16] = 0;
638	return VINF_SUCCESS;
639	}
640	}
641	fclose(fp);
642	}
643	return VERR_INTERNAL_ERROR;
644	}
645	#endif /* RT_OS_LINUX */
646
647
648	/**
649	* Entry point.
650	*/
651	extern "C" DECLEXPORT(int) TrustedMain(int argc, char argv, char envp)
652	{
653	/*
654	* Init the runtime and parse the arguments.
655	*/
656	RTR3InitExe(argc, &argv, 0);
657
658	static RTGETOPTDEF const s_aOptions[] =
659	{
660	{ "--duration", 'd', RTGETOPT_REQ_UINT32 },
661	{ "--file", 'f', RTGETOPT_REQ_STRING },
662	{ "--interface", 'i', RTGETOPT_REQ_STRING },
663	{ "--mac-sharing", 'm', RTGETOPT_REQ_NOTHING },
664	{ "--network", 'n', RTGETOPT_REQ_STRING },
665	{ "--promiscuous", 'p', RTGETOPT_REQ_NOTHING },
666	{ "--recv-buffer", 'r', RTGETOPT_REQ_UINT32 },
667	{ "--send-buffer", 's', RTGETOPT_REQ_UINT32 },
668	{ "--sniffer", 'S', RTGETOPT_REQ_NOTHING },
669	{ "--text-file", 't', RTGETOPT_REQ_STRING },
670	{ "--xmit-test", 'x', RTGETOPT_REQ_NOTHING },
671	{ "--ping-test", 'P', RTGETOPT_REQ_NOTHING },
672	};
673
674	uint32_t cMillies = 1000;
675	PRTSTREAM pFileRaw = NULL;
676	#ifdef RT_OS_DARWIN
677	const char *pszIf = "en0";
678	#elif defined(RT_OS_LINUX)
679	char szIf[IFNAMSIZ+1] = "eth0"; /* Reasonable default */
680	/*
681	* Try to update the default interface by consulting the routing table.
682	* If we fail we still have our reasonable default.
683	*/
684	getDefaultIfaceName(szIf);
685	const char *pszIf = szIf;
686	#elif defined(RT_OS_SOLARIS)
687	const char* pszIf = "rge0";
688	#else
689	const char *pszIf = "em0";
690	#endif
691	bool fMacSharing = false;
692	const char *pszNetwork = "tstIntNet-1";
693	bool fPromiscuous = false;
694	uint32_t cbRecv = 0;
695	uint32_t cbSend = 0;
696	bool fSniffer = false;
697	PRTSTREAM pFileText = g_pStdOut;
698	bool fXmitTest = false;
699	bool fPingTest = false;
700	RTMAC SrcMac;
701	SrcMac.au8[0] = 0x08;
702	SrcMac.au8[1] = 0x03;
703	SrcMac.au8[2] = 0x86;
704	RTRandBytes(&SrcMac.au8[3], sizeof(SrcMac) - 3);
705
706	int rc;
707	int ch;
708	int iArg = 1;
709	RTGETOPTUNION Value;
710	RTGETOPTSTATE GetState;
711	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0 /* fFlags */);
712	while ((ch = RTGetOpt(&GetState, &Value)))
713	switch (ch)
714	{
715	case 'd':
716	cMillies = Value.u32 * 1000;
717	if (cMillies / 1000 != Value.u32)
718	{
719	RTPrintf("tstIntNet-1: warning duration overflowed\n");
720	cMillies = UINT32_MAX - 1;
721	}
722	break;
723
724	case 'f':
725	rc = RTStrmOpen(Value.psz, "w+b", &pFileRaw);
726	if (RT_FAILURE(rc))
727	{
728	RTPrintf("tstIntNet-1: Failed to creating \"%s\" for writing: %Rrc\n", Value.psz, rc);
729	return 1;
730	}
731	break;
732
733	case 'i':
734	pszIf = Value.psz;
735	if (strlen(pszIf) >= INTNET_MAX_TRUNK_NAME)
736	{
737	RTPrintf("tstIntNet-1: Interface name is too long (max %d chars): %s\n", INTNET_MAX_TRUNK_NAME - 1, pszIf);
738	return 1;
739	}
740	break;
741
742	case 'm':
743	fMacSharing = true;
744	break;
745
746	case 'n':
747	pszNetwork = Value.psz;
748	if (strlen(pszNetwork) >= INTNET_MAX_NETWORK_NAME)
749	{
750	RTPrintf("tstIntNet-1: Network name is too long (max %d chars): %s\n", INTNET_MAX_NETWORK_NAME - 1, pszNetwork);
751	return 1;
752	}
753	break;
754
755	case 'p':
756	fPromiscuous = true;
757	break;
758
759	case 'r':
760	cbRecv = Value.u32;
761	break;
762
763	case 's':
764	cbSend = Value.u32;
765	break;
766
767	case 'S':
768	fSniffer = true;
769	break;
770
771	case 't':
772	if (!*Value.psz)
773	pFileText = NULL;
774	else if (!strcmp(Value.psz, "-"))
775	pFileText = g_pStdOut;
776	else if (!strcmp(Value.psz, "!"))
777	pFileText = g_pStdErr;
778	else
779	{
780	rc = RTStrmOpen(Value.psz, "w", &pFileText);
781	if (RT_FAILURE(rc))
782	{
783	RTPrintf("tstIntNet-1: Failed to creating \"%s\" for writing: %Rrc\n", Value.psz, rc);
784	return 1;
785	}
786	}
787	break;
788
789	case 'x':
790	fXmitTest = true;
791	break;
792
793	case 'P':
794	fPingTest = true;
795	break;
796
797	case 'h':
798	RTPrintf("syntax: tstIntNet-1 <options>\n"
799	"\n"
800	"Options:\n");
801	for (size_t i = 0; i < RT_ELEMENTS(s_aOptions); i++)
802	RTPrintf(" -%c,%s\n", s_aOptions[i].iShort, s_aOptions[i].pszLong);
803	RTPrintf("\n"
804	"Examples:\n"
805	" tstIntNet-1 -r 8192 -s 4096 -xS\n"
806	" tstIntNet-1 -n VBoxNetDhcp -r 4096 -s 4096 -i \"\" -xS\n");
807	return 1;
808
809	case 'V':
810	RTPrintf("$Revision: 57358 $\n");
811	return 0;
812
813	default:
814	return RTGetOptPrintError(ch, &Value);
815	}
816
817	RTPrintf("tstIntNet-1: TESTING...\n");
818
819	/*
820	* Open the session, load ring-0 and issue the request.
821	*/
822	PSUPDRVSESSION pSession;
823	rc = SUPR3Init(&pSession);
824	if (RT_FAILURE(rc))
825	{
826	RTPrintf("tstIntNet-1: SUPR3Init -> %Rrc\n", rc);
827	return 1;
828	}
829
830	char szPath[RTPATH_MAX];
831	rc = RTPathExecDir(szPath, sizeof(szPath) - sizeof("/../VMMR0.r0"));
832	if (RT_FAILURE(rc))
833	{
834	RTPrintf("tstIntNet-1: RTPathExecDir -> %Rrc\n", rc);
835	return 1;
836	}
837
838	strcat(szPath, "/../VMMR0.r0");
839
840	char szAbsPath[RTPATH_MAX];
841	rc = RTPathAbs(szPath, szAbsPath, sizeof(szAbsPath));
842	if (RT_FAILURE(rc))
843	{
844	RTPrintf("tstIntNet-1: RTPathAbs -> %Rrc\n", rc);
845	return 1;
846	}
847
848	rc = SUPR3LoadVMM(szAbsPath);
849	if (RT_FAILURE(rc))
850	{
851	RTPrintf("tstIntNet-1: SUPR3LoadVMM(\"%s\") -> %Rrc\n", szAbsPath, rc);
852	return 1;
853	}
854
855	/*
856	* Create the request, picking the network and trunk names from argv[2]
857	* and argv[1] if present.
858	*/
859	INTNETOPENREQ OpenReq;
860	OpenReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
861	OpenReq.Hdr.cbReq = sizeof(OpenReq);
862	OpenReq.pSession = pSession;
863	strncpy(OpenReq.szNetwork, pszNetwork, sizeof(OpenReq.szNetwork));
864	strncpy(OpenReq.szTrunk, pszIf, sizeof(OpenReq.szTrunk));
865	OpenReq.enmTrunkType = *pszIf ? kIntNetTrunkType_NetFlt : kIntNetTrunkType_WhateverNone;
866	OpenReq.fFlags = fMacSharing ? INTNET_OPEN_FLAGS_SHARED_MAC_ON_WIRE : 0;
867	OpenReq.cbSend = cbSend;
868	OpenReq.cbRecv = cbRecv;
869	OpenReq.hIf = INTNET_HANDLE_INVALID;
870
871	/*
872	* Issue the request.
873	*/
874	RTPrintf("tstIntNet-1: attempting to open/create network \"%s\" with NetFlt trunk \"%s\"...\n",
875	OpenReq.szNetwork, OpenReq.szTrunk);
876	RTStrmFlush(g_pStdOut);
877	rc = SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, VMMR0_DO_INTNET_OPEN, 0, &OpenReq.Hdr);
878	if (RT_SUCCESS(rc))
879	{
880	RTPrintf("tstIntNet-1: successfully opened/created \"%s\" with NetFlt trunk \"%s\" - hIf=%#x\n",
881	OpenReq.szNetwork, OpenReq.szTrunk, OpenReq.hIf);
882	RTStrmFlush(g_pStdOut);
883
884	/*
885	* Get the ring-3 address of the shared interface buffer.
886	*/
887	INTNETIFGETBUFFERPTRSREQ GetBufferPtrsReq;
888	GetBufferPtrsReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
889	GetBufferPtrsReq.Hdr.cbReq = sizeof(GetBufferPtrsReq);
890	GetBufferPtrsReq.pSession = pSession;
891	GetBufferPtrsReq.hIf = OpenReq.hIf;
892	GetBufferPtrsReq.pRing3Buf = NULL;
893	GetBufferPtrsReq.pRing0Buf = NIL_RTR0PTR;
894	rc = SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS, 0, &GetBufferPtrsReq.Hdr);
895	if (RT_SUCCESS(rc))
896	{
897	PINTNETBUF pBuf = GetBufferPtrsReq.pRing3Buf;
898	RTPrintf("tstIntNet-1: pBuf=%p cbBuf=%d cbSend=%d cbRecv=%d\n",
899	pBuf, pBuf->cbBuf, pBuf->cbSend, pBuf->cbRecv);
900	RTStrmFlush(g_pStdOut);
901	if (fPromiscuous)
902	{
903	INTNETIFSETPROMISCUOUSMODEREQ PromiscReq;
904	PromiscReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
905	PromiscReq.Hdr.cbReq = sizeof(PromiscReq);
906	PromiscReq.pSession = pSession;
907	PromiscReq.hIf = OpenReq.hIf;
908	PromiscReq.fPromiscuous = true;
909	rc = SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE, 0, &PromiscReq.Hdr);
910	if (RT_SUCCESS(rc))
911	RTPrintf("tstIntNet-1: interface in promiscuous mode\n");
912	}
913	if (RT_SUCCESS(rc))
914	{
915	/*
916	* Activate the interface.
917	*/
918	INTNETIFSETACTIVEREQ ActiveReq;
919	ActiveReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
920	ActiveReq.Hdr.cbReq = sizeof(ActiveReq);
921	ActiveReq.pSession = pSession;
922	ActiveReq.hIf = OpenReq.hIf;
923	ActiveReq.fActive = true;
924	rc = SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, VMMR0_DO_INTNET_IF_SET_ACTIVE, 0, &ActiveReq.Hdr);
925	if (RT_SUCCESS(rc))
926	{
927	/*
928	* Start the stop watch, init the pcap file.
929	*/
930	g_StartTS = RTTimeNanoTS();
931	if (pFileRaw)
932	PcapStreamHdr(pFileRaw, g_StartTS);
933
934	/*
935	* Do the transmit test first and so we can sniff for the response.
936	*/
937	if (fXmitTest)
938	doXmitTest(OpenReq.hIf, pSession, pBuf, &SrcMac, pFileRaw, pFileText);
939
940	if (fPingTest)
941	doPingTest(OpenReq.hIf, pSession, pBuf, &SrcMac, pFileRaw, pFileText);
942
943	/*
944	* Either enter sniffing mode or do a timeout thing.
945	*/
946	if (fSniffer)
947	{
948	doPacketSniffing(OpenReq.hIf, pSession, pBuf, cMillies, pFileRaw, pFileText, &SrcMac);
949	if ( fXmitTest
950	&& !g_fDhcpReply)
951	{
952	RTPrintf("tstIntNet-1: Error! The DHCP server didn't reply... (Perhaps you don't have one?)\n");
953	g_cErrors++;
954	}
955
956	if ( fPingTest
957	&& !g_fPingReply)
958	{
959	RTPrintf("tstIntNet-1: Error! No reply for ping request...\n");
960	g_cErrors++;
961	}
962	}
963	else
964	RTThreadSleep(cMillies);
965	}
966	else
967	{
968	RTPrintf("tstIntNet-1: SUPR3CallVMMR0Ex(,VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE,) failed, rc=%Rrc\n", rc);
969	g_cErrors++;
970	}
971	}
972	else
973	{
974	RTPrintf("tstIntNet-1: SUPR3CallVMMR0Ex(,VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE,) failed, rc=%Rrc\n", rc);
975	g_cErrors++;
976	}
977	}
978	else
979	{
980	RTPrintf("tstIntNet-1: SUPR3CallVMMR0Ex(,VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS,) failed, rc=%Rrc\n", rc);
981	g_cErrors++;
982	}
983	}
984	else
985	{
986	RTPrintf("tstIntNet-1: SUPR3CallVMMR0Ex(,VMMR0_DO_INTNET_OPEN,) failed, rc=%Rrc\n", rc);
987	g_cErrors++;
988	}
989
990	SUPR3Term(false /fForced/);
991
992	/* close open files */
993	if (pFileRaw)
994	RTStrmClose(pFileRaw);
995	if (pFileText && pFileText != g_pStdErr && pFileText != g_pStdOut)
996	RTStrmClose(pFileText);
997
998	/*
999	* Summary.
1000	*/
1001	if (!g_cErrors)
1002	RTPrintf("tstIntNet-1: SUCCESS\n");
1003	else
1004	RTPrintf("tstIntNet-1: FAILURE - %d errors\n", g_cErrors);
1005
1006	return !!g_cErrors;
1007	}
1008
1009
1010	#if !defined(VBOX_WITH_HARDENING) \|\| !defined(RT_OS_WINDOWS)
1011	/**
1012	* Main entry point.
1013	*/
1014	int main(int argc, char argv, char envp)
1015	{
1016	return TrustedMain(argc, argv, envp);
1017	}
1018	#endif
1019

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

source: vbox/trunk/src/VBox/Devices/Network/testcase/tstIntNet-1.cpp@ 57358

Download in other formats: