datatypes.c

srtp 1.0.1 比较适用于头一次看。其他版本的有需要也可以传上来。

    if (tmp == -1)
      return hex_len;
    x = (tmp << 4);
    hex_len++;
    tmp = hex_char_to_nibble(hex[1]);
    if (tmp == -1)
      return hex_len;
    x |= (tmp & 0xff);
    hex_len++;
    *raw++ = x;
    hex += 2;
  }
  return hex_len;
}

v16_t
hex_string_to_v16(char *s) {
  v16_t x;
  int i, j;

  for (i=j=0; i < 4; i += 2, j++) {
    x.octet[j] = (hex_char_to_nibble(s[i]) << 4)
      | hex_char_to_nibble(s[i+1] & 0xFF);
  }
  return x;
}

v32_t
hex_string_to_v32(char *s) {
  v32_t x;
  int i, j;

  for (i=j=0; i < 8; i += 2, j++) {
    x.octet[j] = (hex_char_to_nibble(s[i]) << 4)
      | hex_char_to_nibble(s[i+1] & 0xFF);
  }
  return x;
}

v64_t
hex_string_to_v64(char *s) {
  v64_t x;
  int i, j;

  for (i=j=0; i < 16; i += 2, j++) {
    x.octet[j] = (hex_char_to_nibble(s[i]) << 4)
      | hex_char_to_nibble(s[i+1] & 0xFF);
  }
  return x;
}

v128_t
hex_string_to_v128(char *s) {
  v128_t x;
  int i, j;

  for (i=j=0; i < 32; i += 2, j++) {
    x.octet[j] = (hex_char_to_nibble(s[i]) << 4)
      | hex_char_to_nibble(s[i+1] & 0xFF);
  }
  return x;
}



/* the matrix A[] is stored in column format, i.e., A[i] is
   the ith column of the matrix */

octet_t 
A_times_x_plus_b(octet_t A[8], octet_t x, octet_t b) {
  int index = 0;
  unsigned mask;
  
  for (mask=1; mask < 256; mask *= 2) {
    if (x & mask)
      b^= A[index];
    ++index;
  }

  return b;
}

inline void
v16_copy_octet_string(v128_t *x, const octet_t s[2]) {
  x->octet[0]  = s[0];
  x->octet[1]  = s[1];
}

inline void
v32_copy_octet_string(v128_t *x, const octet_t s[4]) {
  x->octet[0]  = s[0];
  x->octet[1]  = s[1];
  x->octet[2]  = s[2];
  x->octet[3]  = s[3];
}

inline void
v64_copy_octet_string(v128_t *x, const octet_t s[8]) {
  x->octet[0]  = s[0];
  x->octet[1]  = s[1];
  x->octet[2]  = s[2];
  x->octet[3]  = s[3];
  x->octet[4]  = s[4];
  x->octet[5]  = s[5];
  x->octet[6]  = s[6];
  x->octet[7]  = s[7];
  x->octet[8]  = s[8];
}

inline void
v128_copy_octet_string(v128_t *x, const octet_t s[16]) {
  x->octet[0]  = s[0];
  x->octet[1]  = s[1];
  x->octet[2]  = s[2];
  x->octet[3]  = s[3];
  x->octet[4]  = s[4];
  x->octet[5]  = s[5];
  x->octet[6]  = s[6];
  x->octet[7]  = s[7];
  x->octet[8]  = s[8];
  x->octet[9]  = s[9];
  x->octet[10] = s[10];
  x->octet[11] = s[11];
  x->octet[12] = s[12];
  x->octet[13] = s[13];
  x->octet[14] = s[14];
  x->octet[15] = s[15];

}

#ifndef DATATYPES_USE_MACROS /* little functions are not macros */

void
v128_set_to_zero(v128_t *x) {
  _v128_set_to_zero(x);
}

void
v128_copy(v128_t *x, const v128_t *y) {
  _v128_copy(x, y);
}

void
v128_xor(v128_t *z, v128_t *x, v128_t *y) {
  _v128_xor(z, x, y);
} 

void
v128_and(v128_t *z, v128_t *x, v128_t *y) {
  _v128_and(z, x, y);
}

void
v128_or(v128_t *z, v128_t *x, v128_t *y) {
  _v128_or(z, x, y);
}

void
v128_complement(v128_t *x) {
  _v128_complement(x);
}

int
v128_is_eq(const v128_t *x, const v128_t *y) {
  return _v128_is_eq(x, y);
}

int
v128_get_bit(v128_t *x, int i) {
  return _v128_get_bit(x, i);
}

void
v128_set_bit(v128_t *x, int i) {
  _v128_set_bit(x, i);
}     

void
v128_clear_bit(v128_t *x, int i){
  _v128_clear_bit(x, i);
}    

void
v128_set_bit_to(v128_t *x, int i, int y){
  _v128_set_bit_to(x, i, y);
}


#endif /* DATATYPES_USE_MACROS */


inline void
v128_left_shift2(v128_t *x, int num_bits) {
  int i;
  int word_shift = num_bits >> 5;
  int bit_shift  = num_bits & 31;

  for (i=0; i < (4-word_shift); i++) {
    x->v32[i] = x->v32[i+word_shift] << bit_shift;
  }
  
  for (   ; i < word_shift; i++) {
    x->v32[i] = 0;
  }
  
}

inline void
v128_right_shift(v128_t *x, int index) {
  const int base_index = index >> 5;
  const int bit_index = index & 31;
  int i, from;
  unsigned long b;
    
  if (index > 127) {
    v128_set_to_zero(x);
    return;
  }

  if (bit_index == 0) {

    /* copy each word from left size to right side */
    x->v32[4-1] = x->v32[4-1-base_index];
    for (i=4-1; i > base_index; i--) 
      x->v32[i-1] = x->v32[i-1-base_index];

  } else {
    
    /* set each word to the "or" of the two bit-shifted words */
    for (i = 4; i > base_index; i--) {
      from = i-1 - base_index;
      b = x->v32[from] << bit_index;
      if (from > 0)
        b |= x->v32[from-1] >> (32-bit_index);
      x->v32[i-1] = b;
    }
    
  }

  /* now wrap up the final portion */
  for (i=0; i < base_index; i++) 
    x->v32[i] = 0;
  
}

void
v128_left_shift(v128_t *x, int index) {
  int i;
  const int base_index = index >> 5;
  const int bit_index = index & 31;

  if (index > 127) {
    v128_set_to_zero(x);
    return;
  } 
  
  if (bit_index == 0) {
    for (i=0; i < 4 - base_index; i++)
      x->v32[i] = x->v32[i+base_index];
  } else {
    for (i=0; i < 4 - base_index - 1; i++)
      x->v32[i] = (x->v32[i+base_index] >> bit_index) ^
	(x->v32[i+base_index+1] << (32 - bit_index));
    x->v32[4 - base_index-1] = x->v32[4-1] >> bit_index;
  }

  /* now wrap up the final portion */
  for (i = 4 - base_index; i < 4; i++) 
    x->v32[i] = 0;

}


void
v128_add(v128_t *z, v128_t *x, v128_t *y) {
  /* integer addition modulo 2^128    */

#if WORDS_BIGENDIAN
  uint64_t tmp;
    
  tmp = x->v32[3] + y->v32[3];
  z->v32[3] = (uint32_t) tmp;
  
  tmp =  x->v32[2] + y->v32[2] + (tmp >> 32);
  z->v32[2] = (uint32_t) tmp;

  tmp =  x->v32[1] + y->v32[1] + (tmp >> 32);
  z->v32[1] = (uint32_t) tmp;
  
  tmp =  x->v32[0] + y->v32[0] + (tmp >> 32);
  z->v32[0] = (uint32_t) tmp;

#else /* assume little endian architecture */
  uint64_t tmp;
  
  tmp = htonl(x->v32[3]) + htonl(y->v32[3]);
  z->v32[3] = ntohl((uint32_t) tmp);
  
  tmp =  htonl(x->v32[2]) + htonl(y->v32[2]) + htonl(tmp >> 32);
  z->v32[2] = ntohl((uint32_t) tmp);

  tmp =  htonl(x->v32[1]) + htonl(y->v32[1]) + htonl(tmp >> 32);
  z->v32[1] = ntohl((uint32_t) tmp);
  
  tmp =  htonl(x->v32[0]) + htonl(y->v32[0]) + htonl(tmp >> 32);
  z->v32[0] = ntohl((uint32_t) tmp);

#endif /* WORDS_BIGENDIAN */
  
}


inline int
octet_string_is_eq(octet_t *a, octet_t *b, int len) {
  octet_t *end = b + len;
  while (b < end)
    if (*a++ != *b++)
      return 1;
  return 0;
}

inline void
octet_string_set_to_zero(octet_t *s, int len) {
  octet_t *end = s + len;
  
  do {
    *s = 0;
  } while (s++ < end);
  
}

/* functions manipulating bit_vector_t */

#include <stdlib.h>           /* for malloc() */

int
bitvector_init(bitvector_t *v, unsigned long length) {
  unsigned long l = (length + bytes_per_word - 1) / bytes_per_word;
  int i;
  
  v->word   = malloc(l);
  v->length = length;

  if (v->word == NULL)
    return -1;
  
  for (i=0; i < (length >> 5); i++) {
    v->word = 0;
  }

  return 0;
}

void
bitvector_set_bit(bitvector_t *v, int bit_index) {

  v->word[(bit_index >> 5)] |= (1 << (bit_index & 31));
  
}

int
bitvector_get_bit(const bitvector_t *v, int bit_index) {

  return ((v->word[(bit_index >> 5)]) >> (bit_index & 31)) & 1;
  
}





/* functions below not yet tested! */

int
v32_low_bit(v32_t *w) {
  int value;

  value = low_bit[w->octet[0]];
  if (value != -1)
    return value;
  value = low_bit[w->octet[1]];
  if (value != -1)
    return value + 8;
  value = low_bit[w->octet[2]];
  if (value != -1)
    return value + 16;
  value = low_bit[w->octet[3]];
  if (value == -1)
    return -1;
  return value + 24;
}

/* high_bit not done yet */