#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <signal.h>
#include <stdio.h>
#include <tai.h>
#include <time.h>

#define COM_BULL "com_bull.conf" /* nom du fichier de configuration */
#define ENTETE_MESSAGE_DPS7 "TCT01 " /* entête du msg transmis au dps7 */
#define ERREUR_SYSTEME "2" /* erreur remontée à la tache UNIX */   
#define FIN_TRANSACTION "1\n" /* fin de la transaction avec le dps7 */
#define SUITE_TRANSACTION "0\n" /* suite de la transaction avec le dps7 */
#define AUTRE_ECRAN '0' /* transaction avec le dps7 non terminée */
#define TIMEOUT_MSGSND 2 /* attente de file bloquée */
#define TIMEOUT_MSGRCV 5 /* attente de file bloquée */
#define TIMEOUT_READ 5 /* attente d'une réponse du dps7 */
#define DELAI5 5 /* de 5 secondes */
#define DELAI10 10 /* de 10 secondes */
#define LG_BUFFER_EMI 2000 /* longueur du buffer d'émission */
#define LG_BUFFER_REC 2000 /* longueur du buffer de réception */
#define HEURE_SEM 17 /* heure d'arrêt en semaine */
#define MIN_SEM 25 /* minute d'arrêt en semaine */
#define HEURE_VEN 11 /* heure d'arrêt vendredi */
#define MIN_VEN 50 /* minute d'arrêt vendredi */


struct tdc st_tdc;

struct cnftgt st_cnftgt;

int  i_msqin;
int  i_msqout;
void alarme();
char ch_buffer[132];
int  i_buffer;
extern int  errno;
struct msqid_ds  st_msqds,*BUF_IPC_STAT;
struct t_st_msg {
    long mtype;
    char mtext[128];
    }st_msgin,st_msgout;
char buf_emi[LG_BUFFER_EMI];
char buf_rec[LG_BUFFER_REC];
int  i_bufrec = 0;
int  lg_bufrec = 0;

int jour, heure, min;
struct tm *recup_heure;

main(argc,argv)
int  argc;
char **argv;
{
char ch[LG_BUFFER_REC];
int  traite=0;
BUF_IPC_STAT = &st_msqds;
setpgrp();
/*
vérification de la non existence d'une tache servdps7
*/
/*
if ( system("ps -ef | grep servdps7 | wc -l | grep '  3' >/dev/null") != 0 )
  {
  printf("Le serveur DPS7 est déjà lancé\n");
  exit(-1);
  }
*/


/*
création des files d'attente de communication entre les tâches UNIX et
servdps7
*/
if ( creer_file() == -1 )
  {
  printf("servdps7 : arrêt de servdps7\n");
  exit(-1);
  }

/*
strcpy(ch_correspondant,argv[1]);
strcpy(ch_utilisateur,argv[2]);
strcpy(ch_projet,argv[3]);
strcpy(ch_motpasse,argv[4]);
*/

/*
contrôle connexion au tds 
positionnement d'une fonction de déroutage pour autoriser les time out
*/
signal(SIGALRM,alarme);
if (connexion()==0)
  {
  connectdatanet("PROG1","COMBULL"," ","COMBULL1");
  
  if (testconnect()==1)
    {
    do
    {
    #ifdef TEST
    printf("\nboucle main: début traite_question\n");
    #endif
    traite = traiter_question();
    #ifdef TEST
    printf("boucle main: fin traite_question = %d\n",traite);
    #endif
    } while(traite != -1);
    }
  }
supprimer_file();
deconnexion();
}


int  test_heure_arret()
{
time_t heure;
time(&heure);
recup_heure = localtime(&heure);

jour = recup_heure->tm_wday;
heure = recup_heure->tm_hour;
min = recup_heure->tm_min;

if  ((jour == 5 && heure == HEURE_VEN && min >= MIN_VEN) ||
   (jour != 5 && heure == HEURE_SEM && min >= MIN_SEM))
  {
  #ifdef TEST
  printf("\n*** IL EST %d H %d MN : ARRET DU SERVEUR ***\n",heure,min);
  #endif
  return(1);

  }
else {
  #ifdef TEST
  printf("\n*** IL EST %d H %d MN : ***\n",heure,min);
  #endif
  return(0);
  }
}


int  deconnexion()
{
if (envoi("$*$dis") != 0)
  {
  #ifdef TEST
  printf("déconnexion :pb envoi $*$dis\n");
  #endif
  }
if (lit_jusqua("$$ 0900")!=0)
  {
  #ifdef TEST
  printf("déconnexion :pb lit_jusqua $$0900\n");
  #endif
  }
tclose(&st_tdc);
if (st_tdc.cr_exec != 0 )
  {
  #ifdef TEST
  printf("déconnexion :pb tclose\n");
printf("déconnexion :cr_exec = %d\n",st_tdc.cr_exec);
  #endif
  sleep(2);
  return(-1);
  }
return(0);
}

int  connexion()
{
FILE *fp;
char ch_libelle[32];
int  i;

fp = fopen(COM_BULL,"r");
if ( fp == NULL )
  {
#ifdef TEST
  printf("servdps7 : ouverture du fichier %s impossible\n",COM_BULL);
#endif
  return(-1);
  }
fscanf(fp,"%s %s\n",ch_libelle,st_tdc.typ_tam);
fscanf(fp,"%s %d\n",ch_libelle,&st_tdc.delai);
fscanf(fp,"%s %d\n",ch_libelle,&st_cnftgt.as_ae);
fscanf(fp,"%s %d\n",ch_libelle,&st_cnftgt.adremet1);
fscanf(fp,"%s %x\n",ch_libelle,&st_cnftgt.adremet2);
fscanf(fp,"%s %d\n",ch_libelle,&st_cnftgt.typemet1);
fscanf(fp,"%s %d\n",ch_libelle,&st_cnftgt.typemet2);
fscanf(fp,"%s %x\n",ch_libelle,&st_cnftgt.symbole);
fscanf(fp,"%s %d\n",ch_libelle,&st_cnftgt.lngpage);
fscanf(fp,"%s %d\n",ch_libelle,&st_cnftgt.lngligne);
fscanf(fp,"%s %x\n",ch_libelle,&st_cnftgt.modclas);
fscanf(fp,"%s %x\n",ch_libelle,&st_cnftgt.typappar);
fscanf(fp,"%s %d\n",ch_libelle,&st_cnftgt.lgadresse);
fscanf(fp,"%s %s\n",ch_libelle,st_cnftgt.adrtpac);
fscanf(fp,"%s %d\n",ch_libelle,&st_cnftgt.lgfacilitie);
fscanf(fp,"%s %s\n",ch_libelle,st_cnftgt.facil);
fscanf(fp,"%s %x\n",ch_libelle,&st_cnftgt.numcv);
fscanf(fp,"%s %d\n",ch_libelle,&st_cnftgt.indicseg);
fclose(fp);
#ifdef TEST
printf("servdps7 : typ_tam = %s\n",st_tdc.typ_tam);
printf("servdps7 : delai = %d\n",st_tdc.delai);
printf("servdps7 : as_ae = %d\n",st_cnftgt.as_ae);
printf("servdps7 : adremet1 = %d\n",st_cnftgt.adremet1);
printf("servdps7 : adremet2 = 0x%x\n",st_cnftgt.adremet2);
printf("servdps7 : typemet1 = %d\n",st_cnftgt.typemet1);
printf("servdps7 : typemet2 = %d\n",st_cnftgt.typemet2);
printf("servdps7 : symbole = 0x%x\n",st_cnftgt.symbole);
printf("servdps7 : lngpage = %d\n",st_cnftgt.lngpage);
printf("servdps7 : lngligne = %d\n",st_cnftgt.lngligne);
printf("servdps7 : modclas = 0x%x\n",st_cnftgt.modclas);
printf("servdps7 : typappar = 0x%x\n",st_cnftgt.typappar);
printf("servdps7 : lgadresse = %d\n",st_cnftgt.lgadresse);
printf("servdps7 : adrtpac = %s\n",st_cnftgt.adrtpac);
printf("servdps7 : lgfacilitie = %d\n",st_cnftgt.lgfacilitie);
printf("servdps7 : facil = %s\n",st_cnftgt.facil);
printf("servdps7 : numcv = 0x%x\n",st_cnftgt.numcv);
printf("servdps7 : indicseg = %d\n",st_cnftgt.indicseg);
#endif
st_tdc.lg_emi = LG_BUFFER_EMI;
st_tdc.lg_rec = LG_BUFFER_REC;
st_tdc.delai = DELAI10;
topen(&st_tdc,&st_cnftgt);
st_tdc.delai = DELAI5;
if (st_tdc.cr_exec != 0 )
  {
  #ifdef TEST
  printf("servdps7 : erreur à la connexion\n");
  printf("servdps7 : cr_exec = %d\n",st_tdc.cr_exec);
  #endif
  return(-1);
  }
  else
  {
  return(0);
  }
}

int connectdatanet(mailbox,util,proj,passe)
char *mailbox;
char *util;
char *proj;
char *passe;
{ 
char ch[LG_BUFFER_REC];
 if (!lit_jusqua("$$ 4700"))
  { do
   envoi(" ");
  while(!lit_jusqua("$*$"));
  envoi("CN");
  lit(ch);}
 envoi(mailbox);
 lit(ch);
 envoi(util);
 lit(ch);
 envoi(proj);
 lit(ch);
 envoi(passe);
}

int testconnect(void)
{
char ch[LG_BUFFER_REC];
 lit(ch);
 if (strstr(ch,"$$ 0100"))
  {
  #ifdef TEST
    printf("testconnect : OK :$$ 0100 recu \n");
  #endif
  lit(ch);
  if (strstr(ch,"ACCUEIL")==0)
   {printf("On est d_j_ dans une transaction\n");
   envoi("1");
   lit(ch); }
  else
   {envoi("$*$brk");
   lit(ch);
   envoi("$*$brk");
   lit_jusqua("BREAK"); }
  return(1);
  }
 else
  { printf("Erreur controle d'accès : (%s)\n",ch);
   if (strstr(ch,"CONNEXION REFUSEE")!=0)
    {
    #ifdef TEST
    printf("CONNEXION REFUSEE -> analyse \n");
    if (strstr(ch,"004")!=0)
    printf("CONNEXION REFUSEE : TRANSACTIONNEL NON LANCE\n"); 
    #endif
    }
   lit_jusqua("$$$");
  return(0);
  }
}

int  envoi(ch_requete)
char *ch_requete;
{
st_tdc.lg_emi = strlen(ch_requete);
strcpy(buf_emi,ch_requete);
st_tdc.delai = DELAI10;
#ifdef TEST  
   printf("servdps7 : envoi : buf_emi = %s\n",buf_emi);
#endif
twrite(&st_tdc,buf_emi);
st_tdc.delai = DELAI5;
if ( st_tdc.cr_exec != 0 )
  { 
  #ifdef TEST
    printf("servdps7 : envoi : erreur à l'émission\n");
    printf("servdps7 : envoi : cr_exec = %d\n",st_tdc.cr_exec);
  #endif
  return(-1);
  }
return(0);
}

int lit(ch)
char *ch;
{
int rc;
int i;
int j;
  st_tdc.lg_rec = LG_BUFFER_REC;
  st_tdc.delai = DELAI5;
  rc=tread(&st_tdc,buf_rec);
  for(i=0,j=0;i<st_tdc.cb_rec && j<70;i++)
    {
    if (buf_rec[i] >= 32 && buf_rec[i] <= 127)
      {
      ch[j] = buf_rec[i];
      j++;
      }
    }
  ch[j]=0;
  if (st_tdc.cr_exec == 50303)
    {
    strncpy(ch,"TIME OUT",9);
    }
  #ifdef TEST
  printf("servdps7 : lit : cr_exec=%d\n",st_tdc.cr_exec);
  printf("servdps7 : lit : buf_rec=%s\n",ch);
  #endif
}

int lit_jusqua(ch)
char *ch;
{
char chlu[LG_BUFFER_REC];
#ifdef TEST
  printf("lit_jusqua : début \n");
#endif
do
  lit(chlu);
  while (strstr(chlu,ch)==0 && ((st_tdc.cr_exec==0)||(st_tdc.cr_exec==5031
6)));
#ifdef TEST
  printf("lit_jusqua : fin \n");
#endif
 if (strstr(chlu,"TIME OUT") == 0)
  return(1);
 if ((st_tdc.cr_exec!=0)&&(st_tdc.cr_exec!=50316))
  return(-1);
 else
  return(0);
}


int  supprimer_file()
{
if ( msgctl(i_msqin,IPC_RMID,0) == -1 )
  {
#ifdef TEST
  printf("servdps7 : suppression de la file d'attente QUESTION impossible\
n");
  printf("servdps7 : errno = %d\n",errno);
#endif
  }
if ( msgctl(i_msqout,IPC_RMID,0) == -1 )
  {
#ifdef TEST
  printf("servdps7 : suppression de la file d'attente REPONSE impossible\n
");
  printf("servdps7 : errno = %d\n",errno);
#endif
  }
return(0);
}

int  creer_file()
{
i_msqin = msgget(ftok("/usr/bin",'1'),0);
msgctl(i_msqin,IPC_RMID,0);
i_msqin = msgget(ftok("/usr/bin",'1'),IPC_CREAT | 0666 );
if ( i_msqin == -1 )
  {
#ifdef TEST
  printf("servdps7 : création de la file d'attente QUESTION impossible\n")
;
  printf("servdps7 : errno = %d\n",errno);
#endif
  return(-1);
  }
i_msqout = msgget(ftok("/usr/bin",'2'),0);
msgctl(i_msqout,IPC_RMID,0);
i_msqout = msgget(ftok("/usr/bin",'2'),IPC_CREAT | 0666 );
if ( i_msqout == -1 )
  {
#ifdef TEST
  printf("servdps7 : création de la file d'attente REPONSE impossible\n");
  printf("servdps7 : errno = %d\n",errno);
#endif
  return(-1);
  }
return(0);
}



int  traiter_question()
{
int  arret_tds,i_retour, b_heure, message_recu ;
char ch[LG_BUFFER_REC];


if (msgctl(i_msqin,IPC_STAT,BUF_IPC_STAT) == -1)
  {
  printf("traiter_question : PB IPC_STAT sur MSQUIN \n");
  }

#ifdef TEST
  printf("traiter_question : %d messages ds i_msqin\n",st_msqds.msg_qnum);
#endif

arret_tds = test_heure_arret();
if (arret_tds == 1 && st_msqds.msg_qnum == 0) 
  {
  return(-1);
  }

heure = 0;
while (st_msqds.msg_qnum == 0)
  {
  if (b_heure >= 300)
    {
    #ifdef TEST
    printf("traiter_question : controle TDS début %d\n",b_heure);
    #endif
    arret_tds = test_heure_arret();
    if (arret_tds == 1 && st_msqds.msg_qnum == 0)
      {
      return(-1);
      }
    envoi("SORTIE");
    lit_jusqua("FIN NOR");
    b_heure = 0;
    #ifdef TEST
    printf("traiter_question : controle TDS fin\n");
    #endif
    }
  else
    {
    sleep(1);
    msgctl(i_msqin,IPC_STAT,BUF_IPC_STAT);
    b_heure++;
    }

  }

if ( msgrcv(i_msqin,&st_msgin,128,0,MSG_NOERROR) == -1 )
  {
  #ifdef TEST
    printf("traiter_question : fin attente message : msgrcv\n");
  #endif
  #ifdef TEST
    printf("servdps7 : erreur à la réception d'une question\n");
    printf("servdps7 : errno = %d\n",errno);
    sleep(2);
  #endif
  return(-1);
  }

/*
arrivée du message de service qui déclenche l'arrêt de servdps7
*/
if ( st_msgin.mtype == 1 )
  {
  return(-1);
  }
st_msgout.mtype = st_msgin.mtype;

#ifdef TEST
  printf("traiter_question : deb envoi_requete \n");
#endif

i_retour = envoi_requete(st_msgin.mtext);
if ( i_retour == -1 )
  {
  strcpy(st_msgout.mtext,ERREUR_SYSTEME);
  #ifdef TEST 
    printf("traiter_question :envoi_requete : cr = -1\n");
    debug();
  #endif
  return (-1);
  }
else
  {
  #ifdef TEST
  printf("traiter_question : deb reception_reponse\n");
  #endif
  i_retour = reception_reponse(st_msgout.mtext);
  }
#ifdef TEST
  printf("traiter_question :envoi_reponse %s\n",st_msgout.mtext);
#endif
envoi_reponse();
return(i_retour);
}

int  debug()

{
int  choix;
char ch[LG_BUFFER_REC];

    do
      {
      printf("\nSaisir- 1 pour sortir\n");
      printf("  - 2 pour envoyer(ch) recevoir \n");
      printf("  - 3 pour lit_jusqua(ch) \n");
      printf("  - 4 pour envoyer(ch) \n");
      printf("  - 5 pour lire(ch) \n");
      printf("  - 6 pour close() \n");
      printf("  - 7 pour open() \n");
      scanf("%d",&choix);
      switch (choix)
        {
        case 1:
          break;
        case 2:
          printf(" chaîne envoyer_recevoir :?\n");
          scanf("%s",&ch);
          envoi(ch);
          lit(ch);
          break;
        case 3:
          printf(" chaîne lit_jusqua :?\n");
          scanf("%s",&ch);
          lit_jusqua(ch);
          break;
        case 4:
          printf(" chaîne envoyer:?\n");
          scanf("%s",&ch);
          envoi(ch);
          break;
        case 5:
          lit(ch);
          break;
        case 6:
          st_tdc.delai = DELAI10;
          tclose(&st_tdc);
          printf("close : cr_exec= %d\n",st_tdc.cr_exec);
          st_tdc.delai = DELAI5;
          break;
        case 7:
          topen(&st_tdc,&st_cnftgt);
          printf("open : cr_exec= %d\n",st_tdc.cr_exec);
          break;
        default:
          choix = 1;
          break;
        }
      } while(choix != 1);
}

int  envoi_reponse()
{
int  i_tempo;

/*
test du message bloqué dans la file d'attente REPONSE.
le dernier message déposé n'a pas été lu par la tâche UNIX concernée.
on lui donne encore TIMEOUT_MSGRCV secondes pour le lire.
on vide la file si le message est toujours bloqué
*/
for (i_tempo=0;i_tempo<TIMEOUT_MSGRCV;i_tempo++)
  {
  msgctl(i_msqout,IPC_STAT,&st_msqds);
  if ( st_msqds.msg_qnum == 0 )
    break;
  }
while ( msgrcv(i_msqout,&st_msgin,128,0,MSG_NOERROR|IPC_NOWAIT)==0);
/*
envoi de la réponse à la tache UNIX demandeuse.
*/
alarm(TIMEOUT_MSGSND);
if ( msgsnd(i_msqout,&st_msgout,128,0) == -1 )
  {
  alarm(0);
#ifdef TEST
  printf("servdps7 envoi_reponse : erreur à l'émission de la réponse\n");
  printf("servdps7 envoi_reponse : errno = %d\n",errno);
#endif
  return(-1);
  }
alarm(0);
return(0);
}


int  reception_reponse(ch_reponse)
{
/*
lecture des données venant du dps7 jusqu'à $$$.
*/
memset(ch_buffer,'\0',129);
i_buffer = 0;
#ifdef TEST
  printf("reception_reponse : début\n");
#endif
for (;;)
  {
  if ( iread(&ch_buffer[i_buffer]) != 0 )
    {
    strcpy(ch_reponse,ERREUR_SYSTEME);
    return(-1);
    }
  if ( ch_buffer[i_buffer] != '\n' )
    i_buffer++;
  else
    ch_buffer[i_buffer] = '\0';
  if ( i_buffer >= 5 )
    {
    if ( ch_buffer[i_buffer-1] == '$' &&
      ch_buffer[i_buffer-2] == '$' &&
      ch_buffer[i_buffer-3] == '$' )
      {
      memset(ch_reponse,'\0',128);
      memcpy(ch_reponse,&ch_buffer[1],i_buffer-4);
      /*
      gestion des réponse sur plusieurs messages
      */
      if ( ch_buffer[1] == AUTRE_ECRAN )
        {
        #ifdef TEST
        printf("reception_reponse+suite %s\n",SUITE_TRANSACTION);
        #endif
        return(1);
        }
      else
        {
        #ifdef TEST
        printf("reception_reponse fin %s\n",FIN_TRANSACTION);
        printf("reception_reponse : envoi 1\n");
        #endif
        envoi("1");
        #ifdef TEST
        printf("reception_envoi : lit -FIN NOR- \n");
        #endif
        lit_jusqua("FIN NOR");
        return(0);
        }
      }
    if ( i_buffer >= 128 )
      i_buffer--;
    }
  }
#ifdef TEST
printf("reception_reponse : fin\n");
#endif
}


int  envoi_requete(ch_requete)
char *ch_requete;
{
char ch_s[135];

strcpy(ch_s,ENTETE_MESSAGE_DPS7);
strcat(ch_s,ch_requete);
st_tdc.lg_emi = strlen(ch_s);
strcpy(buf_emi,ch_s);
twrite(&st_tdc,buf_emi);
  #ifdef TEST
   printf("envoi_requete -> DPS7 :%s\n",ch_s);
  #endif
if ( st_tdc.cr_exec != 0)
  {
  #ifdef TEST
  printf("envoi_requete: erreur a l'émission\n");
  printf("envoi_requete: cr_exec = %d\n",st_tdc.cr_exec);
  #endif
  return(-1);
  }
return(0);
}

void alarme()
{
signal(SIGALRM,alarme);
}


iread(buf)
char *buf;
{
if ( lg_bufrec <= 0 )
  {
  st_tdc.lg_rec = 2000;
  tread(&st_tdc,buf_rec);
  if ( st_tdc.cr_exec != 0 )
    {
    #ifdef TEST
    printf("servdps7 : iread : erreur à la réception\n");
    #endif
    return(st_tdc.cr_exec);
    }
  lg_bufrec = st_tdc.cb_rec;
  i_bufrec = 0;
  buf_rec[lg_bufrec] = '\0';
  #ifdef TEST
    printf("servdps7 : iread : cr_exec = %d\n",st_tdc.cr_exec);
    printf("servdps7 : iread : %s\n",buf_rec);
  #endif
  }
*buf = buf_rec[i_bufrec];
i_bufrec++;
if ( i_bufrec >= lg_bufrec )
  {
  lg_bufrec = 0;
  i_bufrec = 0;
  }
return(0);
}