libpcap  1.10.1
About: libpcap is a packet filter library used by tools like tcpdump.
  Fossies Dox: libpcap-1.10.1.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

extract.h
Go to the documentation of this file.
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 
22 #ifndef _WIN32
23 #include <arpa/inet.h>
24 #endif
25 
26 #include <pcap/pcap-inttypes.h>
27 #include <pcap/compiler-tests.h>
28 #include "portability.h"
29 
30 /*
31  * If we have versions of GCC or Clang that support an __attribute__
32  * to say "if we're building with unsigned behavior sanitization,
33  * don't complain about undefined behavior in this function", we
34  * label these functions with that attribute - we *know* it's undefined
35  * in the C standard, but we *also* know it does what we want with
36  * the ISA we're targeting and the compiler we're using.
37  *
38  * For GCC 4.9.0 and later, we use __attribute__((no_sanitize_undefined));
39  * pre-5.0 GCC doesn't have __has_attribute, and I'm not sure whether
40  * GCC or Clang first had __attribute__((no_sanitize(XXX)).
41  *
42  * For Clang, we check for __attribute__((no_sanitize(XXX)) with
43  * __has_attribute, as there are versions of Clang that support
44  * __attribute__((no_sanitize("undefined")) but don't support
45  * __attribute__((no_sanitize_undefined)).
46  *
47  * We define this here, rather than in funcattrs.h, because we
48  * only want it used here, we don't want it to be broadly used.
49  * (Any printer will get this defined, but this should at least
50  * make it harder for people to find.)
51  */
52 #if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 409)
53 #define UNALIGNED_OK __attribute__((no_sanitize_undefined))
54 #elif __has_attribute(no_sanitize)
55 #define UNALIGNED_OK __attribute__((no_sanitize("undefined")))
56 #else
57 #define UNALIGNED_OK
58 #endif
59 
60 #if (defined(__i386__) || defined(_M_IX86) || defined(__X86__) || defined(__x86_64__) || defined(_M_X64)) || \
61  (defined(__m68k__) && (!defined(__mc68000__) && !defined(__mc68010__))) || \
62  (defined(__ppc__) || defined(__ppc64__) || defined(_M_PPC) || defined(_ARCH_PPC) || defined(_ARCH_PPC64)) || \
63  (defined(__s390__) || defined(__s390x__) || defined(__zarch__))
64 /*
65  * The processor natively handles unaligned loads, so we can just
66  * cast the pointer and fetch through it.
67  *
68  * XXX - are those all the x86 tests we need?
69  * XXX - are those the only 68k tests we need not to generated
70  * unaligned accesses if the target is the 68000 or 68010?
71  * XXX - are there any tests we don't need, because some definitions are for
72  * compilers that also predefine the GCC symbols?
73  * XXX - do we need to test for both 32-bit and 64-bit versions of those
74  * architectures in all cases?
75  */
76 UNALIGNED_OK static inline uint16_t
77 EXTRACT_BE_U_2(const void *p)
78 {
79  return ((uint16_t)ntohs(*(const uint16_t *)(p)));
80 }
81 
82 UNALIGNED_OK static inline int16_t
83 EXTRACT_BE_S_2(const void *p)
84 {
85  return ((int16_t)ntohs(*(const int16_t *)(p)));
86 }
87 
88 UNALIGNED_OK static inline uint32_t
89 EXTRACT_BE_U_4(const void *p)
90 {
91  return ((uint32_t)ntohl(*(const uint32_t *)(p)));
92 }
93 
94 UNALIGNED_OK static inline int32_t
95 EXTRACT_BE_S_4(const void *p)
96 {
97  return ((int32_t)ntohl(*(const int32_t *)(p)));
98 }
99 
100 UNALIGNED_OK static inline uint64_t
101 EXTRACT_BE_U_8(const void *p)
102 {
103  return ((uint64_t)(((uint64_t)ntohl(*((const uint32_t *)(p) + 0))) << 32 |
104  ((uint64_t)ntohl(*((const uint32_t *)(p) + 1))) << 0));
105 
106 }
107 
108 UNALIGNED_OK static inline int64_t
109 EXTRACT_BE_S_8(const void *p)
110 {
111  return ((int64_t)(((int64_t)ntohl(*((const uint32_t *)(p) + 0))) << 32 |
112  ((uint64_t)ntohl(*((const uint32_t *)(p) + 1))) << 0));
113 
114 }
115 #elif PCAP_IS_AT_LEAST_GNUC_VERSION(2,0) && \
116  (defined(__alpha) || defined(__alpha__) || \
117  defined(__mips) || defined(__mips__))
118 /*
119  * This is MIPS or Alpha, which don't natively handle unaligned loads,
120  * but which have instructions that can help when doing unaligned
121  * loads, and this is GCC 2.0 or later or a compiler that claims to
122  * be GCC 2.0 or later, which we assume that mean we have
123  * __attribute__((packed)), which we can use to convince the compiler
124  * to generate those instructions.
125  *
126  * Declare packed structures containing a uint16_t and a uint32_t,
127  * cast the pointer to point to one of those, and fetch through it;
128  * the GCC manual doesn't appear to explicitly say that
129  * __attribute__((packed)) causes the compiler to generate unaligned-safe
130  * code, but it apppears to do so.
131  *
132  * We do this in case the compiler can generate code using those
133  * instructions to do an unaligned load and pass stuff to "ntohs()" or
134  * "ntohl()", which might be better than the code to fetch the
135  * bytes one at a time and assemble them. (That might not be the
136  * case on a little-endian platform, such as DEC's MIPS machines and
137  * Alpha machines, where "ntohs()" and "ntohl()" might not be done
138  * inline.)
139  *
140  * We do this only for specific architectures because, for example,
141  * at least some versions of GCC, when compiling for 64-bit SPARC,
142  * generate code that assumes alignment if we do this.
143  *
144  * XXX - add other architectures and compilers as possible and
145  * appropriate.
146  *
147  * HP's C compiler, indicated by __HP_cc being defined, supports
148  * "#pragma unaligned N" in version A.05.50 and later, where "N"
149  * specifies a number of bytes at which the typedef on the next
150  * line is aligned, e.g.
151  *
152  * #pragma unalign 1
153  * typedef uint16_t unaligned_uint16_t;
154  *
155  * to define unaligned_uint16_t as a 16-bit unaligned data type.
156  * This could be presumably used, in sufficiently recent versions of
157  * the compiler, with macros similar to those below. This would be
158  * useful only if that compiler could generate better code for PA-RISC
159  * or Itanium than would be generated by a bunch of shifts-and-ORs.
160  *
161  * DEC C, indicated by __DECC being defined, has, at least on Alpha,
162  * an __unaligned qualifier that can be applied to pointers to get the
163  * compiler to generate code that does unaligned loads and stores when
164  * dereferencing the pointer in question.
165  *
166  * XXX - what if the native C compiler doesn't support
167  * __attribute__((packed))? How can we get it to generate unaligned
168  * accesses for *specific* items?
169  */
170 typedef struct {
171  uint16_t val;
172 } __attribute__((packed)) unaligned_uint16_t;
173 
174 typedef struct {
175  int16_t val;
176 } __attribute__((packed)) unaligned_int16_t;
177 
178 typedef struct {
179  uint32_t val;
180 } __attribute__((packed)) unaligned_uint32_t;
181 
182 typedef struct {
183  int32_t val;
184 } __attribute__((packed)) unaligned_int32_t;
185 
186 UNALIGNED_OK static inline uint16_t
187 EXTRACT_BE_U_2(const void *p)
188 {
189  return ((uint16_t)ntohs(((const unaligned_uint16_t *)(p))->val));
190 }
191 
192 UNALIGNED_OK static inline int16_t
193 EXTRACT_BE_S_2(const void *p)
194 {
195  return ((int16_t)ntohs(((const unaligned_int16_t *)(p))->val));
196 }
197 
198 UNALIGNED_OK static inline uint32_t
199 EXTRACT_BE_U_4(const void *p)
200 {
201  return ((uint32_t)ntohl(((const unaligned_uint32_t *)(p))->val));
202 }
203 
204 UNALIGNED_OK static inline int32_t
205 EXTRACT_BE_S_4(const void *p)
206 {
207  return ((int32_t)ntohl(((const unaligned_int32_t *)(p))->val));
208 }
209 
210 UNALIGNED_OK static inline uint64_t
211 EXTRACT_BE_U_8(const void *p)
212 {
213  return ((uint64_t)(((uint64_t)ntohl(((const unaligned_uint32_t *)(p) + 0)->val)) << 32 |
214  ((uint64_t)ntohl(((const unaligned_uint32_t *)(p) + 1)->val)) << 0));
215 }
216 
217 UNALIGNED_OK static inline int64_t
218 EXTRACT_BE_S_8(const void *p)
219 {
220  return ((int64_t)(((uint64_t)ntohl(((const unaligned_uint32_t *)(p) + 0)->val)) << 32 |
221  ((uint64_t)ntohl(((const unaligned_uint32_t *)(p) + 1)->val)) << 0));
222 }
223 #else
224 /*
225  * This architecture doesn't natively support unaligned loads, and either
226  * this isn't a GCC-compatible compiler, we don't have __attribute__,
227  * or we do but we don't know of any better way with this instruction
228  * set to do unaligned loads, so do unaligned loads of big-endian
229  * quantities the hard way - fetch the bytes one at a time and
230  * assemble them.
231  *
232  * XXX - ARM is a special case. ARMv1 through ARMv5 didn't suppory
233  * unaligned loads; ARMv6 and later support it *but* have a bit in
234  * the system control register that the OS can set and that causes
235  * unaligned loads to fault rather than succeeding.
236  *
237  * At least some OSes may set that flag, so we do *not* treat ARM
238  * as supporting unaligned loads. If your OS supports them on ARM,
239  * and you want to use them, please update the tests in the #if above
240  * to check for ARM *and* for your OS.
241  */
242 #define EXTRACT_BE_U_2(p) \
243  ((uint16_t)(((uint16_t)(*((const uint8_t *)(p) + 0)) << 8) | \
244  ((uint16_t)(*((const uint8_t *)(p) + 1)) << 0)))
245 #define EXTRACT_BE_S_2(p) \
246  ((int16_t)(((uint16_t)(*((const uint8_t *)(p) + 0)) << 8) | \
247  ((uint16_t)(*((const uint8_t *)(p) + 1)) << 0)))
248 #define EXTRACT_BE_U_4(p) \
249  ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 24) | \
250  ((uint32_t)(*((const uint8_t *)(p) + 1)) << 16) | \
251  ((uint32_t)(*((const uint8_t *)(p) + 2)) << 8) | \
252  ((uint32_t)(*((const uint8_t *)(p) + 3)) << 0)))
253 #define EXTRACT_BE_S_4(p) \
254  ((int32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 24) | \
255  ((uint32_t)(*((const uint8_t *)(p) + 1)) << 16) | \
256  ((uint32_t)(*((const uint8_t *)(p) + 2)) << 8) | \
257  ((uint32_t)(*((const uint8_t *)(p) + 3)) << 0)))
258 #define EXTRACT_BE_U_8(p) \
259  ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 56) | \
260  ((uint64_t)(*((const uint8_t *)(p) + 1)) << 48) | \
261  ((uint64_t)(*((const uint8_t *)(p) + 2)) << 40) | \
262  ((uint64_t)(*((const uint8_t *)(p) + 3)) << 32) | \
263  ((uint64_t)(*((const uint8_t *)(p) + 4)) << 24) | \
264  ((uint64_t)(*((const uint8_t *)(p) + 5)) << 16) | \
265  ((uint64_t)(*((const uint8_t *)(p) + 6)) << 8) | \
266  ((uint64_t)(*((const uint8_t *)(p) + 7)) << 0)))
267 #define EXTRACT_BE_S_8(p) \
268  ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 56) | \
269  ((uint64_t)(*((const uint8_t *)(p) + 1)) << 48) | \
270  ((uint64_t)(*((const uint8_t *)(p) + 2)) << 40) | \
271  ((uint64_t)(*((const uint8_t *)(p) + 3)) << 32) | \
272  ((uint64_t)(*((const uint8_t *)(p) + 4)) << 24) | \
273  ((uint64_t)(*((const uint8_t *)(p) + 5)) << 16) | \
274  ((uint64_t)(*((const uint8_t *)(p) + 6)) << 8) | \
275  ((uint64_t)(*((const uint8_t *)(p) + 7)) << 0)))
276 
277 /*
278  * Extract an IPv4 address, which is in network byte order, and not
279  * necessarily aligned, and provide the result in host byte order.
280  */
281 #define EXTRACT_IPV4_TO_HOST_ORDER(p) \
282  ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 24) | \
283  ((uint32_t)(*((const uint8_t *)(p) + 1)) << 16) | \
284  ((uint32_t)(*((const uint8_t *)(p) + 2)) << 8) | \
285  ((uint32_t)(*((const uint8_t *)(p) + 3)) << 0)))
286 #endif /* unaligned access checks */
287 
288 /*
289  * Non-power-of-2 sizes.
290  */
291 #define EXTRACT_BE_U_3(p) \
292  ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 16) | \
293  ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
294  ((uint32_t)(*((const uint8_t *)(p) + 2)) << 0)))
295 
296 #define EXTRACT_BE_S_3(p) \
297  (((*((const uint8_t *)(p) + 0)) & 0x80) ? \
298  ((int32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 16) | \
299  ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
300  ((uint32_t)(*((const uint8_t *)(p) + 2)) << 0))) : \
301  ((int32_t)(0xFF000000U | \
302  ((uint32_t)(*((const uint8_t *)(p) + 0)) << 16) | \
303  ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
304  ((uint32_t)(*((const uint8_t *)(p) + 2)) << 0))))
305 
306 #define EXTRACT_BE_U_5(p) \
307  ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 32) | \
308  ((uint64_t)(*((const uint8_t *)(p) + 1)) << 24) | \
309  ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
310  ((uint64_t)(*((const uint8_t *)(p) + 3)) << 8) | \
311  ((uint64_t)(*((const uint8_t *)(p) + 4)) << 0)))
312 
313 #define EXTRACT_BE_S_5(p) \
314  (((*((const uint8_t *)(p) + 0)) & 0x80) ? \
315  ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 32) | \
316  ((uint64_t)(*((const uint8_t *)(p) + 1)) << 24) | \
317  ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
318  ((uint64_t)(*((const uint8_t *)(p) + 3)) << 8) | \
319  ((uint64_t)(*((const uint8_t *)(p) + 4)) << 0))) : \
320  ((int64_t)(INT64_T_CONSTANT(0xFFFFFF0000000000U) | \
321  ((uint64_t)(*((const uint8_t *)(p) + 0)) << 32) | \
322  ((uint64_t)(*((const uint8_t *)(p) + 1)) << 24) | \
323  ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
324  ((uint64_t)(*((const uint8_t *)(p) + 3)) << 8) | \
325  ((uint64_t)(*((const uint8_t *)(p) + 4)) << 0))))
326 
327 #define EXTRACT_BE_U_6(p) \
328  ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 40) | \
329  ((uint64_t)(*((const uint8_t *)(p) + 1)) << 32) | \
330  ((uint64_t)(*((const uint8_t *)(p) + 2)) << 24) | \
331  ((uint64_t)(*((const uint8_t *)(p) + 3)) << 16) | \
332  ((uint64_t)(*((const uint8_t *)(p) + 4)) << 8) | \
333  ((uint64_t)(*((const uint8_t *)(p) + 5)) << 0)))
334 
335 #define EXTRACT_BE_S_6(p) \
336  (((*((const uint8_t *)(p) + 0)) & 0x80) ? \
337  ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 40) | \
338  ((uint64_t)(*((const uint8_t *)(p) + 1)) << 32) | \
339  ((uint64_t)(*((const uint8_t *)(p) + 2)) << 24) | \
340  ((uint64_t)(*((const uint8_t *)(p) + 3)) << 16) | \
341  ((uint64_t)(*((const uint8_t *)(p) + 4)) << 8) | \
342  ((uint64_t)(*((const uint8_t *)(p) + 5)) << 0))) : \
343  ((int64_t)(INT64_T_CONSTANT(0xFFFFFFFF00000000U) | \
344  ((uint64_t)(*((const uint8_t *)(p) + 0)) << 40) | \
345  ((uint64_t)(*((const uint8_t *)(p) + 1)) << 32) | \
346  ((uint64_t)(*((const uint8_t *)(p) + 2)) << 24) | \
347  ((uint64_t)(*((const uint8_t *)(p) + 3)) << 16) | \
348  ((uint64_t)(*((const uint8_t *)(p) + 4)) << 8) | \
349  ((uint64_t)(*((const uint8_t *)(p) + 5)) << 0))))
350 
351 #define EXTRACT_BE_U_7(p) \
352  ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 48) | \
353  ((uint64_t)(*((const uint8_t *)(p) + 1)) << 40) | \
354  ((uint64_t)(*((const uint8_t *)(p) + 2)) << 32) | \
355  ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
356  ((uint64_t)(*((const uint8_t *)(p) + 4)) << 16) | \
357  ((uint64_t)(*((const uint8_t *)(p) + 5)) << 8) | \
358  ((uint64_t)(*((const uint8_t *)(p) + 6)) << 0)))
359 
360 #define EXTRACT_BE_S_7(p) \
361  (((*((const uint8_t *)(p) + 0)) & 0x80) ? \
362  ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 48) | \
363  ((uint64_t)(*((const uint8_t *)(p) + 1)) << 40) | \
364  ((uint64_t)(*((const uint8_t *)(p) + 2)) << 32) | \
365  ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
366  ((uint64_t)(*((const uint8_t *)(p) + 4)) << 16) | \
367  ((uint64_t)(*((const uint8_t *)(p) + 5)) << 8) | \
368  ((uint64_t)(*((const uint8_t *)(p) + 6)) << 0))) : \
369  ((int64_t)(INT64_T_CONSTANT(0xFFFFFFFFFF000000U) | \
370  ((uint64_t)(*((const uint8_t *)(p) + 0)) << 48) | \
371  ((uint64_t)(*((const uint8_t *)(p) + 1)) << 40) | \
372  ((uint64_t)(*((const uint8_t *)(p) + 2)) << 32) | \
373  ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
374  ((uint64_t)(*((const uint8_t *)(p) + 4)) << 16) | \
375  ((uint64_t)(*((const uint8_t *)(p) + 5)) << 8) | \
376  ((uint64_t)(*((const uint8_t *)(p) + 6)) << 0))))
377 
378 /*
379  * Macros to extract possibly-unaligned little-endian integral values.
380  * XXX - do loads on little-endian machines that support unaligned loads?
381  */
382 #define EXTRACT_LE_U_2(p) \
383  ((uint16_t)(((uint16_t)(*((const uint8_t *)(p) + 1)) << 8) | \
384  ((uint16_t)(*((const uint8_t *)(p) + 0)) << 0)))
385 #define EXTRACT_LE_S_2(p) \
386  ((int16_t)(((uint16_t)(*((const uint8_t *)(p) + 1)) << 8) | \
387  ((uint16_t)(*((const uint8_t *)(p) + 0)) << 0)))
388 #define EXTRACT_LE_U_4(p) \
389  ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 3)) << 24) | \
390  ((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
391  ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
392  ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
393 #define EXTRACT_LE_S_4(p) \
394  ((int32_t)(((uint32_t)(*((const uint8_t *)(p) + 3)) << 24) | \
395  ((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
396  ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
397  ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
398 #define EXTRACT_LE_U_3(p) \
399  ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
400  ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
401  ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
402 #define EXTRACT_LE_S_3(p) \
403  ((int32_t)(((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
404  ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
405  ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
406 #define EXTRACT_LE_U_8(p) \
407  ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 7)) << 56) | \
408  ((uint64_t)(*((const uint8_t *)(p) + 6)) << 48) | \
409  ((uint64_t)(*((const uint8_t *)(p) + 5)) << 40) | \
410  ((uint64_t)(*((const uint8_t *)(p) + 4)) << 32) | \
411  ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
412  ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
413  ((uint64_t)(*((const uint8_t *)(p) + 1)) << 8) | \
414  ((uint64_t)(*((const uint8_t *)(p) + 0)) << 0)))
415 #define EXTRACT_LE_S_8(p) \
416  ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 7)) << 56) | \
417  ((uint64_t)(*((const uint8_t *)(p) + 6)) << 48) | \
418  ((uint64_t)(*((const uint8_t *)(p) + 5)) << 40) | \
419  ((uint64_t)(*((const uint8_t *)(p) + 4)) << 32) | \
420  ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
421  ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
422  ((uint64_t)(*((const uint8_t *)(p) + 1)) << 8) | \
423  ((uint64_t)(*((const uint8_t *)(p) + 0)) << 0)))
#define EXTRACT_BE_U_2(p)
Definition: extract.h:242
#define EXTRACT_BE_S_8(p)
Definition: extract.h:267
#define EXTRACT_BE_U_4(p)
Definition: extract.h:248
#define EXTRACT_BE_S_4(p)
Definition: extract.h:253
#define EXTRACT_BE_U_8(p)
Definition: extract.h:258
#define UNALIGNED_OK
Definition: extract.h:57
#define EXTRACT_BE_S_2(p)
Definition: extract.h:245