turnserver-devel

[Turnserver-devel] SF.net SVN: turnserver:[234] trunk/src

[<s-v...@us...>]

Revision: 234
          http://sourceforge.net/p/turnserver/code/234
Author:   s-vincent
Date:     2013-03-26 17:06:14 +0000 (Tue, 26 Mar 2013)
Log Message:
-----------
Rename index to idx (if we define _BSD_SOURCE it causes problem because of index() function).

Modified Paths:
--------------
    trunk/src/protocol.c
    trunk/src/turnserver.c

Modified: trunk/src/protocol.c
===================================================================
--- trunk/src/protocol.c	2013-03-02 07:55:15 UTC (rev 233)
+++ trunk/src/protocol.c	2013-03-26 17:06:14 UTC (rev 234)
@@ -930,437 +930,437 @@
 }
 
 struct turn_msg_hdr* turn_error_response_400(int method, const uint8_t* id,
-    struct iovec* iov, size_t* index)
+    struct iovec* iov, size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
-  if(!(attr = turn_attr_error_create(400, STUN_ERROR_400, sizeof(STUN_ERROR_400), &iov[*index])))
+  if(!(attr = turn_attr_error_create(400, STUN_ERROR_400, sizeof(STUN_ERROR_400), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
 
 struct turn_msg_hdr* turn_error_response_401(int method, const uint8_t* id,
     const char* realm, const uint8_t* nonce, size_t nonce_len,
-    struct iovec* iov, size_t* index)
+    struct iovec* iov, size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
   if(!(attr = turn_attr_error_create(401, STUN_ERROR_401,
-          sizeof(STUN_ERROR_401), &iov[*index])))
+          sizeof(STUN_ERROR_401), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   /* realm */
-  if(!(attr = turn_attr_realm_create(realm, strlen(realm), &iov[*index])))
+  if(!(attr = turn_attr_realm_create(realm, strlen(realm), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   /* nonce */
-  if(!(attr = turn_attr_nonce_create(nonce, nonce_len, &iov[*index])))
+  if(!(attr = turn_attr_nonce_create(nonce, nonce_len, &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
 
 struct turn_msg_hdr* turn_error_response_420(int method, const uint8_t* id,
     const uint16_t* unknown, size_t unknown_size, struct iovec* iov,
-    size_t* index)
+    size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
   if(!(attr = turn_attr_error_create(420, STUN_ERROR_420,
-          sizeof(STUN_ERROR_420), &iov[*index])))
+          sizeof(STUN_ERROR_420), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   if(!(attr = turn_attr_unknown_attributes_create(unknown, unknown_size,
-          &iov[*index])))
+          &iov[*idx])))
   {
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
 
 struct turn_msg_hdr* turn_error_response_438(int method, const uint8_t* id,
     const char* realm, const uint8_t* nonce, size_t nonce_len,
-    struct iovec* iov, size_t* index)
+    struct iovec* iov, size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
   if(!(attr = turn_attr_error_create(438, STUN_ERROR_438,
-          sizeof(STUN_ERROR_438), &iov[*index])))
+          sizeof(STUN_ERROR_438), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   /* realm */
-  if(!(attr = turn_attr_realm_create(realm, strlen(realm), &iov[*index])))
+  if(!(attr = turn_attr_realm_create(realm, strlen(realm), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   /* nonce */
-  if(!(attr = turn_attr_nonce_create(nonce, nonce_len, &iov[*index])))
+  if(!(attr = turn_attr_nonce_create(nonce, nonce_len, &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
 
 struct turn_msg_hdr* turn_error_response_500(int method, const uint8_t* id,
-    struct iovec* iov, size_t* index)
+    struct iovec* iov, size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
   if(!(attr = turn_attr_error_create(500, STUN_ERROR_500,
-          sizeof(STUN_ERROR_500), &iov[*index])))
+          sizeof(STUN_ERROR_500), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
 
 struct turn_msg_hdr* turn_error_response_403(int method, const uint8_t* id,
-    struct iovec* iov, size_t* index)
+    struct iovec* iov, size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
   if(!(attr = turn_attr_error_create(403, TURN_ERROR_403,
-          sizeof(TURN_ERROR_403), &iov[*index])))
+          sizeof(TURN_ERROR_403), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
 
 struct turn_msg_hdr* turn_error_response_437(int method, const uint8_t* id,
-    struct iovec* iov, size_t* index)
+    struct iovec* iov, size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
   if(!(attr = turn_attr_error_create(437, TURN_ERROR_437,
-          sizeof(TURN_ERROR_437), &iov[*index])))
+          sizeof(TURN_ERROR_437), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
 
 struct turn_msg_hdr* turn_error_response_440(int method, const uint8_t* id,
-    struct iovec* iov, size_t* index)
+    struct iovec* iov, size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
   if(!(attr = turn_attr_error_create(440, TURN_ERROR_440,
-          sizeof(TURN_ERROR_440), &iov[*index])))
+          sizeof(TURN_ERROR_440), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
 
 struct turn_msg_hdr* turn_error_response_441(int method, const uint8_t* id,
-    struct iovec* iov, size_t* index)
+    struct iovec* iov, size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
   if(!(attr = turn_attr_error_create(441, TURN_ERROR_441,
-          sizeof(TURN_ERROR_441), &iov[*index])))
+          sizeof(TURN_ERROR_441), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
 
 struct turn_msg_hdr* turn_error_response_442(int method, const uint8_t* id,
-    struct iovec* iov, size_t* index)
+    struct iovec* iov, size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
   if(!(attr = turn_attr_error_create(442, TURN_ERROR_442,
-          sizeof(TURN_ERROR_442), &iov[*index])))
+          sizeof(TURN_ERROR_442), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
 
 struct turn_msg_hdr* turn_error_response_443(int method, const uint8_t* id,
-    struct iovec* iov, size_t* index)
+    struct iovec* iov, size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
   if(!(attr = turn_attr_error_create(443, TURN_ERROR_443,
-          sizeof(TURN_ERROR_443), &iov[*index])))
+          sizeof(TURN_ERROR_443), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
 
 struct turn_msg_hdr* turn_error_response_446(int method, const uint8_t* id,
-    struct iovec* iov, size_t* index)
+    struct iovec* iov, size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
   if(!(attr = turn_attr_error_create(446, TURN_ERROR_446,
-          sizeof(TURN_ERROR_446), &iov[*index])))
+          sizeof(TURN_ERROR_446), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
 
 struct turn_msg_hdr* turn_error_response_447(int method, const uint8_t* id,
-    struct iovec* iov, size_t* index)
+    struct iovec* iov, size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
   if(!(attr = turn_attr_error_create(447, TURN_ERROR_447,
-          sizeof(TURN_ERROR_447), &iov[*index])))
+          sizeof(TURN_ERROR_447), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
 
 struct turn_msg_hdr* turn_error_response_486(int method, const uint8_t* id,
-    struct iovec* iov, size_t* index)
+    struct iovec* iov, size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
   if(!(attr = turn_attr_error_create(486, TURN_ERROR_486,
-          sizeof(TURN_ERROR_486), &iov[*index])))
+          sizeof(TURN_ERROR_486), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
 
 struct turn_msg_hdr* turn_error_response_508(int method, const uint8_t* id,
-    struct iovec* iov, size_t* index)
+    struct iovec* iov, size_t* idx)
 {
   struct turn_msg_hdr* error = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   /* header */
-  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*index])))
+  if(!(error = turn_msg_create(method | STUN_ERROR_RESP, 0, id, &iov[*idx])))
   {
     return NULL;
   }
-  (*index)++;
+  (*idx)++;
 
   /* error-code */
   if(!(attr = turn_attr_error_create(508, TURN_ERROR_508,
-          sizeof(TURN_ERROR_508), &iov[*index])))
+          sizeof(TURN_ERROR_508), &iov[*idx])))
   {
-    iovec_free_data(iov, *index);
+    iovec_free_data(iov, *idx);
     return NULL;
   }
-  error->turn_msg_len += iov[*index].iov_len;
-  (*index)++;
+  error->turn_msg_len += iov[*idx].iov_len;
+  (*idx)++;
 
   return error;
 }
@@ -1622,38 +1622,38 @@
   return crc;
 }
 
-int turn_add_message_integrity(struct iovec* iov, size_t* index,
+int turn_add_message_integrity(struct iovec* iov, size_t* idx,
     const unsigned char* key, size_t key_len, int add_fingerprint)
 {
   struct turn_attr_hdr* attr = NULL;
   struct turn_msg_hdr* hdr = iov[0].iov_base;
 
-  if(*index == 0)
+  if(*idx == 0)
   {
     /* could not place message-integrity or fingerprint in first place */
     return -1;
   }
 
-  if(!(attr = turn_attr_message_integrity_create(NULL, &iov[*index])))
+  if(!(attr = turn_attr_message_integrity_create(NULL, &iov[*idx])))
   {
     return -1;
   }
-  hdr->turn_msg_len += iov[(*index)].iov_len;
-  (*index)++;
+  hdr->turn_msg_len += iov[(*idx)].iov_len;
+  (*idx)++;
 
   /* compute HMAC */
   /* convert length to big endian */
   hdr->turn_msg_len = htons(hdr->turn_msg_len);
 
   /* do not take into account the attribute itself */
-  turn_calculate_integrity_hmac_iov(iov, (*index) - 1, key, key_len,
+  turn_calculate_integrity_hmac_iov(iov, (*idx) - 1, key, key_len,
       ((struct turn_attr_message_integrity*)attr)->turn_attr_hmac);
 
   hdr->turn_msg_len = ntohs(hdr->turn_msg_len);
 
   if(add_fingerprint)
   {
-    turn_add_fingerprint(iov, index);
+    turn_add_fingerprint(iov, idx);
   }
 
   hdr->turn_msg_len = htons(hdr->turn_msg_len);
@@ -1661,24 +1661,24 @@
   return 0;
 }
 
-int turn_add_fingerprint(struct iovec* iov, size_t* index)
+int turn_add_fingerprint(struct iovec* iov, size_t* idx)
 {
   struct turn_attr_hdr* attr = NULL;
   struct turn_msg_hdr* hdr = iov[0].iov_base;
 
-  if(*index == 0)
+  if(*idx == 0)
   {
     /* could not place fingerprint in first place */
     return -1;
   }
 
   /* add a fingerprint */
-  if(!(attr = turn_attr_fingerprint_create(0, &iov[(*index)])))
+  if(!(attr = turn_attr_fingerprint_create(0, &iov[(*idx)])))
   {
     return -1;
   }
-  hdr->turn_msg_len += iov[(*index)].iov_len;
-  (*index)++;
+  hdr->turn_msg_len += iov[(*idx)].iov_len;
+  (*idx)++;
 
   /* compute fingerprint */
   /* convert to big endian */
@@ -1686,7 +1686,7 @@
 
   /* do not take into account the attribute itself */
   ((struct turn_attr_fingerprint*)attr)->turn_attr_crc = htonl(
-    turn_calculate_fingerprint(iov, (*index) - 1));
+    turn_calculate_fingerprint(iov, (*idx) - 1));
   ((struct turn_attr_fingerprint*)attr)->turn_attr_crc ^= htonl(
     STUN_FINGERPRINT_XOR_VALUE);
 
@@ -1738,7 +1738,7 @@
   /* attributes length */
   ssize_t len = 0;
   const char* ptr = msg;
-  size_t unknown_index = 0;
+  size_t unknown_idx = 0;
   /* count of XOR-PEER-ADDRESS attribute */
   size_t xor_peer_address_nb = 0;
 
@@ -1889,9 +1889,9 @@
           {
             break;
           }
-          unknown[unknown_index] = htons(attr->turn_attr_type);
+          unknown[unknown_idx] = htons(attr->turn_attr_type);
           (*unknown_size)--;
-          unknown_index++;
+          unknown_idx++;
         }
         break;
     }
@@ -1911,7 +1911,7 @@
     }
   }
 
-  *unknown_size = unknown_index;
+  *unknown_size = unknown_idx;
 
   return 0;
 }

Modified: trunk/src/turnserver.c
===================================================================
--- trunk/src/turnserver.c	2013-03-02 07:55:15 UTC (rev 233)
+++ trunk/src/turnserver.c	2013-03-26 17:06:14 UTC (rev 234)
@@ -646,45 +646,45 @@
   struct iovec iov[16]; /* should be sufficient */
   struct turn_msg_hdr* hdr = NULL;
   struct turn_attr_hdr* attr = NULL;
-  size_t index = 0;
+  size_t idx = 0;
 
   switch(error)
   {
     case 400: /* Bad request */
-      hdr = turn_error_response_400(method, id, &iov[index], &index);
+      hdr = turn_error_response_400(method, id, &iov[idx], &idx);
       break;
     case 403: /* Forbidden */
-      hdr = turn_error_response_403(method, id, &iov[index], &index);
+      hdr = turn_error_response_403(method, id, &iov[idx], &idx);
       break;
     case 437: /* Alocation mismatch */
-      hdr = turn_error_response_437(method, id, &iov[index], &index);
+      hdr = turn_error_response_437(method, id, &iov[idx], &idx);
       break;
     case 440: /* Address family not supported */
-      hdr = turn_error_response_440(method, id, &iov[index], &index);
+      hdr = turn_error_response_440(method, id, &iov[idx], &idx);
       break;
     case 441: /* Wrong credentials */
-      hdr = turn_error_response_441(method, id, &iov[index], &index);
+      hdr = turn_error_response_441(method, id, &iov[idx], &idx);
       break;
     case 442: /* Unsupported transport protocol */
-      hdr = turn_error_response_442(method, id, &iov[index], &index);
+      hdr = turn_error_response_442(method, id, &iov[idx], &idx);
       break;
     case 443: /* Peer address family mismatch */
-      hdr = turn_error_response_443(method, id, &iov[index], &index);
+      hdr = turn_error_response_443(method, id, &iov[idx], &idx);
       break;
     case 446: /* Connection already exists (RFC6062) */
-      hdr = turn_error_response_446(method, id, &iov[index], &index);
+      hdr = turn_error_response_446(method, id, &iov[idx], &idx);
       break;
     case 447: /* Connection timeout or failure (RFC6062) */
-      hdr = turn_error_response_447(method, id, &iov[index], &index);
+      hdr = turn_error_response_447(method, id, &iov[idx], &idx);
       break;
     case 486: /* Allocation quota reached */
-      hdr = turn_error_response_486(method, id, &iov[index], &index);
+      hdr = turn_error_response_486(method, id, &iov[idx], &idx);
       break;
     case 500: /* Server error */
-      hdr = turn_error_response_500(method, id, &iov[index], &index);
+      hdr = turn_error_response_500(method, id, &iov[idx], &idx);
       break;
     case 508: /* Insufficient port capacity */
-      hdr = turn_error_response_508(method, id, &iov[index], &index);
+      hdr = turn_error_response_508(method, id, &iov[idx], &idx);
       break;
     default:
       break;
@@ -697,27 +697,27 @@
 
   /* software (not fatal if it cannot be allocated) */
   if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-          sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[index])))
+          sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[idx])))
   {
-    hdr->turn_msg_len += iov[index].iov_len;
-    index++;
+    hdr->turn_msg_len += iov[idx].iov_len;
+    idx++;
   }
 
   if(key)
   {
-    if(turn_add_message_integrity(iov, &index, key, 16, 1) == -1)
+    if(turn_add_message_integrity(iov, &idx, key, 16, 1) == -1)
     {
       /* MESSAGE-INTEGRITY option has to be in message, so
        * deallocate ressources and return
        */
-      iovec_free_data(iov, index);
+      iovec_free_data(iov, idx);
       return -1;
     }
     /* function above already set turn_msg_len field to big endian */
   }
   else
   {
-    turn_add_fingerprint(iov, &index); /* not fatal if not successful */
+    turn_add_fingerprint(iov, &idx); /* not fatal if not successful */
 
     /* convert to big endian */
     hdr->turn_msg_len = htons(hdr->turn_msg_len);
@@ -725,13 +725,13 @@
 
   /* finally send the response */
   if(turn_send_message(transport_protocol, sock, speer, saddr, saddr_size,
-        ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, index)
+        ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, idx)
       == -1)
   {
     debug(DBG_ATTR, "turn_send_message failed\n");
   }
 
-  iovec_free_data(iov, index);
+  iovec_free_data(iov, idx);
   return 0;
 }
 
@@ -936,7 +936,7 @@
   struct turn_msg_hdr* hdr = NULL;
   struct turn_attr_hdr* attr = NULL;
   struct iovec iov[8];
-  size_t index = 0;
+  size_t idx = 0;
 
   debug(DBG_ATTR, "ConnectionBind request received!\n");
 
@@ -1000,57 +1000,57 @@
 
   /* ConnectionBind response */
   if(!(hdr = turn_msg_connectionbind_response_create(0,
-      message->msg->turn_msg_id, &iov[index])))
+      message->msg->turn_msg_id, &iov[idx])))
   {
     turnserver_send_error(transport_protocol, sock, method,
         message->msg->turn_msg_id, 500, saddr, saddr_size, speer, account->key);
     return -1;
   }
-  index++;
+  idx++;
 
   /* connection-id */
   if(!(attr = turn_attr_connection_id_create(
-          message->connection_id->turn_attr_id, &iov[index])))
+          message->connection_id->turn_attr_id, &iov[idx])))
   {
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     turnserver_send_error(transport_protocol, sock, method,
         message->msg->turn_msg_id, 500, saddr, saddr_size, speer, account->key);
     return -1;
   }
-  hdr->turn_msg_len += iov[index].iov_len;
-  index++;
+  hdr->turn_msg_len += iov[idx].iov_len;
+  idx++;
 
   /* software (not fatal if it cannot be allocated) */
   if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-          strlen(SOFTWARE_DESCRIPTION), &iov[index])))
+          strlen(SOFTWARE_DESCRIPTION), &iov[idx])))
   {
-    hdr->turn_msg_len += iov[index].iov_len;
-    index++;
+    hdr->turn_msg_len += iov[idx].iov_len;
+    idx++;
   }
 
-  if(turn_add_message_integrity(iov, &index, desc->key, sizeof(desc->key), 1)
+  if(turn_add_message_integrity(iov, &idx, desc->key, sizeof(desc->key), 1)
       == -1)
   {
     /* MESSAGE-INTEGRITY option has to be in message, so
      * deallocate ressources and return
      */
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     turnserver_send_error(transport_protocol, sock, method,
         message->msg->turn_msg_id, 500, saddr, saddr_size, speer, account->key);
     return -1;
   }
 
   if(turn_send_message(transport_protocol, sock, speer, saddr, saddr_size,
-        ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, index)
+        ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, idx)
       == -1)
   {
     debug(DBG_ATTR, "turn_send_message failed\n");
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     return -1;
   }
 
   /* free message */
-  iovec_free_data(iov, index);
+  iovec_free_data(iov, idx);
 
   /* initialized client socket */
   tcp_relay->client_sock = sock;
@@ -1137,51 +1137,51 @@
     socklen_t saddr_size, struct tls_peer* speer)
 {
   struct iovec iov[4]; /* header, software, xor-address, fingerprint */
-  size_t index = 0;
+  size_t idx = 0;
   struct turn_msg_hdr* hdr = NULL;
   struct turn_attr_hdr* attr = NULL;
 
   debug(DBG_ATTR, "Binding request received!\n");
 
   if(!(hdr = turn_msg_binding_response_create(0, message->msg->turn_msg_id,
-          &iov[index])))
+          &iov[idx])))
   {
     return -1;
   }
-  index++;
+  idx++;
 
   if(!(attr = turn_attr_xor_mapped_address_create(saddr, STUN_MAGIC_COOKIE,
-          message->msg->turn_msg_id, &iov[index])))
+          message->msg->turn_msg_id, &iov[idx])))
   {
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     turnserver_send_error(transport_protocol, sock, STUN_METHOD_BINDING,
         message->msg->turn_msg_id, 500, saddr, saddr_size, speer, NULL);
     return -1;
   }
-  hdr->turn_msg_len += iov[index].iov_len;
-  index++;
+  hdr->turn_msg_len += iov[idx].iov_len;
+  idx++;
 
   /* software (not fatal if it cannot be allocated) */
   if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-          sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[index])))
+          sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[idx])))
   {
-    hdr->turn_msg_len += iov[index].iov_len;
-    index++;
+    hdr->turn_msg_len += iov[idx].iov_len;
+    idx++;
   }
 
   /* NOTE: maybe add a configuration flag to enable/disable fingerprint in
    * output message
    */
   /* add a fingerprint */
-  if(!(attr = turn_attr_fingerprint_create(0, &iov[index])))
+  if(!(attr = turn_attr_fingerprint_create(0, &iov[idx])))
   {
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     turnserver_send_error(transport_protocol, sock, STUN_METHOD_BINDING,
         message->msg->turn_msg_id, 500, saddr, saddr_size, speer, NULL);
     return -1;
   }
-  hdr->turn_msg_len += iov[index].iov_len;
-  index++;
+  hdr->turn_msg_len += iov[idx].iov_len;
+  idx++;
 
   /* compute fingerprint */
 
@@ -1190,18 +1190,18 @@
 
   /* do not take into account the attribute itself */
   ((struct turn_attr_fingerprint*)attr)->turn_attr_crc =
-    htonl(turn_calculate_fingerprint(iov, index - 1));
+    htonl(turn_calculate_fingerprint(iov, idx - 1));
   ((struct turn_attr_fingerprint*)attr)->turn_attr_crc ^=
     htonl(STUN_FINGERPRINT_XOR_VALUE);
 
   if(turn_send_message(transport_protocol, sock, speer, saddr, saddr_size,
-        ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, index)
+        ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, idx)
       == -1)
   {
     debug(DBG_ATTR, "turn_send_message failed\n");
   }
 
-  iovec_free_data(iov, index);
+  iovec_free_data(iov, idx);
   return 0;
 }
 
@@ -1615,7 +1615,7 @@
   struct turn_msg_hdr* hdr = NULL;
   struct turn_attr_hdr* attr = NULL;
   struct iovec iov[4]; /* header, software, integrity, fingerprint */
-  size_t index = 0;
+  size_t idx = 0;
   char str[INET6_ADDRSTRLEN];
   char str2[INET6_ADDRSTRLEN];
   char str3[INET6_ADDRSTRLEN];
@@ -1777,26 +1777,26 @@
 
   /* send a CreatePermission success response */
   if(!(hdr = turn_msg_createpermission_response_create(0,
-          message->msg->turn_msg_id, &iov[index])))
+          message->msg->turn_msg_id, &iov[idx])))
   {
     turnserver_send_error(transport_protocol, sock, method,
         message->msg->turn_msg_id, 500, saddr, saddr_size, speer, desc->key);
     return -1;
   }
-  index++;
+  idx++;
 
   /* software (not fatal if it cannot be allocated) */
   if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-          sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[index])))
+          sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[idx])))
   {
-    hdr->turn_msg_len += iov[index].iov_len;
-    index++;
+    hdr->turn_msg_len += iov[idx].iov_len;
+    idx++;
   }
 
-  if(turn_add_message_integrity(iov, &index, desc->key, sizeof(desc->key), 1)
+  if(turn_add_message_integrity(iov, &idx, desc->key, sizeof(desc->key), 1)
       == -1)
   {
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     turnserver_send_error(transport_protocol, sock, method,
         message->msg->turn_msg_id, 500, saddr, saddr_size, speer, desc->key);
     return -1;
@@ -1808,13 +1808,13 @@
   /* finally send the response */
 
   if(turn_send_message(transport_protocol, sock, speer, saddr, saddr_size,
-        ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, index)
+        ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, idx)
       == -1)
   {
     debug(DBG_ATTR, "turn_send_message failed\n");
   }
 
-  iovec_free_data(iov, index);
+  iovec_free_data(iov, idx);
   return 0;
 }
 
@@ -1837,7 +1837,7 @@
   uint16_t hdr_msg_type = htons(message->msg->turn_msg_type);
   uint16_t method = STUN_GET_METHOD(hdr_msg_type);
   struct iovec iov[5]; /* header, lifetime, software, integrity, fingerprint */
-  size_t index = 0;
+  size_t idx = 0;
   struct turn_msg_hdr* hdr = NULL;
   struct turn_attr_hdr* attr = NULL;
   uint16_t channel = 0;
@@ -2026,26 +2026,26 @@
 
   /* finally send the response */
   if(!(hdr = turn_msg_channelbind_response_create(0, message->msg->turn_msg_id,
-          &iov[index])))
+          &iov[idx])))
   {
     turnserver_send_error(transport_protocol, sock, method,
         message->msg->turn_msg_id, 500, saddr, saddr_size, speer, desc->key);
     return -1;
   }
-  index++;
+  idx++;
 
   /* software (not fatal if it cannot be allocated) */
   if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-          sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[index])))
+          sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[idx])))
   {
-    hdr->turn_msg_len += iov[index].iov_len;
-    index++;
+    hdr->turn_msg_len += iov[idx].iov_len;
+    idx++;
   }
 
-  if(turn_add_message_integrity(iov, &index, desc->key, sizeof(desc->key), 1)
+  if(turn_add_message_integrity(iov, &idx, desc->key, sizeof(desc->key), 1)
       == -1)
   {
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     turnserver_send_error(transport_protocol, sock, method,
         message->msg->turn_msg_id, 500, saddr, saddr_size, speer, desc->key);
     return -1;
@@ -2056,13 +2056,13 @@
 
   /* finally send the response */
   if(turn_send_message(transport_protocol, sock, speer, saddr, saddr_size,
-        ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, index)
+        ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, idx)
       == -1)
   {
     debug(DBG_ATTR, "turn_send_message failed\n");
   }
 
-  iovec_free_data(iov, index);
+  iovec_free_data(iov, idx);
   return 0;
 }
 
@@ -2090,7 +2090,7 @@
   uint16_t method = STUN_GET_METHOD(hdr_msg_type);
   uint32_t lifetime = 0;
   struct iovec iov[5]; /* header, lifetime, software, integrity, fingerprint */
-  size_t index = 0;
+  size_t idx = 0;
   struct turn_msg_hdr* hdr = NULL;
   struct turn_attr_hdr* attr = NULL;
   uint8_t key[16];
@@ -2207,35 +2207,35 @@
   }
 
   if(!(hdr = turn_msg_refresh_response_create(0, message->msg->turn_msg_id,
-          &iov[index])))
+          &iov[idx])))
   {
     turnserver_send_error(transport_protocol, sock, method,
         message->msg->turn_msg_id, 500, saddr, saddr_size, speer, key);
     return -1;
   }
-  index++;
+  idx++;
 
-  if(!(attr = turn_attr_lifetime_create(lifetime, &iov[index])))
+  if(!(attr = turn_attr_lifetime_create(lifetime, &iov[idx])))
   {
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     turnserver_send_error(transport_protocol, sock, method,
         message->msg->turn_msg_id, 500, saddr, saddr_size, speer, key);
     return -1;
   }
-  hdr->turn_msg_len += iov[index].iov_len;
-  index++;
+  hdr->turn_msg_len += iov[idx].iov_len;
+  idx++;
 
   /* software (not fatal if it cannot be allocated) */
   if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-          sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[index])))
+          sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[idx])))
   {
-    hdr->turn_msg_len += iov[index].iov_len;
-    index++;
+    hdr->turn_msg_len += iov[idx].iov_len;
+    idx++;
   }
 
-  if(turn_add_message_integrity(iov, &index, key, sizeof(key), 1) == -1)
+  if(turn_add_message_integrity(iov, &idx, key, sizeof(key), 1) == -1)
   {
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     turnserver_send_error(transport_protocol, sock, method,
         message->msg->turn_msg_id, 500, saddr, saddr_size, speer, key);
     return -1;
@@ -2245,13 +2245,13 @@
 
   /* finally send the response */
   if(turn_send_message(transport_protocol, sock, speer, saddr, saddr_size,
-        ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, index)
+        ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, idx)
       == -1)
   {
     debug(DBG_ATTR, "turn_send_message failed\n");
   }
 
-  iovec_free_data(iov, index);
+  iovec_free_data(iov, idx);
   return 0;
 }
 
@@ -2389,13 +2389,13 @@
     uint16_t unknown[2];
     struct turn_msg_hdr* error = NULL;
     struct turn_attr_hdr* attr = NULL;
-    size_t index = 0;
+    size_t idx = 0;
 
     /* send error 420 */
     unknown[0] = TURN_ATTR_DONT_FRAGMENT;
 
     if(!(error = turn_error_response_420(method, message->msg->turn_msg_id,
-            unknown, 1, iov, &index)))
+            unknown, 1, iov, &idx)))
     {
       turnserver_send_error(transport_protocol, sock, method,
           message->msg->turn_msg_id, 500, saddr, saddr_size, speer,
@@ -2405,16 +2405,16 @@
 
     /* software (not fatal if it cannot be allocated) */
     if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-            sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[index])))
+            sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[idx])))
     {
-      error->turn_msg_len += iov[index].iov_len;
-      index++;
+      error->turn_msg_len += iov[idx].iov_len;
+      idx++;
     }
 
-    if(turn_add_message_integrity(iov, &index, desc->key, sizeof(desc->key), 1)
+    if(turn_add_message_integrity(iov, &idx, desc->key, sizeof(desc->key), 1)
         == -1)
     {
-      iovec_free_data(iov, index);
+      iovec_free_data(iov, idx);
       turnserver_send_error(transport_protocol, sock, method,
           message->msg->turn_msg_id, 500, saddr, saddr_size, speer,
           account->key);
@@ -2422,14 +2422,14 @@
     }
 
     if(turn_send_message(transport_protocol, sock, speer, saddr, saddr_size,
-          ntohs(error->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, index)
+          ntohs(error->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, idx)
         == -1)
     {
       debug(DBG_ATTR, "turn_send_message failed\n");
     }
 
     /* free sent data */
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     return 0;
   }
 #endif
@@ -2806,39 +2806,39 @@
     struct iovec iov[12];
     struct turn_msg_hdr* hdr = NULL;
     struct turn_attr_hdr* attr = NULL;
-    size_t index = 0;
+    size_t idx = 0;
 
     if(!(hdr = turn_msg_allocate_response_create(0, message->msg->turn_msg_id,
-            &iov[index])))
+            &iov[idx])))
     {
       turnserver_send_error(transport_protocol, sock, method,
           message->msg->turn_msg_id, 500, saddr, saddr_size, speer, desc->key);
       return -1;
     }
-    index++;
+    idx++;
 
     /* required attributes */
     if(!(attr = turn_attr_xor_relayed_address_create(
             (struct sockaddr*)&relayed_addr, STUN_MAGIC_COOKIE,
-            message->msg->turn_msg_id, &iov[index])))
+            message->msg->turn_msg_id, &iov[idx])))
     {
-      iovec_free_data(iov, index);
+      iovec_free_data(iov, idx);
       turnserver_send_error(transport_protocol, sock, method,
           message->msg->turn_msg_id, 500, saddr, saddr_size, speer, desc->key);
       return -1;
     }
-    hdr->turn_msg_len += iov[index].iov_len;
-    index++;
+    hdr->turn_msg_len += iov[idx].iov_len;
+    idx++;
 
-    if(!(attr = turn_attr_lifetime_create(lifetime, &iov[index])))
+    if(!(attr = turn_attr_lifetime_create(lifetime, &iov[idx])))
     {
-      iovec_free_data(iov, index);
+      iovec_free_data(iov, idx);
       turnserver_send_error(transport_protocol, sock, method,
           message->msg->turn_msg_id, 500,saddr, saddr_size, speer, desc->key);
       return -1;
     }
-    hdr->turn_msg_len += iov[index].iov_len;
-    index++;
+    hdr->turn_msg_len += iov[idx].iov_len;
+    idx++;
 
     switch(saddr->sa_family)
     {
@@ -2849,51 +2849,51 @@
         port = ntohs(((struct sockaddr_in6*)saddr)->sin6_port);
         break;
       default:
-        iovec_free_data(iov, index);
+        iovec_free_data(iov, idx);
         return -1;
         break;
     }
 
     if(!(attr = turn_attr_xor_mapped_address_create(saddr, STUN_MAGIC_COOKIE,
-            message->msg->turn_msg_id, &iov[index])))
+            message->msg->turn_msg_id, &iov[idx])))
     {
-      iovec_free_data(iov, index);
+      iovec_free_data(iov, idx);
       turnserver_send_error(transport_protocol, sock, method,
           message->msg->turn_msg_id, 500, saddr, saddr_size, speer, desc->key);
       return -1;
     }
-    hdr->turn_msg_len += iov[index].iov_len;
-    index++;
+    hdr->turn_msg_len += iov[idx].iov_len;
+    idx++;
 
     if(reservation_port)
     {
       /* server has stored a socket/port */
       debug(DBG_ATTR, "Send a reservation-token attribute\n");
       if(!(attr = turn_attr_reservation_token_create(reservation_token,
-              &iov[index])))
+              &iov[idx])))
       {
-        iovec_free_data(iov, index);
+        iovec_free_data(iov, idx);
         turnserver_send_error(transport_protocol, sock, method,
             message->msg->turn_msg_id, 500, saddr, saddr_size, speer,
             desc->key);
         return -1;
       }
-      hdr->turn_msg_len += iov[index].iov_len;
-      index++;
+      hdr->turn_msg_len += iov[idx].iov_len;
+      idx++;
     }
 
     /* software (not fatal if it cannot be allocated) */
     if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-            sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[index])))
+            sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[idx])))
     {
-      hdr->turn_msg_len += iov[index].iov_len;
-      index++;
+      hdr->turn_msg_len += iov[idx].iov_len;
+      idx++;
     }
 
-    if(turn_add_message_integrity(iov, &index, desc->key, sizeof(desc->key), 1)
+    if(turn_add_message_integrity(iov, &idx, desc->key, sizeof(desc->key), 1)
         == -1)
     {
-      iovec_free_data(iov, index);
+      iovec_free_data(iov, idx);
       turnserver_send_error(transport_protocol, sock, method,
           message->msg->turn_msg_id, 500, saddr, saddr_size, speer, desc->key);
       return -1;
@@ -2902,13 +2902,13 @@
     debug(DBG_ATTR, "Allocation successful, send success allocate response\n");
 
     if(turn_send_message(transport_protocol, sock, speer, saddr, saddr_size,
-          ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, index)
+          ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, idx)
         == -1)
     {
       debug(DBG_ATTR, "turn_send_message failed\n");
     }
 
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
   }
 
   return 0;
@@ -3267,7 +3267,7 @@
       struct turn_msg_hdr* error = NULL;
       struct turn_attr_hdr* attr = NULL;
       char* key = NULL;
-      size_t index = 0;
+      size_t idx = 0;
 
       debug(DBG_ATTR, "No message integrity\n");
 
@@ -3276,7 +3276,7 @@
           strlen(key));
 
       if(!(error = turn_error_response_401(method, message.msg->turn_msg_id,
-              turnserver_cfg_realm(), nonce, sizeof(nonce), iov, &index)))
+              turnserver_cfg_realm(), nonce, sizeof(nonce), iov, &idx)))
       {
         turnserver_send_error(transport_protocol, sock, method,
             message.msg->turn_msg_id, 500, saddr, saddr_size, speer, NULL);
@@ -3285,26 +3285,26 @@
 
       /* software (not fatal if it cannot be allocated) */
       if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-              sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[index])))
+              sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[idx])))
       {
-        error->turn_msg_len += iov[index].iov_len;
-        index++;
+        error->turn_msg_len += iov[idx].iov_len;
+        idx++;
       }
 
-      turn_add_fingerprint(iov, &index); /* not fatal if not successful */
+      turn_add_fingerprint(iov, &idx); /* not fatal if not successful */
 
       /* convert to big endian */
       error->turn_msg_len = htons(error->turn_msg_len);
 
       if(turn_send_message(transport_protocol, sock, speer, saddr, saddr_size,
             ntohs(error->turn_msg_len) + sizeof(struct turn_msg_hdr), iov,
-            index) == -1)
+            idx) == -1)
       {
         debug(DBG_ATTR, "turn_send_message failed\n");
       }
 
       /* free sent data */
-      iovec_free_data(iov, index);
+      iovec_free_data(iov, idx);
       return 0;
     }
 
@@ -3324,7 +3324,7 @@
       /* nonce staled => error 438 */
       /* header, error-code, realm, nonce, software */
       struct iovec iov[5];
-      size_t index = 0;
+      size_t idx = 0;
       struct turn_msg_hdr* error = NULL;
       struct turn_attr_hdr* attr = NULL;
       uint8_t nonce[48];
@@ -3333,10 +3333,10 @@
 
       turn_generate_nonce(nonce, sizeof(nonce), (unsigned char*)key,
           strlen(key));
-      index = 0;
+      idx = 0;
 
       if(!(error = turn_error_response_438(method, message.msg->turn_msg_id,
-              realm, nonce, sizeof(nonce), iov, &index)))
+              realm, nonce, sizeof(nonce), iov, &idx)))
       {
         turnserver_send_error(transport_protocol, sock, method,
             message.msg->turn_msg_id, 500, saddr, saddr_size, speer, NULL);
@@ -3345,10 +3345,10 @@
 
       /* software (not fatal if it cannot be allocated) */
       if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-              sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[index])))
+              sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[idx])))
       {
-        error->turn_msg_len += iov[index].iov_len;
-        index++;
+        error->turn_msg_len += iov[idx].iov_len;
+        idx++;
       }
 
       /* convert to big endian */
@@ -3356,13 +3356,13 @@
 
       if(turn_send_message(transport_protocol, sock, speer, saddr, saddr_size,
             ntohs(error->turn_msg_len) + sizeof(struct turn_msg_hdr), iov,
-            index) == -1)
+            idx) == -1)
       {
         debug(DBG_ATTR, "turn_send_message failed\n");
       }
 
       /* free sent data */
-      iovec_free_data(iov, index);
+      iovec_free_data(iov, idx);
       return 0;
     }
 
@@ -3394,7 +3394,7 @@
       {
         /* not valid username => error 401 */
         struct iovec iov[5]; /* header, error-code, realm, nonce, software */
-        size_t index = 0;
+        size_t idx = 0;
         struct turn_msg_hdr* error = NULL;
         struct turn_attr_hdr* attr = NULL;
         uint8_t nonce[48];
@@ -3405,10 +3405,10 @@
 
         turn_generate_nonce(nonce, sizeof(nonce), (unsigned char*)key,
             strlen(key));
-        index = 0;
+        idx = 0;
 
         if(!(error = turn_error_response_401(method, message.msg->turn_msg_id,
-                realm, nonce, sizeof(nonce), iov, &index)))
+                realm, nonce, sizeof(nonce), iov, &idx)))
         {
           turnserver_send_error(transport_protocol, sock, method,
               message.msg->turn_msg_id, 500, saddr, saddr_size, speer, NULL);
@@ -3417,26 +3417,26 @@
 
         /* software (not fatal if it cannot be allocated) */
         if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-                sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[index])))
+                sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[idx])))
         {
-          error->turn_msg_len += iov[index].iov_len;
-          index++;
+          error->turn_msg_len += iov[idx].iov_len;
+          idx++;
         }
 
-        turn_add_fingerprint(iov, &index); /* not fatal if not successful */
+        turn_add_fingerprint(iov, &idx); /* not fatal if not successful */
 
         /* convert to big endian */
         error->turn_msg_len = htons(error->turn_msg_len);
 
         if(turn_send_message(transport_protocol, sock, speer, saddr, saddr_size,
               ntohs(error->turn_msg_len) + sizeof(struct turn_msg_hdr), iov,
-              index) == -1)
+              idx) == -1)
         {
           debug(DBG_ATTR, "turn_send_message failed\n");
         }
 
         /* free sent data */
-        iovec_free_data(iov, index);
+        iovec_free_data(iov, idx);
         return 0;
       }
     }
@@ -3474,7 +3474,7 @@
       {
         /* integrity does not match => error 401 */
         struct iovec iov[5]; /* header, error-code, realm, nonce, software */
-        size_t index = 0;
+        size_t idx = 0;
         struct turn_msg_hdr* error = NULL;
         struct turn_attr_hdr* attr = NULL;
         uint8_t nonce[48];
@@ -3488,10 +3488,10 @@
 #endif
         turn_generate_nonce(nonce, sizeof(nonce), (unsigned char*)nonce_key,
             strlen(nonce_key));
-        index = 0;
+        idx = 0;
 
         if(!(error = turn_error_response_401(method, message.msg->turn_msg_id,
-                turnserver_cfg_realm(), nonce, sizeof(nonce), iov, &index)))
+                turnserver_cfg_realm(), nonce, sizeof(nonce), iov, &idx)))
         {
           turnserver_send_error(transport_protocol, sock, method,
               message.msg->turn_msg_id, 500, saddr, saddr_size, speer, NULL);
@@ -3500,26 +3500,26 @@
 
         /* software (not fatal if it cannot be allocated) */
         if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-                sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[index])))
+                sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[idx])))
         {
-          error->turn_msg_len += iov[index].iov_len;
-          index++;
+          error->turn_msg_len += iov[idx].iov_len;
+          idx++;
         }
 
-        turn_add_fingerprint(iov, &index); /* not fatal if not successful */
+        turn_add_fingerprint(iov, &idx); /* not fatal if not successful */
 
         /* convert to big endian */
         error->turn_msg_len = htons(error->turn_msg_len);
 
         if(turn_send_message(transport_protocol, sock, speer, saddr, saddr_size,
               ntohs(error->turn_msg_len) + sizeof(struct turn_msg_hdr), iov,
-              index) == -1)
+              idx) == -1)
         {
           debug(DBG_ATTR, "turn_send_message failed\n");
         }
 
         /* free sent data */
-        iovec_free_data(iov, index);
+        iovec_free_data(iov, idx);
         return 0;
       }
     }
@@ -3529,7 +3529,7 @@
   if(unknown_size)
   {
     struct iovec iov[4]; /* header, error-code, unknown-attributes, software */
-    size_t index = 0;
+    size_t idx = 0;
     struct turn_msg_hdr* error = NULL;
     struct turn_attr_hdr* attr = NULL;
 
@@ -3543,7 +3543,7 @@
 
     /* unknown attributes found => error 420 */
     if(!(error = turn_error_response_420(method, message.msg->turn_msg_id,
-            unknown, unknown_size, iov, &index)))
+            unknown, unknown_size, iov, &idx)))
     {
       turnserver_send_error(transport_protocol, sock, method,
           message.msg->turn_msg_id, 500, saddr, saddr_size, speer,
@@ -3553,24 +3553,24 @@
 
     /* software (not fatal if it cannot be allocated) */
     if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-            sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[index])))
+            sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[idx])))
     {
-      error->turn_msg_len += iov[index].iov_len;
-      index++;
+      error->turn_msg_len += iov[idx].iov_len;
+      idx++;
     }
 
     /* convert to big endian */
     error->turn_msg_len = htons(error->turn_msg_len);
 
     if(turn_send_message(transport_protocol, sock, speer, saddr, saddr_size,
-          ntohs(error->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, index)
+          ntohs(error->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, idx)
         == -1)
     {
       debug(DBG_ATTR, "turn_send_message failed\n");
     }
 
     /* free sent data */
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     return 0;
   }
 
@@ -3603,7 +3603,7 @@
   uint16_t peer_port;
   uint32_t channel = 0;
   struct iovec iov[8]; /* header, peer-address, data */
-  size_t index = 0;
+  size_t idx = 0;
   struct turn_msg_hdr* hdr = NULL;
   struct turn_attr_hdr* attr = NULL;
   struct turn_channel_data channel_data;
@@ -3663,25 +3663,25 @@
     channel_data.turn_channel_number = htons(channel);
     channel_data.turn_channel_len = htons(buflen); /* big endian */
 
-    iov[index].iov_base = &channel_data;
-    iov[index].iov_len = sizeof(struct turn_channel_data);
-    index++;
+    iov[idx].iov_base = &channel_data;
+    iov[idx].iov_len = sizeof(struct turn_channel_data);
+    idx++;
 
     if(buflen > 0)
     {
-      iov[index].iov_base = (void*)buf;
-      iov[index].iov_len = buflen;
+      iov[idx].iov_base = (void*)buf;
+      iov[idx].iov_len = buflen;
       len += buflen;
-      index++;
+      idx++;
     }
 
     /* add padding (MUST be included for TCP, MAY be included for UDP) */
     if(buflen % 4)
     {
-      iov[index].iov_base = &padding;
-      iov[index].iov_len = 4 - (buflen % 4);
-      len += iov[index].iov_len;
-      index++;
+      iov[idx].iov_base = &padding;
+      iov[idx].iov_len = 4 - (buflen % 4);
+      len += iov[idx].iov_len;
+      idx++;
     }
   }
   else
@@ -3690,28 +3690,28 @@
     uint8_t id[12];
 
     turn_generate_transaction_id(id);
-    if(!(hdr = turn_msg_data_indication_create(0, id, &iov[index])))
+    if(!(hdr = turn_msg_data_indication_create(0, id, &iov[idx])))
     {
       return -1;
     }
-    index++;
+    idx++;
 
     if(!(attr = turn_attr_xor_peer_address_create(saddr, STUN_MAGIC_COOKIE, id,
-            &iov[index])))
+            &iov[idx])))
     {
-      iovec_free_data(iov, index);
+      iovec_free_data(iov, idx);
       return -1;
     }
-    hdr->turn_msg_len += iov[index].iov_len;
-    index++;
+    hdr->turn_msg_len += iov[idx].iov_len;
+    idx++;
 
-    if(!(attr = turn_attr_data_create(buf, buflen, &iov[index])))
+    if(!(attr = turn_attr_data_create(buf, buflen, &iov[idx])))
     {
-      iovec_free_data(iov, index);
+      iovec_free_data(iov, idx);
       return -1;
     }
-    hdr->turn_msg_len += iov[index].iov_len;
-    index++;
+    hdr->turn_msg_len += iov[idx].iov_len;
+    idx++;
 
     len = hdr->turn_msg_len + sizeof(struct turn_msg_hdr);
     hdr->turn_msg_len = htons(hdr->turn_msg_len);
@@ -3723,7 +3723,7 @@
   if(speer) /* TLS */
   {
     nb = turn_tls_send(speer, (struct sockaddr*)&desc->tuple.client_addr,
-        sockaddr_get_size(&desc->tuple.client_addr), len, iov, index);
+        sockaddr_get_size(&desc->tuple.client_addr), len, iov, idx);
   }
   else if(desc->tuple.transport_protocol == IPPROTO_UDP) /* UDP */
   {
@@ -3768,7 +3768,7 @@
 
     nb = turn_udp_send(desc->tuple_sock,
         (struct sockaddr*)&desc->tuple.client_addr,
-        sockaddr_get_size(&desc->tuple.client_addr), iov, index);
+        sockaddr_get_size(&desc->tuple.client_addr), iov, idx);
 
     /* if not an IPv4-IPv4 relay, optlen keep its default value 0 */
 #ifdef OS_SET_DF_SUPPORT
@@ -3782,7 +3782,7 @@
   }
   else /* TCP */
   {
-    nb = turn_tcp_send(desc->tuple_sock, iov, index);
+    nb = turn_tcp_send(desc->tuple_sock, iov, idx);
   }
 
   if(nb == -1)
@@ -3793,7 +3793,7 @@
   /* if use a channel, do not used dynamic allocation */
   if(!channel)
   {
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
   }
 
   return 0;
@@ -3988,7 +3988,7 @@
   int err = 0;
   socklen_t err_size = sizeof(int);
   struct iovec iov[8];
-  size_t index = 0;
+  size_t idx = 0;
   struct turn_msg_hdr* hdr = NULL;
   struct turn_attr_hdr* attr = NULL;
   struct sockaddr* saddr = (struct sockaddr*)&desc->tuple.client_addr;
@@ -4007,42 +4007,42 @@
   }
 
   if(!(hdr = turn_msg_connect_response_create(0, relay->connect_msg_id,
-          &iov[index])))
+          &iov[idx])))
   {
     return -2;
   }
-  index++;
+  idx++;
 
   /* software (not fatal if it cannot be allocated) */
   if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-          sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[index])))
+          sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[idx])))
   {
-    hdr->turn_msg_len += iov[index].iov_len;
-    index++;
+    hdr->turn_msg_len += iov[idx].iov_len;
+    idx++;
   }
 
   if(!(attr = turn_attr_connection_id_create(relay->connection_id,
-          &iov[index])))
+          &iov[idx])))
   {
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     return -2;
   }
-  hdr->turn_msg_len += iov[index].iov_len;
-  index++;
+  hdr->turn_msg_len += iov[idx].iov_len;
+  idx++;
 
-  if(turn_add_message_integrity(iov, &index, desc->key, sizeof(desc->key), 1)
+  if(turn_add_message_integrity(iov, &idx, desc->key, sizeof(desc->key), 1)
       == -1)
   {
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     return -2;
   }
 
   /* send message */
   ret = turn_send_message(IPPROTO_TCP, desc->tuple_sock, speer, saddr,
       saddr_size, ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov,
-      index);
+      idx);
 
-  iovec_free_data(iov, index);
+  iovec_free_data(iov, idx);
 
   if(ret == -1)
   {
@@ -4085,7 +4085,7 @@
   uint16_t peer_port = 0;
   uint32_t id = 0;
   uint8_t msg_id[12]; /* for ConnectionAttempt message ID */
-  size_t index = 0;
+  size_t idx = 0;
   struct turn_msg_hdr* hdr = NULL;
   struct turn_attr_hdr* attr = NULL;
   struct iovec iov[8];
@@ -4143,46 +4143,46 @@
 
   /* now send ConnectionAttempt to client */
   if(!(hdr = turn_msg_connectionattempt_indication_create(0, msg_id,
-          &iov[index])))
+          &iov[idx])))
   {
     /* ignore ? */
     close(rsock);
     return;
   }
-  index++;
+  idx++;
 
   /* software (not fatal if it cannot be allocated) */
   if((attr = turn_attr_software_create(SOFTWARE_DESCRIPTION,
-          sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[index])))
+          sizeof(SOFTWARE_DESCRIPTION) - 1, &iov[idx])))
   {
-    hdr->turn_msg_len += iov[index].iov_len;
-    index++;
+    hdr->turn_msg_len += iov[idx].iov_len;
+    idx++;
   }
 
-  if(!(attr = turn_attr_connection_id_create(id, &iov[index])))
+  if(!(attr = turn_attr_connection_id_create(id, &iov[idx])))
   {
     close(rsock);
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     return;
   }
-  hdr->turn_msg_len += iov[index].iov_len;
-  index++;
+  hdr->turn_msg_len += iov[idx].iov_len;
+  idx++;
 
   if(!(attr = turn_attr_xor_peer_address_create((struct sockaddr*)&saddr,
-          STUN_MAGIC_COOKIE, msg_id, &iov[index])))
+          STUN_MAGIC_COOKIE, msg_id, &iov[idx])))
   {
     close(rsock);
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     return;
   }
-  hdr->turn_msg_len += iov[index].iov_len;
-  index++;
+  hdr->turn_msg_len += iov[idx].iov_len;
+  idx++;
 
-  if(turn_add_message_integrity(iov, &index, desc->key, sizeof(desc->key), 1)
+  if(turn_add_message_integrity(iov, &idx, desc->key, sizeof(desc->key), 1)
       == -1)
   {
     close(rsock);
-    iovec_free_data(iov, index);
+    iovec_free_data(iov, idx);
     return;
   }
 
@@ -4190,13 +4190,13 @@
   if(turn_send_message(IPPROTO_TCP, desc->tuple_sock, speer,
         (struct sockaddr*)&desc->tuple.client_addr,
         sockaddr_get_size(&desc->tuple.client_addr),
-        ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, index)
+        ntohs(hdr->turn_msg_len) + sizeof(struct turn_msg_hdr), iov, idx)
       == -1)
   {
     debug(DBG_ATTR, "turn_send_message failed\n");
   }
 
-  iovec_free_data(iov, index);
+  iovec_free_data(iov, idx);
   return;
 }
 

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Turnserver-devel] SF.net SVN: turnserver:[241] trunk/src

[<s-v...@us...>]

Revision: 241
          http://sourceforge.net/p/turnserver/code/241
Author:   s-vincent
Date:     2013-12-21 20:31:44 +0000 (Sat, 21 Dec 2013)
Log Message:
-----------
Fixes compilation on FreeBSD 9.x.

Modified Paths:
--------------
    trunk/src/Makefile.am
    trunk/src/test_echo_server.c
    trunk/src/tls_peer.c

Modified: trunk/src/Makefile.am
===================================================================
--- trunk/src/Makefile.am	2013-12-21 17:34:42 UTC (rev 240)
+++ trunk/src/Makefile.am	2013-12-21 20:31:44 UTC (rev 241)
@@ -1,4 +1,4 @@
-AM_CFLAGS = -std=c99 -Wall -Wextra -Werror -Wstrict-prototypes -Wredundant-decls -Wshadow -pedantic -fno-strict-aliasing -D_POSIX_C_SOURCE=200112L -D_XOPEN_SOURCE=600 -O2 -D_SVID_SOURCE
+AM_CFLAGS = -std=c99 -Wall -Wextra -Werror -Wstrict-prototypes -Wredundant-decls -Wshadow -pedantic -fno-strict-aliasing -D_POSIX_C_SOURCE=200112L -D_XOPEN_SOURCE=600 -O2
 
 if ENABLE_DEBUG_BUILD
 AM_CFLAGS += -g 

Modified: trunk/src/test_echo_server.c
===================================================================
--- trunk/src/test_echo_server.c	2013-12-21 17:34:42 UTC (rev 240)
+++ trunk/src/test_echo_server.c	2013-12-21 20:31:44 UTC (rev 241)
@@ -132,15 +132,15 @@
 
   while(g_run)
   {
-    fd_set fdsr;
+    sfd_set fdsr;
     int nsock = sock;
 
-    FD_ZERO(&fdsr);
-    FD_SET(sock, &fdsr);
+    NET_SFD_ZERO(&fdsr);
+    NET_SFD_SET(sock, &fdsr);
 
     nsock++;
 
-    if(select(nsock, &fdsr, NULL, NULL, NULL) > 0)
+    if(select(nsock, (fd_set*)(void*)&fdsr, NULL, NULL, NULL) > 0)
     {
       if(FD_ISSET(sock, &fdsr))
       {

Modified: trunk/src/tls_peer.c
===================================================================
--- trunk/src/tls_peer.c	2013-12-21 17:34:42 UTC (rev 240)
+++ trunk/src/tls_peer.c	2013-12-21 20:31:44 UTC (rev 241)
@@ -491,10 +491,10 @@
 
   while(!speer->handshake_complete)
   {
-    fd_set fdsr;
+    sfd_set fdsr;
 
-    FD_ZERO(&fdsr);
-    FD_SET(peer->sock, &fdsr);
+    NET_SFD_ZERO(&fdsr);
+    NET_SFD_SET(peer->sock, &fdsr);
 
     /* 5 seconds of timeout */
     tv.tv_sec = 5;
@@ -514,7 +514,7 @@
       }
     }
 
-    ret = select(nsock, &fdsr, NULL, NULL, &tv);
+    ret = select(nsock, (fd_set*)(void*)&fdsr, NULL, NULL, &tv);
 
     if(ret > 0)
     {

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Turnserver-devel] SF.net SVN: turnserver:[243] trunk/src

[<s-v...@us...>]

Revision: 243
          http://sourceforge.net/p/turnserver/code/243
Author:   s-vincent
Date:     2014-01-15 20:28:10 +0000 (Wed, 15 Jan 2014)
Log Message:
-----------
Initializes crypto seed for systems that do not have /dev/urandom (which is done transparently by OpenSSL). Initialize list elements due to change of list.h.

Modified Paths:
--------------
    trunk/src/account.c
    trunk/src/conf.c
    trunk/src/turnserver.c

Modified: trunk/src/account.c
===================================================================
--- trunk/src/account.c	2013-12-21 20:36:38 UTC (rev 242)
+++ trunk/src/account.c	2014-01-15 20:28:10 UTC (rev 243)
@@ -72,6 +72,7 @@
   ret->state = state;
   ret->allocations = 0;
   ret->is_tmp = 0;
+  list_head_init(&ret->list);
 
   turn_calculate_authentication_key(username, realm, password, ret->key,
       sizeof(ret->key));

Modified: trunk/src/conf.c
===================================================================
--- trunk/src/conf.c	2013-12-21 20:36:38 UTC (rev 242)
+++ trunk/src/conf.c	2014-01-15 20:28:10 UTC (rev 243)
@@ -186,6 +186,7 @@
     memset(denied, 0x00, sizeof(struct denied_address));
     denied->mask = mask;
     denied->port = port;
+    list_head_init(&denied->list);
 
     if(inet_pton(AF_INET, addr, denied->addr) != 1)
     {

Modified: trunk/src/turnserver.c
===================================================================
--- trunk/src/turnserver.c	2013-12-21 20:36:38 UTC (rev 242)
+++ trunk/src/turnserver.c	2014-01-15 20:28:10 UTC (rev 243)
@@ -3484,8 +3484,8 @@
         debug(DBG_ATTR, "Hash mismatch\n");
 #ifndef NDEBUG
         /* print computed hash and the one from the message */
-        digest_print(hash, 20);
-        digest_print(message.message_integrity->turn_attr_hmac, 20);
+        crypto_digest_print(hash, 20);
+        crypto_digest_print(message.message_integrity->turn_attr_hmac, 20);
 #endif
         turn_generate_nonce(nonce, sizeof(nonce), (unsigned char*)nonce_key,
             strlen(nonce_key));
@@ -5018,6 +5018,12 @@
   char* listen_addr = NULL;
   struct sigaction sa;
 
+  /* initialize cryptographic seed for systems which do not have /dev/urandom */
+  if(crypto_seed_prng_init() == -1)
+  {
+    debug(DBG_ATTR, "Warning cryptographic seed not strong\n");
+  }
+
   /* initialize lists */
   list_head_init(&allocation_list);
   list_head_init(&account_list);
@@ -5657,6 +5663,8 @@
   /* free the configuration parser */
   turnserver_cfg_free();
 
+  crypto_seed_prng_cleanup();
+
   return EXIT_SUCCESS;
 }
 

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Turnserver-devel] SF.net SVN: turnserver:[244] trunk/src

[<s-v...@us...>]

Revision: 244
          http://sourceforge.net/p/turnserver/code/244
Author:   s-vincent
Date:     2014-01-15 20:46:52 +0000 (Wed, 15 Jan 2014)
Log Message:
-----------
Fixes calls of list_head_add/remove (intervert arguments since refactoring).

Modified Paths:
--------------
    trunk/src/account.c
    trunk/src/allocation.c
    trunk/src/conf.c
    trunk/src/mod_tmpuser.c
    trunk/src/turnserver.c

Modified: trunk/src/account.c
===================================================================
--- trunk/src/account.c	2014-01-15 20:28:10 UTC (rev 243)
+++ trunk/src/account.c	2014-01-15 20:46:52 UTC (rev 244)
@@ -72,7 +72,6 @@
   ret->state = state;
   ret->allocations = 0;
   ret->is_tmp = 0;
-  list_head_init(&ret->list);
 
   turn_calculate_authentication_key(username, realm, password, ret->key,
       sizeof(ret->key));
@@ -130,7 +129,7 @@
 
 void account_list_add(struct list_head* list, struct account_desc* desc)
 {
-  list_head_add(&desc->list, list);
+  list_head_add(list, &desc->list);
 }
 
 void account_list_remove(struct list_head* list, struct account_desc* desc)

Modified: trunk/src/allocation.c
===================================================================
--- trunk/src/allocation.c	2014-01-15 20:28:10 UTC (rev 243)
+++ trunk/src/allocation.c	2014-01-15 20:46:52 UTC (rev 244)
@@ -341,7 +341,7 @@
   allocation_permission_set_timer(ret, lifetime);
 
   /* add to the list */
-  list_head_add(&ret->list, &desc->peers_permissions);
+  list_head_add(&desc->peers_permissions, &ret->list);
   list_head_init(&ret->list2);
   return 0;
 }
@@ -421,7 +421,7 @@
   allocation_channel_set_timer(ret, lifetime);
 
   /* add to the list */
-  list_head_add(&ret->list, &desc->peers_channels);
+  list_head_add(&desc->peers_channels, &ret->list);
   list_head_init(&ret->list2);
   return 0;
 }
@@ -481,7 +481,7 @@
 
 void allocation_list_add(struct list_head* list, struct allocation_desc* desc)
 {
-  list_head_add_tail(&desc->list, list);
+  list_head_add_tail(list, &desc->list);
 }
 
 void allocation_list_remove(struct list_head* list,
@@ -642,7 +642,7 @@
   allocation_tcp_relay_set_timer(ret, timeout);
 
   /* add to the list */
-  list_head_add(&ret->list, &desc->tcp_relays);
+  list_head_add(&desc->tcp_relays, &ret->list);
   list_head_init(&ret->list2);
   return 0;
 }
@@ -806,7 +806,7 @@
 void allocation_token_list_add(struct list_head* list,
     struct allocation_token* token)
 {
-  list_head_add(&token->list, list);
+  list_head_add(list, &token->list);
 }
 
 void allocation_token_list_remove(struct list_head* list,

Modified: trunk/src/conf.c
===================================================================
--- trunk/src/conf.c	2014-01-15 20:28:10 UTC (rev 243)
+++ trunk/src/conf.c	2014-01-15 20:46:52 UTC (rev 244)
@@ -186,7 +186,6 @@
     memset(denied, 0x00, sizeof(struct denied_address));
     denied->mask = mask;
     denied->port = port;
-    list_head_init(&denied->list);
 
     if(inet_pton(AF_INET, addr, denied->addr) != 1)
     {
@@ -219,7 +218,7 @@
     }
 
     /* add to the list */
-    list_head_add(&denied->list, denied_address_list);
+    list_head_add(denied_address_list, &denied->list);
   }
 
   return 0;

Modified: trunk/src/mod_tmpuser.c
===================================================================
--- trunk/src/mod_tmpuser.c	2014-01-15 20:28:10 UTC (rev 243)
+++ trunk/src/mod_tmpuser.c	2014-01-15 20:46:52 UTC (rev 244)
@@ -172,7 +172,7 @@
 void tmpuser_add_tcp_client(struct socket_desc* desc)
 {
   struct list_head* l = (struct list_head*)&desc->list;
-  list_head_add(l, &g_tmpuser.client_list);
+  list_head_add(&g_tmpuser.client_list, l);
 }
 
 void tmpuser_remove_tcp_client(struct socket_desc* desc)

Modified: trunk/src/turnserver.c
===================================================================
--- trunk/src/turnserver.c	2014-01-15 20:28:10 UTC (rev 243)
+++ trunk/src/turnserver.c	2014-01-15 20:46:52 UTC (rev 244)
@@ -265,7 +265,7 @@
     /* add it to the expired list, the next loop will
      * purge it
      */
-    list_head_add(&desc->list2, &g_expired_allocation_list);
+    list_head_add(&g_expired_allocation_list, &desc->list2);
   }
   else if(signo == SIGRT_EXPIRE_PERMISSION)
   {
@@ -278,7 +278,7 @@
 
     debug(DBG_ATTR, "Permission expires: %p\n", desc);
     /* add it to the expired list */
-    list_head_add(&desc->list2, &g_expired_permission_list);
+    list_head_add(&g_expired_permission_list, &desc->list2);
   }
   else if(signo == SIGRT_EXPIRE_CHANNEL)
   {
@@ -291,7 +291,7 @@
 
     debug(DBG_ATTR, "Channel expires: %p\n", desc);
     /* add it to the expired list */
-    list_head_add(&desc->list2, &g_expired_channel_list);
+    list_head_add(&g_expired_channel_list, &desc->list2);
   }
   else if(signo == SIGRT_EXPIRE_TOKEN)
   {
@@ -304,7 +304,7 @@
 
     debug(DBG_ATTR, "Token expires: %p\n", desc);
     /* add it to the expired list */
-    list_head_add(&desc->list2, &g_expired_token_list);
+    list_head_add(&g_expired_token_list, &desc->list2);
   }
   else if(signo == SIGRT_EXPIRE_TCP_RELAY)
   {
@@ -317,7 +317,7 @@
 
     /* remove relay from list */
     debug(DBG_ATTR, "TCP relay expires: %p\n", desc);
-    list_head_add(&desc->list2, &g_expired_tcp_relay_list);
+    list_head_add(&g_expired_tcp_relay_list, &desc->list2);
   }
 }
 
@@ -4249,7 +4249,7 @@
         sdesc->sock = rsock;
 
         /* add it to the list */
-        list_head_add(&sdesc->list, tcp_socket_list);
+        list_head_add(tcp_socket_list, &sdesc->list);
       }
     }
   }

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.