/* Archi - kopiert nicht archivierte Files auf eine Backup-Disk 
   (C)1989 Oliver Graf
   Datum : 15.5.1989
*/

#include <libraries/dos.h>
#include <exec/types.h>
#include <exec/memory.h>
#include <functions.h>

BOOL status = FALSE;

char *make_name(dirname,filename)   /* verbindet dirname und filename zum */
 char *dirname,*filename;	    /* vollständigen Pfadnamen */
{
 char fullname[150];	/* Puffer für den gesamten Namen */
 int laenge;

 strcpy(fullname,dirname);
 laenge = strlen(fullname);
 if(fullname[laenge-1] != ':')		/* wenn keine reine Deviceangabe */
  fullname[laenge++] = '/';		/* Schrägstrich einfügen */
 strcpy(&fullname[laenge],filename);
 return(fullname);
}

int CopyFile(quellpfad,zielpfad,filename)	/* ein File kopieren */
 char *quellpfad,*zielpfad,*filename;
{
 struct FileHandle *source,*dest;
 int laenge,fehler = 0;
 char quellname[150],zielname[150],*puffer;

 strcpy(quellname,make_name(quellpfad,filename));
 strcpy(zielname,make_name(zielpfad,filename));
 printf("kopiere %s nach %s\n",quellname,zielname);
 puffer = AllocMem(1024L,MEMF_CLEAR);	/* Zwischenpuffer für 2 Blocks */
 if(puffer != NULL)
 {
  source = Open(quellname,MODE_OLDFILE);
  if(source != NULL)
  {
   dest = Open(zielname,MODE_NEWFILE);
   if(dest != NULL)
   {
    do    
    {
     laenge = Read(source,puffer,1024L);	/* 1 KB Daten holen */
     if(Write(dest,puffer,(long)laenge) == -1)	/* in neue Datei schreiben */
     {
      fehler = -1;
      break;
     }
    }
    while(laenge == 1024);		/* solange, bis Dateiende */
    Close(dest);
   }
   else
    fehler = IoErr();
   Close(source);
  }
  FreeMem(puffer,1024L);
 }
 return(fehler);
}

main()
{
 char quellpfad[60],zielpfad[60],antwort[2];

 printf("Archi written in 1989 by Oliver Graf.\n");
 printf("Quellpfad : ");
 gets(quellpfad);
 printf("Zielpfad : ");
 gets(zielpfad);
 printf("archivierte Unterdirectories durchsuchen ? (j/n) ");
 gets(antwort);
 if(antwort[0] == 'j')
  status = TRUE;
 scan(quellpfad,zielpfad);	/* Aufruf mit angegebenen Directories */
}

scan(quellpfad,zielpfad)	/* Directory quellpfad durchsuchen */
 char *quellpfad,*zielpfad;	/* und evtl. Files nach zielpfad kopieren */
{
 struct FileLock 	*lock;
 struct FileInfoBlock	*fib;
 long protstate;
 char filename[60],srcname[150],desname[150];

 lock = Lock(zielpfad,ACCESS_READ);	/* ist Zieldir vorhanden */
 if(lock == NULL)			/* nein -> dann Dir anlegen */
 {
  printf("lege an %s\n",zielpfad);
  lock = CreateDir(zielpfad);		/* anlegen */
  if(lock == NULL)			/* wenn nicht geklappt */
  {
   printf("kann Dir nicht anlegen !\n");
   return;				/* dann nicht durchsuchen */
  }
 }
 UnLock(lock);				/* Dir wieder freigeben */
 fib = AllocMem((long)sizeof(*fib),MEMF_CHIP|MEMF_CLEAR);
 if(fib != NULL)
 {
  lock = Lock(quellpfad,ACCESS_READ);	/* Lockstruktur holen */
  if(lock != NULL)			/* hat geklappt */
  {
   if(Examine(lock,fib))		/* erste Untersuchung */
   {
    while(ExNext(lock,fib))	/* bis zum letzten Eintrag untersuchen */
    {
     protstate = fib->fib_Protection;		/* Schutzflags holen */
     strcpy(filename,fib->fib_FileName);	/* Filenamen holen */
     if(fib->fib_EntryType < 0)		/* ist ein File */
     {
      if((protstate & FIBF_ARCHIVE) == 0)	/* Archiveflag ungesetzt ? */
      {
       if(CopyFile(quellpfad,zielpfad,filename) == 0) /* dann File kopieren */
       {					/* wenn Copy geklappt */
        protstate |= FIBF_ARCHIVE;		/* Archiveflag setzen */
        if(!SetProtection(make_name(quellpfad,filename),protstate))
         printf("kann Flags nicht setzen !\n");
       }
       else
        printf("Fehler beim Kopieren !\n");
      }
     }
     else			/* File ist ein Directory */
     {
     /* nur weitersuchen, wenn nicht archiviert oder ausdrücklich gewollt */
      if(((protstate & FIBF_ARCHIVE) == 0) || (status))
      {
       strcpy(srcname,make_name(quellpfad,filename));
       strcpy(desname,make_name(zielpfad,filename));
       scan(srcname,desname);		/* Rekursionsaufruf */
      }
     }
    }	/* von while-Schleife */
   }
   else
    printf("Kann Dir nicht untersuchen !\n");
   UnLock(lock);			/* Lock wieder freigeben */
  }
  else
   printf("Kann Dir nicht festsetzen !\n");
  FreeMem(fib,(long)sizeof(*fib));	/* Puffer wieder freigeben */
 }
}