typescript – mantener conexion con socket creado con c

estoy tratando de aprender c, tengo las bases y decidí meter mano y crear una conexion mediate socket para tener comunicado el servidor y el cliente, estoy tratando de crear una simple app donde pueda manejar redes sociales mediate la api correspondiente de dicha red social, este es mi servidor que escribi con c

/* server parameters */
#define SERV_PORT 8080                /* port */
#define SERV_HOST_ADDR "192.168.1.47" /* IP, only IPV4 support  */
#define BUF_SIZE 100                  /* Buffer rx, tx max size  */
#define BACKLOG 5                     /* Max. client pending connections  */

int main(int argc, char *argv()) /* input arguments are not used */
{
  int sockfd, connfd; /* listening socket and connection socket file descriptors */
  unsigned int len;   /* length of client address */
  struct sockaddr_in servaddr, client;

  int len_rx, len_tx = 0; /* received and sent length, in bytes */
  char buff_tx(BUF_SIZE) = "Hello client, I am the server";
  char buff_rx(BUF_SIZE); /* buffers for reception  */

  /* socket creation */
  sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd == -1)
  {
    fprintf(stderr, "(SERVER-error): socket creation failed. %d: %s n", errno, strerror(errno));
    return -1;
  }
  else
  {
    printf("(SERVER): Socket successfully created..n");
  }

  /* clear structure */
  memset(&servaddr, 0, sizeof(servaddr));

  /* assign IP, SERV_PORT, IPV4 */
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = inet_addr(SERV_HOST_ADDR);
  servaddr.sin_port = htons(SERV_PORT);

  /* Bind socket */
  if ((bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr))) != 0)
  {
    fprintf(stderr, "(SERVER-error): socket bind failed. %d: %s n", errno, strerror(errno));
    return -1;
  }
  else
  {
    printf("(SERVER): Socket successfully binded n");
  }

  /* Listen */
  if ((listen(sockfd, BACKLOG)) != 0)
  {
    fprintf(stderr, "(SERVER-error): socket listen failed. %d: %s n", errno, strerror(errno));
    return -1;
  }
  else
  {
    printf("(SERVER): Listening on SERV_PORT %d nn", ntohs(servaddr.sin_port));
  }

  len = sizeof(client);

  /* Accept the data from incoming sockets in a iterative way */
  while (1)
  {
    connfd = accept(sockfd, (struct sockaddr *)&client, &len);
    if (connfd < 0)
    {
      fprintf(stderr, "(SERVER-error): connection not accepted. %d: %s n", errno, strerror(errno));
      return -1;
    }
    else
    {
      while (1) /* read data from a client socket till it is closed */
      {
        /* read client message, copy it into buffer */
        len_rx = read(connfd, buff_rx, sizeof(buff_rx));

        if (len_rx == -1)
        {
          fprintf(stderr, "(SERVER-error): connfd cannot be read. %d: %s n", errno, strerror(errno));
        }
        else if (len_rx == 0) /* if length is 0 client socket closed, then exit */
        {
          printf("(SERVER): client socket closed nn");
          close(connfd);
          break;
        }
        else
        {
          write(connfd, buff_tx, strlen(buff_tx));
          printf("(SERVER): %s n", buff_rx);
        }
      }
    }
  }
}

el cliente esta echo con react native, cree un contexto donde conecto el cliente con el server

const context = createContext<IContext | null>(null)

export function SocketIoProvider({ children }: Props) {

  const (socket, setSocket) = useState<Socket | null>(null)

  useEffect(() => {
    const SOCKET_URL = process.env.SOCKET_URL || "ws://192.168.1.47:8080"
    const socket = io(SOCKET_URL)
    setSocket(socket)
  }, ())

  const value = useMemo(() => ({
    socket: socket!
  }), (socket))

  return (
    <context.Provider value={value}>
      {children}
    </context.Provider>
  )
}

al parecer la conexión se realizar, cuando se monta el componente de react lanza la conexión y envía datos al server y los puedo visualizar en la consola, pero luego por algún motivo se desconecta,