1/*
2 * Copyright (c) 1992, 1993, 1994, 1995, 1996
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that: (1) source code distributions
7 * retain the above copyright notice and this paragraph in its entirety, (2)
8 * distributions including binary code include the above copyright notice and
9 * this paragraph in its entirety in the documentation or other materials
10 * provided with the distribution, and (3) all advertising materials mentioning
11 * features or use of this software display the following acknowledgement:
12 * ``This product includes software developed by the University of California,
13 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
14 * the University nor the names of its contributors may be used to endorse
15 * or promote products derived from this software without specific prior
16 * written permission.
17 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
18 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
20 *
21 * @(#) Header: /tcpdump/master/tcpdump/extract.h,v 1.25 2006-01-30 16:20:07 hannes Exp (LBL)
22 */
23
24#ifdef __NetBSD__
25#include <string.h>
26
27/*
28 * Do it the portable way and let the compiler optimize the code
29 */
30static inline uint16_t EXTRACT_16BITS(const void *p)
31{
32	uint16_t t;
33	memcpy(&t, p, sizeof(t));
34	return ntohs(t);
35}
36
37static inline uint32_t EXTRACT_24BITS(const void *p)
38{
39	uint8_t t[3];
40	memcpy(t, p, sizeof(t));
41	return
42	    ((uint32_t)t[0] << 16) |
43	    ((uint32_t)t[1] << 8) |
44	    t[2];
45}
46
47static inline uint32_t EXTRACT_32BITS(const void *p)
48{
49	uint32_t t;
50	memcpy(&t, p, sizeof(t));
51	return ntohl(t);
52}
53
54static inline uint64_t EXTRACT_64BITS(const void *p)
55{
56	uint32_t t[2];
57	memcpy(&t[0], p, sizeof(t[0]));
58	memcpy(&t[1], (const uint8_t *)p + sizeof(t[0]), sizeof(t[1]));
59	return ((uint64_t)ntohl(t[0]) << 32) | ntohl(t[1]);
60}
61
62static inline uint8_t EXTRACT_LE_8BITS(const void *p)
63{
64	uint8_t t[1];
65	memcpy(t, p, sizeof(t));
66	return t[0];
67}
68
69static inline uint16_t EXTRACT_LE_16BITS(const void *p)
70{
71	uint8_t t[2];
72	memcpy(t, p, sizeof(t));
73	return
74	    ((uint16_t)t[1] << 8) |
75	    t[0];
76}
77
78static inline uint32_t EXTRACT_LE_24BITS(const void *p)
79{
80	uint8_t t[3];
81	memcpy(t, p, sizeof(t));
82	return
83	    ((uint32_t)t[2] << 16) |
84	    ((uint32_t)t[1] << 8) |
85	    t[0];
86}
87
88static inline uint32_t EXTRACT_LE_32BITS(const void *p)
89{
90	uint8_t t[4];
91	memcpy(t, p, sizeof(t));
92	return
93	    ((uint32_t)t[3] << 24) |
94	    ((uint32_t)t[2] << 16) |
95	    ((uint32_t)t[1] << 8) |
96	    t[0];
97}
98
99static inline uint64_t EXTRACT_LE_64BITS(const void *p)
100{
101	uint8_t t[8];
102	memcpy(&t, p, sizeof(t));
103	return
104	    ((uint64_t)t[7] << 56) |
105	    ((uint64_t)t[6] << 48) |
106	    ((uint64_t)t[5] << 40) |
107	    ((uint64_t)t[4] << 32) |
108	    ((uint64_t)t[3] << 24) |
109	    ((uint64_t)t[2] << 16) |
110	    ((uint64_t)t[1] << 8) |
111	    t[0];
112}
113
114#else /* Fast & Loose */
115/*
116 * Macros to extract possibly-unaligned big-endian integral values.
117 */
118#ifdef LBL_ALIGN
119/*
120 * The processor doesn't natively handle unaligned loads.
121 */
122#ifdef HAVE___ATTRIBUTE__
123/*
124 * We have __attribute__; we assume that means we have __attribute__((packed)).
125 * Declare packed structures containing a u_int16_t and a u_int32_t,
126 * cast the pointer to point to one of those, and fetch through it;
127 * the GCC manual doesn't appear to explicitly say that
128 * __attribute__((packed)) causes the compiler to generate unaligned-safe
129 * code, but it apppears to do so.
130 *
131 * We do this in case the compiler can generate, for this instruction set,
132 * better code to do an unaligned load and pass stuff to "ntohs()" or
133 * "ntohl()" than the code to fetch the bytes one at a time and
134 * assemble them.  (That might not be the case on a little-endian platform,
135 * where "ntohs()" and "ntohl()" might not be done inline.)
136 */
137typedef struct {
138	u_int16_t	val;
139} __attribute__((packed)) unaligned_u_int16_t;
140
141typedef struct {
142	u_int32_t	val;
143} __attribute__((packed)) unaligned_u_int32_t;
144
145#define EXTRACT_16BITS(p) \
146	((u_int16_t)ntohs(((const unaligned_u_int16_t *)(p))->val))
147#define EXTRACT_32BITS(p) \
148	((u_int32_t)ntohl(((const unaligned_u_int32_t *)(p))->val))
149#define EXTRACT_64BITS(p) \
150	((u_int64_t)(((u_int64_t)ntohl(((const unaligned_u_int32_t *)(p) + 0)->val)) << 32 | \
151		     ((u_int64_t)ntohl(((const unaligned_u_int32_t *)(p) + 1)->val)) << 0))
152
153#else /* HAVE___ATTRIBUTE__ */
154/*
155 * We don't have __attribute__, so do unaligned loads of big-endian
156 * quantities the hard way - fetch the bytes one at a time and
157 * assemble them.
158 */
159#define EXTRACT_16BITS(p) \
160	((u_int16_t)((u_int16_t)*((const u_int8_t *)(p) + 0) << 8 | \
161		     (u_int16_t)*((const u_int8_t *)(p) + 1)))
162#define EXTRACT_32BITS(p) \
163	((u_int32_t)((u_int32_t)*((const u_int8_t *)(p) + 0) << 24 | \
164		     (u_int32_t)*((const u_int8_t *)(p) + 1) << 16 | \
165		     (u_int32_t)*((const u_int8_t *)(p) + 2) << 8 | \
166		     (u_int32_t)*((const u_int8_t *)(p) + 3)))
167#define EXTRACT_64BITS(p) \
168	((u_int64_t)((u_int64_t)*((const u_int8_t *)(p) + 0) << 56 | \
169		     (u_int64_t)*((const u_int8_t *)(p) + 1) << 48 | \
170		     (u_int64_t)*((const u_int8_t *)(p) + 2) << 40 | \
171		     (u_int64_t)*((const u_int8_t *)(p) + 3) << 32 | \
172	             (u_int64_t)*((const u_int8_t *)(p) + 4) << 24 | \
173		     (u_int64_t)*((const u_int8_t *)(p) + 5) << 16 | \
174		     (u_int64_t)*((const u_int8_t *)(p) + 6) << 8 | \
175		     (u_int64_t)*((const u_int8_t *)(p) + 7)))
176#endif /* HAVE___ATTRIBUTE__ */
177#else /* LBL_ALIGN */
178/*
179 * The processor natively handles unaligned loads, so we can just
180 * cast the pointer and fetch through it.
181 */
182#define EXTRACT_16BITS(p) \
183	((u_int16_t)ntohs(*(const u_int16_t *)(p)))
184#define EXTRACT_32BITS(p) \
185	((u_int32_t)ntohl(*(const u_int32_t *)(p)))
186#define EXTRACT_64BITS(p) \
187	((u_int64_t)(((u_int64_t)ntohl(*((const u_int32_t *)(p) + 0))) << 32 | \
188		     ((u_int64_t)ntohl(*((const u_int32_t *)(p) + 1))) << 0))
189#endif /* LBL_ALIGN */
190
191#define EXTRACT_24BITS(p) \
192	((u_int32_t)((u_int32_t)*((const u_int8_t *)(p) + 0) << 16 | \
193		     (u_int32_t)*((const u_int8_t *)(p) + 1) << 8 | \
194		     (u_int32_t)*((const u_int8_t *)(p) + 2)))
195
196/*
197 * Macros to extract possibly-unaligned little-endian integral values.
198 * XXX - do loads on little-endian machines that support unaligned loads?
199 */
200#define EXTRACT_LE_8BITS(p) (*(p))
201#define EXTRACT_LE_16BITS(p) \
202	((u_int16_t)((u_int16_t)*((const u_int8_t *)(p) + 1) << 8 | \
203		     (u_int16_t)*((const u_int8_t *)(p) + 0)))
204#define EXTRACT_LE_32BITS(p) \
205	((u_int32_t)((u_int32_t)*((const u_int8_t *)(p) + 3) << 24 | \
206		     (u_int32_t)*((const u_int8_t *)(p) + 2) << 16 | \
207		     (u_int32_t)*((const u_int8_t *)(p) + 1) << 8 | \
208		     (u_int32_t)*((const u_int8_t *)(p) + 0)))
209#define EXTRACT_LE_24BITS(p) \
210	((u_int32_t)((u_int32_t)*((const u_int8_t *)(p) + 2) << 16 | \
211		     (u_int32_t)*((const u_int8_t *)(p) + 1) << 8 | \
212		     (u_int32_t)*((const u_int8_t *)(p) + 0)))
213#define EXTRACT_LE_64BITS(p) \
214	((u_int64_t)((u_int64_t)*((const u_int8_t *)(p) + 7) << 56 | \
215		     (u_int64_t)*((const u_int8_t *)(p) + 6) << 48 | \
216		     (u_int64_t)*((const u_int8_t *)(p) + 5) << 40 | \
217		     (u_int64_t)*((const u_int8_t *)(p) + 4) << 32 | \
218	             (u_int64_t)*((const u_int8_t *)(p) + 3) << 24 | \
219		     (u_int64_t)*((const u_int8_t *)(p) + 2) << 16 | \
220		     (u_int64_t)*((const u_int8_t *)(p) + 1) << 8 | \
221		     (u_int64_t)*((const u_int8_t *)(p) + 0)))
222#endif /* __NetBSD__ */
223