/* tcpread.c
 *    Copyright Acquisition group, GANIL Caen, France
 *
 *     Fonction :Lecture d'un Buffer de donnee sur un socket
 *
 *    Syntaxe    :int TcpRead(sid_pt,buffer,lg_buffer,lg_recu_pt,timeout).
 *
 *    Entree    :int *sid_pt, indentificateur du socket a lire.
 *
 *        :char Buffer[], Buffer du flot des donnes lues sur le reseau.
 *
 *        :int lg_buffer, longueur du buffer de lecture (Nombre de 
 *         caracteres attendu).
 *
 *        :long timeout (en unite de 0.2 seconde), tcpread attend les 
 *         donnees durant ce laps de temps.
 *
 *    Sortie    :char Buffer[], Buffer du flot des donnes lues sur le reseau.
 *
 *        :int *lg_recu_pt, pointeur sur le nombre de donnees lues.
 *
 *        :int TcpRead(), retourne le code de l'erreur de lecture.
*/

#define _TCPREAD_

#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <sys/types.h>

#ifdef __Lynx__
#include <socket.h>
#include <resource.h>
#include <time.h>
#else
#include <sys/socket.h>
#include <sys/resource.h>
#include <sys/time.h>
#endif

#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/times.h>

#ifndef __Lynx__
#include <sys/param.h>
#else
#include <param.h>
#endif

#include "TCP.h"
#include "TCP_err.h"

extern int TcpWind;

int TcpRead ( int *  sid_pt,
              char * buffer,
              int    lg_buffer,
              int *  lg_recu_pt,
              long   timeout )
{
  int nb_car;
  int LongEnUneFois;
  int err = 0;
  fd_set ready;        /* pour select */
  struct timeval tout;

  int j;
  int jmax;
  char * ptr;

  ptr = buffer;

  if (lg_recu_pt == (int *)0) return(R_TCP_LGBUF);

  *lg_recu_pt = 0;

  if (TcpWind <= 0) TcpWind = WINDOW;

  /* On test si la longueur du buffer est valide */
  if (lg_buffer < 0) return(R_TCP_LGBUF);

  err = 0;

  do
  {
    /* Decoupage du Buffer en Blocs de longeuur <= TcpWind.*/
    if (lg_buffer > TcpWind) LongEnUneFois = TcpWind;
    else LongEnUneFois = lg_buffer;

    if (timeout != 0)
    {
      FD_ZERO(&ready);
      FD_SET(*sid_pt,&ready);
      tout.tv_sec = timeout / 5;
      tout.tv_usec = (timeout % 5) * 200 * 1000;

      if (select((*sid_pt)+1,&ready,(fd_set *)0,(fd_set *)0,&tout) < 0) return(R_TCP_TIMEOUT);

      if (!(FD_ISSET(*sid_pt,&ready))) return(R_TCP_TIMEOUT);
    }

    /* Si erreur de lecture >> sort en retournant le code d'erreur */

    nb_car = recv(*sid_pt,buffer,LongEnUneFois,0);

// printf("recv returns %d; len=%d\n",nb_car,LongEnUneFois);

    if ( nb_car < 0 )
    {
      /* bug LynxOS 2.1 : recv() retourne 0 au lieu de -1 */
          /* quand la connexion est cassee a l'autre bout     */
      err = R_TCP_READ;
    }
    else
    {
      *lg_recu_pt += nb_car;    /* Mise a jour du nbr. d'octets recus */
      buffer += nb_car;    /* Mise a jour du ptr de depart du Buffer */
      lg_buffer -= nb_car;    /* Mise a jour de la taille du Buffer */
    }

  } while((lg_buffer != 0) && (err == 0));

/*
printf("TcpRead returns len=%d\n",*lg_recu_pt);

 jmax = *lg_recu_pt;
 if (jmax > 64) jmax=64;

    for (j = 0; j < jmax;) {
        printf(" 0x%02x", ptr[j]);
        j++;
        if ((j/8)*8 == j) printf("\n");
    }
    printf("\n");
*/

  return(err);
}