?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Correct PPTP server firewall rules chain.
[tomato/davidwu.git] / release / src / router / nettle / macros.h
blob38b9e2198152a393ca92907487b0c718bda582f6
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., 51 Franklin Street, Fifth Floor, Boston,
22 * MA 02111-1301, 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_UINT64(p) \
91 ( (((uint64_t) (p)[7]) << 56) \
92 | (((uint64_t) (p)[6]) << 48) \
93 | (((uint64_t) (p)[5]) << 40) \
94 | (((uint64_t) (p)[4]) << 32) \
95 | (((uint64_t) (p)[3]) << 24) \
96 | (((uint64_t) (p)[2]) << 16) \
97 | (((uint64_t) (p)[1]) << 8) \
98 | ((uint64_t) (p)[0]))
99
100 #define LE_WRITE_UINT64(p, i) \
101 do { \
102 (p)[7] = ((i) >> 56) & 0xff; \
103 (p)[6] = ((i) >> 48) & 0xff; \
104 (p)[5] = ((i) >> 40) & 0xff; \
105 (p)[4] = ((i) >> 32) & 0xff; \
106 (p)[3] = ((i) >> 24) & 0xff; \
107 (p)[2] = ((i) >> 16) & 0xff; \
108 (p)[1] = ((i) >> 8) & 0xff; \
109 (p)[0] = (i) & 0xff; \
110 } while (0)
111
112 #define LE_READ_UINT32(p) \
113 ( (((uint32_t) (p)[3]) << 24) \
114 | (((uint32_t) (p)[2]) << 16) \
115 | (((uint32_t) (p)[1]) << 8) \
116 | ((uint32_t) (p)[0]))
117
118 #define LE_WRITE_UINT32(p, i) \
119 do { \
120 (p)[3] = ((i) >> 24) & 0xff; \
121 (p)[2] = ((i) >> 16) & 0xff; \
122 (p)[1] = ((i) >> 8) & 0xff; \
123 (p)[0] = (i) & 0xff; \
124 } while(0)
125
126 /* Analogous macros, for 16 bit numbers */
127 #define LE_READ_UINT16(p) \
128 ( (((uint32_t) (p)[1]) << 8) \
129 | ((uint32_t) (p)[0]))
130
131 #define LE_WRITE_UINT16(p, i) \
132 do { \
133 (p)[1] = ((i) >> 8) & 0xff; \
134 (p)[0] = (i) & 0xff; \
135 } while(0)
136
137 /* Macro to make it easier to loop over several blocks. */
138 #define FOR_BLOCKS(length, dst, src, blocksize) \
139 assert( !((length) % (blocksize))); \
140 for (; (length); ((length) -= (blocksize), \
141 (dst) += (blocksize), \
142 (src) += (blocksize)) )
143
144 #define ROTL32(n,x) (((x)<<(n)) | ((x)>>(32-(n))))
145
146 #define ROTL64(n,x) (((x)<<(n)) | ((x)>>(64-(n))))
147
148 /* Requires that size > 0 */
149 #define INCREMENT(size, ctr) \
150 do { \
151 unsigned increment_i = (size) - 1; \
152 if (++(ctr)[increment_i] == 0) \
153 while (increment_i > 0 \
154 && ++(ctr)[--increment_i] == 0 ) \
155 ; \
156 } while (0)
157
158
159 /* Helper macro for Merkle-Damgård hash functions. Assumes the context
160 structs includes the following fields:
161
162 xxx count_low, count_high; // Two word block count
163 uint8_t block[...]; // Buffer holding one block
164 unsigned int index; // Index into block
165 */
166
167 /* FIXME: Should probably switch to using uint64_t for the count, but
168 due to alignment and byte order that may be an ABI change. */
169
170 #define MD_INCR(ctx) ((ctx)->count_high += !++(ctx)->count_low)
171
172 /* Takes the compression function f as argument. NOTE: also clobbers
173 length and data. */
174 #define MD_UPDATE(ctx, length, data, f, incr) \
175 do { \
176 if ((ctx)->index) \
177 { \
178 /* Try to fill partial block */ \
179 unsigned __md_left = sizeof((ctx)->block) - (ctx)->index; \
180 if ((length) < __md_left) \
181 { \
182 memcpy((ctx)->block + (ctx)->index, (data), (length)); \
183 (ctx)->index += (length); \
184 goto __md_done; /* Finished */ \
185 } \
186 else \
187 { \
188 memcpy((ctx)->block + (ctx)->index, (data), __md_left); \
189 \
190 f((ctx), (ctx)->block); \
191 (incr); \
192 \
193 (data) += __md_left; \
194 (length) -= __md_left; \
195 } \
196 } \
197 while ((length) >= sizeof((ctx)->block)) \
198 { \
199 f((ctx), (data)); \
200 (incr); \
201 \
202 (data) += sizeof((ctx)->block); \
203 (length) -= sizeof((ctx)->block); \
204 } \
205 memcpy ((ctx)->block, (data), (length)); \
206 (ctx)->index = (length); \
207 __md_done: \
208 ; \
209 } while (0)
210
211 /* Pads the block to a block boundary with the bit pattern 1 0*,
212 leaving size octets for the length field at the end. If needed,
213 compresses the block and starts a new one. */
214 #define MD_PAD(ctx, size, f) \
215 do { \
216 unsigned __md_i; \
217 __md_i = (ctx)->index; \
218 \
219 /* Set the first char of padding to 0x80. This is safe since there \
220 is always at least one byte free */ \
221 \
222 assert(__md_i < sizeof((ctx)->block)); \
223 (ctx)->block[__md_i++] = 0x80; \
224 \
225 if (__md_i > (sizeof((ctx)->block) - 2*sizeof((ctx)->count_low))) \
226 { /* No room for length in this block. Process it and \
227 pad with another one */ \
228 memset((ctx)->block + __md_i, 0, sizeof((ctx)->block) - __md_i); \
229 \
230 f((ctx), (ctx)->block); \
231 __md_i = 0; \
232 } \
233 memset((ctx)->block + __md_i, 0, \
234 sizeof((ctx)->block) - (size) - __md_i); \
235 \
236 } while (0)
237
238 #endif /* NETTLE_MACROS_H_INCLUDED */