/src/libpcap/extract.h

Source (jump to first uncovered line)
/*
 * Copyright (c) 1992, 1993, 1994, 1995, 1996
 *  The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that: (1) source code distributions
 * retain the above copyright notice and this paragraph in its entirety, (2)
 * distributions including binary code include the above copyright notice and
 * this paragraph in its entirety in the documentation or other materials
 * provided with the distribution, and (3) all advertising materials mentioning
 * features or use of this software display the following acknowledgement:
 * ``This product includes software developed by the University of California,
 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
 * the University nor the names of its contributors may be used to endorse
 * or promote products derived from this software without specific prior
 * written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#ifndef _WIN32
#include <arpa/inet.h>
#endif

#include <pcap/pcap-inttypes.h>
#include <pcap/compiler-tests.h>
#include "portability.h"

/*
 * If we have versions of GCC or Clang that support an __attribute__
 * to say "if we're building with unsigned behavior sanitization,
 * don't complain about undefined behavior in this function", we
 * label these functions with that attribute - we *know* it's undefined
 * in the C standard, but we *also* know it does what we want with
 * the ISA we're targeting and the compiler we're using.
 *
 * For GCC 4.9.0 and later, we use __attribute__((no_sanitize_undefined));
 * pre-5.0 GCC doesn't have __has_attribute, and I'm not sure whether
 * GCC or Clang first had __attribute__((no_sanitize(XXX)).
 *
 * For Clang, we check for __attribute__((no_sanitize(XXX)) with
 * __has_attribute, as there are versions of Clang that support
 * __attribute__((no_sanitize("undefined")) but don't support
 * __attribute__((no_sanitize_undefined)).
 *
 * We define this here, rather than in funcattrs.h, because we
 * only want it used here, we don't want it to be broadly used.
 * (Any printer will get this defined, but this should at least
 * make it harder for people to find.)
 */
#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 409)
#define UNALIGNED_OK  __attribute__((no_sanitize_undefined))
#elif __has_attribute(no_sanitize)
#define UNALIGNED_OK  __attribute__((no_sanitize("undefined")))
#else
#define UNALIGNED_OK
#endif

#if (defined(__i386__) || defined(_M_IX86) || defined(__X86__) || defined(__x86_64__) || defined(_M_X64)) || \
    (defined(__m68k__) && (!defined(__mc68000__) && !defined(__mc68010__))) || \
    (defined(__ppc__) || defined(__ppc64__) || defined(_M_PPC) || defined(_ARCH_PPC) || defined(_ARCH_PPC64)) || \
    (defined(__s390__) || defined(__s390x__) || defined(__zarch__))
/*
 * The processor natively handles unaligned loads, so we can just
 * cast the pointer and fetch through it.
 *
 * XXX - are those all the x86 tests we need?
 * XXX - are those the only 68k tests we need not to generated
 * unaligned accesses if the target is the 68000 or 68010?
 * XXX - are there any tests we don't need, because some definitions are for
 * compilers that also predefine the GCC symbols?
 * XXX - do we need to test for both 32-bit and 64-bit versions of those
 * architectures in all cases?
 */
UNALIGNED_OK static inline uint16_t
EXTRACT_BE_U_2(const void *p)
{
  return ((uint16_t)ntohs(*(const uint16_t *)(p)));
}

UNALIGNED_OK static inline int16_t
EXTRACT_BE_S_2(const void *p)
{
  return ((int16_t)ntohs(*(const int16_t *)(p)));
}

UNALIGNED_OK static inline uint32_t
EXTRACT_BE_U_4(const void *p)
{
  return ((uint32_t)ntohl(*(const uint32_t *)(p)));
}

UNALIGNED_OK static inline int32_t
EXTRACT_BE_S_4(const void *p)
{
  return ((int32_t)ntohl(*(const int32_t *)(p)));
}

UNALIGNED_OK static inline uint64_t
EXTRACT_BE_U_8(const void *p)
{
  return ((uint64_t)(((uint64_t)ntohl(*((const uint32_t *)(p) + 0))) << 32 |
    ((uint64_t)ntohl(*((const uint32_t *)(p) + 1))) << 0));

}

UNALIGNED_OK static inline int64_t
EXTRACT_BE_S_8(const void *p)
{
  return ((int64_t)(((int64_t)ntohl(*((const uint32_t *)(p) + 0))) << 32 |
    ((uint64_t)ntohl(*((const uint32_t *)(p) + 1))) << 0));

}
#elif PCAP_IS_AT_LEAST_GNUC_VERSION(2,0) && \
    (defined(__alpha) || defined(__alpha__) || \
     defined(__mips) || defined(__mips__))
/*
 * This is MIPS or Alpha, which don't natively handle unaligned loads,
 * but which have instructions that can help when doing unaligned
 * loads, and this is GCC 2.0 or later or a compiler that claims to
 * be GCC 2.0 or later, which we assume that mean we have
 * __attribute__((packed)), which we can use to convince the compiler
 * to generate those instructions.
 *
 * Declare packed structures containing a uint16_t and a uint32_t,
 * cast the pointer to point to one of those, and fetch through it;
 * the GCC manual doesn't appear to explicitly say that
 * __attribute__((packed)) causes the compiler to generate unaligned-safe
 * code, but it appears to do so.
 *
 * We do this in case the compiler can generate code using those
 * instructions to do an unaligned load and pass stuff to "ntohs()" or
 * "ntohl()", which might be better than the code to fetch the
 * bytes one at a time and assemble them.  (That might not be the
 * case on a little-endian platform, such as DEC's MIPS machines and
 * Alpha machines, where "ntohs()" and "ntohl()" might not be done
 * inline.)
 *
 * We do this only for specific architectures because, for example,
 * at least some versions of GCC, when compiling for 64-bit SPARC,
 * generate code that assumes alignment if we do this.
 *
 * XXX - add other architectures and compilers as possible and
 * appropriate.
 *
 * HP's C compiler, indicated by __HP_cc being defined, supports
 * "#pragma unaligned N" in version A.05.50 and later, where "N"
 * specifies a number of bytes at which the typedef on the next
 * line is aligned, e.g.
 *
 *  #pragma unalign 1
 *  typedef uint16_t unaligned_uint16_t;
 *
 * to define unaligned_uint16_t as a 16-bit unaligned data type.
 * This could be presumably used, in sufficiently recent versions of
 * the compiler, with macros similar to those below.  This would be
 * useful only if that compiler could generate better code for PA-RISC
 * or Itanium than would be generated by a bunch of shifts-and-ORs.
 *
 * DEC C, indicated by __DECC being defined, has, at least on Alpha,
 * an __unaligned qualifier that can be applied to pointers to get the
 * compiler to generate code that does unaligned loads and stores when
 * dereferencing the pointer in question.
 *
 * XXX - what if the native C compiler doesn't support
 * __attribute__((packed))?  How can we get it to generate unaligned
 * accesses for *specific* items?
 */
typedef struct {
  uint16_t  val;
} __attribute__((packed)) unaligned_uint16_t;

typedef struct {
  int16_t   val;
} __attribute__((packed)) unaligned_int16_t;

typedef struct {
  uint32_t  val;
} __attribute__((packed)) unaligned_uint32_t;

typedef struct {
  int32_t   val;
} __attribute__((packed)) unaligned_int32_t;

UNALIGNED_OK static inline uint16_t
EXTRACT_BE_U_2(const void *p)
{
  return ((uint16_t)ntohs(((const unaligned_uint16_t *)(p))->val));
}

UNALIGNED_OK static inline int16_t
EXTRACT_BE_S_2(const void *p)
{
  return ((int16_t)ntohs(((const unaligned_int16_t *)(p))->val));
}

UNALIGNED_OK static inline uint32_t
EXTRACT_BE_U_4(const void *p)
{
  return ((uint32_t)ntohl(((const unaligned_uint32_t *)(p))->val));
}

UNALIGNED_OK static inline int32_t
EXTRACT_BE_S_4(const void *p)
{
  return ((int32_t)ntohl(((const unaligned_int32_t *)(p))->val));
}

UNALIGNED_OK static inline uint64_t
EXTRACT_BE_U_8(const void *p)
{
  return ((uint64_t)(((uint64_t)ntohl(((const unaligned_uint32_t *)(p) + 0)->val)) << 32 |
    ((uint64_t)ntohl(((const unaligned_uint32_t *)(p) + 1)->val)) << 0));
}

UNALIGNED_OK static inline int64_t
EXTRACT_BE_S_8(const void *p)
{
  return ((int64_t)(((uint64_t)ntohl(((const unaligned_uint32_t *)(p) + 0)->val)) << 32 |
    ((uint64_t)ntohl(((const unaligned_uint32_t *)(p) + 1)->val)) << 0));
}
#else
/*
 * This architecture doesn't natively support unaligned loads, and either
 * this isn't a GCC-compatible compiler, we don't have __attribute__,
 * or we do but we don't know of any better way with this instruction
 * set to do unaligned loads, so do unaligned loads of big-endian
 * quantities the hard way - fetch the bytes one at a time and
 * assemble them.
 *
 * XXX - ARM is a special case.  ARMv1 through ARMv5 didn't suppory
 * unaligned loads; ARMv6 and later support it *but* have a bit in
 * the system control register that the OS can set and that causes
 * unaligned loads to fault rather than succeeding.
 *
 * At least some OSes may set that flag, so we do *not* treat ARM
 * as supporting unaligned loads.  If your OS supports them on ARM,
 * and you want to use them, please update the tests in the #if above
 * to check for ARM *and* for your OS.
 */
#define EXTRACT_BE_U_2(p) \
  ((uint16_t)(((uint16_t)(*((const uint8_t *)(p) + 0)) << 8) | \
              ((uint16_t)(*((const uint8_t *)(p) + 1)) << 0)))
#define EXTRACT_BE_S_2(p) \
  ((int16_t)(((uint16_t)(*((const uint8_t *)(p) + 0)) << 8) | \
             ((uint16_t)(*((const uint8_t *)(p) + 1)) << 0)))
#define EXTRACT_BE_U_4(p) \
  ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 24) | \
              ((uint32_t)(*((const uint8_t *)(p) + 1)) << 16) | \
              ((uint32_t)(*((const uint8_t *)(p) + 2)) << 8) | \
              ((uint32_t)(*((const uint8_t *)(p) + 3)) << 0)))
#define EXTRACT_BE_S_4(p) \
  ((int32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 24) | \
             ((uint32_t)(*((const uint8_t *)(p) + 1)) << 16) | \
             ((uint32_t)(*((const uint8_t *)(p) + 2)) << 8) | \
             ((uint32_t)(*((const uint8_t *)(p) + 3)) << 0)))
#define EXTRACT_BE_U_8(p) \
  ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 56) | \
              ((uint64_t)(*((const uint8_t *)(p) + 1)) << 48) | \
              ((uint64_t)(*((const uint8_t *)(p) + 2)) << 40) | \
              ((uint64_t)(*((const uint8_t *)(p) + 3)) << 32) | \
              ((uint64_t)(*((const uint8_t *)(p) + 4)) << 24) | \
              ((uint64_t)(*((const uint8_t *)(p) + 5)) << 16) | \
              ((uint64_t)(*((const uint8_t *)(p) + 6)) << 8) | \
              ((uint64_t)(*((const uint8_t *)(p) + 7)) << 0)))
#define EXTRACT_BE_S_8(p) \
  ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 56) | \
             ((uint64_t)(*((const uint8_t *)(p) + 1)) << 48) | \
             ((uint64_t)(*((const uint8_t *)(p) + 2)) << 40) | \
             ((uint64_t)(*((const uint8_t *)(p) + 3)) << 32) | \
             ((uint64_t)(*((const uint8_t *)(p) + 4)) << 24) | \
             ((uint64_t)(*((const uint8_t *)(p) + 5)) << 16) | \
             ((uint64_t)(*((const uint8_t *)(p) + 6)) << 8) | \
             ((uint64_t)(*((const uint8_t *)(p) + 7)) << 0)))

/*
 * Extract an IPv4 address, which is in network byte order, and not
 * necessarily aligned, and provide the result in host byte order.
 */
#define EXTRACT_IPV4_TO_HOST_ORDER(p) \
  ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 24) | \
              ((uint32_t)(*((const uint8_t *)(p) + 1)) << 16) | \
              ((uint32_t)(*((const uint8_t *)(p) + 2)) << 8) | \
              ((uint32_t)(*((const uint8_t *)(p) + 3)) << 0)))
#endif /* unaligned access checks */

/*
 * Non-power-of-2 sizes.
 */
#define EXTRACT_BE_U_3(p) \
  ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 16) | \
              ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
              ((uint32_t)(*((const uint8_t *)(p) + 2)) << 0)))

#define EXTRACT_BE_S_3(p) \
  (((*((const uint8_t *)(p) + 0)) & 0x80) ? \
    ((int32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 16) | \
               ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
               ((uint32_t)(*((const uint8_t *)(p) + 2)) << 0))) : \
    ((int32_t)(0xFF000000U | \
               ((uint32_t)(*((const uint8_t *)(p) + 0)) << 16) | \
               ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
               ((uint32_t)(*((const uint8_t *)(p) + 2)) << 0))))

#define EXTRACT_BE_U_5(p) \
  ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 32) | \
              ((uint64_t)(*((const uint8_t *)(p) + 1)) << 24) | \
              ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
              ((uint64_t)(*((const uint8_t *)(p) + 3)) << 8) | \
              ((uint64_t)(*((const uint8_t *)(p) + 4)) << 0)))

#define EXTRACT_BE_S_5(p) \
  (((*((const uint8_t *)(p) + 0)) & 0x80) ? \
    ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 32) | \
               ((uint64_t)(*((const uint8_t *)(p) + 1)) << 24) | \
               ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
               ((uint64_t)(*((const uint8_t *)(p) + 3)) << 8) | \
               ((uint64_t)(*((const uint8_t *)(p) + 4)) << 0))) : \
    ((int64_t)(INT64_T_CONSTANT(0xFFFFFF0000000000U) | \
               ((uint64_t)(*((const uint8_t *)(p) + 0)) << 32) | \
               ((uint64_t)(*((const uint8_t *)(p) + 1)) << 24) | \
               ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
               ((uint64_t)(*((const uint8_t *)(p) + 3)) << 8) | \
               ((uint64_t)(*((const uint8_t *)(p) + 4)) << 0))))

#define EXTRACT_BE_U_6(p) \
  ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 40) | \
              ((uint64_t)(*((const uint8_t *)(p) + 1)) << 32) | \
              ((uint64_t)(*((const uint8_t *)(p) + 2)) << 24) | \
              ((uint64_t)(*((const uint8_t *)(p) + 3)) << 16) | \
              ((uint64_t)(*((const uint8_t *)(p) + 4)) << 8) | \
              ((uint64_t)(*((const uint8_t *)(p) + 5)) << 0)))

#define EXTRACT_BE_S_6(p) \
  (((*((const uint8_t *)(p) + 0)) & 0x80) ? \
     ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 40) | \
                ((uint64_t)(*((const uint8_t *)(p) + 1)) << 32) | \
                ((uint64_t)(*((const uint8_t *)(p) + 2)) << 24) | \
                ((uint64_t)(*((const uint8_t *)(p) + 3)) << 16) | \
                ((uint64_t)(*((const uint8_t *)(p) + 4)) << 8) | \
                ((uint64_t)(*((const uint8_t *)(p) + 5)) << 0))) : \
    ((int64_t)(INT64_T_CONSTANT(0xFFFFFFFF00000000U) | \
                ((uint64_t)(*((const uint8_t *)(p) + 0)) << 40) | \
                ((uint64_t)(*((const uint8_t *)(p) + 1)) << 32) | \
                ((uint64_t)(*((const uint8_t *)(p) + 2)) << 24) | \
                ((uint64_t)(*((const uint8_t *)(p) + 3)) << 16) | \
                ((uint64_t)(*((const uint8_t *)(p) + 4)) << 8) | \
                ((uint64_t)(*((const uint8_t *)(p) + 5)) << 0))))

#define EXTRACT_BE_U_7(p) \
  ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 48) | \
              ((uint64_t)(*((const uint8_t *)(p) + 1)) << 40) | \
              ((uint64_t)(*((const uint8_t *)(p) + 2)) << 32) | \
              ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
              ((uint64_t)(*((const uint8_t *)(p) + 4)) << 16) | \
              ((uint64_t)(*((const uint8_t *)(p) + 5)) << 8) | \
              ((uint64_t)(*((const uint8_t *)(p) + 6)) << 0)))

#define EXTRACT_BE_S_7(p) \
  (((*((const uint8_t *)(p) + 0)) & 0x80) ? \
    ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 48) | \
               ((uint64_t)(*((const uint8_t *)(p) + 1)) << 40) | \
               ((uint64_t)(*((const uint8_t *)(p) + 2)) << 32) | \
               ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
               ((uint64_t)(*((const uint8_t *)(p) + 4)) << 16) | \
               ((uint64_t)(*((const uint8_t *)(p) + 5)) << 8) | \
               ((uint64_t)(*((const uint8_t *)(p) + 6)) << 0))) : \
      ((int64_t)(INT64_T_CONSTANT(0xFFFFFFFFFF000000U) | \
               ((uint64_t)(*((const uint8_t *)(p) + 0)) << 48) | \
               ((uint64_t)(*((const uint8_t *)(p) + 1)) << 40) | \
               ((uint64_t)(*((const uint8_t *)(p) + 2)) << 32) | \
               ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
               ((uint64_t)(*((const uint8_t *)(p) + 4)) << 16) | \
               ((uint64_t)(*((const uint8_t *)(p) + 5)) << 8) | \
               ((uint64_t)(*((const uint8_t *)(p) + 6)) << 0))))

/*
 * Macros to extract possibly-unaligned little-endian integral values.
 * XXX - do loads on little-endian machines that support unaligned loads?
 */
#define EXTRACT_LE_U_2(p) \
  ((uint16_t)(((uint16_t)(*((const uint8_t *)(p) + 1)) << 8) | \
              ((uint16_t)(*((const uint8_t *)(p) + 0)) << 0)))
#define EXTRACT_LE_S_2(p) \
  ((int16_t)(((uint16_t)(*((const uint8_t *)(p) + 1)) << 8) | \
             ((uint16_t)(*((const uint8_t *)(p) + 0)) << 0)))
#define EXTRACT_LE_U_4(p) \
  ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 3)) << 24) | \
              ((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
              ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
              ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
#define EXTRACT_LE_S_4(p) \
  ((int32_t)(((uint32_t)(*((const uint8_t *)(p) + 3)) << 24) | \
             ((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
             ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
             ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
#define EXTRACT_LE_U_3(p) \
  ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
              ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
              ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
#define EXTRACT_LE_S_3(p) \
  ((int32_t)(((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
             ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
             ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
#define EXTRACT_LE_U_8(p) \
  ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 7)) << 56) | \
              ((uint64_t)(*((const uint8_t *)(p) + 6)) << 48) | \
              ((uint64_t)(*((const uint8_t *)(p) + 5)) << 40) | \
              ((uint64_t)(*((const uint8_t *)(p) + 4)) << 32) | \
              ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
              ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
              ((uint64_t)(*((const uint8_t *)(p) + 1)) << 8) | \
              ((uint64_t)(*((const uint8_t *)(p) + 0)) << 0)))
#define EXTRACT_LE_S_8(p) \
  ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 7)) << 56) | \
             ((uint64_t)(*((const uint8_t *)(p) + 6)) << 48) | \
             ((uint64_t)(*((const uint8_t *)(p) + 5)) << 40) | \
             ((uint64_t)(*((const uint8_t *)(p) + 4)) << 32) | \
             ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
             ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
             ((uint64_t)(*((const uint8_t *)(p) + 1)) << 8) | \
             ((uint64_t)(*((const uint8_t *)(p) + 0)) << 0)))

Coverage Report

Created: 2024-05-15 07:09

Line	Count	Source (jump to first uncovered line)
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	0	{
79	0	return ((uint16_t)ntohs((const uint16_t )(p)));
80	0	} Unexecuted instantiation: gencode.c:EXTRACT_BE_U_2 Unexecuted instantiation: pcap-usb-linux.c:EXTRACT_BE_U_2 Unexecuted instantiation: bpf_filter.c:EXTRACT_BE_U_2 Unexecuted instantiation: pcap-util.c:EXTRACT_BE_U_2
81
82		UNALIGNED_OK static inline int16_t
83		EXTRACT_BE_S_2(const void *p)
84	0	{
85	0	return ((int16_t)ntohs((const int16_t )(p)));
86	0	} Unexecuted instantiation: gencode.c:EXTRACT_BE_S_2 Unexecuted instantiation: pcap-usb-linux.c:EXTRACT_BE_S_2 Unexecuted instantiation: bpf_filter.c:EXTRACT_BE_S_2 Unexecuted instantiation: pcap-util.c:EXTRACT_BE_S_2
87
88		UNALIGNED_OK static inline uint32_t
89		EXTRACT_BE_U_4(const void *p)
90	0	{
91	0	return ((uint32_t)ntohl((const uint32_t )(p)));
92	0	} Unexecuted instantiation: gencode.c:EXTRACT_BE_U_4 Unexecuted instantiation: pcap-usb-linux.c:EXTRACT_BE_U_4 Unexecuted instantiation: bpf_filter.c:EXTRACT_BE_U_4 Unexecuted instantiation: pcap-util.c:EXTRACT_BE_U_4
93
94		UNALIGNED_OK static inline int32_t
95		EXTRACT_BE_S_4(const void *p)
96	0	{
97	0	return ((int32_t)ntohl((const int32_t )(p)));
98	0	} Unexecuted instantiation: gencode.c:EXTRACT_BE_S_4 Unexecuted instantiation: pcap-usb-linux.c:EXTRACT_BE_S_4 Unexecuted instantiation: bpf_filter.c:EXTRACT_BE_S_4 Unexecuted instantiation: pcap-util.c:EXTRACT_BE_S_4
99
100		UNALIGNED_OK static inline uint64_t
101		EXTRACT_BE_U_8(const void *p)
102	0	{
103	0	return ((uint64_t)(((uint64_t)ntohl(((const uint32_t )(p) + 0))) << 32 \|
104	0	((uint64_t)ntohl(((const uint32_t )(p) + 1))) << 0));
105	0
106	0	} Unexecuted instantiation: gencode.c:EXTRACT_BE_U_8 Unexecuted instantiation: pcap-usb-linux.c:EXTRACT_BE_U_8 Unexecuted instantiation: bpf_filter.c:EXTRACT_BE_U_8 Unexecuted instantiation: pcap-util.c:EXTRACT_BE_U_8
107
108		UNALIGNED_OK static inline int64_t
109		EXTRACT_BE_S_8(const void *p)
110	0	{
111	0	return ((int64_t)(((int64_t)ntohl(((const uint32_t )(p) + 0))) << 32 \|
112	0	((uint64_t)ntohl(((const uint32_t )(p) + 1))) << 0));
113	0
114	0	} Unexecuted instantiation: gencode.c:EXTRACT_BE_S_8 Unexecuted instantiation: pcap-usb-linux.c:EXTRACT_BE_S_8 Unexecuted instantiation: bpf_filter.c:EXTRACT_BE_S_8 Unexecuted instantiation: pcap-util.c:EXTRACT_BE_S_8
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 appears 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	0	((uint16_t)(((uint16_t)(((const uint8_t )(p) + 1)) << 8) \| \
384	0	((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)))