net.h@ 93176

Last change on this file since 93176 was 93115, checked in by vboxsync, 3 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 31.9 KB

Line
1	/** @file
2	* IPRT - Network Protocols.
3	*/
4
5	/*
6	* Copyright (C) 2008-2022 Oracle Corporation
7	*
8	* This file is part of VirtualBox Open Source Edition (OSE), as
9	* available from http://www.virtualbox.org. This file is free software;
10	* you can redistribute it and/or modify it under the terms of the GNU
11	* General Public License (GPL) as published by the Free Software
12	* Foundation, in version 2 as it comes in the "COPYING" file of the
13	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	*
16	* The contents of this file may alternatively be used under the terms
17	* of the Common Development and Distribution License Version 1.0
18	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19	* VirtualBox OSE distribution, in which case the provisions of the
20	* CDDL are applicable instead of those of the GPL.
21	*
22	* You may elect to license modified versions of this file under the
23	* terms and conditions of either the GPL or the CDDL or both.
24	*/
25
26	#ifndef IPRT_INCLUDED_net_h
27	#define IPRT_INCLUDED_net_h
28	#ifndef RT_WITHOUT_PRAGMA_ONCE
29	# pragma once
30	#endif
31
32	#include <iprt/cdefs.h>
33	#include <iprt/types.h>
34	#include <iprt/assert.h>
35
36
37	RT_C_DECLS_BEGIN
38
39	/** @defgroup grp_rt_net RTNet - Network Protocols
40	* @ingroup grp_rt
41	* @{
42	*/
43
44	/**
45	* Converts an stringified Ethernet MAC address into the RTMAC representation.
46	*
47	* @todo This should be move to some generic part of the runtime.
48	*
49	* @returns VINF_SUCCESS on success, VERR_GETOPT_INVALID_ARGUMENT_FORMAT on
50	* failure.
51	*
52	* @param pszAddr The address string to convert.
53	* @param pMacAddr Where to store the result.
54	*/
55	RTDECL(int) RTNetStrToMacAddr(const char *pszAddr, PRTMAC pMacAddr);
56
57	/**
58	* IPv4 address.
59	*/
60	typedef RTUINT32U RTNETADDRIPV4;
61	AssertCompileSize(RTNETADDRIPV4, 4);
62	/** Pointer to a IPv4 address. */
63	typedef RTNETADDRIPV4 *PRTNETADDRIPV4;
64	/** Pointer to a const IPv4 address. */
65	typedef RTNETADDRIPV4 const *PCRTNETADDRIPV4;
66
67	/**
68	* Tests if the given string is an IPv4 address.
69	*
70	* @returns boolean.
71	* @param pcszAddr String which may be an IPv4 address.
72	*/
73	RTDECL(bool) RTNetIsIPv4AddrStr(const char *pcszAddr);
74
75	/**
76	* Tests if the given string is a wildcard IPv4 address.
77	*
78	* @returns boolean.
79	* @param pcszAddr String which may be an IPv4 address.
80	*/
81	RTDECL(bool) RTNetStrIsIPv4AddrAny(const char *pcszAddr);
82
83	/**
84	* Parses dotted-decimal IPv4 address into RTNETADDRIPV4 representation.
85	*
86	* @returns VINF_SUCCESS on success, VERR_INVALID_PARAMETER on
87	* failure.
88	*
89	* @param pcszAddr The value to convert.
90	* @param ppszNext Where to store the pointer to the first char
91	* following the address. (Optional)
92	* @param pAddr Where to store the result.
93	*/
94	RTDECL(int) RTNetStrToIPv4AddrEx(const char pcszAddr, PRTNETADDRIPV4 pAddr, char *ppszNext);
95
96	/**
97	* Parses dotted-decimal IPv4 address into RTNETADDRIPV4 representation.
98	* Leading and trailing whitespace is ignored.
99	*
100	* @returns VINF_SUCCESS on success, VERR_INVALID_PARAMETER on
101	* failure.
102	*
103	* @param pcszAddr The value to convert.
104	* @param pAddr Where to store the result.
105	*/
106	RTDECL(int) RTNetStrToIPv4Addr(const char *pcszAddr, PRTNETADDRIPV4 pAddr);
107
108	/**
109	* Parses dotted-decimal IPv4 CIDR notation into RTNETADDRIPV4
110	* representation and prefix length. Missing prefix specification is
111	* treated as exact address specification (prefix length 32). Leading
112	* and trailing whitespace is ignored.
113	*
114	* @returns VINF_SUCCESS on success, VERR_INVALID_PARAMETER on
115	* failure.
116	*
117	* @param pcszAddr The value to convert.
118	* @param pAddr Where to store the address.
119	* @param piPrefix Where to store the prefix length;
120	*/
121	RTDECL(int) RTNetStrToIPv4Cidr(const char pcszAddr, PRTNETADDRIPV4 pAddr, int piPrefix);
122
123	/**
124	* Verifies that RTNETADDRIPV4 is a valid contiguous netmask and
125	* computes its prefix length.
126	*
127	* @returns VINF_SUCCESS on success, VERR_INVALID_PARAMETER on
128	* failure.
129	*
130	* @param pMask The netmask to verify and convert.
131	* @param piPrefix Where to store the prefix length. (Optional)
132	*/
133	RTDECL(int) RTNetMaskToPrefixIPv4(PCRTNETADDRIPV4 pMask, int *piPrefix);
134
135	/**
136	* Computes netmask corresponding to the prefix length.
137	*
138	* @returns VINF_SUCCESS on success, VERR_INVALID_PARAMETER on
139	* failure.
140	*
141	* @param iPrefix The prefix to convert.
142	* @param pMask Where to store the netmask.
143	*/
144	RTDECL(int) RTNetPrefixToMaskIPv4(int iPrefix, PRTNETADDRIPV4 pMask);
145
146
147	/**
148	* IPv6 address.
149	*/
150	typedef RTUINT128U RTNETADDRIPV6;
151	AssertCompileSize(RTNETADDRIPV6, 16);
152	/** Pointer to a IPv6 address. */
153	typedef RTNETADDRIPV6 *PRTNETADDRIPV6;
154	/** Pointer to a const IPv6 address. */
155	typedef RTNETADDRIPV6 const *PCRTNETADDRIPV6;
156
157	/**
158	* Tests if the given string is a valid IPv6 address.
159	*
160	* @returns @c true if it is, @c false if not.
161	* @param pszAddress String which may be an IPv6 address.
162	*/
163	RTDECL(bool) RTNetIsIPv6AddrStr(const char *pszAddress);
164
165	/**
166	* Tests if the given string is a wildcard IPv6 address.
167	*
168	* @returns @c true if it is, @c false if not.
169	* @param pszAddress String which may be an IPv6 address.
170	*/
171	RTDECL(bool) RTNetStrIsIPv6AddrAny(const char *pszAddress);
172
173	/**
174	* Parses IPv6 address into RTNETADDRIPV6 representation.
175	*
176	* @returns VINF_SUCCESS on success, VERR_INVALID_PARAMETER on
177	* failure.
178	*
179	* @param pcszAddr The value to convert.
180	* @param ppszNext Where to store the pointer to the first char
181	* following the address. (Optional)
182	* @param pAddr Where to store the result.
183	*/
184	RTDECL(int) RTNetStrToIPv6AddrEx(const char pcszAddr, PRTNETADDRIPV6 pAddr, char *ppszNext);
185
186	/**
187	* Parses IPv6 address into RTNETADDRIPV6 representation.
188	* Leading and trailing whitespace is ignored.
189	*
190	* @returns VINF_SUCCESS on success, VERR_INVALID_PARAMETER on
191	* failure.
192	*
193	* @param pcszAddr The value to convert.
194	* @param ppszZone Where to store the pointer to the first char
195	* of the zone id. NULL is stored if there is
196	* no zone id.
197	* @param pAddr Where to store the result.
198	*/
199	RTDECL(int) RTNetStrToIPv6Addr(const char pcszAddr, PRTNETADDRIPV6 pAddr, char *ppszZone);
200
201	/**
202	* Verifies that RTNETADDRIPV6 is a valid contiguous netmask and
203	* computes its prefix length.
204	*
205	* @returns VINF_SUCCESS on success, VERR_INVALID_PARAMETER on
206	* failure.
207	*
208	* @param pMask The netmask to verify and convert.
209	* @param piPrefix Where to store the prefix length. (Optional)
210	*/
211	RTDECL(int) RTNetMaskToPrefixIPv6(PCRTNETADDRIPV6 pMask, int *piPrefix);
212
213	/**
214	* Computes netmask corresponding to the prefix length.
215	*
216	* @returns VINF_SUCCESS on success, VERR_INVALID_PARAMETER on
217	* failure.
218	*
219	* @param iPrefix The prefix to convert.
220	* @param pMask Where to store the netmask.
221	*/
222	RTDECL(int) RTNetPrefixToMaskIPv6(int iPrefix, PRTNETADDRIPV6 pMask);
223
224	/**
225	* Parses IPv6 prefix notation into RTNETADDRIPV6 representation and
226	* prefix length. Missing prefix specification is treated as exact
227	* address specification (prefix length 128). Leading and trailing
228	* whitespace is ignored.
229	*
230	* "CIDR" in the name is a misnomer as IPv6 doesn't have network
231	* classes, but is parallel to the IPv4 name (and naming things is
232	* hard).
233	*
234	* @returns VINF_SUCCESS on success, VERR_INVALID_PARAMETER on
235	* failure.
236	*
237	* @param pcszAddr The value to convert.
238	* @param pAddr Where to store the address.
239	* @param piPrefix Where to store the prefix length;
240	*/
241	RTDECL(int) RTNetStrToIPv6Cidr(const char pcszAddr, PRTNETADDRIPV6 pAddr, int piPrefix);
242
243
244	/**
245	* IPX address.
246	*/
247	#pragma pack(1)
248	typedef struct RTNETADDRIPX
249	{
250	/** The network ID. */
251	uint32_t Network;
252	/** The node ID. (Defaults to the MAC address apparently.) */
253	RTMAC Node;
254	} RTNETADDRIPX;
255	#pragma pack()
256	AssertCompileSize(RTNETADDRIPX, 4+6);
257	/** Pointer to an IPX address. */
258	typedef RTNETADDRIPX *PRTNETADDRIPX;
259	/** Pointer to a const IPX address. */
260	typedef RTNETADDRIPX const *PCRTNETADDRIPX;
261
262	/**
263	* Network address union.
264	*
265	* @remarks The size of this structure may change in the future.
266	*/
267	typedef union RTNETADDRU
268	{
269	/** 64-bit view. */
270	uint64_t au64[2];
271	/** 32-bit view. */
272	uint32_t au32[4];
273	/** 16-bit view. */
274	uint16_t au16[8];
275	/** 8-bit view. */
276	uint8_t au8[16];
277	/** IPv4 view. */
278	RTNETADDRIPV4 IPv4;
279	#ifndef IPv6 /* Work around X11 and RDP defining IPv6 to 1. */
280	/** IPv6 view. */
281	RTNETADDRIPV6 IPv6;
282	#endif
283	/** IPX view. */
284	RTNETADDRIPX Ipx;
285	/** MAC address view. */
286	RTMAC Mac;
287	} RTNETADDRU;
288	AssertCompileSize(RTNETADDRU, 16);
289	/** Pointer to an address union. */
290	typedef RTNETADDRU *PRTNETADDRU;
291	/** Pointer to a const address union. */
292	typedef RTNETADDRU const *PCRTNETADDRU;
293
294	/**
295	* Network address type.
296	*
297	* @remarks The value assignments may change in the future.
298	*/
299	typedef enum RTNETADDRTYPE
300	{
301	/** The invalid 0 entry. */
302	RTNETADDRTYPE_INVALID = 0,
303	/** IP version 4. */
304	RTNETADDRTYPE_IPV4,
305	/** IP version 6. */
306	RTNETADDRTYPE_IPV6,
307	/** IPX. */
308	RTNETADDRTYPE_IPX,
309	/** MAC address. */
310	RTNETADDRTYPE_MAC,
311	/** The end of the valid values. */
312	RTNETADDRTYPE_END,
313	/** The usual 32-bit hack. */
314	RTNETADDRTYPE_32_BIT_HACK = 0x7fffffff
315	} RTNETADDRTYPE;
316	/** Pointer to a network address type. */
317	typedef RTNETADDRTYPE *PRTNETADDRTYPE;
318	/** Pointer to a const network address type. */
319	typedef RTNETADDRTYPE const *PCRTNETADDRTYPE;
320
321	/**
322	* Network address.
323	*
324	* @remarks The size and type values may change.
325	*/
326	typedef struct RTNETADDR
327	{
328	/** The address union. */
329	RTNETADDRU uAddr;
330	/** Indicates which view of @a u that is valid. */
331	RTNETADDRTYPE enmType;
332	/** The port number for IPv4 and IPv6 addresses. This is set to
333	* RTNETADDR_NA_PORT if not applicable. */
334	uint32_t uPort;
335	} RTNETADDR;
336	/** Pointer to a network address. */
337	typedef RTNETADDR *PRTNETADDR;
338	/** Pointer to a const network address. */
339	typedef RTNETADDR const *PCRTNETADDR;
340
341	/** The not applicable value of RTNETADDR::uPort value use to inid. */
342	#define RTNETADDR_PORT_NA UINT32_MAX
343
344	/**
345	* Ethernet header.
346	*/
347	#pragma pack(1)
348	typedef struct RTNETETHERHDR
349	{
350	RTMAC DstMac;
351	RTMAC SrcMac;
352	/** Ethernet frame type or frame size, depending on the kind of ethernet.
353	* This is big endian on the wire. */
354	uint16_t EtherType;
355	} RTNETETHERHDR;
356	#pragma pack()
357	AssertCompileSize(RTNETETHERHDR, 14);
358	/** Pointer to an ethernet header. */
359	typedef RTNETETHERHDR *PRTNETETHERHDR;
360	/** Pointer to a const ethernet header. */
361	typedef RTNETETHERHDR const *PCRTNETETHERHDR;
362
363	/** @name EtherType (RTNETETHERHDR::EtherType)
364	* @{ */
365	#define RTNET_ETHERTYPE_IPV4 UINT16_C(0x0800)
366	#define RTNET_ETHERTYPE_ARP UINT16_C(0x0806)
367	#define RTNET_ETHERTYPE_IPV6 UINT16_C(0x86dd)
368	#define RTNET_ETHERTYPE_VLAN UINT16_C(0x8100)
369	#define RTNET_ETHERTYPE_IPX_1 UINT16_C(0x8037)
370	#define RTNET_ETHERTYPE_IPX_2 UINT16_C(0x8137)
371	#define RTNET_ETHERTYPE_IPX_3 UINT16_C(0x8138)
372	/** @} */
373
374
375	/**
376	* IPv4 header.
377	* All is bigendian on the wire.
378	*/
379	#pragma pack(1)
380	typedef struct RTNETIPV4
381	{
382	#ifdef RT_BIG_ENDIAN
383	unsigned int ip_v : 4;
384	unsigned int ip_hl : 4;
385	unsigned int ip_tos : 8;
386	unsigned int ip_len : 16;
387	#else
388	/** 00:0 - Header length given as a 32-bit word count. */
389	unsigned int ip_hl : 4;
390	/** 00:4 - Header version. */
391	unsigned int ip_v : 4;
392	/** 01 - Type of service. */
393	unsigned int ip_tos : 8;
394	/** 02 - Total length (header + data). */
395	unsigned int ip_len : 16;
396	#endif
397	/** 04 - Packet idenficiation. */
398	uint16_t ip_id;
399	/** 06 - Offset if fragmented. */
400	uint16_t ip_off;
401	/** 08 - Time to live. */
402	uint8_t ip_ttl;
403	/** 09 - Protocol. */
404	uint8_t ip_p;
405	/** 0a - Header check sum. */
406	uint16_t ip_sum;
407	/** 0c - Source address. */
408	RTNETADDRIPV4 ip_src;
409	/** 10 - Destination address. */
410	RTNETADDRIPV4 ip_dst;
411	/** 14 - Options (optional). */
412	uint32_t ip_options[1];
413	} RTNETIPV4;
414	#pragma pack()
415	AssertCompileSize(RTNETIPV4, 6 * 4);
416	/** Pointer to a IPv4 header. */
417	typedef RTNETIPV4 *PRTNETIPV4;
418	/** Pointer to a const IPv4 header. */
419	typedef RTNETIPV4 const *PCRTNETIPV4;
420
421	/** The minimum IPv4 header length (in bytes).
422	* Up to and including RTNETIPV4::ip_dst. */
423	#define RTNETIPV4_MIN_LEN (20)
424
425
426	/** @name IPv4 Protocol Numbers
427	* @{ */
428	/** IPv4: ICMP */
429	#define RTNETIPV4_PROT_ICMP (1)
430	/** IPv4: TCP */
431	#define RTNETIPV4_PROT_TCP (6)
432	/** IPv4: UDP */
433	#define RTNETIPV4_PROT_UDP (17)
434	/** @} */
435
436	/** @name Common IPv4 Port Assignments
437	* @{
438	*/
439	/** Boostrap Protocol / DHCP) Server. */
440	#define RTNETIPV4_PORT_BOOTPS (67)
441	/** Boostrap Protocol / DHCP) Client. */
442	#define RTNETIPV4_PORT_BOOTPC (68)
443	/** @} */
444
445	/** @name IPv4 Flags
446	* @{ */
447	/** IPv4: Don't fragment */
448	#define RTNETIPV4_FLAGS_DF (0x4000)
449	/** IPv4: More fragments */
450	#define RTNETIPV4_FLAGS_MF (0x2000)
451	/** @} */
452
453	RTDECL(uint16_t) RTNetIPv4HdrChecksum(PCRTNETIPV4 pIpHdr);
454	RTDECL(bool) RTNetIPv4IsHdrValid(PCRTNETIPV4 pIpHdr, size_t cbHdrMax, size_t cbPktMax, bool fChecksum);
455	RTDECL(uint32_t) RTNetIPv4PseudoChecksum(PCRTNETIPV4 pIpHdr);
456	RTDECL(uint32_t) RTNetIPv4PseudoChecksumBits(RTNETADDRIPV4 SrcAddr, RTNETADDRIPV4 DstAddr, uint8_t bProtocol, uint16_t cbPkt);
457	RTDECL(uint32_t) RTNetIPv4AddDataChecksum(void const pvData, size_t cbData, uint32_t u32Sum, bool pfOdd);
458	RTDECL(uint16_t) RTNetIPv4FinalizeChecksum(uint32_t u32Sum);
459
460
461	/**
462	* IPv6 header.
463	* All is bigendian on the wire.
464	*/
465	#pragma pack(1)
466	typedef struct RTNETIPV6
467	{
468	/** Version (4 bits), Traffic Class (8 bits) and Flow Lable (20 bits).
469	* @todo this is probably mislabeled - ip6_flow vs. ip6_vfc, fix later. */
470	uint32_t ip6_vfc;
471	/** 04 - Payload length, including extension headers. */
472	uint16_t ip6_plen;
473	/** 06 - Next header type (RTNETIPV4_PROT_XXX). */
474	uint8_t ip6_nxt;
475	/** 07 - Hop limit. */
476	uint8_t ip6_hlim;
477	/** xx - Source address. */
478	RTNETADDRIPV6 ip6_src;
479	/** xx - Destination address. */
480	RTNETADDRIPV6 ip6_dst;
481	} RTNETIPV6;
482	#pragma pack()
483	AssertCompileSize(RTNETIPV6, 8 + 16 + 16);
484	/** Pointer to a IPv6 header. */
485	typedef RTNETIPV6 *PRTNETIPV6;
486	/** Pointer to a const IPv6 header. */
487	typedef RTNETIPV6 const *PCRTNETIPV6;
488
489	/** The minimum IPv6 header length (in bytes).
490	* Up to and including RTNETIPV6::ip6_dst. */
491	#define RTNETIPV6_MIN_LEN (40)
492	#define RTNETIPV6_ICMPV6_ND_WITH_LLA_OPT_MIN_LEN (32)
493
494	RTDECL(uint32_t) RTNetIPv6PseudoChecksum(PCRTNETIPV6 pIpHdr);
495	RTDECL(uint32_t) RTNetIPv6PseudoChecksumEx(PCRTNETIPV6 pIpHdr, uint8_t bProtocol, uint16_t cbPkt);
496	RTDECL(uint32_t) RTNetIPv6PseudoChecksumBits(PCRTNETADDRIPV6 pSrcAddr, PCRTNETADDRIPV6 pDstAddr,
497	uint8_t bProtocol, uint16_t cbPkt);
498
499
500	/**
501	* UDP header.
502	*/
503	#pragma pack(1)
504	typedef struct RTNETUDP
505	{
506	/** The source port. */
507	uint16_t uh_sport;
508	/** The destination port. */
509	uint16_t uh_dport;
510	/** The length of the UDP header and associated data. */
511	uint16_t uh_ulen;
512	/** The checksum of the pseudo header, the UDP header and the data. */
513	uint16_t uh_sum;
514	} RTNETUDP;
515	#pragma pack()
516	AssertCompileSize(RTNETUDP, 8);
517	/** Pointer to an UDP header. */
518	typedef RTNETUDP *PRTNETUDP;
519	/** Pointer to a const UDP header. */
520	typedef RTNETUDP const *PCRTNETUDP;
521
522	/** The minimum UDP packet length (in bytes). (RTNETUDP::uh_ulen) */
523	#define RTNETUDP_MIN_LEN (8)
524
525	RTDECL(uint16_t) RTNetUDPChecksum(uint32_t u32Sum, PCRTNETUDP pUdpHdr);
526	RTDECL(uint32_t) RTNetIPv4AddUDPChecksum(PCRTNETUDP pUdpHdr, uint32_t u32Sum);
527	RTDECL(uint16_t) RTNetIPv4UDPChecksum(PCRTNETIPV4 pIpHdr, PCRTNETUDP pUdpHdr, void const *pvData);
528	RTDECL(bool) RTNetIPv4IsUDPSizeValid(PCRTNETIPV4 pIpHdr, PCRTNETUDP pUdpHdr, size_t cbPktMax);
529	RTDECL(bool) RTNetIPv4IsUDPValid(PCRTNETIPV4 pIpHdr, PCRTNETUDP pUdpHdr, void const *pvData, size_t cbPktMax, bool fChecksum);
530
531
532	/**
533	* IPv4 BOOTP / DHCP packet.
534	*/
535	#pragma pack(1)
536	typedef struct RTNETBOOTP
537	{
538	/** 00 - The packet opcode (RTNETBOOTP_OP_). /
539	uint8_t bp_op;
540	/** 01 - Hardware address type. Same as RTNETARPHDR::ar_htype. */
541	uint8_t bp_htype;
542	/** 02 - Hardware address length. */
543	uint8_t bp_hlen;
544	/** 03 - Gateway hops. */
545	uint8_t bp_hops;
546	/** 04 - Transaction ID. */
547	uint32_t bp_xid;
548	/** 08 - Seconds since boot started. */
549	uint16_t bp_secs;
550	/** 0a - Unused (BOOTP) / Flags (DHCP) (RTNET_DHCP_FLAGS_). /
551	uint16_t bp_flags;
552	/** 0c - Client IPv4 address. */
553	RTNETADDRIPV4 bp_ciaddr;
554	/** 10 - Your IPv4 address. */
555	RTNETADDRIPV4 bp_yiaddr;
556	/** 14 - Server IPv4 address. */
557	RTNETADDRIPV4 bp_siaddr;
558	/** 18 - Gateway IPv4 address. */
559	RTNETADDRIPV4 bp_giaddr;
560	/** 1c - Client hardware address. */
561	union
562	{
563	uint8_t au8[16];
564	RTMAC Mac;
565	} bp_chaddr;
566	/** 2c - Server name. */
567	uint8_t bp_sname[64];
568	/** 6c - File name / more DHCP options. */
569	uint8_t bp_file[128];
570	/** ec - Vendor specific area (BOOTP) / Options (DHCP).
571	* @remark This is really 312 bytes in the DHCP version. */
572	union
573	{
574	uint8_t au8[128];
575	struct DHCP
576	{
577	/** ec - The DHCP cookie (RTNET_DHCP_COOKIE). */
578	uint32_t dhcp_cookie;
579	/** f0 - The DHCP options. */
580	uint8_t dhcp_opts[124];
581	} Dhcp;
582	} bp_vend;
583
584	} RTNETBOOTP;
585	#pragma pack()
586	AssertCompileSize(RTNETBOOTP, 0xec + 128);
587	/** Pointer to a BOOTP / DHCP packet. */
588	typedef RTNETBOOTP *PRTNETBOOTP;
589	/** Pointer to a const BOOTP / DHCP packet. */
590	typedef RTNETBOOTP const *PCRTNETBOOTP;
591
592	/** Minimum BOOTP packet length. For quick validation, no standard thing really. */
593	#define RTNETBOOTP_MIN_LEN 0xec
594	/** Minimum DHCP packet length. For quick validation, no standard thing really. */
595	#define RTNETBOOTP_DHCP_MIN_LEN 0xf1
596
597	/** The normal size of the a DHCP packet (i.e. a RTNETBOOTP).
598	* Same as RTNET_DHCP_OPT_SIZE, just expressed differently. */
599	#define RTNET_DHCP_NORMAL_SIZE (0xec + 4 + RTNET_DHCP_OPT_SIZE)
600	/** The normal size of RTNETBOOTP::bp_vend::Dhcp::dhcp_opts. */
601	#define RTNET_DHCP_OPT_SIZE (312 - 4)
602
603	/** @name BOOTP packet opcode values
604	* @{ */
605	#define RTNETBOOTP_OP_REQUEST 1
606	#define RTNETBOOTP_OP_REPLY 2
607	/** @} */
608
609	/** @name DHCP flags (RTNETBOOTP::bp_flags)
610	* @{ */
611	#define RTNET_DHCP_FLAGS_NO_BROADCAST UINT16_C(0x8000) /** @todo check test!!! */
612	/** @} */
613
614	/** The DHCP cookie (network endian). */
615	#define RTNET_DHCP_COOKIE UINT32_C(0x63825363)
616
617	/**
618	* An IPv4 DHCP option header.
619	*/
620	typedef struct RTNETDHCPOPT
621	{
622	/** 00 - The DHCP option. */
623	uint8_t dhcp_opt;
624	/** 01 - The data length (excluding this header). */
625	uint8_t dhcp_len;
626	/* 02 - The option data follows here, optional and of variable length. */
627	} RTNETDHCPOPT;
628	AssertCompileSize(RTNETDHCPOPT, 2);
629	/** Pointer to a DHCP option header. */
630	typedef RTNETDHCPOPT *PRTNETDHCPOPT;
631	/** Pointer to a const DHCP option header. */
632	typedef RTNETDHCPOPT const *PCRTNETDHCPOPT;
633
634	/** @name DHCP options
635	* @{ */
636	/** 1 byte padding, this has no dhcp_len field. */
637	#define RTNET_DHCP_OPT_PAD 0
638
639	/** The subnet mask. */
640	#define RTNET_DHCP_OPT_SUBNET_MASK 1
641	/** The time offset. */
642	#define RTNET_DHCP_OPT_TIME_OFFSET 2
643	/** The routers for the subnet. */
644	#define RTNET_DHCP_OPT_ROUTERS 3
645	/** Domain Name Server. */
646	#define RTNET_DHCP_OPT_DNS 6
647	/** Host name. */
648	#define RTNET_DHCP_OPT_HOST_NAME 12
649	/** Domain name. */
650	#define RTNET_DHCP_OPT_DOMAIN_NAME 15
651
652	/** The requested address. */
653	#define RTNET_DHCP_OPT_REQ_ADDR 50
654	/** The lease time in seconds. */
655	#define RTNET_DHCP_OPT_LEASE_TIME 51
656	/** Option overload.
657	* Indicates that the bp_file and/or bp_sname holds contains DHCP options. */
658	#define RTNET_DHCP_OPT_OPTION_OVERLOAD 52
659	/** Have a 8-bit message type value as data, see RTNET_DHCP_MT_. /
660	#define RTNET_DHCP_OPT_MSG_TYPE 53
661	/** Server ID. */
662	#define RTNET_DHCP_OPT_SERVER_ID 54
663	/** Parameter request list. */
664	#define RTNET_DHCP_OPT_PARAM_REQ_LIST 55
665	/** The maximum DHCP message size a client is willing to accept. */
666	#define RTNET_DHCP_OPT_MAX_DHCP_MSG_SIZE 57
667	/** Client ID. */
668	#define RTNET_DHCP_OPT_CLIENT_ID 61
669	/** TFTP server name. */
670	#define RTNET_DHCP_OPT_TFTP_SERVER_NAME 66
671	/** Bootfile name. */
672	#define RTNET_DHCP_OPT_BOOTFILE_NAME 67
673
674	/** Marks the end of the DHCP options, this has no dhcp_len field. */
675	#define RTNET_DHCP_OPT_END 255
676	/** @} */
677
678	/** @name DHCP Option overload flags (option 52)
679	* @{ */
680	#define RTNET_DHCP_OPTION_OVERLOAD_FILE 1
681	#define RTNET_DHCP_OPTION_OVERLOAD_SNAME 2
682	#define RTNET_DHCP_OPTION_OVERLOAD_MASK 3
683	/** @} */
684
685	/** @name DHCP Message Types (option 53)
686	* @{ */
687	#define RTNET_DHCP_MT_DISCOVER 1
688	#define RTNET_DHCP_MT_OFFER 2
689	#define RTNET_DHCP_MT_REQUEST 3
690	#define RTNET_DHCP_MT_DECLINE 4
691	#define RTNET_DHCP_MT_ACK 5
692	#define RTNET_DHCP_MT_NAC 6
693	#define RTNET_DHCP_MT_RELEASE 7
694	#define RTNET_DHCP_MT_INFORM 8
695	/** @} */
696
697	/** @name DHCP Flags
698	* @{ */
699	#define RTNET_DHCP_FLAG_BROADCAST 0x8000
700	/** @} */
701
702	RTDECL(bool) RTNetIPv4IsDHCPValid(PCRTNETUDP pUdpHdr, PCRTNETBOOTP pDhcp, size_t cbDhcp, uint8_t *pMsgType);
703
704
705	/**
706	* IPv4 DHCP packet.
707	* @deprecated Use RTNETBOOTP.
708	*/
709	#pragma pack(1)
710	typedef struct RTNETDHCP
711	{
712	/** 00 - The packet opcode. */
713	uint8_t Op;
714	/** Hardware address type. */
715	uint8_t HType;
716	/** Hardware address length. */
717	uint8_t HLen;
718	uint8_t Hops;
719	uint32_t XID;
720	uint16_t Secs;
721	uint16_t Flags;
722	/** Client IPv4 address. */
723	RTNETADDRIPV4 CIAddr;
724	/** Your IPv4 address. */
725	RTNETADDRIPV4 YIAddr;
726	/** Server IPv4 address. */
727	RTNETADDRIPV4 SIAddr;
728	/** Gateway IPv4 address. */
729	RTNETADDRIPV4 GIAddr;
730	/** Client hardware address. */
731	uint8_t CHAddr[16];
732	/** Server name. */
733	uint8_t SName[64];
734	uint8_t File[128];
735	uint8_t abMagic[4];
736	uint8_t DhcpOpt;
737	uint8_t DhcpLen; /* 1 */
738	uint8_t DhcpReq;
739	uint8_t abOptions[57];
740	} RTNETDHCP;
741	#pragma pack()
742	/** @todo AssertCompileSize(RTNETDHCP, ); */
743	/** Pointer to a DHCP packet. */
744	typedef RTNETDHCP *PRTNETDHCP;
745	/** Pointer to a const DHCP packet. */
746	typedef RTNETDHCP const *PCRTNETDHCP;
747
748
749	/**
750	* TCP packet.
751	*/
752	#pragma pack(1)
753	typedef struct RTNETTCP
754	{
755	/** 00 - The source port. */
756	uint16_t th_sport;
757	/** 02 - The destination port. */
758	uint16_t th_dport;
759	/** 04 - The sequence number. */
760	uint32_t th_seq;
761	/** 08 - The acknowledgement number. */
762	uint32_t th_ack;
763	#ifdef RT_BIG_ENDIAN
764	unsigned int th_win : 16;
765	unsigned int th_flags : 8;
766	unsigned int th_off : 4;
767	unsigned int th_x2 : 4;
768	#else
769	/** 0c:0 - Reserved. */
770	unsigned int th_x2 : 4;
771	/** 0c:4 - The data offset given as a dword count from the start of this header. */
772	unsigned int th_off : 4;
773	/** 0d - flags. */
774	unsigned int th_flags : 8;
775	/** 0e - The window. */
776	unsigned int th_win : 16;
777	#endif
778	/** 10 - The checksum of the pseudo header, the TCP header and the data. */
779	uint16_t th_sum;
780	/** 12 - The urgent pointer. */
781	uint16_t th_urp;
782	/* (options follows here and then the data (aka text).) */
783	} RTNETTCP;
784	#pragma pack()
785	AssertCompileSize(RTNETTCP, 20);
786	/** Pointer to a TCP packet. */
787	typedef RTNETTCP *PRTNETTCP;
788	/** Pointer to a const TCP packet. */
789	typedef RTNETTCP const *PCRTNETTCP;
790
791	/** The minimum TCP header length (in bytes). (RTNETTCP::th_off * 4) */
792	#define RTNETTCP_MIN_LEN (20)
793
794	/** @name TCP flags (RTNETTCP::th_flags)
795	* @{ */
796	#define RTNETTCP_F_FIN 0x01
797	#define RTNETTCP_F_SYN 0x02
798	#define RTNETTCP_F_RST 0x04
799	#define RTNETTCP_F_PSH 0x08
800	#define RTNETTCP_F_ACK 0x10
801	#define RTNETTCP_F_URG 0x20
802	#define RTNETTCP_F_ECE 0x40
803	#define RTNETTCP_F_CWR 0x80
804	/** @} */
805
806	RTDECL(uint16_t) RTNetTCPChecksum(uint32_t u32Sum, PCRTNETTCP pTcpHdr, void const *pvData, size_t cbData);
807	RTDECL(uint32_t) RTNetIPv4AddTCPChecksum(PCRTNETTCP pTcpHdr, uint32_t u32Sum);
808	RTDECL(uint16_t) RTNetIPv4TCPChecksum(PCRTNETIPV4 pIpHdr, PCRTNETTCP pTcpHdr, void const *pvData);
809	RTDECL(bool) RTNetIPv4IsTCPSizeValid(PCRTNETIPV4 pIpHdr, PCRTNETTCP pTcpHdr, size_t cbHdrMax, size_t cbPktMax);
810	RTDECL(bool) RTNetIPv4IsTCPValid(PCRTNETIPV4 pIpHdr, PCRTNETTCP pTcpHdr, size_t cbHdrMax, void const *pvData,
811	size_t cbPktMax, bool fChecksum);
812
813
814	/**
815	* IPv4 ICMP packet header.
816	*/
817	#pragma pack(1)
818	typedef struct RTNETICMPV4HDR
819	{
820	/** 00 - The ICMP message type. */
821	uint8_t icmp_type;
822	/** 01 - Type specific code that further qualifies the message. */
823	uint8_t icmp_code;
824	/** 02 - Checksum of the ICMP message. */
825	uint16_t icmp_cksum;
826	} RTNETICMPV4HDR;
827	#pragma pack()
828	AssertCompileSize(RTNETICMPV4HDR, 4);
829	/** Pointer to an ICMP packet header. */
830	typedef RTNETICMPV4HDR *PRTNETICMPV4HDR;
831	/** Pointer to a const ICMP packet header. */
832	typedef RTNETICMPV4HDR const *PCRTNETICMPV4HDR;
833
834	/** @name ICMP (v4) message types.
835	* @{ */
836	#define RTNETICMPV4_TYPE_ECHO_REPLY 0
837	#define RTNETICMPV4_TYPE_ECHO_REQUEST 8
838	#define RTNETICMPV4_TYPE_TRACEROUTE 30
839	/** @} */
840
841	/**
842	* IPv4 ICMP ECHO Reply & Request packet.
843	*/
844	#pragma pack(1)
845	typedef struct RTNETICMPV4ECHO
846	{
847	/** 00 - The ICMP header. */
848	RTNETICMPV4HDR Hdr;
849	/** 04 - The identifier to help the requestor match up the reply.
850	* Can be 0. Typically fixed value. */
851	uint16_t icmp_id;
852	/** 06 - The sequence number to help the requestor match up the reply.
853	* Can be 0. Typically incrementing between requests. */
854	uint16_t icmp_seq;
855	/** 08 - Variable length data that is to be returned unmodified in the reply. */
856	uint8_t icmp_data[1];
857	} RTNETICMPV4ECHO;
858	#pragma pack()
859	AssertCompileSize(RTNETICMPV4ECHO, 9);
860	/** Pointer to an ICMP ECHO packet. */
861	typedef RTNETICMPV4ECHO *PRTNETICMPV4ECHO;
862	/** Pointer to a const ICMP ECHO packet. */
863	typedef RTNETICMPV4ECHO const *PCRTNETICMPV4ECHO;
864
865	/**
866	* IPv4 ICMP TRACEROUTE packet.
867	* This is an reply to an IP packet with the traceroute option set.
868	*/
869	#pragma pack(1)
870	typedef struct RTNETICMPV4TRACEROUTE
871	{
872	/** 00 - The ICMP header. */
873	RTNETICMPV4HDR Hdr;
874	/** 04 - Identifier copied from the traceroute option's ID number. */
875	uint16_t icmp_id;
876	/** 06 - Unused. (Possibly an icmp_seq?) */
877	uint16_t icmp_void;
878	/** 08 - Outbound hop count. From the IP packet causing this message. */
879	uint16_t icmp_ohc;
880	/** 0a - Return hop count. From the IP packet causing this message. */
881	uint16_t icmp_rhc;
882	/** 0c - Output link speed, 0 if not known. */
883	uint32_t icmp_speed;
884	/** 10 - Output link MTU, 0 if not known. */
885	uint32_t icmp_mtu;
886	} RTNETICMPV4TRACEROUTE;
887	#pragma pack()
888	AssertCompileSize(RTNETICMPV4TRACEROUTE, 20);
889	/** Pointer to an ICMP TRACEROUTE packet. */
890	typedef RTNETICMPV4TRACEROUTE *PRTNETICMPV4TRACEROUTE;
891	/** Pointer to a const ICMP TRACEROUTE packet. */
892	typedef RTNETICMPV4TRACEROUTE const *PCRTNETICMPV4TRACEROUTE;
893
894	/** @todo add more ICMPv4 as needed. */
895
896	/**
897	* IPv4 ICMP union packet.
898	*/
899	typedef union RTNETICMPV4
900	{
901	RTNETICMPV4HDR Hdr;
902	RTNETICMPV4ECHO Echo;
903	RTNETICMPV4TRACEROUTE Traceroute;
904	} RTNETICMPV4;
905	/** Pointer to an ICMP union packet. */
906	typedef RTNETICMPV4 *PRTNETICMPV4;
907	/** Pointer to a const ICMP union packet. */
908	typedef RTNETICMPV4 const *PCRTNETICMPV4;
909
910
911	/**
912	* IPv6 ICMP packet header.
913	*/
914	#pragma pack(1)
915	typedef struct RTNETICMPV6HDR
916	{
917	/** 00 - The ICMPv6 message type. */
918	uint8_t icmp6_type;
919	/** 01 - Type specific code that further qualifies the message. */
920	uint8_t icmp6_code;
921	/** 02 - Checksum of the ICMPv6 message. */
922	uint16_t icmp6_cksum;
923	} RTNETICMPV6HDR;
924	#pragma pack()
925	AssertCompileSize(RTNETICMPV6HDR, 4);
926	/** Pointer to an ICMPv6 packet header. */
927	typedef RTNETICMPV6HDR *PRTNETICMPV6HDR;
928	/** Pointer to a const ICMP packet header. */
929	typedef RTNETICMPV6HDR const *PCRTNETICMPV6HDR;
930
931	#define RTNETIPV6_PROT_ICMPV6 (58)
932
933	/** @name Internet Control Message Protocol version 6 (ICMPv6) message types.
934	* @{ */
935	#define RTNETIPV6_ICMP_TYPE_RS 133
936	#define RTNETIPV6_ICMP_TYPE_RA 134
937	#define RTNETIPV6_ICMP_TYPE_NS 135
938	#define RTNETIPV6_ICMP_TYPE_NA 136
939	#define RTNETIPV6_ICMP_TYPE_RDR 137
940	/** @} */
941
942	/** @name Neighbor Discovery option types
943	* @{ */
944	#define RTNETIPV6_ICMP_ND_SLLA_OPT (1)
945	#define RTNETIPV6_ICMP_ND_TLLA_OPT (2)
946	/** @} */
947
948	/** ICMPv6 ND Source/Target Link Layer Address option */
949	#pragma pack(1)
950	typedef struct RTNETNDP_LLA_OPT
951	{
952	uint8_t type;
953	uint8_t len;
954	RTMAC lla;
955	} RTNETNDP_LLA_OPT;
956	#pragma pack()
957
958	AssertCompileSize(RTNETNDP_LLA_OPT, 1+1+6);
959
960	typedef RTNETNDP_LLA_OPT *PRTNETNDP_LLA_OPT;
961	typedef RTNETNDP_LLA_OPT const *PCRTNETNDP_LLA_OPT;
962
963	/** ICMPv6 ND Neighbor Sollicitation */
964	#pragma pack(1)
965	typedef struct RTNETNDP
966	{
967	/** 00 - The ICMPv6 header. */
968	RTNETICMPV6HDR Hdr;
969	/** 04 - reserved */
970	uint32_t reserved;
971	/** 08 - target address */
972	RTNETADDRIPV6 target_address;
973	} RTNETNDP;
974	#pragma pack()
975	AssertCompileSize(RTNETNDP, 4+4+16);
976	/** Pointer to a NDP ND packet. */
977	typedef RTNETNDP *PRTNETNDP;
978	/** Pointer to a const NDP NS packet. */
979	typedef RTNETNDP const *PCRTNETNDP;
980
981
982	/**
983	* Ethernet ARP header.
984	*/
985	#pragma pack(1)
986	typedef struct RTNETARPHDR
987	{
988	/** The hardware type. */
989	uint16_t ar_htype;
990	/** The protocol type (ethertype). */
991	uint16_t ar_ptype;
992	/** The hardware address length. */
993	uint8_t ar_hlen;
994	/** The protocol address length. */
995	uint8_t ar_plen;
996	/** The operation. */
997	uint16_t ar_oper;
998	} RTNETARPHDR;
999	#pragma pack()
1000	AssertCompileSize(RTNETARPHDR, 8);
1001	/** Pointer to an ethernet ARP header. */
1002	typedef RTNETARPHDR *PRTNETARPHDR;
1003	/** Pointer to a const ethernet ARP header. */
1004	typedef RTNETARPHDR const *PCRTNETARPHDR;
1005
1006	/** ARP hardware type - ethernet. */
1007	#define RTNET_ARP_ETHER UINT16_C(1)
1008
1009	/** @name ARP operations
1010	* @{ */
1011	#define RTNET_ARPOP_REQUEST UINT16_C(1) /*< Request hardware address given a protocol address (ARP). /
1012	#define RTNET_ARPOP_REPLY UINT16_C(2)
1013	#define RTNET_ARPOP_REVREQUEST UINT16_C(3) /*< Request protocol address given a hardware address (RARP). /
1014	#define RTNET_ARPOP_REVREPLY UINT16_C(4)
1015	#define RTNET_ARPOP_INVREQUEST UINT16_C(8) /*< Inverse ARP. /
1016	#define RTNET_ARPOP_INVREPLY UINT16_C(9)
1017	/** Check if an ARP operation is a request or not. */
1018	#define RTNET_ARPOP_IS_REQUEST(Op) ((Op) & 1)
1019	/** Check if an ARP operation is a reply or not. */
1020	#define RTNET_ARPOP_IS_REPLY(Op) (!RTNET_ARPOP_IS_REQUEST(Op))
1021	/** @} */
1022
1023
1024	/**
1025	* Ethernet IPv4 + 6-byte MAC ARP request packet.
1026	*/
1027	#pragma pack(1)
1028	typedef struct RTNETARPIPV4
1029	{
1030	/** ARP header. */
1031	RTNETARPHDR Hdr;
1032	/** The sender hardware address. */
1033	RTMAC ar_sha;
1034	/** The sender protocol address. */
1035	RTNETADDRIPV4 ar_spa;
1036	/** The target hardware address. */
1037	RTMAC ar_tha;
1038	/** The target protocol address. */
1039	RTNETADDRIPV4 ar_tpa;
1040	} RTNETARPIPV4;
1041	#pragma pack()
1042	AssertCompileSize(RTNETARPIPV4, 8+6+4+6+4);
1043	/** Pointer to an ethernet IPv4+MAC ARP request packet. */
1044	typedef RTNETARPIPV4 *PRTNETARPIPV4;
1045	/** Pointer to a const ethernet IPv4+MAC ARP request packet. */
1046	typedef RTNETARPIPV4 const *PCRTNETARPIPV4;
1047
1048
1049	/** @} */
1050
1051	RT_C_DECLS_END
1052
1053	#endif /* !IPRT_INCLUDED_net_h */
1054

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

source: vbox/trunk/include/iprt/net.h@ 93176

Download in other formats: