contrib/tcpdump/extract.h

   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 EXTRACT_H
  23 #define EXTRACT_H
  24
  25 #include <string.h>
  26
  27 /*
  28  * For 8-bit values; needed to fetch a one-byte value.  Byte order
  29  * isn't relevant, and alignment isn't an issue.
  30  */
  31 #define EXTRACT_U_1(p)  ((uint8_t)(*(p)))
  32 #define EXTRACT_S_1(p)  ((int8_t)(*(p)))
  33
  34 /*
  35  * Inline functions or macros to extract possibly-unaligned big-endian
  36  * integral values.
  37  */
  38 #include "funcattrs.h"
  39 #include "netdissect.h"
  40 #include "diag-control.h"
  41
  42 /*
  43  * If we have versions of GCC or Clang that support an __attribute__
  44  * to say "if we're building with unsigned behavior sanitization,
  45  * don't complain about undefined behavior in this function", we
  46  * label these functions with that attribute - we *know* it's undefined
  47  * in the C standard, but we *also* know it does what we want with
  48  * the ISA we're targeting and the compiler we're using.
  49  *
  50  * For GCC 4.9.0 and later, we use __attribute__((no_sanitize_undefined));
  51  * pre-5.0 GCC doesn't have __has_attribute, and I'm not sure whether
  52  * GCC or Clang first had __attribute__((no_sanitize(XXX)).
  53  *
  54  * For Clang, we check for __attribute__((no_sanitize(XXX)) with
  55  * __has_attribute, as there are versions of Clang that support
  56  * __attribute__((no_sanitize("undefined")) but don't support
  57  * __attribute__((no_sanitize_undefined)).
  58  *
  59  * We define this here, rather than in funcattrs.h, because we
  60  * only want it used here, we don't want it to be broadly used.
  61  * (Any printer will get this defined, but this should at least
  62  * make it harder for people to find.)
  63  */
  64 #if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 409)
  65 #define UNALIGNED_OK    __attribute__((no_sanitize_undefined))
  66 #elif __has_attribute(no_sanitize)
  67 #define UNALIGNED_OK    __attribute__((no_sanitize("undefined")))
  68 #else
  69 #define UNALIGNED_OK
  70 #endif
  71
  72 #if (defined(__i386__) || defined(_M_IX86) || defined(__X86__) || defined(__x86_64__) || defined(_M_X64)) || \
  73     (defined(__m68k__) && (!defined(__mc68000__) && !defined(__mc68010__))) || \
  74     (defined(__ppc__) || defined(__ppc64__) || defined(_M_PPC) || defined(_ARCH_PPC) || defined(_ARCH_PPC64)) || \
  75     (defined(__s390__) || defined(__s390x__) || defined(__zarch__))
  76 /*
  77  * The processor natively handles unaligned loads, so we can just
  78  * cast the pointer and fetch through it.
  79  *
  80  * XXX - are those all the x86 tests we need?
  81  * XXX - are those the only 68k tests we need not to generated
  82  * unaligned accesses if the target is the 68000 or 68010?
  83  * XXX - are there any tests we don't need, because some definitions are for
  84  * compilers that also predefine the GCC symbols?
  85  * XXX - do we need to test for both 32-bit and 64-bit versions of those
  86  * architectures in all cases?
  87  */
  88 UNALIGNED_OK static inline uint16_t
  89 EXTRACT_BE_U_2(const void *p)
  90 {
  91         return ((uint16_t)ntohs(*(const uint16_t *)(p)));
  92 }
  93
  94 UNALIGNED_OK static inline int16_t
  95 EXTRACT_BE_S_2(const void *p)
  96 {
  97         return ((int16_t)ntohs(*(const int16_t *)(p)));
  98 }
  99
 100 UNALIGNED_OK static inline uint32_t
 101 EXTRACT_BE_U_4(const void *p)
 102 {
 103         return ((uint32_t)ntohl(*(const uint32_t *)(p)));
 104 }
 105
 106 UNALIGNED_OK static inline int32_t
 107 EXTRACT_BE_S_4(const void *p)
 108 {
 109         return ((int32_t)ntohl(*(const int32_t *)(p)));
 110 }
 111
 112 UNALIGNED_OK static inline uint64_t
 113 EXTRACT_BE_U_8(const void *p)
 114 {
 115         return ((uint64_t)(((uint64_t)ntohl(*((const uint32_t *)(p) + 0))) << 32 |
 116                 ((uint64_t)ntohl(*((const uint32_t *)(p) + 1))) << 0));
 117
 118 }
 119
 120 UNALIGNED_OK static inline int64_t
 121 EXTRACT_BE_S_8(const void *p)
 122 {
 123         return ((int64_t)(((int64_t)ntohl(*((const uint32_t *)(p) + 0))) << 32 |
 124                 ((uint64_t)ntohl(*((const uint32_t *)(p) + 1))) << 0));
 125
 126 }
 127
 128 /*
 129  * Extract an IPv4 address, which is in network byte order, and not
 130  * necessarily aligned, and provide the result in host byte order.
 131  */
 132 UNALIGNED_OK static inline uint32_t
 133 EXTRACT_IPV4_TO_HOST_ORDER(const void *p)
 134 {
 135         return ((uint32_t)ntohl(*(const uint32_t *)(p)));
 136 }
 137 #elif ND_IS_AT_LEAST_GNUC_VERSION(2,0) && \
 138     (defined(__alpha) || defined(__alpha__) || \
 139      defined(__mips) || defined(__mips__))
 140 /*
 141  * This is MIPS or Alpha, which don't natively handle unaligned loads,
 142  * but which have instructions that can help when doing unaligned
 143  * loads, and this is GCC 2.0 or later or a compiler that claims to
 144  * be GCC 2.0 or later, which we assume that mean we have
 145  * __attribute__((packed)), which we can use to convince the compiler
 146  * to generate those instructions.
 147  *
 148  * Declare packed structures containing a uint16_t and a uint32_t,
 149  * cast the pointer to point to one of those, and fetch through it;
 150  * the GCC manual doesn't appear to explicitly say that
 151  * __attribute__((packed)) causes the compiler to generate unaligned-safe
 152  * code, but it appears to do so.
 153  *
 154  * We do this in case the compiler can generate code using those
 155  * instructions to do an unaligned load and pass stuff to "ntohs()" or
 156  * "ntohl()", which might be better than the code to fetch the
 157  * bytes one at a time and assemble them.  (That might not be the
 158  * case on a little-endian platform, such as DEC's MIPS machines and
 159  * Alpha machines, where "ntohs()" and "ntohl()" might not be done
 160  * inline.)
 161  *
 162  * We do this only for specific architectures because, for example,
 163  * at least some versions of GCC, when compiling for 64-bit SPARC,
 164  * generate code that assumes alignment if we do this.
 165  *
 166  * XXX - add other architectures and compilers as possible and
 167  * appropriate.
 168  *
 169  * HP's C compiler, indicated by __HP_cc being defined, supports
 170  * "#pragma unaligned N" in version A.05.50 and later, where "N"
 171  * specifies a number of bytes at which the typedef on the next
 172  * line is aligned, e.g.
 173  *
 174  *      #pragma unalign 1
 175  *      typedef uint16_t unaligned_uint16_t;
 176  *
 177  * to define unaligned_uint16_t as a 16-bit unaligned data type.
 178  * This could be presumably used, in sufficiently recent versions of
 179  * the compiler, with macros similar to those below.  This would be
 180  * useful only if that compiler could generate better code for PA-RISC
 181  * or Itanium than would be generated by a bunch of shifts-and-ORs.
 182  *
 183  * DEC C, indicated by __DECC being defined, has, at least on Alpha,
 184  * an __unaligned qualifier that can be applied to pointers to get the
 185  * compiler to generate code that does unaligned loads and stores when
 186  * dereferencing the pointer in question.
 187  *
 188  * XXX - what if the native C compiler doesn't support
 189  * __attribute__((packed))?  How can we get it to generate unaligned
 190  * accesses for *specific* items?
 191  */
 192 typedef struct {
 193         uint16_t        val;
 194 } __attribute__((packed)) unaligned_uint16_t;
 195
 196 typedef struct {
 197         int16_t         val;
 198 } __attribute__((packed)) unaligned_int16_t;
 199
 200 typedef struct {
 201         uint32_t        val;
 202 } __attribute__((packed)) unaligned_uint32_t;
 203
 204 typedef struct {
 205         int32_t         val;
 206 } __attribute__((packed)) unaligned_int32_t;
 207
 208 UNALIGNED_OK static inline uint16_t
 209 EXTRACT_BE_U_2(const void *p)
 210 {
 211         return ((uint16_t)ntohs(((const unaligned_uint16_t *)(p))->val));
 212 }
 213
 214 UNALIGNED_OK static inline int16_t
 215 EXTRACT_BE_S_2(const void *p)
 216 {
 217         return ((int16_t)ntohs(((const unaligned_int16_t *)(p))->val));
 218 }
 219
 220 UNALIGNED_OK static inline uint32_t
 221 EXTRACT_BE_U_4(const void *p)
 222 {
 223         return ((uint32_t)ntohl(((const unaligned_uint32_t *)(p))->val));
 224 }
 225
 226 UNALIGNED_OK static inline int32_t
 227 EXTRACT_BE_S_4(const void *p)
 228 {
 229         return ((int32_t)ntohl(((const unaligned_int32_t *)(p))->val));
 230 }
 231
 232 UNALIGNED_OK static inline uint64_t
 233 EXTRACT_BE_U_8(const void *p)
 234 {
 235         return ((uint64_t)(((uint64_t)ntohl(((const unaligned_uint32_t *)(p) + 0)->val)) << 32 |
 236                 ((uint64_t)ntohl(((const unaligned_uint32_t *)(p) + 1)->val)) << 0));
 237 }
 238
 239 UNALIGNED_OK static inline int64_t
 240 EXTRACT_BE_S_8(const void *p)
 241 {
 242         return ((int64_t)(((uint64_t)ntohl(((const unaligned_uint32_t *)(p) + 0)->val)) << 32 |
 243                 ((uint64_t)ntohl(((const unaligned_uint32_t *)(p) + 1)->val)) << 0));
 244 }
 245
 246 /*
 247  * Extract an IPv4 address, which is in network byte order, and not
 248  * necessarily aligned, and provide the result in host byte order.
 249  */
 250 UNALIGNED_OK static inline uint32_t
 251 EXTRACT_IPV4_TO_HOST_ORDER(const void *p)
 252 {
 253         return ((uint32_t)ntohl(((const unaligned_uint32_t *)(p))->val));
 254 }
 255 #else
 256 /*
 257  * This architecture doesn't natively support unaligned loads, and either
 258  * this isn't a GCC-compatible compiler, we don't have __attribute__,
 259  * or we do but we don't know of any better way with this instruction
 260  * set to do unaligned loads, so do unaligned loads of big-endian
 261  * quantities the hard way - fetch the bytes one at a time and
 262  * assemble them.
 263  *
 264  * XXX - ARM is a special case.  ARMv1 through ARMv5 didn't suppory
 265  * unaligned loads; ARMv6 and later support it *but* have a bit in
 266  * the system control register that the OS can set and that causes
 267  * unaligned loads to fault rather than succeeding.
 268  *
 269  * At least some OSes may set that flag, so we do *not* treat ARM
 270  * as supporting unaligned loads.  If your OS supports them on ARM,
 271  * and you want to use them, please update the tests in the #if above
 272  * to check for ARM *and* for your OS.
 273  */
 274 #define EXTRACT_BE_U_2(p) \
 275         ((uint16_t)(((uint16_t)(*((const uint8_t *)(p) + 0)) << 8) | \
 276                     ((uint16_t)(*((const uint8_t *)(p) + 1)) << 0)))
 277 #define EXTRACT_BE_S_2(p) \
 278         ((int16_t)(((uint16_t)(*((const uint8_t *)(p) + 0)) << 8) | \
 279                    ((uint16_t)(*((const uint8_t *)(p) + 1)) << 0)))
 280 #define EXTRACT_BE_U_4(p) \
 281         ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 24) | \
 282                     ((uint32_t)(*((const uint8_t *)(p) + 1)) << 16) | \
 283                     ((uint32_t)(*((const uint8_t *)(p) + 2)) << 8) | \
 284                     ((uint32_t)(*((const uint8_t *)(p) + 3)) << 0)))
 285 #define EXTRACT_BE_S_4(p) \
 286         ((int32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 24) | \
 287                    ((uint32_t)(*((const uint8_t *)(p) + 1)) << 16) | \
 288                    ((uint32_t)(*((const uint8_t *)(p) + 2)) << 8) | \
 289                    ((uint32_t)(*((const uint8_t *)(p) + 3)) << 0)))
 290 #define EXTRACT_BE_U_8(p) \
 291         ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 56) | \
 292                     ((uint64_t)(*((const uint8_t *)(p) + 1)) << 48) | \
 293                     ((uint64_t)(*((const uint8_t *)(p) + 2)) << 40) | \
 294                     ((uint64_t)(*((const uint8_t *)(p) + 3)) << 32) | \
 295                     ((uint64_t)(*((const uint8_t *)(p) + 4)) << 24) | \
 296                     ((uint64_t)(*((const uint8_t *)(p) + 5)) << 16) | \
 297                     ((uint64_t)(*((const uint8_t *)(p) + 6)) << 8) | \
 298                     ((uint64_t)(*((const uint8_t *)(p) + 7)) << 0)))
 299 #define EXTRACT_BE_S_8(p) \
 300         ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 56) | \
 301                    ((uint64_t)(*((const uint8_t *)(p) + 1)) << 48) | \
 302                    ((uint64_t)(*((const uint8_t *)(p) + 2)) << 40) | \
 303                    ((uint64_t)(*((const uint8_t *)(p) + 3)) << 32) | \
 304                    ((uint64_t)(*((const uint8_t *)(p) + 4)) << 24) | \
 305                    ((uint64_t)(*((const uint8_t *)(p) + 5)) << 16) | \
 306                    ((uint64_t)(*((const uint8_t *)(p) + 6)) << 8) | \
 307                    ((uint64_t)(*((const uint8_t *)(p) + 7)) << 0)))
 308
 309 /*
 310  * Extract an IPv4 address, which is in network byte order, and not
 311  * necessarily aligned, and provide the result in host byte order.
 312  */
 313 #define EXTRACT_IPV4_TO_HOST_ORDER(p) \
 314         ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 24) | \
 315                     ((uint32_t)(*((const uint8_t *)(p) + 1)) << 16) | \
 316                     ((uint32_t)(*((const uint8_t *)(p) + 2)) << 8) | \
 317                     ((uint32_t)(*((const uint8_t *)(p) + 3)) << 0)))
 318 #endif /* unaligned access checks */
 319
 320 /*
 321  * Extract numerical values in *host* byte order.  (Some metadata
 322  * headers are in the byte order of the host that wrote the file,
 323  * and libpcap translate them to the byte order of the host
 324  * reading the file.  This means that if a program on that host
 325  * reads with libpcap and writes to a new file, the new file will
 326  * be written in the byte order of the host writing the file.  Thus,
 327  * the magic number in pcap files and byte-order magic in pcapng
 328  * files can be used to determine the byte order in those metadata
 329  * headers.)
 330  *
 331  * XXX - on platforms that can do unaligned accesses, just cast and
 332  * dereference the pointer.
 333  */
 334 static inline uint16_t
 335 EXTRACT_HE_U_2(const void *p)
 336 {
 337         uint16_t val;
 338
 339         UNALIGNED_MEMCPY(&val, p, sizeof(uint16_t));
 340         return val;
 341 }
 342
 343 static inline int16_t
 344 EXTRACT_HE_S_2(const void *p)
 345 {
 346         int16_t val;
 347
 348         UNALIGNED_MEMCPY(&val, p, sizeof(int16_t));
 349         return val;
 350 }
 351
 352 static inline uint32_t
 353 EXTRACT_HE_U_4(const void *p)
 354 {
 355         uint32_t val;
 356
 357         UNALIGNED_MEMCPY(&val, p, sizeof(uint32_t));
 358         return val;
 359 }
 360
 361 static inline int32_t
 362 EXTRACT_HE_S_4(const void *p)
 363 {
 364         int32_t val;
 365
 366         UNALIGNED_MEMCPY(&val, p, sizeof(int32_t));
 367         return val;
 368 }
 369
 370 /*
 371  * Extract an IPv4 address, which is in network byte order, and which
 372  * is not necessarily aligned on a 4-byte boundary, and provide the
 373  * result in network byte order.
 374  *
 375  * This works the same way regardless of the host's byte order.
 376  */
 377 static inline uint32_t
 378 EXTRACT_IPV4_TO_NETWORK_ORDER(const void *p)
 379 {
 380         uint32_t addr;
 381
 382         UNALIGNED_MEMCPY(&addr, p, sizeof(uint32_t));
 383         return addr;
 384 }
 385
 386 /*
 387  * Non-power-of-2 sizes.
 388  */
 389 #define EXTRACT_BE_U_3(p) \
 390         ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 16) | \
 391                     ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
 392                     ((uint32_t)(*((const uint8_t *)(p) + 2)) << 0)))
 393
 394 #define EXTRACT_BE_S_3(p) \
 395         (((*((const uint8_t *)(p) + 0)) & 0x80) ? \
 396           ((int32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 16) | \
 397                      ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
 398                      ((uint32_t)(*((const uint8_t *)(p) + 2)) << 0))) : \
 399           ((int32_t)(0xFF000000U | \
 400                      ((uint32_t)(*((const uint8_t *)(p) + 0)) << 16) | \
 401                      ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
 402                      ((uint32_t)(*((const uint8_t *)(p) + 2)) << 0))))
 403
 404 #define EXTRACT_BE_U_5(p) \
 405         ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 32) | \
 406                     ((uint64_t)(*((const uint8_t *)(p) + 1)) << 24) | \
 407                     ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
 408                     ((uint64_t)(*((const uint8_t *)(p) + 3)) << 8) | \
 409                     ((uint64_t)(*((const uint8_t *)(p) + 4)) << 0)))
 410
 411 #define EXTRACT_BE_S_5(p) \
 412         (((*((const uint8_t *)(p) + 0)) & 0x80) ? \
 413           ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 32) | \
 414                      ((uint64_t)(*((const uint8_t *)(p) + 1)) << 24) | \
 415                      ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
 416                      ((uint64_t)(*((const uint8_t *)(p) + 3)) << 8) | \
 417                      ((uint64_t)(*((const uint8_t *)(p) + 4)) << 0))) : \
 418           ((int64_t)(INT64_T_CONSTANT(0xFFFFFF0000000000U) | \
 419                      ((uint64_t)(*((const uint8_t *)(p) + 0)) << 32) | \
 420                      ((uint64_t)(*((const uint8_t *)(p) + 1)) << 24) | \
 421                      ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
 422                      ((uint64_t)(*((const uint8_t *)(p) + 3)) << 8) | \
 423                      ((uint64_t)(*((const uint8_t *)(p) + 4)) << 0))))
 424
 425 #define EXTRACT_BE_U_6(p) \
 426         ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 40) | \
 427                     ((uint64_t)(*((const uint8_t *)(p) + 1)) << 32) | \
 428                     ((uint64_t)(*((const uint8_t *)(p) + 2)) << 24) | \
 429                     ((uint64_t)(*((const uint8_t *)(p) + 3)) << 16) | \
 430                     ((uint64_t)(*((const uint8_t *)(p) + 4)) << 8) | \
 431                     ((uint64_t)(*((const uint8_t *)(p) + 5)) << 0)))
 432
 433 #define EXTRACT_BE_S_6(p) \
 434         (((*((const uint8_t *)(p) + 0)) & 0x80) ? \
 435            ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 40) | \
 436                       ((uint64_t)(*((const uint8_t *)(p) + 1)) << 32) | \
 437                       ((uint64_t)(*((const uint8_t *)(p) + 2)) << 24) | \
 438                       ((uint64_t)(*((const uint8_t *)(p) + 3)) << 16) | \
 439                       ((uint64_t)(*((const uint8_t *)(p) + 4)) << 8) | \
 440                       ((uint64_t)(*((const uint8_t *)(p) + 5)) << 0))) : \
 441           ((int64_t)(INT64_T_CONSTANT(0xFFFFFFFF00000000U) | \
 442                       ((uint64_t)(*((const uint8_t *)(p) + 0)) << 40) | \
 443                       ((uint64_t)(*((const uint8_t *)(p) + 1)) << 32) | \
 444                       ((uint64_t)(*((const uint8_t *)(p) + 2)) << 24) | \
 445                       ((uint64_t)(*((const uint8_t *)(p) + 3)) << 16) | \
 446                       ((uint64_t)(*((const uint8_t *)(p) + 4)) << 8) | \
 447                       ((uint64_t)(*((const uint8_t *)(p) + 5)) << 0))))
 448
 449 #define EXTRACT_BE_U_7(p) \
 450         ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 48) | \
 451                     ((uint64_t)(*((const uint8_t *)(p) + 1)) << 40) | \
 452                     ((uint64_t)(*((const uint8_t *)(p) + 2)) << 32) | \
 453                     ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
 454                     ((uint64_t)(*((const uint8_t *)(p) + 4)) << 16) | \
 455                     ((uint64_t)(*((const uint8_t *)(p) + 5)) << 8) | \
 456                     ((uint64_t)(*((const uint8_t *)(p) + 6)) << 0)))
 457
 458 #define EXTRACT_BE_S_7(p) \
 459         (((*((const uint8_t *)(p) + 0)) & 0x80) ? \
 460           ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 48) | \
 461                      ((uint64_t)(*((const uint8_t *)(p) + 1)) << 40) | \
 462                      ((uint64_t)(*((const uint8_t *)(p) + 2)) << 32) | \
 463                      ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
 464                      ((uint64_t)(*((const uint8_t *)(p) + 4)) << 16) | \
 465                      ((uint64_t)(*((const uint8_t *)(p) + 5)) << 8) | \
 466                      ((uint64_t)(*((const uint8_t *)(p) + 6)) << 0))) : \
 467             ((int64_t)(INT64_T_CONSTANT(0xFFFFFFFFFF000000U) | \
 468                      ((uint64_t)(*((const uint8_t *)(p) + 0)) << 48) | \
 469                      ((uint64_t)(*((const uint8_t *)(p) + 1)) << 40) | \
 470                      ((uint64_t)(*((const uint8_t *)(p) + 2)) << 32) | \
 471                      ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
 472                      ((uint64_t)(*((const uint8_t *)(p) + 4)) << 16) | \
 473                      ((uint64_t)(*((const uint8_t *)(p) + 5)) << 8) | \
 474                      ((uint64_t)(*((const uint8_t *)(p) + 6)) << 0))))
 475
 476 /*
 477  * Macros to extract possibly-unaligned little-endian integral values.
 478  * XXX - do loads on little-endian machines that support unaligned loads?
 479  */
 480 #define EXTRACT_LE_U_2(p) \
 481         ((uint16_t)(((uint16_t)(*((const uint8_t *)(p) + 1)) << 8) | \
 482                     ((uint16_t)(*((const uint8_t *)(p) + 0)) << 0)))
 483 #define EXTRACT_LE_S_2(p) \
 484         ((int16_t)(((uint16_t)(*((const uint8_t *)(p) + 1)) << 8) | \
 485                    ((uint16_t)(*((const uint8_t *)(p) + 0)) << 0)))
 486 #define EXTRACT_LE_U_4(p) \
 487         ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 3)) << 24) | \
 488                     ((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
 489                     ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
 490                     ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
 491 #define EXTRACT_LE_S_4(p) \
 492         ((int32_t)(((uint32_t)(*((const uint8_t *)(p) + 3)) << 24) | \
 493                    ((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
 494                    ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
 495                    ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
 496 #define EXTRACT_LE_U_8(p) \
 497         ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 7)) << 56) | \
 498                     ((uint64_t)(*((const uint8_t *)(p) + 6)) << 48) | \
 499                     ((uint64_t)(*((const uint8_t *)(p) + 5)) << 40) | \
 500                     ((uint64_t)(*((const uint8_t *)(p) + 4)) << 32) | \
 501                     ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
 502                     ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
 503                     ((uint64_t)(*((const uint8_t *)(p) + 1)) << 8) | \
 504                     ((uint64_t)(*((const uint8_t *)(p) + 0)) << 0)))
 505 #define EXTRACT_LE_S_8(p) \
 506         ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 7)) << 56) | \
 507                    ((uint64_t)(*((const uint8_t *)(p) + 6)) << 48) | \
 508                    ((uint64_t)(*((const uint8_t *)(p) + 5)) << 40) | \
 509                    ((uint64_t)(*((const uint8_t *)(p) + 4)) << 32) | \
 510                    ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
 511                    ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
 512                    ((uint64_t)(*((const uint8_t *)(p) + 1)) << 8) | \
 513                    ((uint64_t)(*((const uint8_t *)(p) + 0)) << 0)))
 514
 515 /*
 516  * Non-power-of-2 sizes.
 517  */
 518
 519 #define EXTRACT_LE_U_3(p) \
 520         ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
 521                     ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
 522                     ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
 523 #define EXTRACT_LE_S_3(p) \
 524         ((int32_t)(((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
 525                    ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
 526                    ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
 527 #define EXTRACT_LE_U_5(p) \
 528         ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 4)) << 32) |   \
 529                     ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) |   \
 530                     ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) |   \
 531                     ((uint64_t)(*((const uint8_t *)(p) + 1)) << 8) |    \
 532                     ((uint64_t)(*((const uint8_t *)(p) + 0)) << 0)))
 533 #define EXTRACT_LE_U_6(p) \
 534         ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 5)) << 40) |   \
 535                     ((uint64_t)(*((const uint8_t *)(p) + 4)) << 32) |   \
 536                     ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) |   \
 537                     ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) |   \
 538                     ((uint64_t)(*((const uint8_t *)(p) + 1)) << 8) |    \
 539                     ((uint64_t)(*((const uint8_t *)(p) + 0)) << 0)))
 540 #define EXTRACT_LE_U_7(p) \
 541         ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 6)) << 48) |   \
 542                     ((uint64_t)(*((const uint8_t *)(p) + 5)) << 40) |   \
 543                     ((uint64_t)(*((const uint8_t *)(p) + 4)) << 32) |   \
 544                     ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) |   \
 545                     ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) |   \
 546                     ((uint64_t)(*((const uint8_t *)(p) + 1)) << 8) |    \
 547                     ((uint64_t)(*((const uint8_t *)(p) + 0)) << 0)))
 548
 549 /*
 550  * Macros to check the presence of the values in question.
 551  */
 552 #define ND_TTEST_1(p) ND_TTEST_LEN((p), 1)
 553 #define ND_TCHECK_1(p) ND_TCHECK_LEN((p), 1)
 554
 555 #define ND_TTEST_2(p) ND_TTEST_LEN((p), 2)
 556 #define ND_TCHECK_2(p) ND_TCHECK_LEN((p), 2)
 557
 558 #define ND_TTEST_3(p) ND_TTEST_LEN((p), 3)
 559 #define ND_TCHECK_3(p) ND_TCHECK_LEN((p), 3)
 560
 561 #define ND_TTEST_4(p) ND_TTEST_LEN((p), 4)
 562 #define ND_TCHECK_4(p) ND_TCHECK_LEN((p), 4)
 563
 564 #define ND_TTEST_5(p) ND_TTEST_LEN((p), 5)
 565 #define ND_TCHECK_5(p) ND_TCHECK_LEN((p), 5)
 566
 567 #define ND_TTEST_6(p) ND_TTEST_LEN((p), 6)
 568 #define ND_TCHECK_6(p) ND_TCHECK_LEN((p), 6)
 569
 570 #define ND_TTEST_7(p) ND_TTEST_LEN((p), 7)
 571 #define ND_TCHECK_7(p) ND_TCHECK_LEN((p), 7)
 572
 573 #define ND_TTEST_8(p) ND_TTEST_LEN((p), 8)
 574 #define ND_TCHECK_8(p) ND_TCHECK_LEN((p), 8)
 575
 576 #define ND_TTEST_16(p) ND_TTEST_LEN((p), 16)
 577 #define ND_TCHECK_16(p) ND_TCHECK_LEN((p), 16)
 578
 579 /* get_u_1 and get_s_1 */
 580
 581 static inline uint8_t
 582 get_u_1(netdissect_options *ndo, const u_char *p)
 583 {
 584         if (!ND_TTEST_1(p))
 585                 nd_trunc_longjmp(ndo);
 586         return EXTRACT_U_1(p);
 587 }
 588
 589 static inline int8_t
 590 get_s_1(netdissect_options *ndo, const u_char *p)
 591 {
 592         if (!ND_TTEST_1(p))
 593                 nd_trunc_longjmp(ndo);
 594         return EXTRACT_S_1(p);
 595 }
 596
 597 /* get_be_u_N */
 598
 599 static inline uint16_t
 600 get_be_u_2(netdissect_options *ndo, const u_char *p)
 601 {
 602         if (!ND_TTEST_2(p))
 603                 nd_trunc_longjmp(ndo);
 604         return EXTRACT_BE_U_2(p);
 605 }
 606
 607 static inline uint32_t
 608 get_be_u_3(netdissect_options *ndo, const u_char *p)
 609 {
 610         if (!ND_TTEST_3(p))
 611                 nd_trunc_longjmp(ndo);
 612         return EXTRACT_BE_U_3(p);
 613 }
 614
 615 static inline uint32_t
 616 get_be_u_4(netdissect_options *ndo, const u_char *p)
 617 {
 618         if (!ND_TTEST_4(p))
 619                 nd_trunc_longjmp(ndo);
 620         return EXTRACT_BE_U_4(p);
 621 }
 622
 623 static inline uint64_t
 624 get_be_u_5(netdissect_options *ndo, const u_char *p)
 625 {
 626         if (!ND_TTEST_5(p))
 627                 nd_trunc_longjmp(ndo);
 628         return EXTRACT_BE_U_5(p);
 629 }
 630
 631 static inline uint64_t
 632 get_be_u_6(netdissect_options *ndo, const u_char *p)
 633 {
 634         if (!ND_TTEST_6(p))
 635                 nd_trunc_longjmp(ndo);
 636         return EXTRACT_BE_U_6(p);
 637 }
 638
 639 static inline uint64_t
 640 get_be_u_7(netdissect_options *ndo, const u_char *p)
 641 {
 642         if (!ND_TTEST_7(p))
 643                 nd_trunc_longjmp(ndo);
 644         return EXTRACT_BE_U_7(p);
 645 }
 646
 647 static inline uint64_t
 648 get_be_u_8(netdissect_options *ndo, const u_char *p)
 649 {
 650         if (!ND_TTEST_8(p))
 651                 nd_trunc_longjmp(ndo);
 652         return EXTRACT_BE_U_8(p);
 653 }
 654
 655 /* get_be_s_N  */
 656
 657 static inline int16_t
 658 get_be_s_2(netdissect_options *ndo, const u_char *p)
 659 {
 660         if (!ND_TTEST_2(p))
 661                 nd_trunc_longjmp(ndo);
 662         return EXTRACT_BE_S_2(p);
 663 }
 664
 665 static inline int32_t
 666 get_be_s_3(netdissect_options *ndo, const u_char *p)
 667 {
 668         if (!ND_TTEST_3(p))
 669                 nd_trunc_longjmp(ndo);
 670         return EXTRACT_BE_S_3(p);
 671 }
 672
 673 static inline int32_t
 674 get_be_s_4(netdissect_options *ndo, const u_char *p)
 675 {
 676         if (!ND_TTEST_4(p))
 677                 nd_trunc_longjmp(ndo);
 678         return EXTRACT_BE_S_4(p);
 679 }
 680
 681 static inline int64_t
 682 get_be_s_5(netdissect_options *ndo, const u_char *p)
 683 {
 684         if (!ND_TTEST_5(p))
 685                 nd_trunc_longjmp(ndo);
 686         return EXTRACT_BE_S_5(p);
 687 }
 688
 689 static inline int64_t
 690 get_be_s_6(netdissect_options *ndo, const u_char *p)
 691 {
 692         if (!ND_TTEST_6(p))
 693                 nd_trunc_longjmp(ndo);
 694         return EXTRACT_BE_S_6(p);
 695 }
 696
 697 static inline int64_t
 698 get_be_s_7(netdissect_options *ndo, const u_char *p)
 699 {
 700         if (!ND_TTEST_7(p))
 701                 nd_trunc_longjmp(ndo);
 702         return EXTRACT_BE_S_7(p);
 703 }
 704
 705 static inline int64_t
 706 get_be_s_8(netdissect_options *ndo, const u_char *p)
 707 {
 708         if (!ND_TTEST_8(p))
 709                 nd_trunc_longjmp(ndo);
 710         return EXTRACT_BE_S_8(p);
 711 }
 712
 713 /* get_he_u_N */
 714
 715 static inline uint16_t
 716 get_he_u_2(netdissect_options *ndo, const u_char *p)
 717 {
 718         if (!ND_TTEST_2(p))
 719                 nd_trunc_longjmp(ndo);
 720         return EXTRACT_HE_U_2(p);
 721 }
 722
 723 static inline uint32_t
 724 get_he_u_4(netdissect_options *ndo, const u_char *p)
 725 {
 726         if (!ND_TTEST_4(p))
 727                 nd_trunc_longjmp(ndo);
 728         return EXTRACT_HE_U_4(p);
 729 }
 730
 731 /* get_he_s_N */
 732
 733 static inline int16_t
 734 get_he_s_2(netdissect_options *ndo, const u_char *p)
 735 {
 736         if (!ND_TTEST_2(p))
 737                 nd_trunc_longjmp(ndo);
 738         return EXTRACT_HE_S_2(p);
 739 }
 740
 741 static inline int32_t
 742 get_he_s_4(netdissect_options *ndo, const u_char *p)
 743 {
 744         if (!ND_TTEST_4(p))
 745                 nd_trunc_longjmp(ndo);
 746         return EXTRACT_HE_S_4(p);
 747 }
 748
 749 /* get_le_u_N */
 750
 751 static inline uint16_t
 752 get_le_u_2(netdissect_options *ndo, const u_char *p)
 753 {
 754         if (!ND_TTEST_2(p))
 755                 nd_trunc_longjmp(ndo);
 756         return EXTRACT_LE_U_2(p);
 757 }
 758
 759 static inline uint32_t
 760 get_le_u_3(netdissect_options *ndo, const u_char *p)
 761 {
 762         if (!ND_TTEST_3(p))
 763                 nd_trunc_longjmp(ndo);
 764         return EXTRACT_LE_U_3(p);
 765 }
 766
 767 static inline uint32_t
 768 get_le_u_4(netdissect_options *ndo, const u_char *p)
 769 {
 770         if (!ND_TTEST_4(p))
 771                 nd_trunc_longjmp(ndo);
 772         return EXTRACT_LE_U_4(p);
 773 }
 774
 775 static inline uint64_t
 776 get_le_u_5(netdissect_options *ndo, const u_char *p)
 777 {
 778         if (!ND_TTEST_5(p))
 779                 nd_trunc_longjmp(ndo);
 780         return EXTRACT_LE_U_5(p);
 781 }
 782
 783 static inline uint64_t
 784 get_le_u_6(netdissect_options *ndo, const u_char *p)
 785 {
 786         if (!ND_TTEST_6(p))
 787                 nd_trunc_longjmp(ndo);
 788         return EXTRACT_LE_U_6(p);
 789 }
 790
 791 static inline uint64_t
 792 get_le_u_7(netdissect_options *ndo, const u_char *p)
 793 {
 794         if (!ND_TTEST_7(p))
 795                 nd_trunc_longjmp(ndo);
 796         return EXTRACT_LE_U_7(p);
 797 }
 798
 799 static inline uint64_t
 800 get_le_u_8(netdissect_options *ndo, const u_char *p)
 801 {
 802         if (!ND_TTEST_8(p))
 803                 nd_trunc_longjmp(ndo);
 804         return EXTRACT_LE_U_8(p);
 805 }
 806
 807 /* get_le_s_N */
 808
 809 static inline int16_t
 810 get_le_s_2(netdissect_options *ndo, const u_char *p)
 811 {
 812         if (!ND_TTEST_2(p))
 813                 nd_trunc_longjmp(ndo);
 814         return EXTRACT_LE_S_2(p);
 815 }
 816
 817 static inline int32_t
 818 get_le_s_3(netdissect_options *ndo, const u_char *p)
 819 {
 820         if (!ND_TTEST_3(p))
 821                 nd_trunc_longjmp(ndo);
 822         return EXTRACT_LE_S_3(p);
 823 }
 824
 825 static inline int32_t
 826 get_le_s_4(netdissect_options *ndo, const u_char *p)
 827 {
 828         if (!ND_TTEST_4(p))
 829                 nd_trunc_longjmp(ndo);
 830         return EXTRACT_LE_S_4(p);
 831 }
 832
 833 static inline int64_t
 834 get_le_s_8(netdissect_options *ndo, const u_char *p)
 835 {
 836         if (!ND_TTEST_8(p))
 837                 nd_trunc_longjmp(ndo);
 838         return EXTRACT_LE_S_8(p);
 839 }
 840
 841 /* get_ipv4_to_{host|network]_order */
 842
 843 static inline uint32_t
 844 get_ipv4_to_host_order(netdissect_options *ndo, const u_char *p)
 845 {
 846         if (!ND_TTEST_4(p))
 847                 nd_trunc_longjmp(ndo);
 848         return EXTRACT_IPV4_TO_HOST_ORDER(p);
 849 }
 850
 851 static inline uint32_t
 852 get_ipv4_to_network_order(netdissect_options *ndo, const u_char *p)
 853 {
 854         if (!ND_TTEST_4(p))
 855                 nd_trunc_longjmp(ndo);
 856         return EXTRACT_IPV4_TO_NETWORK_ORDER(p);
 857 }
 858
 859 static inline void
 860 get_cpy_bytes(netdissect_options *ndo, u_char *dst, const u_char *p, size_t len)
 861 {
 862         if (!ND_TTEST_LEN(p, len))
 863                 nd_trunc_longjmp(ndo);
 864         UNALIGNED_MEMCPY(dst, p, len);
 865 }
 866
 867 #define GET_U_1(p) get_u_1(ndo, (const u_char *)(p))
 868 #define GET_S_1(p) get_s_1(ndo, (const u_char *)(p))
 869
 870 #define GET_BE_U_2(p) get_be_u_2(ndo, (const u_char *)(p))
 871 #define GET_BE_U_3(p) get_be_u_3(ndo, (const u_char *)(p))
 872 #define GET_BE_U_4(p) get_be_u_4(ndo, (const u_char *)(p))
 873 #define GET_BE_U_5(p) get_be_u_5(ndo, (const u_char *)(p))
 874 #define GET_BE_U_6(p) get_be_u_6(ndo, (const u_char *)(p))
 875 #define GET_BE_U_7(p) get_be_u_7(ndo, (const u_char *)(p))
 876 #define GET_BE_U_8(p) get_be_u_8(ndo, (const u_char *)(p))
 877
 878 #define GET_BE_S_2(p) get_be_s_2(ndo, (const u_char *)(p))
 879 #define GET_BE_S_3(p) get_be_s_3(ndo, (const u_char *)(p))
 880 #define GET_BE_S_4(p) get_be_s_4(ndo, (const u_char *)(p))
 881 #define GET_BE_S_5(p) get_be_s_5(ndo, (const u_char *)(p))
 882 #define GET_BE_S_6(p) get_be_s_6(ndo, (const u_char *)(p))
 883 #define GET_BE_S_7(p) get_be_s_7(ndo, (const u_char *)(p))
 884 #define GET_BE_S_8(p) get_be_s_8(ndo, (const u_char *)(p))
 885
 886 #define GET_HE_U_2(p) get_he_u_2(ndo, (const u_char *)(p))
 887 #define GET_HE_U_4(p) get_he_u_4(ndo, (const u_char *)(p))
 888
 889 #define GET_HE_S_2(p) get_he_s_2(ndo, (const u_char *)(p))
 890 #define GET_HE_S_4(p) get_he_s_4(ndo, (const u_char *)(p))
 891
 892 #define GET_LE_U_2(p) get_le_u_2(ndo, (const u_char *)(p))
 893 #define GET_LE_U_3(p) get_le_u_3(ndo, (const u_char *)(p))
 894 #define GET_LE_U_4(p) get_le_u_4(ndo, (const u_char *)(p))
 895 #define GET_LE_U_5(p) get_le_u_5(ndo, (const u_char *)(p))
 896 #define GET_LE_U_6(p) get_le_u_6(ndo, (const u_char *)(p))
 897 #define GET_LE_U_7(p) get_le_u_7(ndo, (const u_char *)(p))
 898 #define GET_LE_U_8(p) get_le_u_8(ndo, (const u_char *)(p))
 899
 900 #define GET_LE_S_2(p) get_le_s_2(ndo, (const u_char *)(p))
 901 #define GET_LE_S_3(p) get_le_s_3(ndo, (const u_char *)(p))
 902 #define GET_LE_S_4(p) get_le_s_4(ndo, (const u_char *)(p))
 903 #define GET_LE_S_8(p) get_le_s_8(ndo, (const u_char *)(p))
 904
 905 #define GET_IPV4_TO_HOST_ORDER(p) get_ipv4_to_host_order(ndo, (const u_char *)(p))
 906 #define GET_IPV4_TO_NETWORK_ORDER(p) get_ipv4_to_network_order(ndo, (const u_char *)(p))
 907
 908 #define GET_CPY_BYTES(dst, p, len) get_cpy_bytes(ndo, (u_char *)(dst), (const u_char *)(p), len)
 909
 910 #endif /* EXTRACT_H */