math.c

srtp-1.3.20 security RTP source

  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(v16_t *x, const octet_t s[2]) {
  x->octet[0]  = s[0];
  x->octet[1]  = s[1];
}

inline void
v32_copy_octet_string(v32_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(v64_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(const 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 */

#define BITVECTOR_MAX_WORDS 5

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

  /* allocate memory, then set parameters */
  if (l > BITVECTOR_MAX_WORDS)
    return -1;
  else
    l = BITVECTOR_MAX_WORDS;
  v->word   = malloc(l);
  if (v->word == NULL)
    return -1;
  v->length = length;

  /* initialize bitvector to zero */
  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;
  
}

#include <stdio.h>

int
bitvector_print_hex(const bitvector_t *v, FILE *stream) {
  int i;
  int m = v->length >> 5;
  int n = v->length & 31;
  char string[9];
  uint32_t tmp;

  /* if length isn't a multiple of four, we can't hex_print */
  if (n & 3)
    return -1;
  
  /* if the length is zero, do nothing */
  if (v->length == 0)
    return 0;

  /*
   * loop over words from most significant to least significant - 
   */
  
  for (i=m; i > 0; i++) {
    char *str = string + 8;
    tmp = v->word[i];
    
    /* null terminate string */
    string[9] = 0;   

    /* loop over nibbles */
    *str-- = nibble_to_hex_char(tmp & 0xf);  tmp >>= 4; 
    *str-- = nibble_to_hex_char(tmp & 0xf);  tmp >>= 4; 
    *str-- = nibble_to_hex_char(tmp & 0xf);  tmp >>= 4; 
    *str-- = nibble_to_hex_char(tmp & 0xf);  tmp >>= 4; 
    *str-- = nibble_to_hex_char(tmp & 0xf);  tmp >>= 4; 
    *str-- = nibble_to_hex_char(tmp & 0xf);  tmp >>= 4; 
    *str-- = nibble_to_hex_char(tmp & 0xf);  tmp >>= 4; 
    *str-- = nibble_to_hex_char(tmp & 0xf);   

    /* now print stream */
    fprintf(stream, string);
  }
  
  return 0;

}


int
hex_string_length(char *s) {
  int count = 0;
  
  /* ignore leading zeros */
  while ((*s != 0) && *s == '0')
    s++;

  /* count remaining characters */
  while (*s != 0) {
    if (hex_char_to_nibble(*s++) == -1)
      return -1;
    count++;
  }

  return count;
}

int
bitvector_set_from_hex(bitvector_t *v, char *string) {
  int num_hex_chars, m, n, i, j;
  uint32_t tmp;
  
  num_hex_chars = hex_string_length(string);
  if (num_hex_chars == -1)
    return -1;

  /* set length */
  v->length = num_hex_chars * 4;
  /* 
   * at this point, we should subtract away a bit if the high
   * bit of the first character is zero, but we ignore that 
   * for now and assume that we're four-bit aligned - DAM
   */

  
  m = num_hex_chars / 8;   /* number of words                */
  n = num_hex_chars % 8;   /* number of nibbles in last word */

  /* if the length is greater than the bitvector, return an error */
  if (m > BITVECTOR_MAX_WORDS)
    return -1;

  /* 
   * loop over words from most significant - first word is a special
   * case 
   */
  
  if (n) {
    tmp = 0;
    for (i=0; i < n; i++) {
      tmp = hex_char_to_nibble(*string++); 
      tmp <<= 4;  
    }
    v->word[m] = tmp;
  }

  /* now loop over the rest of the words */
  for (i=m-1; i >= 0; i--) {
     tmp = 0;
     for (j=0; j < 8; j++) {
       tmp = hex_char_to_nibble(*string++); 
       tmp <<= 4;  
     }
     v->word[i] = tmp;
  }

  return 0;
}


/* 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 */