macros.h

   1 /* macros.h
   2  *
   3  */
   4
   5 /* nettle, low-level cryptographics library
   6  *
   7  * Copyright (C) 2001, 2010 Niels Möller
   8  *
   9  * The nettle library is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 of the License, or (at your
  12  * option) any later version.
  13  *
  14  * The nettle library is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  17  * License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with the nettle library; see the file COPYING.LIB.  If not, write to
  21  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  22  * MA 02111-1307, USA.
  23  */
  24
  25 #ifndef NETTLE_MACROS_H_INCLUDED
  26 #define NETTLE_MACROS_H_INCLUDED
  27
  28 /* Reads a 64-bit integer, in network, big-endian, byte order */
  29 #define READ_UINT64(p)                          \
  30 (  (((uint64_t) (p)[0]) << 56)                  \
  31  | (((uint64_t) (p)[1]) << 48)                  \
  32  | (((uint64_t) (p)[2]) << 40)                  \
  33  | (((uint64_t) (p)[3]) << 32)                  \
  34  | (((uint64_t) (p)[4]) << 24)                  \
  35  | (((uint64_t) (p)[5]) << 16)                  \
  36  | (((uint64_t) (p)[6]) << 8)                   \
  37  |  ((uint64_t) (p)[7]))
  38
  39 #define WRITE_UINT64(p, i)                      \
  40 do {                                            \
  41   (p)[0] = ((i) >> 56) & 0xff;                  \
  42   (p)[1] = ((i) >> 48) & 0xff;                  \
  43   (p)[2] = ((i) >> 40) & 0xff;                  \
  44   (p)[3] = ((i) >> 32) & 0xff;                  \
  45   (p)[4] = ((i) >> 24) & 0xff;                  \
  46   (p)[5] = ((i) >> 16) & 0xff;                  \
  47   (p)[6] = ((i) >> 8) & 0xff;                   \
  48   (p)[7] = (i) & 0xff;                          \
  49 } while(0)
  50
  51 /* Reads a 32-bit integer, in network, big-endian, byte order */
  52 #define READ_UINT32(p)                          \
  53 (  (((uint32_t) (p)[0]) << 24)                  \
  54  | (((uint32_t) (p)[1]) << 16)                  \
  55  | (((uint32_t) (p)[2]) << 8)                   \
  56  |  ((uint32_t) (p)[3]))
  57
  58 #define WRITE_UINT32(p, i)                      \
  59 do {                                            \
  60   (p)[0] = ((i) >> 24) & 0xff;                  \
  61   (p)[1] = ((i) >> 16) & 0xff;                  \
  62   (p)[2] = ((i) >> 8) & 0xff;                   \
  63   (p)[3] = (i) & 0xff;                          \
  64 } while(0)
  65
  66 /* Analogous macros, for 24 and 16 bit numbers */
  67 #define READ_UINT24(p)                          \
  68 (  (((uint32_t) (p)[0]) << 16)                  \
  69  | (((uint32_t) (p)[1]) << 8)                   \
  70  |  ((uint32_t) (p)[2]))
  71
  72 #define WRITE_UINT24(p, i)                      \
  73 do {                                            \
  74   (p)[0] = ((i) >> 16) & 0xff;                  \
  75   (p)[1] = ((i) >> 8) & 0xff;                   \
  76   (p)[2] = (i) & 0xff;                          \
  77 } while(0)
  78
  79 #define READ_UINT16(p)                          \
  80 (  (((uint32_t) (p)[0]) << 8)                   \
  81  |  ((uint32_t) (p)[1]))
  82
  83 #define WRITE_UINT16(p, i)                      \
  84 do {                                            \
  85   (p)[0] = ((i) >> 8) & 0xff;                   \
  86   (p)[1] = (i) & 0xff;                          \
  87 } while(0)
  88
  89 /* And the other, little-endian, byteorder */
  90 #define LE_READ_UINT32(p)                       \
  91 (  (((uint32_t) (p)[3]) << 24)                  \
  92  | (((uint32_t) (p)[2]) << 16)                  \
  93  | (((uint32_t) (p)[1]) << 8)                   \
  94  |  ((uint32_t) (p)[0]))
  95
  96 #define LE_WRITE_UINT32(p, i)                   \
  97 do {                                            \
  98   (p)[3] = ((i) >> 24) & 0xff;                  \
  99   (p)[2] = ((i) >> 16) & 0xff;                  \
 100   (p)[1] = ((i) >> 8) & 0xff;                   \
 101   (p)[0] = (i) & 0xff;                          \
 102 } while(0)
 103
 104 /* Analogous macros, for 16 bit numbers */
 105 #define LE_READ_UINT16(p)                       \
 106   (  (((uint32_t) (p)[1]) << 8)                 \
 107      |  ((uint32_t) (p)[0]))
 108
 109 #define LE_WRITE_UINT16(p, i)                   \
 110   do {                                          \
 111     (p)[1] = ((i) >> 8) & 0xff;                 \
 112     (p)[0] = (i) & 0xff;                        \
 113   } while(0)
 114
 115 /* Macro to make it easier to loop over several blocks. */
 116 #define FOR_BLOCKS(length, dst, src, blocksize) \
 117   assert( !((length) % (blocksize)));           \
 118   for (; (length); ((length) -= (blocksize),    \
 119                   (dst) += (blocksize),         \
 120                   (src) += (blocksize)) )
 121
 122 #endif /* NETTLE_MACROS_H_INCLUDED */