← Back to branch summary

~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.2.1/third_party/srtp/crypto/include/datatypes.h

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2015-01-07 14:51:16 UTC
  • mfrom: (4.3.5 sid)
  • Revision ID: package-import@ubuntu.com-20150107145116-yxnafinf4lrdvrmx
Tags: 1.4.1-0.1ubuntu1
* Merge with Debian, remaining changes:
 - Drop soprano, nepomuk build-dep
* Drop ubuntu patches, now upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.2.1/third_party/srtp/crypto/include/datatypes.h
 
1
/*
 
2
 * datatypes.h
 
3
 * 
 
4
 * data types for bit vectors and finite fields
 
5
 *
 
6
 * David A. McGrew
 
7
 * Cisco Systems, Inc.
 
8
 */
 
9
 
 
10
/*
 
11
 *      
 
12
 * Copyright (c) 2001-2006, Cisco Systems, Inc.
 
13
 * All rights reserved.
 
14
 * 
 
15
 * Redistribution and use in source and binary forms, with or without
 
16
 * modification, are permitted provided that the following conditions
 
17
 * are met:
 
18
 * 
 
19
 *   Redistributions of source code must retain the above copyright
 
20
 *   notice, this list of conditions and the following disclaimer.
 
21
 * 
 
22
 *   Redistributions in binary form must reproduce the above
 
23
 *   copyright notice, this list of conditions and the following
 
24
 *   disclaimer in the documentation and/or other materials provided
 
25
 *   with the distribution.
 
26
 * 
 
27
 *   Neither the name of the Cisco Systems, Inc. nor the names of its
 
28
 *   contributors may be used to endorse or promote products derived
 
29
 *   from this software without specific prior written permission.
 
30
 * 
 
31
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
32
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
33
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 
34
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 
35
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 
36
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 
37
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 
38
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
39
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 
40
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 
41
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 
42
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 
43
 *
 
44
 */
 
45
 
 
46
 
 
47
#ifndef _DATATYPES_H
 
48
#define _DATATYPES_H
 
49
 
 
50
#include "integers.h"           /* definitions of uint32_t, et cetera   */
 
51
#include "alloc.h"
 
52
 
 
53
#include <stdarg.h>
 
54
 
 
55
#ifndef SRTP_KERNEL
 
56
# include <stdio.h>
 
57
# include <string.h>
 
58
# include <time.h>
 
59
# ifdef HAVE_NETINET_IN_H
 
60
#  include <netinet/in.h>
 
61
# elif defined HAVE_WINSOCK2_H
 
62
#  include <winsock2.h>
 
63
# endif
 
64
#endif
 
65
 
 
66
 
 
67
/* if DATATYPES_USE_MACROS is defined, then little functions are macros */
 
68
#define DATATYPES_USE_MACROS  
 
69
 
 
70
typedef union {
 
71
  uint8_t  v8[2];
 
72
  uint16_t value;
 
73
} v16_t;
 
74
 
 
75
typedef union {
 
76
  uint8_t  v8[4];
 
77
  uint16_t v16[2];
 
78
  uint32_t value;
 
79
} v32_t;
 
80
 
 
81
typedef union {
 
82
  uint8_t  v8[8];
 
83
  uint16_t v16[4];
 
84
  uint32_t v32[2];
 
85
  uint64_t value;
 
86
} v64_t;
 
87
 
 
88
typedef union {
 
89
  uint8_t  v8[16];
 
90
  uint16_t v16[8];
 
91
  uint32_t v32[4];
 
92
  uint64_t v64[2];
 
93
} v128_t;
 
94
 
 
95
 
 
96
 
 
97
/* some useful and simple math functions */
 
98
 
 
99
#define pow_2(X) ( (unsigned int)1 << (X) )   /* 2^X     */
 
100
 
 
101
#define pow_minus_one(X) ( (X) ? -1 : 1 )      /* (-1)^X  */
 
102
 
 
103
 
 
104
/*
 
105
 * octet_get_weight(x) returns the hamming weight (number of bits equal to
 
106
 * one) in the octet x
 
107
 */
 
108
 
 
109
int
 
110
octet_get_weight(uint8_t octet);
 
111
 
 
112
char *
 
113
octet_bit_string(uint8_t x);
 
114
 
 
115
#define MAX_PRINT_STRING_LEN 1024
 
116
 
 
117
char *
 
118
octet_string_hex_string(const void *str, int length);
 
119
 
 
120
char *
 
121
v128_bit_string(v128_t *x);
 
122
 
 
123
char *
 
124
v128_hex_string(v128_t *x);
 
125
 
 
126
uint8_t
 
127
nibble_to_hex_char(uint8_t nibble);
 
128
 
 
129
char *
 
130
char_to_hex_string(char *x, int num_char);
 
131
 
 
132
uint8_t
 
133
hex_string_to_octet(char *s);
 
134
 
 
135
/*
 
136
 * hex_string_to_octet_string(raw, hex, len) converts the hexadecimal
 
137
 * string at *hex (of length len octets) to the equivalent raw data
 
138
 * and writes it to *raw.
 
139
 *
 
140
 * if a character in the hex string that is not a hexadeciaml digit
 
141
 * (0123456789abcdefABCDEF) is encountered, the function stops writing
 
142
 * data to *raw
 
143
 *
 
144
 * the number of hex digits copied (which is two times the number of
 
145
 * octets in *raw) is returned
 
146
 */
 
147
 
 
148
int
 
149
hex_string_to_octet_string(char *raw, char *hex, int len);
 
150
 
 
151
v128_t
 
152
hex_string_to_v128(char *s);
 
153
 
 
154
void
 
155
v128_copy_octet_string(v128_t *x, const uint8_t s[16]);
 
156
 
 
157
void
 
158
v128_left_shift(v128_t *x, int index);
 
159
 
 
160
void
 
161
v128_right_shift(v128_t *x, int index);
 
162
 
 
163
/*
 
164
 * the following macros define the data manipulation functions
 
165
 * 
 
166
 * If DATATYPES_USE_MACROS is defined, then these macros are used
 
167
 * directly (and function call overhead is avoided).  Otherwise,
 
168
 * the macros are used through the functions defined in datatypes.c
 
169
 * (and the compiler provides better warnings).
 
170
 */
 
171
 
 
172
#define _v128_set_to_zero(x)     \
 
173
(                               \
 
174
  (x)->v32[0] = 0,              \
 
175
  (x)->v32[1] = 0,              \
 
176
  (x)->v32[2] = 0,              \
 
177
  (x)->v32[3] = 0               \
 
178
)
 
179
 
 
180
#define _v128_copy(x, y)          \
 
181
(                                \
 
182
  (x)->v32[0] = (y)->v32[0],     \
 
183
  (x)->v32[1] = (y)->v32[1],     \
 
184
  (x)->v32[2] = (y)->v32[2],     \
 
185
  (x)->v32[3] = (y)->v32[3]      \
 
186
)
 
187
 
 
188
#define _v128_xor(z, x, y)                       \
 
189
(                                               \
 
190
   (z)->v32[0] = (x)->v32[0] ^ (y)->v32[0],     \
 
191
   (z)->v32[1] = (x)->v32[1] ^ (y)->v32[1],     \
 
192
   (z)->v32[2] = (x)->v32[2] ^ (y)->v32[2],     \
 
193
   (z)->v32[3] = (x)->v32[3] ^ (y)->v32[3]      \
 
194
)
 
195
 
 
196
#define _v128_and(z, x, y)                       \
 
197
(                                               \
 
198
   (z)->v32[0] = (x)->v32[0] & (y)->v32[0],     \
 
199
   (z)->v32[1] = (x)->v32[1] & (y)->v32[1],     \
 
200
   (z)->v32[2] = (x)->v32[2] & (y)->v32[2],     \
 
201
   (z)->v32[3] = (x)->v32[3] & (y)->v32[3]      \
 
202
)
 
203
 
 
204
#define _v128_or(z, x, y)                        \
 
205
(                                               \
 
206
   (z)->v32[0] = (x)->v32[0] | (y)->v32[0],     \
 
207
   (z)->v32[1] = (x)->v32[1] | (y)->v32[1],     \
 
208
   (z)->v32[2] = (x)->v32[2] | (y)->v32[2],     \
 
209
   (z)->v32[3] = (x)->v32[3] | (y)->v32[3]      \
 
210
)
 
211
 
 
212
#define _v128_complement(x)        \
 
213
(                                  \
 
214
   (x)->v32[0] = ~(x)->v32[0],     \
 
215
   (x)->v32[1] = ~(x)->v32[1],     \
 
216
   (x)->v32[2] = ~(x)->v32[2],     \
 
217
   (x)->v32[3] = ~(x)->v32[3]      \
 
218
)
 
219
 
 
220
/* ok for NO_64BIT_MATH if it can compare uint64_t's (even as structures) */
 
221
#define _v128_is_eq(x, y)                                        \
 
222
  (((x)->v64[0] == (y)->v64[0]) && ((x)->v64[1] == (y)->v64[1]))
 
223
 
 
224
 
 
225
#ifdef NO_64BIT_MATH
 
226
#define _v128_xor_eq(z, x)         \
 
227
(                                  \
 
228
   (z)->v32[0] ^= (x)->v32[0],     \
 
229
   (z)->v32[1] ^= (x)->v32[1],     \
 
230
   (z)->v32[2] ^= (x)->v32[2],     \
 
231
   (z)->v32[3] ^= (x)->v32[3]      \
 
232
)
 
233
#else
 
234
#define _v128_xor_eq(z, x)         \
 
235
(                                  \
 
236
   (z)->v64[0] ^= (x)->v64[0],     \
 
237
   (z)->v64[1] ^= (x)->v64[1]      \
 
238
)
 
239
#endif
 
240
 
 
241
/* NOTE!  This assumes an odd ordering! */
 
242
/* This will not be compatible directly with math on some processors */
 
243
/* bit 0 is first 32-bit word, low order bit. in little-endian, that's
 
244
   the first byte of the first 32-bit word.  In big-endian, that's
 
245
   the 3rd byte of the first 32-bit word */
 
246
/* The get/set bit code is used by the replay code ONLY, and it doesn't
 
247
   really care which bit is which.  AES does care which bit is which, but
 
248
   doesn't use the 128-bit get/set or 128-bit shifts  */
 
249
 
 
250
#define _v128_get_bit(x, bit)                     \
 
251
(                                                 \
 
252
  ((((x)->v32[(bit) >> 5]) >> ((bit) & 31)) & 1)  \
 
253
)
 
254
 
 
255
#define _v128_set_bit(x, bit)                                    \
 
256
(                                                                \
 
257
  (((x)->v32[(bit) >> 5]) |= ((uint32_t)1 << ((bit) & 31))) \
 
258
)
 
259
 
 
260
#define _v128_clear_bit(x, bit)                                   \
 
261
(                                                                 \
 
262
  (((x)->v32[(bit) >> 5]) &= ~((uint32_t)1 << ((bit) & 31))) \
 
263
)
 
264
 
 
265
#define _v128_set_bit_to(x, bit, value)   \
 
266
(                                         \
 
267
   (value) ? _v128_set_bit(x, bit) :      \
 
268
             _v128_clear_bit(x, bit)      \
 
269
)
 
270
 
 
271
 
 
272
#if 0
 
273
/* nothing uses this */
 
274
#ifdef WORDS_BIGENDIAN
 
275
 
 
276
#define _v128_add(z, x, y) {                    \
 
277
  uint64_t tmp;                                 \
 
278
                                                \
 
279
  tmp = x->v32[3] + y->v32[3];                  \
 
280
  z->v32[3] = (uint32_t) tmp;                   \
 
281
                                                \
 
282
  tmp =  x->v32[2] + y->v32[2] + (tmp >> 32);   \
 
283
  z->v32[2] = (uint32_t) tmp;                   \
 
284
                                                \
 
285
  tmp =  x->v32[1] + y->v32[1] + (tmp >> 32);   \
 
286
  z->v32[1] = (uint32_t) tmp;                   \
 
287
                                                \
 
288
  tmp =  x->v32[0] + y->v32[0] + (tmp >> 32);   \
 
289
  z->v32[0] = (uint32_t) tmp;                   \
 
290
}
 
291
 
 
292
#else /* assume little endian architecture */
 
293
 
 
294
#define _v128_add(z, x, y) {                    \
 
295
  uint64_t tmp;                                 \
 
296
                                                \
 
297
  tmp = htonl(x->v32[3]) + htonl(y->v32[3]);    \
 
298
  z->v32[3] = ntohl((uint32_t) tmp);            \
 
299
                                                \
 
300
  tmp =  htonl(x->v32[2]) + htonl(y->v32[2])    \
 
301
       + htonl(tmp >> 32);                      \
 
302
  z->v32[2] = ntohl((uint32_t) tmp);            \
 
303
                                                \
 
304
  tmp =  htonl(x->v32[1]) + htonl(y->v32[1])    \
 
305
       + htonl(tmp >> 32);                      \
 
306
  z->v32[1] = ntohl((uint32_t) tmp);            \
 
307
                                                \
 
308
  tmp =  htonl(x->v32[0]) + htonl(y->v32[0])    \
 
309
       + htonl(tmp >> 32);                      \
 
310
  z->v32[0] = ntohl((uint32_t) tmp);            \
 
311
}
 
312
#endif /* WORDS_BIGENDIAN */                      
 
313
#endif /* 0 */
 
314
 
 
315
 
 
316
#ifdef DATATYPES_USE_MACROS  /* little functions are really macros */
 
317
   
 
318
#define v128_set_to_zero(z)       _v128_set_to_zero(z)
 
319
#define v128_copy(z, x)           _v128_copy(z, x)
 
320
#define v128_xor(z, x, y)         _v128_xor(z, x, y)
 
321
#define v128_and(z, x, y)         _v128_and(z, x, y)
 
322
#define v128_or(z, x, y)          _v128_or(z, x, y)
 
323
#define v128_complement(x)        _v128_complement(x) 
 
324
#define v128_is_eq(x, y)          _v128_is_eq(x, y)
 
325
#define v128_xor_eq(x, y)         _v128_xor_eq(x, y)
 
326
#define v128_get_bit(x, i)        _v128_get_bit(x, i)
 
327
#define v128_set_bit(x, i)        _v128_set_bit(x, i)
 
328
#define v128_clear_bit(x, i)      _v128_clear_bit(x, i)
 
329
#define v128_set_bit_to(x, i, y)  _v128_set_bit_to(x, i, y)
 
330
 
 
331
#else
 
332
 
 
333
void
 
334
v128_set_to_zero(v128_t *x);
 
335
 
 
336
int
 
337
v128_is_eq(const v128_t *x, const v128_t *y);
 
338
 
 
339
void
 
340
v128_copy(v128_t *x, const v128_t *y);
 
341
 
 
342
void
 
343
v128_xor(v128_t *z, v128_t *x, v128_t *y);
 
344
 
 
345
void
 
346
v128_and(v128_t *z, v128_t *x, v128_t *y);
 
347
 
 
348
void
 
349
v128_or(v128_t *z, v128_t *x, v128_t *y); 
 
350
 
 
351
void
 
352
v128_complement(v128_t *x);
 
353
 
 
354
int
 
355
v128_get_bit(const v128_t *x, int i);
 
356
 
 
357
void
 
358
v128_set_bit(v128_t *x, int i) ;     
 
359
 
 
360
void
 
361
v128_clear_bit(v128_t *x, int i);    
 
362
 
 
363
void
 
364
v128_set_bit_to(v128_t *x, int i, int y);
 
365
 
 
366
#endif /* DATATYPES_USE_MACROS */
 
367
 
 
368
/*
 
369
 * octet_string_is_eq(a,b, len) returns 1 if the length len strings a
 
370
 * and b are not equal, returns 0 otherwise
 
371
 */
 
372
 
 
373
int
 
374
octet_string_is_eq(uint8_t *a, uint8_t *b, int len);
 
375
 
 
376
void
 
377
octet_string_set_to_zero(uint8_t *s, int len);
 
378
 
 
379
 
 
380
#ifndef SRTP_KERNEL_LINUX
 
381
 
 
382
/* 
 
383
 * Convert big endian integers to CPU byte order.
 
384
 */
 
385
#ifdef WORDS_BIGENDIAN
 
386
/* Nothing to do. */
 
387
# define be32_to_cpu(x) (x)
 
388
# define be64_to_cpu(x) (x)
 
389
#elif defined(HAVE_BYTESWAP_H)
 
390
/* We have (hopefully) optimized versions in byteswap.h */
 
391
# include <byteswap.h>
 
392
# define be32_to_cpu(x) bswap_32((x))
 
393
# define be64_to_cpu(x) bswap_64((x))
 
394
#else
 
395
 
 
396
#if defined(__GNUC__) && defined(HAVE_X86)
 
397
/* Fall back. */
 
398
static inline uint32_t be32_to_cpu(uint32_t v) {
 
399
   /* optimized for x86. */
 
400
   asm("bswap %0" : "=r" (v) : "0" (v));
 
401
   return v;
 
402
}
 
403
# else /* HAVE_X86 */
 
404
#  ifdef HAVE_NETINET_IN_H
 
405
#   include <netinet/in.h>
 
406
#  elif defined HAVE_WINSOCK2_H
 
407
#   include <winsock2.h>
 
408
#  endif
 
409
#  define be32_to_cpu(x)        ntohl((x))
 
410
# endif /* HAVE_X86 */
 
411
 
 
412
static inline uint64_t be64_to_cpu(uint64_t v) {
 
413
# ifdef NO_64BIT_MATH
 
414
   /* use the make64 functions to do 64-bit math */
 
415
   v = make64(htonl(low32(v)),htonl(high32(v)));
 
416
# else
 
417
   /* use the native 64-bit math */
 
418
   v= (uint64_t)((be32_to_cpu((uint32_t)(v >> 32))) | (((uint64_t)be32_to_cpu((uint32_t)v)) << 32));
 
419
# endif
 
420
   return v;
 
421
}
 
422
 
 
423
#endif /* ! SRTP_KERNEL_LINUX */
 
424
 
 
425
#endif /* WORDS_BIGENDIAN */
 
426
 
 
427
#endif /* _DATATYPES_H */