///////////////PAMELA PACKETS READER/////////////////////////////////
#include "descript.h"

#include "CRC.h"

short int CRC_H(char [], char []);

void verify(char fni[], char inf[], char log[], char pam[],
		  char fno[], char path[], char name_ini[], char name_in[], int packet_type[],
		  int GLOBAL_LEN_ER, float IndexQ, int r_counter, int real_route[])
{
 FILE *fo_log, *fo_inf, *fo_work, *fo_miss, *fo_row;

 time_t seconds;
 struct tm *timeinfo;
 char time_year[5], time_month[5], time_day[5];
 char data_time[80];
 char cirquit_no[10], route_no[80], name_path[80], name_cln2[80];
 bool file_ready, file_deleted, file_archived, file_proces;
 int  flag_to_transmit=0;
 int flag_sec_trans=0;             /*Second transmission flag*/
 int num_rows=0;
 int current_route=0;

 char str_route[10];
 char str_file[80];

 char ch;
 char miss_file[80];
 char Name_Buf[9];                 /*Name buffer*/
 char Name_Buf_add[9];             /*Header buffer*/
 char buff[16];
 char Name_Buf_old[9];             /*Old name buffer*/
 char Name_Buf_add_old[9];         /*Old header buffer*/
 
 short int CalcCheckSum=0;
 int num_type=0;                   /*Packet type number*/
 int num_type1=0;
 int num_type2=0;
 int stop=0;
 int Hex[3];
 int Byte_adr1[4];                 /*Bytes for Packet begin packing*/
 int Byte_adr2[4];                 /*Bytes for Packet end packing*/
 int packet_counter[NumberPack+1]; /*Counter for each packet type*/
 int count_name_cor=0;             /*Counter for packet with corrected name*/
 int er_pack_count=0;              /*Error packet counter*/
 int count_miss=0;                 /*Missed packet counter*/
 int P_er=0;                       /*Number of packet with counter error*/
 int flag_CRC_H[3];                /*Flag for CRC header error*/
 int flag_pack[3];                 /*Flag for error in packet counter*/
 int flag_len[3];                  /*Flag for PAMELA packet length error*/
 int flag_len_weak[3];             /*Suspicion flag for PAMELA packet length error*/
 int flag_name[3];                 /*Flag for name error*/
 int flag_type[3];                 /*Flag for packet type error*/
 int flag_time[3];                 /*Flag for time error*/
 int flag_CRC_cor[3];              /*Flag for CRC error correction*/
 int CRC_bad_pack[3];              /*Current header CRC bad packet number*/
 int CRC_Header[3];                /*CRC in header for previous packets*/
 int Mis_group=0;                  /*Number of missed packet group*/
 short int flags=0;                /*Number for all errors*/
 long int tmpP=0;                  /*Temporary PAMELA packet number*/
 long long int icount=0;           /*Number of bytes in identified packets*/ 
 long long int icount_total=0;     /*Total number of bytes*/
 long int icount_int=0;            /*Entire part of total file size in Kbytes*/
 long int icount_frac=0;           /*Fractional part of total file size*/
 long int N1=0;                    /*Number of identified PAMELA packets*/
 long int numP[3];	               /*Packet numbers for previous packets*/
 long int LenP[3];                 /*Packet length for previous packets*/
 unsigned long int time_p[3];      /*Packet time*/
 long int pack_length=0;           /*PAMELA packet length*/
 long long int adr_first[3];       /*Start displacement from file begin*/
 long long int adr_last[3];        /*Finish displacement from file begin*/
 long int temp[2];  
 char *buffer=new char[Nmax];      /*Buffer for PAMELA current packet*/
 int FLAG_BIG=0;                   /*Flag for large packet*/
 unsigned long int k=0, j=0;
 int i;
 //initialization  , all =0

 stringstream oss, oss1;

 TSQLServer *sqlServer = TSQLServer::Connect("mysql://pamela_1.ntsomz.ru:3306/rawreader", "pamelaprod", "rawprod");

 oss.str("");
 oss<<"select * from FILES1";
 TSQLResult *res1=sqlServer->Query(oss.str().c_str());
 num_rows=res1->GetRowCount();
 if (num_rows>0)
 {
  oss.str("");
  oss<<"select max(my_route) from FILES1";
  TSQLResult *res2=sqlServer->Query(oss.str().c_str());  
  TSQLRow *row=res2->Next();
  strcpy(str_route,row->GetField(0));

  strcpy(str_file,inf);
  str_file[strlen(inf)-9]='\0';
  strcat(str_file,"_tmp.dat"); 
  fo_row=fopen(str_file,"w+"); 
  fprintf(fo_row,"%s",str_route);
  fseek(fo_row,0,0);
  fscanf(fo_row,"%i",&current_route); 
  current_route+=1; 
  fclose(fo_row);
  remove(str_file); 
 }
 else
 {
  current_route=1;
 }

 for (i=0; i<NumberPack+1; i++) packet_counter[i]=0;
 for (i=0; i<3; i++)
 {numP[i]=0; time_p[i]=0; CRC_Header[i]=0; CRC_bad_pack[i]=0;
  flag_CRC_H[i]=0; flag_len[i]=0; flag_len_weak[i]=0; flag_pack[i]=0; flag_CRC_cor[i]=0;
  flag_name[i]=0; flag_type[i]=0; flag_time[i]=0;
  LenP[i]=0;
  adr_first[i]=0; adr_last[i]=0;
  Hex[i]=0;}
 for (i=0; i<4; i++) {Byte_adr1[i]=0; Byte_adr2[i]=0;}
 for (i=0; i<2; i++) temp[i]=0;

 ifstream fin;
 ofstream fo_pam;  

/**********************OPEN NECESSARY FILES************************/
/******************************************************************/
 fin.open(fni, ios::binary);     // open input file "mmm_counter_nnnnn__cln1.pam"
 if(fin.good()==0) {cerr<<"can not open input file"; exit(1);}

 fo_work=fopen(fno, "wb");       //open output help file "work.dat"
 if(fo_work==NULL) {cerr<<"can not open outputfile"; exit(1);}

 fo_log=fopen(log, "wb");        //open output file "Route_cln2.log"
 if(fo_log==NULL) {cerr<<"can not open log file"; exit(1);}

 fo_pam.open(pam, ios::binary);  //open output file "Route_cln2.pam"
 if(fo_pam.good()==0) {cerr<<"can not open pam file"; exit(1);}

 fo_inf=fopen(inf, "wb");        //open output file "mmm_conter_nnnnn_cln2.inf"
 if(fo_inf==NULL) {cerr<<"can not open inf file"; exit(1);}

 strcpy(miss_file,path);
 strncat(miss_file,name_in,strlen(name_in)-8); 
 fo_miss=fopen(strcat(miss_file,"mis_cln2.dat"), "wb");
                                 //open output file "mmm_nnnnn_mis_cln2.dat"
 if(fo_miss==NULL) {cerr<<"can not open miss file"; exit(1);}
/******************************************************************/
/******************************************************************/

//Write proccessed filename in help file
 fprintf(fo_work,"file name=%s\n",name_in); 

/******************************************************************/
/******************MAIN READING CYCLE BEGIN************************/
/******************************************************************/

 while(fin.eof()==0)
 {
  num_type=0; num_type1=0;  num_type2=0;

/**********************data reading********************************/
  if ((N1==0)&&(icount_total==0)) {fin.read(Name_Buf,8); icount_total+=8;}

/*******************temporary packet number************************/
  tmpP=(long int)(unsigned char)(Name_Buf[7])+
   	             256*(long int)(unsigned char)(Name_Buf[6])+
             256*256*(long int)(unsigned char)(Name_Buf[5]);

  if (N1==0) numP[2]=tmpP-1;    //initial packet identification

/******************packet type identification**********************/
  for (i=0;i<NumberPack;i++)
  {if (packet_type[i]==(int)(unsigned char)(Name_Buf[3]))
      num_type1=i+1;
   if (packet_type[i]==(int)(unsigned char)(Name_Buf[4]))
	  num_type2=i+1;}
  if ((num_type1==num_type2)&&(num_type1!=0)) num_type=num_type1;
  if ((num_type1==0)&&(num_type2!=0)) num_type=num_type2;	  
  if ((num_type1!=0)&&(num_type2==0)) num_type=num_type1;

///////////////////////////////////////////////////////////////////
////////////////// PAMELA PACKET IDENTIFICATION////////////////////
///////////////////////////////////////////////////////////////////
  if (((int)(unsigned char)Name_Buf[0]==CODE_BYTE1&&
	   (tmpP==numP[2]+1)&&num_type!=0)||
      ((int)(unsigned char)Name_Buf[1]==CODE_BYTE2&&
	   (tmpP==numP[2]+1)&&num_type!=0)||
	  ((int)(unsigned char)Name_Buf[2]==CODE_BYTE3&&
	   (tmpP==numP[2]+1)&&num_type!=0)||
	  ((int)(unsigned char)Name_Buf[0]==CODE_BYTE1&&
	   (int)(unsigned char)Name_Buf[1]==CODE_BYTE2&&
	   (int)(unsigned char)Name_Buf[2]==CODE_BYTE3&&num_type1!=0&&num_type2!=0)||
	  ((int)(unsigned char)Name_Buf[0]==CODE_BYTE1&&
	   (int)(unsigned char)Name_Buf[1]==CODE_BYTE2&&
	   (int)(unsigned char)Name_Buf[2]==CODE_BYTE3&&
	   (tmpP==numP[2]+1)))	   
  {if (N1==0) {for (i=0;i<8;i++) buffer[i]=Name_Buf[i]; }
   N1+=1; FLAG_BIG=0;
   if (N1==1) {icount+=8;}    
   packet_counter[num_type]+=1;  //count packet number for each type
   if ((fmod((float)(tmpP),(float)(1000.))==0.)&&(tmpP!=0)) cout<<"verifying "<<tmpP<<"\n";

   if (N1!=1) 
   {
/**************PAMELA PREVIOUS PACKET END DISPLACEMENT*************/
    if ((icount-8-adr_first[2]+1-LenP[2]-16)<=Limit) {adr_last[2]=icount-8;}               //end byte for previous packet
    else if ((icount-8-adr_first[2]+1-LenP[2]-16)>Limit) {adr_last[2]=adr_first[2]+Limit;} //end byte for previous packet

/**************PAMELA PACKET LENGTH ERROR ANALYSIS*****************/
	 if ( (flag_CRC_H[2]==1)&&(GLOBAL_LEN_ER>0)&&
		  ( ((adr_last[2]-adr_first[2]+1)<(LenP[2]+16))
		    ||((adr_last[2]-adr_first[2]+1-LenP[2]-16)>64) ) )
	 {flag_len[2]=1;
	  cout<<"pack num "<<numP[2]<<" len="<<LenP[2]<<" true len="<<
	        adr_last[2]-adr_first[2]-16<<" Type="<<num_type<<"\n";}
	 if ( (flag_CRC_H[2]==0)&&(GLOBAL_LEN_ER>0)&&
		  ( ((adr_last[2]-adr_first[2]+1)<(LenP[2]+16))||((adr_last[2]-adr_first[2]+1-LenP[2]-16)>64) ) )
	 {flag_len_weak[2]=1;
	  cout<<"weak length error; pack num "<<numP[2]<<" len="<<LenP[2]<<" true len="<<
	        adr_last[2]-adr_first[2]-16<<" Type="<<num_type<<"\n";}

    if ((GLOBAL_LEN_ER>0)&&(flag_len[2]==1))
    {
//Write data in file "mmm_counter_nnnnn_cln2.pam"
     for (i=0;i<adr_last[2]-adr_first[2]+1;i++)
     {fo_pam<< buffer[i];}
    }
    else if ((GLOBAL_LEN_ER>0)&&(flag_len[2]!=1))
    {
//Write data in file "mmm_counter_nnnnn_cln2.pam"
     for (i=0;i<LenP[2]+16;i++)
     {fo_pam<< buffer[i];}
     adr_last[2]=adr_first[2]+LenP[2]+15;
     icount=adr_first[2]+15+LenP[2]+8;
    }
    else if ((GLOBAL_LEN_ER==0)&&(adr_last[2]-adr_first[2]+1-LenP[2]-16>=0))
    {
     for (i=0;i<LenP[2]+16;i++)
     {fo_pam<< buffer[i];}
     adr_last[2]=adr_first[2]+LenP[2]+15;
     icount=adr_first[2]+15+LenP[2]+8;
    }
    delete [] buffer;
    buffer=new char[Nmax];
    for (i=0;i<8;i++) buffer[i]=Name_Buf[i]; 

    temp[1]=adr_last[2];
    for (i=0;i<4;i++) Byte_adr2[i]=0;
    for (i=0;i<4;i++)
    {if (temp[1]/(long int)(pow(256.,3-i))>=1) 
     {Byte_adr2[3-i]=(int)(temp[1]/(long int)(pow(256.,3-i)));
      temp[1]=temp[1]-(long int)pow(256.,3-i)*
      (int)(temp[1]/(long int)(pow(256.,3-i)));}}	
      //Write previous packet end displacement in mmm_counter_nnnnn_cln2.log file
     for (i=0;i<4;i++) fprintf(fo_log,"%1c",char(Byte_adr2[i]));
    }
/*********************reading remaining header********************/
   fin.read(Name_Buf_add, 8);
   if (fin.eof()) break;
   icount+=8; icount_total+=8;
   for (i=0;i<8;i++) buffer[i+8]=Name_Buf_add[i];

//packet length
   pack_length=(long int)(unsigned char)(Name_Buf_add[6])+
           256*(long int)(unsigned char)(Name_Buf_add[5])+
       256*256*(long int)(unsigned char)(Name_Buf_add[4]);
//   cout<<pack_length<<"  "<<tmpP<<" "<<icount_total<<"\n";
/***********PACKET HEADER DATA ANALYSIS****************************/
   switch (N1)
   { 
    case 1:{
            LenP[2]=pack_length;
		    numP[2]=(long int)(unsigned char)(Name_Buf[7])+
   	            256*(long int)(unsigned char)(Name_Buf[6])+
            256*256*(long int)(unsigned char)(Name_Buf[5]);
		    time_p[2]=(long int)(unsigned char)(Name_Buf_add[3])+
   	                 256*(long int)(unsigned char)(Name_Buf_add[2])+
                256*256*(long int)(unsigned char)(Name_Buf_add[1])+
			256*256*256*(long int)(unsigned char)(Name_Buf_add[0]);

			CRC_Header[2]=(int)(unsigned char)(Name_Buf_add[7]);
			adr_first[2]=icount-15;
			CRC_bad_pack[2]=0;
            flag_CRC_H[2]=0;
			flag_pack[2]=0;
			flag_name[2]=0;
			flag_type[2]=0;
			flag_time[2]=0;
			flag_CRC_cor[2]=0;
            for (i=0; i<2; i++)
			{numP[i]=numP[2]; time_p[i]=time_p[2];
			 CRC_Header[i]=CRC_Header[2]; 
			 LenP[i]=LenP[2];
			 adr_first[i]=adr_first[2];
			 CRC_bad_pack[i]=CRC_bad_pack[2];
			 flag_CRC_H[i]=flag_CRC_H[2];
			 flag_pack[i]=flag_pack[2];
             flag_name[i]=flag_name[2];
             flag_type[i]=flag_type[2];
             flag_time[i]=flag_time[2];
             flag_CRC_cor[i]=flag_CRC_cor[2];}
			break;
		   }
    default:{
             for (i=0; i<2; i++)
			 {numP[i]=numP[i+1];
			  time_p[i]=time_p[i+1];
			  CRC_Header[i]=CRC_Header[i+1];
			  CRC_bad_pack[i]=CRC_bad_pack[i+1];
			  LenP[i]=LenP[i+1];
			  adr_first[i]=adr_first[i+1];
                          adr_last[i]=adr_last[i+1];
			  flag_CRC_H[i]=flag_CRC_H[i+1];
                          flag_len[i]=flag_len[i+1];
                          flag_len_weak[i]=flag_len_weak[i+1];
			  flag_pack[i]=flag_pack[i+1];
			  flag_name[i]=flag_name[i+1];
			  flag_type[i]=flag_type[i+1];
			  flag_time[i]=flag_time[i+1];
			  flag_CRC_cor[i]=flag_CRC_cor[i+1];}
		          numP[2]=(long int)(unsigned char)(Name_Buf[7])+
   	                      256*(long int)(unsigned char)(Name_Buf[6])+
                          256*256*(long int)(unsigned char)(Name_Buf[5]);
		          time_p[2]=(long int)(unsigned char)(Name_Buf_add[3])+
   	                         256*(long int)(unsigned char)(Name_Buf_add[2])+
                             256*256*(long int)(unsigned char)(Name_Buf_add[1])+
			 256*256*256*(long int)(unsigned char)(Name_Buf_add[0]);
   
			 CRC_Header[2]=(int)(unsigned char)(Name_Buf_add[7]);
			 CRC_bad_pack[2]=0;
			 adr_first[2]=icount-15;
			 flag_CRC_H[2]=0;			 
                         flag_len[2]=0;
                         flag_len_weak[2]=0;
			 flag_pack[2]=0;
			 flag_name[2]=0;
			 flag_type[2]=0;
			 flag_time[2]=0;
			 flag_CRC_cor[2]=0;
                         LenP[2]=pack_length;
			}
   }
/********packet header CRC error analysis**************************/
//   CalcCheckSum=CRC_H(Name_Buf, Name_Buf_add);
  
   for (i=0; i<8; i++)
   {buff[i]=Name_Buf[i];
    buff[i+8]=Name_Buf_add[i];}

   CalcCheckSum=(short int)(unsigned char)CM_Compute_CRC16(0, (unsigned char*)&buff, 15); 
   if (CalcCheckSum!=(short int)(unsigned char)(Name_Buf_add[7]))
   {cerr<<"checksum error "<<N1<<" Pack="<<numP[2]<<
    " "<<num_type<<" "<<bitset<8>(CalcCheckSum)<<
	" CRC="<<bitset<8>((int)(unsigned char)(Name_Buf_add[7]))<<"\n";
//    cout<<(int)(unsigned char)(Name_Buf[0])<<" "
//		<<(int)(unsigned char)(Name_Buf[1])<<" "
//		<<(int)(unsigned char)(Name_Buf[2])
//		<<" "<<num_type<<" "<<num_type1<<" "<<num_type2<<" "<<tmpP<<"\n";
	CRC_bad_pack[2]=numP[2];
   	flag_CRC_H[2]=1;}
/*********packet counter error analysis****************************/
   if ((numP[2]!=(numP[1]+1))&&(N1!=1)&&
	   (flag_len[1]==0)&&(CRC_bad_pack[2]==numP[2])) flag_pack[2]=1;

   if ((numP[1]!=(numP[0]+1))&&(numP[1]!=(numP[2]-1))&&(N1!=1)&&
	   (CRC_bad_pack[1]==numP[1])) 
   {P_er=N1-1; flag_pack[1]=1;
//Correct error packet number//
   tmpP=numP[0]+1;
    for (i=0;i<3;i++) Hex[i]=0;
	for (i=0;i<3;i++)
	{if (tmpP/(long int)      (pow(256.,2-i))>=1) 
		{Hex[2-i]=(int)(tmpP/(long int)(pow(256.,2-i)));
	     tmpP=tmpP-(long int)(pow(256.,2-i)*
			 (int)(tmpP/(long int)(pow(256.,2-i)) ));}}
	for (i=5;i<8;i++) (Name_Buf_old[i]=(char)(Hex[7-i]));
	if (CRC_Header[1]==(int)(CRC_H(Name_Buf_old, Name_Buf_add_old)))
	{flag_CRC_cor[1]=1;}

    tmpP=numP[2]-1;
    for (i=0;i<3;i++) Hex[i]=0;
	for (i=0;i<3;i++)
	{if (tmpP/(long int)(pow(256.,2-i))>=1) 
		{Hex[2-i]=(int)(tmpP/(long int)(pow(256.,2-i)));
	     tmpP=tmpP-(long int)pow(256.,2-i)*
			 (int)(tmpP/(long int)(pow(256.,2-i)));}}
	for (i=5;i<8;i++) (Name_Buf_old[i]=(char)(Hex[7-i]));
	if (CRC_Header[1]==(int)(CRC_H(Name_Buf_old, Name_Buf_add_old)))
	{flag_CRC_cor[1]=1;}
   }
/*********************Missing packet analysis**********************/
/**packet numbers: 10 11 (12 15 19) 20 ****************************/
/***********missed kadrs: 16 17 18 ********************************/
   if ((numP[1]>numP[0]+1)&&(numP[1]<numP[2]-1)&&
	   (flag_pack[0]==0)&&(flag_pack[1]==0)&&(flag_pack[2]==0))
   {Mis_group+=1;
    fprintf(fo_miss,"%9i%9i\n",numP[1]+1,numP[2]-1);
    count_miss+=numP[2]-numP[1]-1;}
/**packet numbers: 10 (11 12 15) 19 20 ****************************/
/***********missed kadrs: 13 14 ***********************************/
   else if ((numP[1]>=numP[0]+1)&&(numP[1]<numP[2]-1)&&	        
			(flag_pack[2]==0)&&(flag_pack[1]==0)&&(flag_pack[0]==0))
   {Mis_group+=1;
    fprintf(fo_miss,"%9i%9i\n",numP[0]+2,numP[2]-1);
    count_miss+=numP[2]-numP[1]-1;}
/**packet numbers: 10 (11 20 15) 16 17 ****************************/
/********missed kadrs number =2 ***********************************/
   else if ((numP[0]<numP[2]-2)&&	        
			(flag_pack[2]==0)&&(flag_pack[1]==1)&&(flag_pack[0]==0)) 
  
   {Mis_group+=1;
    fprintf(fo_miss,"%9i%9i%9i\n",numP[0]+1,numP[1],numP[2]-1);
    count_miss+=numP[2]-numP[0]-2;}

/**************Time error******************************************/
   if ((numP[2]>=numP[0]+2)&&(flag_pack[2]==0)&&(flag_pack[0]==0)&&
	   (flag_time[0]==0)&&(time_p[2]>time_p[0])&&
	   ((time_p[1]<time_p[0])||(time_p[1]>time_p[2]))) 
   {flag_time[1]=1;}

/**************Error number calculation****************************/
   if (N1!=1)
   {flags=(short int)((float)(flag_len_weak[1])+
                      pow((float)(2*flag_CRC_H[1]),1)+
 	                  pow((float)(2*flag_len[1]),2)+
                      pow((float)(2*flag_pack[1]),3)+
					  pow((float)(2*flag_name[1]),4)+
                      pow((float)(2*flag_type[1]),5)+
                      pow((float)(2*flag_time[1]),6)+
					  pow((float)(2*flag_CRC_cor[1]),7));
    if (flags!=0) er_pack_count+=1;
//Write error number in log and work.dat files
	fprintf(fo_log,"%1c",char(flags));
//    fprintf(fo_work," error num.=%i CRC=%i Calc=%i\n",
//		    flags,bitset<8>(CRC_Header[1]),
//			(int)(CRC_H(Name_Buf_old, Name_Buf_add_old)));
   }
/***********************NAME ERROR*********************************/
   if (((int)(unsigned char)Name_Buf[0]!=CODE_BYTE1)||
       ((int)(unsigned char)Name_Buf[1]!=CODE_BYTE2)||
       ((int)(unsigned char)Name_Buf[2]!=CODE_BYTE3))
   {
    Name_Buf[0]=(char)(CODE_BYTE1);
    Name_Buf[1]=(char)(CODE_BYTE2);
    Name_Buf[2]=(char)(CODE_BYTE3);
    flag_name[2]=1;
    count_name_cor+=1;
    buffer[0]=(char)(CODE_BYTE1);
    buffer[1]=(char)(CODE_BYTE2);
    buffer[2]=(char)(CODE_BYTE3);
    if (CRC_Header[2]==(int)(CRC_H(Name_Buf, Name_Buf_add)))
    flag_CRC_cor[2]=1;
   }

/***********************PACKET TYPE ERROR**************************/
   if ((num_type==0)||(num_type1==0)||(num_type2==0)) flag_type[2]=1;

/******************PAMELA BEGIN PACKET DISPLACEMENT****************/
   temp[0]=adr_first[2];
   for (i=0;i<4;i++) Byte_adr1[i]=0;
   for (i=0;i<4;i++)
   {if (temp[0]/(long int)(pow(256.,3-i))>=1) 
	{Byte_adr1[3-i]=(int)(temp[0]/(long int)(pow(256.,3-i)));
	 temp[0]=temp[0]-(long int)pow(256.,3-i)*
			   (int)(temp[0]/(long int)(pow(256.,3-i)));}
   }   

//Write packet type and begin displacement in log and work.dat files
//   fprintf(fo_work,"Type %i: num. %i: first=%i:",
//           num_type, numP[2], adr_first[2]);
   fprintf(fo_log,"%1c",char(num_type));
   for (i=0;i<4;i++) fprintf(fo_log,"%1c",char(Byte_adr1[i]));

/**************PAMELA PACKET OLD BUFFER***************************/
   for (i=0;i<8;i++)
   {Name_Buf_old[i]=Name_Buf[i];Name_Buf_add_old[i]=Name_Buf_add[i];}

/**********************data reading********************************/
   fin.seekg(-1,ios::cur); icount-=1; icount_total-=1;
   fin.read(Name_Buf,8); 
   if (fin.eof()) break;
   icount+=8; icount_total+=8;
   for (i=0;i<7;i++) buffer[i+16]=Name_Buf[i+1]; 
  }
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
/**********************data reading********************************/
  fin.get(ch);
  if (fin.eof()) {break;}
  icount_total+=1;
  if (fmod( double(icount_total), double(100000000.))==double(0.)) {cout<<"Mbytes="<<icount_total/1000000.<<"\n";}
  if ((N1>0)&&(FLAG_BIG==0)) icount+=1; 
  for (i=0;i<7;i++) Name_Buf[i]=Name_Buf[i+1];
  Name_Buf[7]=ch; /*for(i=0;i<8;i++) printf("%x",(int)(unsigned char)Name_Buf[i]); printf("\n");*/
  if ((icount-adr_first[2]-1)<Nmax)
  {buffer[icount-adr_first[2]]=ch;}
  else
  {flag_len[2]=1;
   if (FLAG_BIG==0) {cout<<"too long packet "<<numP[2]<<"\n";}
   FLAG_BIG=1;
  }
 }
/******************************************************************/
/********************MAIN READING CYCLE END************************/
/******************************************************************/

/*************PAMELA LAST PACKET END DISPLACEMENT******************/
  if (FLAG_BIG==0) {adr_last[2]=icount;}
  else {adr_last[2]=adr_first[2]+Limit;}
  if ((adr_last[2]-adr_first[2]+1-LenP[2]-16>64)||(adr_last[2]-adr_first[2]+1-LenP[2]-16<0)) flag_len[2]=1;
  if ( (flag_len[2]!=1)&&(flag_CRC_H[2]!=1) )
  {adr_last[2]=adr_first[2]+LenP[2]+15;}
  temp[1]=adr_last[2];
  for (i=0;i<4;i++) Byte_adr2[i]=0;
  for (i=0;i<4;i++)
  {if (temp[1]/(long int)(pow(256.,3-i))>=1) 
	{Byte_adr2[3-i]=(int)(temp[1]/(long int)(pow(256.,3-i)));
     temp[1]=temp[1]-(long int)pow(256.,3-i)*
     (int)(temp[1]/(long int)(pow(256.,3-i)));}}
  
/*********PAMELA LAST PACKET LENGTH ERROR ANALYSIS*****************/
// if ((adr_last[2]-adr_first[2]+1)!=(LenP[2]+(64-LenP[2]%64)))
// {flag_len[2]=1;}

//Write last packet end displacement in log and work.dat files
 for (i=0;i<4;i++) fprintf(fo_log,"%1c",char(Byte_adr2[i]));
// fprintf(fo_work," last=%i",adr_last[2]);

//Write error number in log and work.dat files
 flags=(short int)(pow((float)(2*flag_CRC_H[2]),1)+
 	               pow((float)(2*flag_len[2]),2)+
                   pow((float)(2*flag_pack[2]),3)+
                   pow((float)(2*flag_name[2]),4)+
				   pow((float)(2*flag_type[2]),5)+
                   pow((float)(2*flag_time[2]),6)+
				   pow((float)(2*flag_CRC_cor[2]),7));
 if ((flags!=0)&&(N1>0)) er_pack_count+=1; 
 fprintf(fo_log,"%1c",char(flags));
// fprintf(fo_work," error num.=%i CRC=%i Calc=%i\n",
//	     flags,bitset<8>(CRC_Header[2]),
//		 (int)(CRC_H(Name_Buf, Name_Buf_add)));

//Write inf file
 fprintf(fo_inf,"file name=%s\n",name_in);
 fprintf(fo_inf,"%lli bytes\n",icount_total);
 icount_int = (int)(icount_total/1024);
 icount_frac= icount_total%1024;
 fprintf(fo_inf,"file size= %i,%i kByte \n", icount_int,
		                                       icount_frac);

 fprintf(fo_inf,"number of identified packets= %i\n", N1);
 fprintf(fo_inf,"number of PAMELA missed packets= %i\n",
	             count_miss);
 fprintf(fo_inf,"number of PAMELA packets with error= %i\n",
	             er_pack_count);
 fprintf(fo_inf,"number of PAMELA packets with corrected name= %i\n",
	             count_name_cor);
 fprintf(fo_inf,"number of PAMELA packets with non identified type");
 fprintf(fo_inf," =%i\n",packet_counter[0]);

 for (i=1;i<NumberPack;i++)
 {
  fprintf(fo_inf,"Type %x  number of PAMELA packets= %i\n",
	             packet_type[i-1], packet_counter[i]);
 }
//Write data in file "mmm_counter_nnnnn_cln2.pam"
 for (i=0;i<adr_last[2]-adr_first[2]+1;i++)
 {fo_pam<<buffer[i];}

 time(&seconds);
 timeinfo=localtime(&seconds);
 strftime(time_year,5,"%Y",timeinfo);
 strftime(time_month,5,"%m",timeinfo);
 strftime(time_day,5,"%d",timeinfo);
 strcat( strcat(strcat(strcat(strcpy(data_time,time_year),"-"),time_month),"-"),time_day);

 for (i=strlen(pam)-22;i<=strlen(pam);i++)
 {name_cln2[i-(strlen(pam)-22)]=pam[i];}
 for (i=0;i<strlen(pam)-22;i++)
 {name_path[i]=pam[i];}
 name_path[strlen(pam)-22]='\0';
 for (i=8;i<13;i++)
 {cirquit_no[i-8]=name_cln2[i];}
 cirquit_no[5]='\0';
 for (i=0;i<3;i++)
 {route_no[i]=name_cln2[i];}
 route_no[3]='\0';
 file_ready=1;
 file_deleted=0;
 file_archived=0;
 file_proces=0;
 if (IndexQ>0.9) file_proces=1;

/* printf("cirquit=%s \n", cirquit_no);
 printf("route=%s \n", route_no);
 printf("quality=%f \n", IndexQ);
 printf("ready=%i \n", file_ready);
 printf("deleted=%i \n", file_deleted);
 printf("data=%s \n", data_time);
 printf("achived=%i \n", file_archived);
 printf("path=%s \n", name_path);
 printf("name=%s \n", name_cln2);
 printf("processed=%i \n", file_proces);*/

 if (IndexQ>0.999) {flag_to_transmit=1;}
 else {flag_to_transmit=0;}
 oss.str("");
 oss << "INSERT INTO FILES (cirquit_n, route_n, counter, qual_index, ready, deleted, date,"
     << " archived, path, cln2_name, proces_flag, transit_flag)"
     << " VALUES ('"<< cirquit_no << "','"<< route_no << "','"<<r_counter<<"','"<< IndexQ << "','"
     << file_ready << "','"<< file_deleted << "','"<< data_time << "','"<< file_archived << "','"
     << name_path << "', '" << name_cln2 << "', '" << file_proces << "','"
     << flag_to_transmit << "')";
 cout<<oss.str().c_str()<<" table FILES\n";      
 TSQLResult *res=sqlServer->Query(oss.str().c_str());

 flag_sec_trans=0;
 
 oss1.str("");
 oss1 <<"INSERT INTO FILES1 (my_route, raw_filename, pam_size, cirquit_n, route_n, route_real,"
      <<" counter, board_time, Num_all, Num_macro, flag_twice)"
      <<" VALUES ('"<<current_route<<"','"<<name_ini<<"','"<<icount<<"','"<<cirquit_no<<"','"
      <<route_no<<"','"<<real_route[r_counter]<<"','"<<r_counter
      <<"','"<<time_p[2]<<"','"<<N1<<"','"<<packet_counter[28]<<"','"<<flag_sec_trans<<"')";
 cout<<oss1.str().c_str()<<" table FILES1\n";      
 TSQLResult *res3=sqlServer->Query(oss1.str().c_str()); 

// if (conn->Query(oss.str().c_str()) == 0)
// {
//  printf("ERROR!!!");
// }

 delete [] buffer;

/***************************************************************/
  fin.close();
  fclose(fo_work);
  fclose(fo_log);
  fclose(fo_inf);
  fo_pam.close();
  fclose(fo_miss);
}