tstIntNet-1.cpp@ 14180

Last change on this file since 14180 was 11822, checked in by vboxsync, 16 years ago
IPRT: RTR3Init cleanup.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 36.0 KB

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

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

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

Download in other formats: