Modification de chaine passée en paramètre non prise en compte

Bonjour,

J'ai eu un projet à faire pour mon école, projet que je n'ai pas pu rendre fonctionnel à cause d'un soucis que je n'ai pas réussi à régler.
Ce projet consistait en la réalisation d'une fonction modifiant une chaîne en passant un (char **) en paramètre, or cette modification semble bien avoir eu lieu dans la fonction mais à l'extérieur c'est comme si rien ne s'était passé.
Je crée donc dans mon main de test un (char *) que je nomme str, je passe donc &str en paramètre de la fonction à tester.
Dans la fonction à tester; je commençais par réallouer de la mémoire au char ** passé en paramètre, puis au char * pointé par le char ** précédent.
Dans le prototype de la fonction, le char ** s'appelle line.
J'alloue donc de la mémoire à line, puis à *line

Chose curieuse, je n'arrive pas à utiliser la notation *line[index], même après allocation de mémoire, cette notation entraîne automatiquement un segfault.

Ensuite la copie s'effectue de la manière suivante :
*(*line + index) = *(buffer + index);
(où buffer est un char *)

Bien entendu il y a autour de cela les boucles et instructions nécessaires au bon fonctionnement de la fonction, mais je pense que le problème se situe dans la forme par laquelle je fais la copie.

à la sortie de la fonction; lorsque j'essaie de lire la chaine que je devrais avoir modifié, j'ai un segfault, apparement elle n'a pas du tout été modifiée.

J'aimerais donc comprende d'où vient l'erreur et si possible comment la corriger. J'aimerais aussi comprendre pourquoi j'ai un segfault en utilisant la notation avec les crochets.

BUF_SIZE est défini dans le header get_next_line.h.

Je vous donne cependant à côté de cela la source de la fonction :

#include <stdlib.h>
#include <unistd.h>
#include "get_next_line.h"
#include "libft.h"

static int empty_buf(char **buffer, int size, char **line);

int   get_next_line(int const fd, char **line)
{
 char *buffer;
 int  size;
 int  index;
 int  counter;

 size = 0;
 buffer = (char *) malloc(sizeof(char) * BUF_SIZE);
 index = update_buf(fd, &buffer, BUF_SIZE);
 while (index >= 0)
 {
  if (index == 0)
  {
   line = (char **) ft_realloc((void **) line, size, size + BUF_SIZE);
/* ft_realloc augmente la taille en conservant les char déjà entrés */
   size = size + BUF_SIZE;
  }
/* c'est ici que la copie se fait */
  *(*line + size + index - BUF_SIZE) = *(buffer + index); 
               ft_putchar(*(*line + size + index - BUF_SIZE));
  index = update_buf(fd, &buffer, index); /*update_buf renvoie l'index suivant, et met à jour le buffer le cas échéant. */
 }
 if (index == (- 1) || index == (- 2))
 {
  counter = 0;
  while (*(buffer + counter) != '\n')
   counter = counter + 1;
  line = (char **) ft_realloc((void **) line, size, size + counter);
  counter = empty_buf(&buffer, size, line);
 }
 return (index + 2);
}

static int empty_buf(char **buffer, int size, char **line)
{
 int  index;

 index = 0;
 while (*(*buffer + index) != '\n')
  index = index + 1;
 line = (char **) ft_realloc((void **) line, size, size + index);
 index = 0;
 while (*(*buffer + index) != '\n')
 {
  *(*line + size + index) = *(*buffer + index);
  index = index + 1;
 }
 return (index);
}

int   update_buf(const int fd, char **buffer, int index)
{
 int  counter;
 int  result;

 if (index < BUF_SIZE - 1)
 {
  return (index + 1);
 }
 counter = 0;
 while (counter < BUF_SIZE)
 {
  result = read(fd, (char *) (*buffer + counter), 1);
  if (*(*buffer + counter) == '\n')
   return (- 1);
  if (result == 0)
  {
   *(*buffer + counter) = '\n';
   return (- 2);
  }
  if (result == (- 1))
   return (- 3);
  counter = counter + 1;
 }
 ft_putstr(" fub_etadpu ");
 return (0);
}

void  **ft_realloc(void **ptr, size_t prev_size, size_t size)
{
 unsigned char **src;
 unsigned char **dst;
 int    counter;

 src = (unsigned char **) ptr;
 dst = (unsigned char **) malloc(sizeof(unsigned char) * size);
 *dst = (unsigned char *) malloc(sizeof(unsigned char) * size);
 counter = 0;
 while (counter < (int) prev_size)
 {
  *(*dst + counter) = *(*src + counter);
  counter = counter + 1;
 }
 return ((void **) dst);
}

!
Je vous remercie par avance pour votre aide