net.h@ 68920

Last change on this file since 68920 was 67414, checked in by vboxsync, 8 years ago
IPRT: RTNetMaskToPrefixIPv6 and RTNetPrefixToMaskIPv6
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 30.3 KB

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

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

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

Download in other formats: