1 files changed, 32 insertions, 25 deletions

diff --git a/ot_vector.c b/ot_vector.c
index 7f18246..a56d55b 100644
--- a/ot_vector.c
+++ b/ot_vector.c
@@ -19,7 +19,7 @@ static int vector_compare_peer4(const void *peer1, const void *peer2) { return m
    no exact match is found. In that case it sets exactmatch 0 and gives
    calling functions the chance to insert data
 */
-void *binary_search(const void *const key, const void *base, const size_t member_count, const size_t member_size, size_t compare_size, int *exactmatch) {
+void *vector_binary_search(const void *const key, const void *base, const size_t member_count, const size_t member_size, size_t compare_size, int *exactmatch) {
   size_t interval = member_count;
 
   while (interval) {
@@ -50,70 +50,75 @@ static uint8_t vector_hash_peer(ot_peer const *peer, size_t compare_size, size_t
 
 /* This is the generic insert operation for our vector type.
    It tries to locate the object at "key" with size "member_size" by comparing its first "compare_size" bytes with
-   those of objects in vector. Our special "binary_search" function does that and either returns the match or a
+   those of objects in vector. Our special "vector_binary_search" function does that and either returns the match or a
    pointer to where the object is to be inserted. vector_find_or_insert makes space for the object and copies it,
    if it wasn't found in vector. Caller needs to check the passed "exactmatch" variable to see, whether an insert
    took place. If resizing the vector failed, NULL is returned, else the pointer to the object in vector.
 */
 void *vector_find_or_insert(ot_vector *vector, void *key, size_t member_size, size_t compare_size, int *exactmatch) {
-  uint8_t *match = binary_search(key, vector->data, vector->size, member_size, compare_size, exactmatch);
+  uint8_t *match = vector_binary_search(key, vector->data, vector->size, member_size, compare_size, exactmatch);
+  size_t   match_offset, bytes_after;
 
   if (*exactmatch)
     return match;
 
+  /* Hold the insertion point as an offset rather than a pointer: it survives
+     the realloc below, and an empty vector has no data pointer to offset from
+     in the first place */
+  match_offset = vector->size ? (size_t)(match - (uint8_t *)vector->data) : 0;
+  bytes_after  = member_size * vector->size - match_offset;
+
   if (vector->size + 1 > vector->space) {
-    size_t    new_space = vector->space ? OT_VECTOR_GROW_RATIO * vector->space : OT_VECTOR_MIN_MEMBERS;
-    ptrdiff_t match_off = match - (uint8_t *)vector->data;
-    uint8_t  *new_data  = realloc(vector->data, new_space * member_size);
+    size_t   new_space = vector->space ? OT_VECTOR_GROW_RATIO * vector->space : OT_VECTOR_MIN_MEMBERS;
+    uint8_t *new_data  = realloc(vector->data, new_space * member_size);
 
     if (!new_data)
       return NULL;
 
-    /* Adjust pointer if it moved by realloc */
-    match         = new_data + match_off;
-
     vector->data  = new_data;
     vector->space = new_space;
   }
-  memmove(match + member_size, match, ((uint8_t *)vector->data) + member_size * vector->size - match);
+
+  match = (uint8_t *)vector->data + match_offset;
+  memmove(match + member_size, match, bytes_after);
 
   vector->size++;
   return match;
 }
 
 ot_peer *vector_find_or_insert_peer(ot_vector *vector, ot_peer const *peer, size_t peer_size, int *exactmatch) {
-  ot_peer     *match, *end;
+  ot_peer     *match;
   const size_t compare_size = OT_PEER_COMPARE_SIZE_FROM_PEER_SIZE(peer_size);
-  size_t       match_to_end;
+  size_t       match_offset, bytes_after;
 
   /* If space is zero but size is set, we're dealing with a list of vector->size buckets */
   if (vector->space < vector->size)
     vector = ((ot_vector *)vector->data) + vector_hash_peer(peer, compare_size, vector->size);
-  match = binary_search(peer, vector->data, vector->size, peer_size, compare_size, exactmatch);
+  match = vector_binary_search(peer, vector->data, vector->size, peer_size, compare_size, exactmatch);
 
   if (*exactmatch)
     return match;
 
-  /* This is the amount of bytes that needs to be pushed backwards by peer_size bytes to make room for new peer */
-  end          = (ot_peer *)vector->data + vector->size * peer_size;
-  match_to_end = end - match;
+  /* Hold the insertion point as an offset rather than a pointer: it survives
+     the realloc below, and an empty vector has no data pointer to offset from
+     in the first place. bytes_after is what has to move up by peer_size to
+     make room for the new peer */
+  match_offset = vector->size ? (size_t)(match - (ot_peer *)vector->data) : 0;
+  bytes_after  = vector->size * peer_size - match_offset;
 
   if (vector->size + 1 > vector->space) {
-    ptrdiff_t offset    = match - (ot_peer *)vector->data;
-    size_t    new_space = vector->space ? OT_VECTOR_GROW_RATIO * vector->space : OT_VECTOR_MIN_MEMBERS;
-    ot_peer  *new_data  = realloc(vector->data, new_space * peer_size);
+    size_t   new_space = vector->space ? OT_VECTOR_GROW_RATIO * vector->space : OT_VECTOR_MIN_MEMBERS;
+    ot_peer *new_data  = realloc(vector->data, new_space * peer_size);
 
     if (!new_data)
       return NULL;
-    /* Adjust pointer if it moved by realloc */
-    match         = new_data + offset;
 
     vector->data  = new_data;
     vector->space = new_space;
   }
 
-  /* Here we're guaranteed to have enough space in vector to move the block of peers after insertion point */
-  memmove(match + peer_size, match, match_to_end);
+  match = (ot_peer *)vector->data + match_offset;
+  memmove(match + peer_size, match, bytes_after);
 
   vector->size++;
   return match;
@@ -137,7 +142,7 @@ int vector_remove_peer(ot_vector *vector, ot_peer const *peer, size_t peer_size)
     vector = ((ot_vector *)vector->data) + vector_hash_peer(peer, compare_size, vector->size);
 
   end   = ((ot_peer *)vector->data) + peer_size * vector->size;
-  match = (ot_peer *)binary_search(peer, vector->data, vector->size, peer_size, compare_size, &exactmatch);
+  match = (ot_peer *)vector_binary_search(peer, vector->data, vector->size, peer_size, compare_size, &exactmatch);
   if (!exactmatch)
     return 0;
 
@@ -150,11 +155,13 @@ int vector_remove_peer(ot_vector *vector, ot_peer const *peer, size_t peer_size)
 }
 
 void vector_remove_torrent(ot_vector *vector, ot_torrent *match) {
-  ot_torrent *end = ((ot_torrent *)vector->data) + vector->size;
+  ot_torrent *end;
 
   if (!vector->size)
     return;
 
+  end = ((ot_torrent *)vector->data) + vector->size;
+
   free_peerlist(match->peer_list6);
   free_peerlist(match->peer_list4);