#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#include<io.h>


char wpath[230]; char emsg=0,emr=0;

char* estrai(char* path, char* file) // Separa un indirizzo in Percorso (path) e Filename (file).
{int fcount=0;
 for (int cic=0; cic<=strlen(path); cic++)
   {file[fcount++]=path[cic];
    if (path[cic]=='\\') fcount=0;
   }
path[(strlen(path)-strlen(file))]=0;
return file;
}

char* aggiusta(char* path)     // path punta all'indirizzo da aggiustare.
{char temp[330];
estrai(path,temp);
if (*path!=0) {strcat(path,temp); }
   else {strcat(path,wpath);strcat(path,temp);}
return path;                   // path punta all'indirizzo aggiustato.
}


FILE * p1,* p3,* p4;
char fn3[100],fn5[100],fn4[100],fnz[100],fnapp[100];char* tempnf;char* tempnf2;
int blocchi;
unsigned long int lof;


int finderror(char *fn2, FILE *p2, unsigned long int dimex)
{unsigned long int lof2;
 int handle = fileno(p2);
 lof2=filelength (handle);
 printf("Checking output file size...");
 if (dimex==lof2) {printf(" Ok.\n");return 0;}
    else {emsg=1;
	  printf("\nERROR #5 : Output file size is different from estimated value.\n           Impossible to determine causes for this error.\n           Probably not enough space on disk.\nRemoving previously generated blocks...\n");
	  if (remove(fn2)==0) printf("File %s has been removed.\n",fn2);
	     else {printf("ERROR #6 : File %s could not be removed.\n           Probably file is read-only or disk is write-protected.\n",fn2); emr=1;}
	  return 1;
	 }
}



int uguali(unsigned char* a, unsigned char *b)
{int i=-1;int verita=1; 
while (a[++i]!=0)
if (a[i]!=b[i]) verita=0;
return verita;
}

void testo(int lenfn2,unsigned long int dim,char* fn3)
{fprintf(p4,"Chunk v 1.0       (c) 1998 Gianluca Palermo\n\nDocumentation for file : %s \n\nThis file has been chunked in %d blocks of %ld bytes max length each.\n\n",tempnf,blocchi,dim);
 fprintf(p4,"Reassembled file size will be %ld bytes.\n\n",lof);
 fprintf(p4,"Run %s to reassemble file making sure all %d files are present \nin the working directory.\n",( fn3+(lenfn2-strlen(tempnf2)) ),blocchi); // Estrae il nome del file dal percorso utilizzando la differenza di lunghezza tra l'array puntato da fn2 e l'array puntato da tempnf2, e aggiungendola al puntatore fn3 come offset. Questo metodo è più conveniente in quanto il nome del file puntato da fn3 deve essere estratto una sola volta.
 fprintf(p3,"@echo off\necho Chunk v 1.0       (c) 1998 Gianluca Palermo\necho -\necho Reassembling procedure for file : %s \necho -\necho ",tempnf);
 fprintf(p3,"%d blocks of %ld bytes.\necho -\npause\nif exist %s echo File %s already exists!\nif exist %s echo To run this procedure you must remove\nif exist %s echo %s from current directory.\n",blocchi,dim,tempnf,tempnf,tempnf,tempnf,tempnf); // il parametro /Y nel comando copy è stato tolto per mantenere la compatibilità con Windows NT. L'utente verrà avvisato prima di sovrascrivere un file se non avrà modificato la variabile di ambiente COPYCMD.
 fprintf(p3,"if exist %s del %s\n",fnapp,fnapp);
 return;
}

void nome_estensione (unsigned char* fn1, unsigned char* fn2, int ordine, unsigned char temp, int conta) //  Nota: Il parametro temp non necessita passaggio per variabile. Il suo valore non verrà riutilizzato alla fine della funzione. Lo stesso dicasi per il parametro conta.
{temp='x';
char* ext=(char*)malloc(5*sizeof(char));
ext[0]='.';
ext[1]=ordine/100+'0';
ext[2]=ordine/10-(ordine/100)*10+'0';
ext[3]=ordine-(ordine/10)*10+'0';
ext[4]=0;
if (fn2[0]=='*') strcpy(fn2,fn1);
	conta=0;
	while (temp!='\0')
		{temp=fn2[conta];if (temp=='.')  temp=fn2[conta]=0;conta++;} // Attenzione !!! questo algoritmo non funziona se nel nome completo del file compare una directory che ha nel nome il carattere '.' !!!
	strcat(fn2, ext);
        aggiusta(fn2); 
	free(ext);
	 char* temparr=(char*)malloc(330*sizeof(char));
	 temparr[0]=0;
	 strcat(temparr,fn2);
	 estrai(temparr,tempnf2);
	 free (temparr);
}



//procedura ricorsiva:
void scrivifile(unsigned char* fn1, unsigned char* fn2, int ordine, unsigned long int dim)  //restituisce int per sapere se ci sono errori
{unsigned char temp='x',temp1;
int cic;int conta;
//char fn4[100];
//char*fn4=(char*)malloc(100*sizeof(char));
printf("\n\n");
strcpy(fn4,fn2);

nome_estensione (fn1, fn2, ordine,temp,conta);

FILE * tmpunt;
if (NULL!=(tmpunt=fopen(fn2,"r")))
	{printf("Warning ! File %s already exists!\nOverwrite (y/n)? ",fn2);
	fclose(tmpunt);
	scanf(" %c",&temp1);//printf("\n");
	if (temp1!='y'&&temp1!='Y')
	     {printf("No action taken.");    if (ordine>0) printf("Removing previously generated blocks...\n\n"); else printf("\n\nProcess aborted.");    emsg=1;return;}
	    else {printf ("Overwriting %s ...\n",fn2);
		  if (remove(fn2)!=0) 
  		    {printf("ERROR #6 : File %s could not be overwritten.\n           Probably file is read-only or disk is write-protected.\n",fn2);
		     //printf("\nProcess aborted.\n");
		     printf("Removing previously generated blocks...\n");emsg=1;return;
                    }
                 }
	}
   else fclose(tmpunt);

printf("Output file : %s\n",fn2);
unsigned char bridge;
FILE * p2;

if(ordine==0)
	{p1=fopen(fn1,"rb");
	strcpy(fn3,fn2);
	temp='x';conta=0;
	while (temp!='\0')
		{temp=fn3[conta];if (temp=='.')  temp=fn3[conta]=0;conta++;} // Attenzione !!! questo algoritmo non funziona se nel nome completo del file compare una directory che ha nel nome il carattere '.' !!!
        strcpy(fn5,fn3);        	

		strcpy(fnz, fn5);strcat(fnz, ".txt"); //verifica che filename.txt non esista già
		if (NULL!=(tmpunt=fopen(fnz,"r"))) {fn5[strlen(fn5)-1-(strlen(fn5)>=3)]=39;} // sostituisce il penultimo carattere prima del punto (l'ultimo se i caratteri prima del punto sono solo 2) con il carattere ' (apostrofo)  [sostituzione : 39<=>'~']
        	fclose(tmpunt);
		strcpy(fnz, fn3);strcat(fnz, ".bat"); //verifica che filename.bat non esista già
		if (NULL!=(tmpunt=fopen(fnz,"r"))) {fn3[strlen(fn3)-1-(strlen(fn3)>=3)]=39;} // sostituisce il penultimo carattere prima del punto (l'ultimo se i caratteri prima del punto sono solo 2) con il carattere ' (apostrofo)  [sostituzione : 39<=>'~']
        	fclose(tmpunt);
                
	strcat(fn5, ".txt");
	strcat(fn3, ".bat");
	//int handle1=fileno(p1);
	//unsigned long int cc=(filelength (handle1)-1)/(int)dim +1;
	//printf("<><><><>blocchi %d  dim %ld",cc,dim);
	p3=fopen(fn3,"w");
	p4=fopen(fn5,"w");
        testo(strlen(fn2),dim,fn3);
	//fprintf(p3,"%s",fn2);
	fclose(p4);
        }
     //else

fprintf(p3,"if not exist %s COPY /B %s+%s %s\n",tempnf,fnapp,tempnf2,fnapp);
p2=fopen(fn2,"wb");
unsigned long int ctrl=0;
while(fscanf(p1,"%c",&bridge)!=EOF && ctrl<dim)
  {
   fprintf(p2,"%c",bridge);
   ctrl++;
   if(ctrl>=dim ) {if (fscanf(p1,"%c",&bridge)!=EOF) {fclose(p2);p2=fopen(fn2,"r");if (finderror(fn2,p2,dim)) {if (ordine==0) printf("\nProcess aborted.\n");return;} fclose(p2);fseek(p1,-1,1);scrivifile(fn1,fn4,ordine+1,dim);}}
  }

if (ctrl<dim)
{fclose(p2);p2=fopen(fn2,"r");if (finderror( fn2, p2,(lof-(dim*ordine)) )) return; // Non accade mai per il primo blocco: vengono sempre generati almeno due blocchi.
}


fclose(p2);

nome_estensione (fn1, fn2, ordine,temp,conta);         // Ripristina il nome del file (array puntato da fn2) trattato in questa chiamata sulla base del numero contenuto in ordine : infatti questo non viene modificato nelle successive chiamate ricorsive, il primo si.
					       	       // Il riutilizzo dell'array puntato da fn2 e dichiarato come variabile globale si è reso necessario per impedire che si verifichi un errore di buffer overflow dovuto alla ricorsione, che può raggiungere profondità pari a 999.
if (emsg)
{if (remove(fn2)==0) printf("File %s has been removed.\n",fn2);
   else {printf("ERROR #6 : File %s could not be removed.\n           Probably file is read-only or disk is write-protected.\n",fn2); emr=1;}
}



if (ordine==0) {fclose(p1);
		if (emsg==0)
		   {printf("\nProcess successfully completed.\n");


		    fprintf(p3,"if not exist %s ren %s %s\n",tempnf,fnapp,tempnf);
		    fclose(p3);
		   }
		  else {fclose(p3);
			emr+=remove(fn3);
			emr+=remove(fn5);
			p4=fopen(fn5,"w");
			fprintf(p4,"Chunk v 1.0       (c) 1998 Gianluca Palermo\n\nDocumentation for file : %s \n\nThis file was supposed to be chunked in %d blocks of %ld bytes max length each.\n\n",tempnf,blocchi,dim);
			fprintf(p4,"An error occurred while blocks were being generated.\nProcess was aborted.\n");

			if (emr==0) {printf("All blocks generated were removed.\n");fprintf(p4,"All blocks generated were removed.\n");}
			   else{printf("One or more files generated could not be removed.\n");fprintf(p4,"One or more files generated could not be removed.\n");}
			printf("\nProcess aborted.\n");
			//fprintf(p4,"\nThis file should be removed before trying again.\n");
			fclose(p4);
                       }
		
               }
}





int main (argc,argv)
char **argv;

{*wpath=0;
char stk[100], temp[330];	   // wpath è un array dichiarato come variabile globale.
char* param2=argc>1 ? argv[1] : "default";
if (argc==2){strcpy(wpath,param2);
	     estrai(wpath, stk);
            }
char* param=stk;

printf("Chunk V 2.0       (c) 1998 Gianluca Palermo                  \n\n");
unsigned long int root=0;int handle;

printf("Please enter dimension for each block in bytes (0 for 1.44 MB)> ");
scanf("%ld",&root);printf("\n");
if (root==0) root=1457664;
if (root<=0) printf("ERROR #1 : You must specify positive sizes.\n");
  else
       {unsigned char fname1[255],filename2[255],*filename1,escapept[5];

	if (argc==2)
	   {printf("Processing file %s. \n'\\' to abort, '+' to continue > ",param);}
	   else	printf("Please enter name of file to be processed ('\\' to abort)\n > ");
           scanf("%s",fname1);printf("\n");
	   if (uguali(fname1,"\\")) printf("Terminated by user.\n");
		else {if (argc==2) {filename1=param; printf("Proceeding...\n");} else filename1=fname1;
		      ////if (*wpath!=0) {strcpy(temp,path); strcat(temp, filename1);filename1=temp;}
                      //char nomecnf[100]; strcpy(nomecnf,param);
		      aggiusta(filename1);    

        //unsigned char filename1[105],filename2[105];
	//printf("Please enter name of file to be processed ('\\' to abort)\n > ");
	//scanf("%s",filename1);printf("\n");
	//if (uguali(filename1,"\\")) printf("Terminated by user.\n");
		//else {
		      FILE * tmpunt; if (NULL==(tmpunt=fopen(filename1,"r"))) {printf("ERROR #2 : Couldn't find specified file : %s\n",filename1);fclose(tmpunt);}
			else {printf("Please enter name of output files \n(entering '*' outputs to *.xxx)\n > "); // In caso venga inserita erroneamente anche l'estensione, essa verrà rimossa automaticamente.
	      		      scanf("%s",filename2);printf("\n");
			      if (uguali(filename2,"\\")) {printf("Terminated by user.\n");fclose(tmpunt);}
					   else {if (root==1457664) printf("Diskette-fit size specified (1.44 MB).\n");
						     else printf("Chunking file in %0.1lf KB blocks (%ld bytes).\n", (long float)root/1024.0,root);
						handle = fileno(tmpunt);
						lof=filelength (handle);
						fclose(tmpunt);
						if ((lof-1)/root +1>999) printf("Blocks overflow. Try to specify larger block size. No output has been generated.\n");
						else
						if ((lof-1)/root==0) printf("File size is not above block dimension. No output has been generated.\n");
						  else {printf("%ld blocks will be generated.\nEnter '+' to continue, '\\' to abort > ", (lof-1)/root +1);
							scanf("%s",escapept);printf("\n");
							if (uguali(escapept,"\\")) printf("Terminated by user.\n");
							   else { char* temparr=(char*)malloc(330*sizeof(char));
								  tempnf=(char*)malloc(16*sizeof(char));
								  tempnf2=(char*)malloc(16*sizeof(char));
								  temparr[0]=0;
								  strcat(temparr,filename1);
								  estrai(temparr,tempnf);
								  fnapp[0]='~';fnapp[1]=tempnf[0];fnapp[2]=tempnf[2];fnapp[3]=tempnf[4];
								  fnapp[4]='@';fnapp[5]=(rand()%25)+65;fnapp[6]=(rand()%25)+65;fnapp[7]=(rand()%25)+65;fnapp[8]=0;
								  strcat(fnapp,".!@#"); // fnapp non deve essere aggiustato perchè utilizzato solo dal file batch di riassemblaggio.
								  free (temparr);
								 blocchi=(lof-1)/root +1;                                                          
								 scrivifile(filename1,filename2,0,root);
								  free (tempnf);free (tempnf2);
								}
                                                       }
						}

                     	      }
		      }
	}
}