
#include <fcntl.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

#include "commun.h"

char szErreur [300];

#define BLOCK 8192 // Taille des blocs lus et ecrits

#include <stdio.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <malloc.h>

#define BLOCK 8192

#define false 0
#define true  1
#define bool int

char * buffer;
bool bCopy = false;

//using namespace std;

void InitCopy(void)
{
	bCopy = false;
}

bool TstCopy(void)
{
	return bCopy;
}


bool CopyFile (char *szFileSrc, char *szFileDest)
{
    int iHdlSrc, iHdlDest, iTaille, iTailleWrite;
    struct stat stBufferStat;
    bool fErreur;
    
/*	printf (szFileSrc);
	printf (" modifié.\n");*/

    iHdlSrc = open(szFileSrc, O_RDWR, S_IRUSR | S_IRGRP | S_IRWXO);
    
    if (iHdlSrc != -1)
    {
     iHdlDest = creat(szFileDest, S_IRWXU | S_IRWXG | S_IRWXO);
     if (iHdlDest != -1)
     {
        buffer = (char *)malloc (BLOCK);
        fstat (iHdlSrc, &stBufferStat);
        iTaille = stBufferStat.st_size;

        fErreur = false;
        
        if (iTaille > BLOCK)
        {
           do
           {
                    if (read (iHdlSrc, buffer, BLOCK) == BLOCK)
                    {
                             iTailleWrite = write (iHdlDest, buffer, BLOCK);
                             if (iTailleWrite != BLOCK)
                             {
								sprintf (szErreur, "Erreur durant l'écriture du fichier %s:%d-%d", szFileSrc,errno, iTailleWrite);
								GenereErreur (szErreur);

                                fErreur = true;
                             }
                             else
                                iTaille -= BLOCK;
                    }
                    else
                    {
						sprintf (szErreur, "Erreur durant la lecture du fichier %s:%d", szFileSrc,errno);
						GenereErreur (szErreur);

                        fErreur = true;
                    }

           }while (iTaille > BLOCK && !fErreur);
        }
        
        if (iTaille > 0)
        {
                    if (read (iHdlSrc, buffer, iTaille) == iTaille)
                    {
                             iTailleWrite = write (iHdlDest, buffer, iTaille);
                             if (iTailleWrite != iTaille)
                             {
								sprintf (szErreur, "Erreur durant l'écriture du fichier %s:%d-%d", szFileSrc,errno, iTailleWrite);
								GenereErreur (szErreur);
								fErreur = true;
                             }
                             else
                                iTaille = 0;
                    }
                    else
                    {
                        sprintf (szErreur, "Erreur durant la lecture du fichier %s:%d", szFileSrc,errno);
						GenereErreur (szErreur);

                        fErreur = true;
                    }                    
        }
        
		bCopy = true;
        free (buffer);        
        close (iHdlDest);
        close (iHdlSrc);

     }  
     else
     {
		sprintf (szErreur, "Erreur durant la creation du fichier %s:%d", szFileDest,errno);
		GenereErreur (szErreur);
		close (iHdlSrc);
		fErreur = true;

     }          
    }
    else
    {		
		sprintf (szErreur, "Erreur durant l'ouverture du fichier %s:%d", szFileSrc, errno);
		GenereErreur (szErreur);
		fErreur = true;
    }

    return !fErreur;
}


void copyfileok (void)
{

		bCopy = true;
}

