/* tcpwrite.c
 *    Copyright Acquisition group, GANIL Caen, France
 *
 *     Fonction :Ecriture d'un Buffer de donnee sur un socket,
 *          dans la limite d'un Timeout.
 *
 *    Syntaxe    :int TcpWrite(sid_pt,buffer,lg_buffer,lg_ecrit_pt,timeout).
 *    
 *    Entree    :int *sid_pt, indentificateur du socket a Ecrire.
 *
 *        :int lg_buffer, longueur du buffer a transmettre.
 *
 *        :long timeout (en unite de 0.2 seconde), TcpWrite tente d'
 *         ecrire les donnees durant ce laps de temps.
 *
 *               :char Buffer[], Buffer du flot des donnes a ecrire.
 *
 *    Sortie     :int *lg_ecrit_pt, pointeur sur le nombre de donnees ecrites.
 *
 *        :int TcpWrite(), retourne le code de l'erreur d'ecriture.
*/

#define _TCPWRITE_

#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 TcpWrite ( int *  sid_pt,
               char * buffer,
               int    lg_buffer,
               int *  lg_ecrit_pt,
               long   timeout )
{
  int nb_car;
  int LongEnUneFois;
  int err;
  fd_set ready;        /* pour select */
  struct timeval tout;
  char *buf;

  int j;
  int jmax;
  char * ptr;

  ptr = buffer;

  buf = buffer;

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

  *lg_ecrit_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;

/*
printf("TcpWrite requests len=%d\n",lg_buffer);

 jmax = lg_buffer;
 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");
*/

  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,(fd_set *)0,&ready,(fd_set *)0,&tout) < 0) return(R_TCP_TIMEOUT);

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

    /* Si erreur d'ecriture >> sort en retournant le code d'erreur */
    if ((nb_car = send(*sid_pt,buffer,LongEnUneFois,0)) < 0)
    {
      printf("TcpWrite() : send() returns %d with errno=%d\n",nb_car,errno);

      if (errno != EWOULDBLOCK) return(R_TCP_WRITE);
    }
    else
    {
      *lg_ecrit_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));

  return(err);
}