/***************************************************************************
 *   MultiAri                                                              *
 *   2006 DvbXtreme                                          *
 *   http://dvbxtreme.dvb-z.net/                                           *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#include <stdio.h>
//---------------------------------------------------------------------------
#define DEFAULTSIZE 0x00200000
static unsigned char buf[DEFAULTSIZE];
//---------------------------------------------------------------------------
unsigned int DefaultSize(void) {return DEFAULTSIZE;};
//---------------------------------------------------------------------------
unsigned char* Buf(void) {return buf;};
//---------------------------------------------------------------------------
static void ClearBuf(unsigned char *data)
{
int i;
for (i=0; i<DEFAULTSIZE; i++)
        {
        data[i]=0;
        };
}
//---------------------------------------------------------------------------
static unsigned int Load(char *FileName, unsigned char *data, unsigned int size, unsigned char verbose)
{
unsigned int ret=0;
FILE * pFile;
pFile=fopen(FileName,"rb");
if (pFile!=NULL)
   {
    if (verbose) {printf("Open: %s\n",FileName);};
   ret=fread(data,1,size,pFile);
   fclose(pFile);
    if (verbose) {printf("Read: %i bytes\n",ret);};
   }
else
    {
    printf("Open: %s - Error!\n",FileName);
    };
return ret;
}
//---------------------------------------------------------------------------
static unsigned int Save(char *FileName, unsigned char *data, unsigned int size, unsigned char verbose)
{
unsigned int ret=0;
FILE * pFile;
pFile=fopen(FileName,"wb");
if (pFile!=NULL)
   {
   if (verbose) {printf("Save: %s\n",FileName);};
   ret=fwrite(data,1,size,pFile);
   fclose(pFile);
    if (verbose) {printf("Write: %i bytes\n",ret);};
   }
else
    {
    printf("Save: %s - Error!\n",FileName);
    };
return ret;
}
//---------------------------------------------------------------------------
extern const unsigned int TabCode[];
static void Range(unsigned char *data,unsigned int start, unsigned int stop)
{
unsigned int i;
unsigned int sum=0xFFFFFFFF;
for (i=0; i<(stop-start); i++)
   {
   sum=(sum<<8)^(TabCode[(sum>>24)^(data[i+start])]);
   };
for (i=0; i<4; i++)
   {
   data[stop+i]=(sum & 0xFF);
   sum>>=8;
   };
}
//---------------------------------------------------------------------------
extern const unsigned char IRKHeader[];
static unsigned int BuildIRK(unsigned char *data)
{
int i;
Range(data,0,17600);
for (i=0; i<65536; i++)
   {
   data[65535+64-i]=data[65535-i];
   };
for (i=0; i<64; i++)
   {
   data[i]=IRKHeader[i];
   };
return (65600);
}
//---------------------------------------------------------------------------
#define SN(b) (((b&0xf0)>>4)+((b&0xf)<<4))
extern const unsigned char BC[];
extern const unsigned char TD[];
extern const unsigned char key[];
extern const unsigned char T1[];
extern const unsigned char T2[];
void InsertCP(unsigned char *data)
{
unsigned int position=0,i,j,x,y=0,s=0,spec=0,g;
unsigned char ok,dt,d[8],D[4],kk[16],*k;
for (x=0; x<2; x++)
   {
   for (j=position; j<DEFAULTSIZE; j++)
      {
      ok=1;
      for (i=0; i<8; i++)
         {
         if (data[j+i]!=BC[i])
            {
            ok=0;
            i=8;
            };
         };
      if (ok)
         {
         position=j+8;
         j=DEFAULTSIZE;
         y++;
         };
      };
   };
if (y==2)
   {
    for (g=0; g<4; g++) {spec<<=8;spec+=data[0x14+g];};
   i=64;
    if (spec==0xDDFFDDFF) {i+=65536;};   
   while (i<(position-8))
      {
        for (j=0; j<8; j++)
         {
         s+=data[i];
         i++;
         };
      i+=8;
      };
   d[3]=(s & 0xFF000000) >> 24;
   d[2]=(s & 0xFF0000) >> 16;
   d[1]=(s & 0xFF00) >> 8;
   d[0]=(s & 0xFF);
   d[4]=0x00;
   d[5]=0x00;
   d[6]=0x00;
   d[7]=0x00;
   for(i=0;i<16;++i) {kk[i]=key[i];};
   for(j=i=0;i<16;++i,j=(j+4)&0xf)
      {
      for(x=0;x<4;++x)
         {
         kk[j+x]^=T1[kk[(j+x+1)&0xf]^kk[(j+x+15)&0xf]^i];
         };
      if (i>0)
         {
         for(x=0;x<4;++x)
            {
            dt=d[x];d[x]=d[4+x];d[4+x]=dt;
            };
         };
      for(x=0; x<4; ++x) {D[x]=d[x+4];};
      k=&kk[j];
      for(x=0;x<4;++x) {D[x]^=k[x];};
      for(x=0;x<4;++x) {D[x]=T1[D[x]];};
      for(x=6;x>3;--x)
         {
         D[(x+2)&3]^=D[(x+1)&3];
         dt=(SN(D[(x+1)&3])+D[x&3])&0xff;
         D[x&3]=T2[dt];
         };
      for(x=3;x>0;--x)
         {
         D[(x+2)&3]^=D[(x+1)&3];
         D[x&3]=T1[(SN(D[(x+1)&3])+D[x&3])&0xff];
         };
      D[2]^=D[1];
      D[1]^=D[0];    
      for(x=0;x<4;++x) {d[x]^=T2[D[TD[x]]];};
      };
   for (i=0;i<8;i++) {data[position+i]=d[i];};
   };
};
//---------------------------------------------------------------------------
unsigned int W(unsigned char *data,unsigned int pos)
{
unsigned int ret;
ret=((unsigned int)(data[pos+1]) << 8)+data[pos];
return ret;
}
//---------------------------------------------------------------------------
static unsigned int L(unsigned char *data, unsigned int pos)
{
unsigned int ret=0,i;
for (i=0; i<4; i++) {ret<<=8; ret|=data[pos+3-i];};
return ret;
}
//---------------------------------------------------------------------------
static void Ls(unsigned char *data, unsigned int pos, unsigned int val)
{
unsigned int i;
for (i=0; i<4; i++) {data[pos+i]=val&0xFF;val>>=8;};
}
//---------------------------------------------------------------------------
unsigned int FSizeH(unsigned char *data)
{
return (L(data,0x1C));
}
//---------------------------------------------------------------------------
unsigned int HSum(unsigned char *data)
{
unsigned int ret=0,i;
for (i=0; i<60; i++) {ret+=data[i];};
return ret;
}
//---------------------------------------------------------------------------
unsigned char CpMes(char *dest, char *source)
{
int i=0,ret=0;
while (i<255)
   {
   dest[i]=source[i];
   i++;
   if (source[i]==0) {ret=i;i=255;};
   }
return ret;
}
//---------------------------------------------------------------------------
static char Info[255];
char* FileInfo(void)
{
int i;
i=CpMes(Info,"MultiAri - console version - DvbXtreme - ");
CpMes(&Info[i],__DATE__);
return Info;
}
//---------------------------------------------------------------------------
static char FileTypeStr[255];
enum FTYPE {UNK,AUC,BUC,IRD,IRK,IRS,IRP,IRC,MST,ARI};
char* FileType(void) {return FileTypeStr;};
//---------------------------------------------------------------------------
void NewHeader(char *HeaderName, unsigned char *data, unsigned char verbose)
{
unsigned int i;
unsigned char newh[20];
i=Load(HeaderName,newh,20,verbose);
if (i==20)
   {
   if (verbose)
      {
      printf("Change (type) %s to %s\n",&data[4],&newh[0]);
      printf("Change (Ver.) %s to %s\n",&data[32],&newh[4]);
      printf("Change (Model) %s to %s\n",&data[38],&newh[10]);
      };   
   for (i=0; i<4; i++) {data[4+i]=newh[i];}; data[8]=0;
   for (i=0; i<6; i++) {data[32+i]=newh[4+i];}; data[36]=0;
   for (i=0; i<10; i++) {data[38+i]=newh[10+i];}; data[47]=0;
   Ls(data,0x3C,HSum(data));
   if (verbose)
      {
      printf("Header sum = 0x%x\n",HSum(data));
      };
   printf("New header: OK\n");
   }
else
   {
   printf("%s - wrong size",HeaderName);
   };
}
//---------------------------------------------------------------------------
unsigned int Prepare(char *FileName, unsigned char *data, unsigned char crc,
                      char *HeaderName, unsigned char ah,unsigned char verbose)
{
unsigned int i,j;
enum FTYPE ft;
ClearBuf(data);
for (i=0; i<255; i++) {FileTypeStr[i]=0;};
i=Load(FileName,data,DEFAULTSIZE,verbose);
if ((L(data,0x30)==0x41414141) && (L(data,0x34)==0x41414141) && (L(data,0x38)==0x00414141) && (L(data,0x00)==0x04212500))
   {
   if (crc)
      {
      Ls(data,0x3C,HSum(data));
      };
   j=L(data,0x14);
   switch (j)
      {
      case 0x00000001:
         {
         ft=AUC;
         if (crc) {InsertCP(data);};
         if (ah) {NewHeader(HeaderName,data,verbose);};
         } break;
      case 0xFFEEFFDD:
         {
         ft=BUC;
         if (ah) {NewHeader(HeaderName,data,verbose);};
         } break;
      case 0xFFDDFFDD:
         {
         ft=MST;
         if (ah) {NewHeader(HeaderName,data,verbose);};
         } break;
      case 0x00008209:
         {
         ft=IRD;
         if (crc)
            {
            Ls(data,0x04,0x6F697241);
            Ls(data,0x08,0x0000006E);
            Ls(data,0x20,0x31535241);
            Ls(data,0x24,0x52410000);
            Ls(data,0x28,0x00003148);
            Ls(data,0x2C,0x00000000);
            Ls(data,0x3C,HSum(data));
            Range(data,0x40,data[0x07006A]*0x1E84+0x40);
            Range(data,0x40,0x02FB24);
            Range(data,0x030040,W(data,0x070076)*0x2C+0x030040);
            Range(data,0x030040,0x059E90);
            Range(data,0x060040,W(data,0x070074)*0x10+0x060040);
            Range(data,0x060040,0x06FA40);
            Range(data,0x070040,0x077974);
            Range(data,0x080040,0x080044);      
            };
         i=FSizeH(data)+64;
         } break;
      case 0xFFCCFFDD:
         {
         ft=IRK;
         if (crc) {Range(data,64,17664);};
         } break;   
      case 0x54425553:
         {
         ft=IRS;
         } break;
      case 0x57454956:
         {
         ft=IRP;
         } break;
      case 0x20205743:
         {
         ft=IRC;
         } break;
      default:
         {
         ft=ARI;
         } break;;
      };
   }
else
   {
   if (i==17600)
      {
      ft=IRK;
      BuildIRK(data);
      i=FSizeH(data)+64;
      }
   else
      {
      ft=UNK;
      };
   };
switch (ft)
   {
   case AUC: {CpMes(FileTypeStr,"AUC: Firmware");} break;
   case BUC: {CpMes(FileTypeStr,"BUC: Boot");} break;
   case MST: {CpMes(FileTypeStr,"Arion Master");} break;
   case IRD: {CpMes(FileTypeStr,"IRD: DataBase");} break;
   case IRK: {CpMes(FileTypeStr,"IRK: Keys");} break;
   case IRS: {CpMes(FileTypeStr,"IRS: Subtitles");} break;
   case IRP: {CpMes(FileTypeStr,"IRP: Panel");} break;
   case IRC: {CpMes(FileTypeStr,"IRC: CW");} break;
   case ARI: {CpMes(FileTypeStr,"Arion File");} break;
   default: {CpMes(FileTypeStr,"Unknown");} break;
   };
return i;
}
//---------------------------------------------------------------------------
unsigned char rec[1024];
//---------------------------------------------------------------------------
#ifdef __WIN32__
//---------------------------------------------------------------------------
#include <windows.h>
char defaultportname[]="COM1";
HANDLE hComm=NULL;
//---------------------------------------------------------------------------
unsigned char ReadABuffer(char *lpBuf, int bsize)
{
DWORD dwRead;
ReadFile(hComm, lpBuf, bsize, &dwRead, NULL);
return 1;
}
//---------------------------------------------------------------------------
unsigned char WriteABuffer(char *lpBuf, int bsize)
{
DWORD dwWritten;
WriteFile(hComm, lpBuf, bsize, &dwWritten, NULL);
return 1;
};
//---------------------------------------------------------------------------
void CloseCOM(void)
{
if (hComm)
   {
   CloseHandle(hComm);
   hComm=NULL;
   };
}
//---------------------------------------------------------------------------
unsigned char OpenCOM(char *COMnm)
{
unsigned char ret;
hComm=CreateFile(COMnm,GENERIC_READ | GENERIC_WRITE,0,0,OPEN_EXISTING,0,0);
if (hComm==INVALID_HANDLE_VALUE) {ret=0;}
else
   {
   DCB dcb;
   FillMemory(&dcb, sizeof(dcb), 0);
   if (!GetCommState(hComm, &dcb)) {ret=0;}
   else
      {
      dcb.BaudRate = CBR_115200 ;
      dcb.ByteSize = 8;
      dcb.Parity = NOPARITY;
      dcb.StopBits = ONESTOPBIT;
      dcb.fOutxDsrFlow = 0;
      dcb.fOutxCtsFlow = 0;
      dcb.fDtrControl = DTR_CONTROL_ENABLE;
      dcb.fRtsControl = RTS_CONTROL_ENABLE;
      dcb.fDsrSensitivity = 0;
      dcb.fTXContinueOnXoff = 1;
      dcb.fInX = dcb.fOutX = 0;
      dcb.XonChar = 0x11;
      dcb.XoffChar = 0x13;
      dcb.XonLim = dcb.XoffLim = 100;
      dcb.fBinary = 1;
      dcb.fParity = 0;
      dcb.fNull = 0;
      if (!SetCommState(hComm, &dcb)) {ret=0;}
      else
        {
        COMMTIMEOUTS timeouts;
        timeouts.ReadIntervalTimeout=50;
        timeouts.ReadTotalTimeoutMultiplier=20;
        timeouts.ReadTotalTimeoutConstant=200;
        timeouts.WriteTotalTimeoutMultiplier=20;
        timeouts.WriteTotalTimeoutConstant=200;
        if (!SetCommTimeouts(hComm, &timeouts)) {ret=0;}
        else {ret=1;};
        };
      };
   };
return ret;
}
#else
//---------------------------------------------------------------------------
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <string.h>
//---------------------------------------------------------------------------
char defaultportname[]="/dev/ttyS0";
int hComm;
struct termios oldtio,newtio;
//---------------------------------------------------------------------------
unsigned char OpenCOM(char *COMnm)
{
unsigned char ret=0;
hComm=open(COMnm, O_RDWR | O_NOCTTY /*| O_NDELAY*/);
if (hComm!=-1)
      {
      tcgetattr(hComm,&oldtio);
      bzero(&newtio, sizeof(newtio));
      newtio.c_cflag = B115200 | CS8 | CLOCAL | CREAD;
      newtio.c_iflag = IGNPAR;
      newtio.c_oflag = 0;
      newtio.c_lflag = 0;
      newtio.c_cc[VTIME] = 2;
      newtio.c_cc[VMIN] = 0;
      tcflush(hComm, TCIFLUSH);
      tcsetattr(hComm,TCSANOW,&newtio);
      ret=1;
      }
else
      {
      hComm=0;        
      }
return ret;
}
//---------------------------------------------------------------------------
void CloseCOM(void)
{
if (hComm)
   {
   tcsetattr(hComm,TCSANOW,&oldtio);
   close(hComm);
   hComm=0;
   };
}
//---------------------------------------------------------------------------
unsigned char smbuf[1024];
unsigned char ReadABuffer(unsigned char *lpBuf, int bsize)
{
unsigned char ret=0,end=0;
int n,i,p=0;
while (!end)
   {
   n=read(hComm,smbuf,bsize-p);
   if (n)
      {
      for (i=0; i<n;i++) {lpBuf[p]=smbuf[i];p++;};
      if (p>=bsize)
         {
          end=1;
          ret=1;
         };     
      }
   else {end=1;};
   }
return ret;
}
//---------------------------------------------------------------------------
unsigned char WriteABuffer(unsigned char *lpBuf, int bsize)
{
unsigned char ret=0;
int n;
n=write(hComm,lpBuf,bsize);
if (n>0) {ret=1;};
return ret;
}
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------
void SendByte(unsigned char b)
{
rec[0]=b;
WriteABuffer(rec,1);
};
//---------------------------------------------------------------------------
unsigned char ReceiveByte(void)
{
rec[0]=0x00;
ReadABuffer(rec,1);
return rec[0];
};
//---------------------------------------------------------------------------
void SendHeader(void)
{
WriteABuffer(Buf(),64);
};
//---------------------------------------------------------------------------
unsigned int ReceiveData(unsigned char *data,unsigned char v)
{
unsigned int DataSize=1,sum,rsum,i,p=0,error=0;
int a=50;
printf("?");
while (a)
   {
   a--;
   if (ReceiveByte()==(unsigned char)(0xE1))
      {
      a=0;
      printf("\nReceiving data...\n");
      if (v) {printf("Receive E1, Send E2\n");};
      SendByte(0xE2);
      if (ReceiveByte()==(unsigned char)(0xEF))
         {
         if (v) {printf("Receive EF, Send E3\n");};
        SendByte(0xE3);
        ReadABuffer(data,64);
        DataSize=0;
         for (i=0; i<4; i++)
            {
           DataSize<<=8;
           DataSize|=data[0x1F-i];
            };
         DataSize+=64;
         p=64;
         if (v) {printf("Receive Header, Data size = %i\nSend E4\n",DataSize);};
         SendByte(0xE4);
         if (ReceiveByte()==(unsigned char)(0xE6))
            {
           while (p<DataSize)
               {
             SendByte(0xE7);
             ReadABuffer(rec,1024); 
             SendByte(0xE8);
             if (ReceiveByte()==(unsigned char)(0xEA))
                  {
                  sum=0;
               for (i=0; i<1021; i++)
                 {
                     data[p]=rec[i+1];
                     sum+=(unsigned char)(rec[i+1]);
                     sum&=0xFFFF;
                     p++;
                     };
                  rsum=((unsigned int)(rec[1022]) << 8)|((unsigned int)(rec[1023]));
               if (sum==rsum)
                  {
                  if (v) {printf("%i / %i ( %x )\n",p,DataSize,rsum);};
                  }
               else
                  {
                  printf("Wrong sum! ( %x / %x )\n",sum,rsum);
                  error=1;
                  };
               }
            else
               {
               printf("Lost EA - Error!\n");
               error=1;
               };
            };
         SendByte(0xEB);
         }
       else
          {
          printf("Lost E6 - Error!\n");
          error=1;
          };
         }
      else
         {
         printf("Lost EF - Error!\n");
         error=1;
         };
      }
   else
      {
      if (v) {printf("?");fflush(stdout);};
      };
   if (!a) {printf("\n");};
   };
if (p>=DataSize)
   {
   if (error)
      {
       printf("Transmission with errors, send EB\n");   
       DataSize=0;   
      }
   else
      {
      if (v) {printf("All data received, send EB\n");};
      };
   SendByte(0xED);
   }
else
    {
    DataSize=0;
    };
return DataSize;
}
//---------------------------------------------------------------------------
unsigned char SendData(unsigned char *data, unsigned char v)
{
char info[]="Sending ( xx% )";
unsigned char ret=0,oki;
unsigned int p=64,i,a,sum;
unsigned char *Data=data;
unsigned int DataSize=FSizeH(Data)+64;
printf("Sending data...\n");
SendByte(0xE6);
while (p<DataSize)
   {
   if (ReceiveByte()==(unsigned char)(0xE7))
       {
       rec[0]=0x47;
       sum=0;
       for (i=0; i<1021; i++)
                {
                rec[i+1]=Data[p];
                sum+=(unsigned char)(rec[i+1]);
                sum&=0xffff;
                p++;
                };
       rec[1022]=(unsigned char)((sum & 0xff00) >> 8);
       rec[1023]=(unsigned char)((sum & 0x00ff));
       WriteABuffer(rec,1024);
       if (ReceiveByte()==(unsigned char)(0xE8))
          {
          unsigned int progress=100*p/DataSize,a,b;
          if (progress>99) {progress=99;};
          a=progress/10;
          b=progress % 10;
          info[10]=a+'0';
          info[11]=b+'0';
          if (v) {printf("%s - %i/%i\n",info,p,DataSize);}
          else {printf("\r%s",info);fflush(stdout);};
          SendByte(0xEA);
          }
       else
          {
          p=DataSize;
          };
       };
   };
printf("\rSending ( 100% )\nUpgrading...");
fflush(stdout);
if (v) {printf("\n");};
a=400;
oki=0;
while (a)
   {
   a--;
   if (ReceiveByte()==(unsigned char)(0xEB))
      {
      a=0;
      oki=1;
      }
   else
      {
      if (v) {printf(".");fflush(stdout);};
      };
   if (a==0)
      {
      ret=1;
      if (oki) {printf("\nDone.");} else {printf("\nDone?");};
      };
   };
return ret;
};
//---------------------------------------------------------------------------
unsigned char Trans(unsigned char *data, unsigned char v)
{
unsigned char ret=0;
int a=50;
printf("?");
while (a)
   {
   a--;
   SendByte(0xE1);
   if (ReceiveByte()==(unsigned char)(0xE2))
     {
     if (v) {printf("\nCOM Confirmed\n");};
     SendByte(0xEF);
     if (v) {printf("Send header\n");};
      if (ReceiveByte()==(unsigned char)(0xE3))
        {
        SendHeader();
        if (ReceiveByte()==(unsigned char)(0xE4))
           {
           if (v) {printf("Header OK\n");} else {printf("\n");};
           if (SendData(data,v))
              {
              ret=1;
              a=0;
              }
           else
              {
              a=0;
              };
           }
        else
           {
           printf("Wrong header!\n");
           a=0;
           };
        }
      else
        {
        printf("Wrong Ack!\n");
        a=0;
        };   
      SendByte(0xED);
      }
   else
      {
      if (v) {printf("?");fflush(stdout);};
      };
   };
printf("\n");
return ret;
}
//---------------------------------------------------------------------------
unsigned char GetHeader(unsigned char *buf,unsigned char v)
{
unsigned char ret=0;
int a=50;
printf("?");
while (a)
   {
   a--;
   if (ReceiveByte()==(unsigned char)(0xE1))
      {
      if (v) {printf("\nReceive E1, Send E2\n");};
      SendByte(0xE2);
      if (ReceiveByte()==(unsigned char)(0xEF))
         {
         if (v) {printf("Receive EF, Send E3\n");};
        SendByte(0xE3);
        ReadABuffer(buf,64);
         if (v) {printf("Receive Header, Send ED (terminate)");};
         SendByte(0xED);
         a=0;
         ret=1;
        }
     else
        {
        SendByte(0xED);
        if (v) {printf("Lost EF - Error!");};
        a=0;
        };
     }
   else
      {
      if (v) {printf("?");fflush(stdout);};
      };
   };
printf("\n");
return ret;
}
//---------------------------------------------------------------------------
void Detect(char *filename, char *portname, unsigned char verbose)
{
int i;
unsigned char buf[64];
unsigned char hf[20];
if (OpenCOM(portname))
   {
   if (verbose) {printf("Open: %s\n",portname);};
   printf("PRESS: 74620\n");
   if (GetHeader(buf,verbose))
      {
      for (i=0; i<20; i++) {hf[i]=0;};
      for (i=0; i<4; i++) {hf[i]=buf[4+i];};
      for (i=0; i<6; i++) {hf[4+i]=buf[32+i];};
      for (i=0; i<10; i++) {hf[10+i]=buf[38+i];};
      if (verbose)
         {
         printf("Header ID:\n");
         printf("Type: %s\n",&hf[0]);
         printf("Ver: %s\n",&hf[4]);
         printf("Model: %s\n",&hf[10]);         
         };
      Save(filename,hf,20,verbose);
      printf("Header ID in file: %s\n",filename);
      }
   else
      {
      printf("Lost header!\n");
      };
   }
else
   {
   printf("Open %s - Error!\n",portname);
   };
CloseCOM();
}
//---------------------------------------------------------------------------
void Receive(char *filename, char *portname, unsigned char verbose)
{
unsigned int i;
if (OpenCOM(portname))
   {
   if (verbose) {printf("Open: %s\n",portname);};
   printf("PRESS: required code\n");
   i=ReceiveData(Buf(),verbose);
   if (i)
      {
      printf("Transmission OK\n");
      Save(filename,Buf(),i,verbose);
      printf("Data in file: %s\n",filename);
      }
   else
      {
      printf("Transmission Error!\n");
      };
   }
else
   {
   printf("Open %s - Error!\n",portname);
   };
CloseCOM();
}
//---------------------------------------------------------------------------
void Send(unsigned char *data, char *portname, unsigned char verbose)
{
if (OpenCOM(portname))
   {
   if (verbose) {printf("Open: %s\n",portname);};
   printf("PRESS: 24680/POWER\n");
   if (Trans(data,verbose))
      {
      printf("Transmission OK\n");
      }
   else
      {
      printf("Transmission Error!\n");
      };
   }
else
   {
   printf("Open %s - Error!\n",portname);
   };
CloseCOM();
}
//---------------------------------------------------------------------------
void Help(char *dpn)
{
printf("\nMultiAri filename [options]\n");
printf("\noptions:\n");
printf(" -?  this info\n");
printf(" -c  recalculate checksums\n");
printf(" -d  detect header and save to filename\n");
printf(" -p portname  port name\n");
printf(" -h headerfile  insert header from headerfile\n");
printf(" -v  verbose mode\n");
printf(" -s file  save to file\n");
printf(" -r  receive data and save to filename\n");
printf("\nexample:\n");
printf("\nMultiAri S190CI.hdr -d\n"); 
printf(" detect header on default port and save to filename\n");
printf("\nMultiAri soft.auc -h S190CI.hdr -c -p %s -v\n",dpn);
printf(" load soft.auc, change header (based on S190CI.hdr), calc new sums, use %s\n",dpn);
printf("\n");
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
int i;
unsigned char file=0,help=0,crc=0,detect=0,port=0,header=0,verbose=0,save=0,receive=0;
char *filename,*headerfile,*portname,*savefile;
printf("%s\n",FileInfo());
for (i=1; i<argc; i++)
   {
   if (argv[i][0]=='-')
      {
      switch (argv[i][1])
         {
         case 'C':
         case 'c':
            {
            crc=1;
            } break;
         case 'D':
         case 'd':
            {
            detect=1;
            } break;
         case 'R':
         case 'r':
            {
            receive=1;
            } break;

         case 'V':
         case 'v':
            {
            verbose=1;
            } break;
         case 'P':
         case 'p':
            {
            if ((i+1)<argc)
            {
                port=1;
                portname=argv[i+1];
                i++;
                }
            else
                {
                help=1;
                };
            } break;
         case 'H':
         case 'h':
            {
            if ((i+1)<argc)
            {
                header=1;
                headerfile=argv[i+1];
                i++;
                }
            else
                {
                help=1;
                };
            } break;
         case 'S':
         case 's':
            {
            if ((i+1)<argc)
            {
                save=1;
                savefile=argv[i+1];
                i++;
                }
            else
                {
                help=1;
                };
            } break;
         default:
            {
            help=1;
            } break;
         };   
      }
   else
      {
      file=1;
      filename=argv[i];
      };
   };   
if ((help) || (!file))
   {
   Help(defaultportname);
   }
else
   {
   if (verbose) {printf("Verobse mode: on\n");};
   if (!port)
         {
         portname=defaultportname;
         if (verbose) {printf("Default port name: %s\n",portname);};
         };
   if ((detect) || (receive))
      {
      if (detect)
         {
         if (verbose) {printf("Detect for %s\n",filename);};
         Detect(filename,portname,verbose);     
         }
      else
         {
         if (verbose) {printf("Receive from %s to %s\n",portname,filename);};
         Receive(filename,portname,verbose);     
         };
      }
   else
      {
      if (verbose)
         {
         printf("Main file: %s\n",filename);
         if (save) {printf("Save to: %s\n",savefile);};
         if (header) {printf("Header file: %s\n",headerfile);};
         if (crc) {printf("CRC: on\n");} else {printf("CRC: off\n");};         
         };
      i=Prepare(filename,Buf(),crc,headerfile,header,verbose);
      if (i)
        {
        printf("FileType: %s\n",FileType());
         if (save)
            {
            printf("Save data to: %s\n",savefile);
            Save(savefile,Buf(),i,verbose);
            }
         else
            {
            Send(Buf(),portname,verbose);
            };
        }
      else
        {
        printf("Unknown File!\n");
        };
      };
   };
printf("Bye\n\n");
return 1;
}
//---------------------------------------------------------------------------
const unsigned char IRKHeader[64]={
   0x00, 0x25, 0x21, 0x04, 0x41, 0x72, 0x69, 0x6F,
   0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0xDD, 0xFF, 0xCC, 0xFF,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
   0x00, 0x41, 0x52, 0x53, 0x31, 0x00, 0x41, 0x52,
   0x48, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
   0x41, 0x41, 0x41, 0x00, 0xD9, 0x0A, 0x00, 0x00};
//---------------------------------------------------------------------------
const unsigned int TabCode[256]={
   0x00000000,   0x04C11DB7,   0x09823B6E,   0x0D4326D9,
   0x130476DC,   0x17C56B6B,   0x1A864DB2,   0x1E475005,
   0x2608EDB8,   0x22C9F00F,   0x2F8AD6D6,   0x2B4BCB61,
   0x350C9B64,   0x31CD86D3,   0x3C8EA00A,   0x384FBDBD,
   0x4C11DB70,   0x48D0C6C7,   0x4593E01E,   0x4152FDA9,
   0x5F15ADAC,   0x5BD4B01B,   0x569796C2,   0x52568B75,
   0x6A1936C8,   0x6ED82B7F,   0x639B0DA6,   0x675A1011,
   0x791D4014,   0x7DDC5DA3,   0x709F7B7A,   0x745E66CD,
   0x9823B6E0,   0x9CE2AB57,   0x91A18D8E,   0x95609039,
   0x8B27C03C,   0x8FE6DD8B,   0x82A5FB52,   0x8664E6E5,
   0xBE2B5B58,   0xBAEA46EF,   0xB7A96036,   0xB3687D81,
   0xAD2F2D84,   0xA9EE3033,   0xA4AD16EA,   0xA06C0B5D,
   0xD4326D90,   0xD0F37027,   0xDDB056FE,   0xD9714B49,
   0xC7361B4C,   0xC3F706FB,   0xCEB42022,   0xCA753D95,
   0xF23A8028,   0xF6FB9D9F,   0xFBB8BB46,   0xFF79A6F1,
   0xE13EF6F4,   0xE5FFEB43,   0xE8BCCD9A,   0xEC7DD02D,
   0x34867077,   0x30476DC0,   0x3D044B19,   0x39C556AE,
   0x278206AB,   0x23431B1C,   0x2E003DC5,   0x2AC12072,
   0x128E9DCF,   0x164F8078,   0x1B0CA6A1,   0x1FCDBB16,
   0x018AEB13,   0x054BF6A4,   0x0808D07D,   0x0CC9CDCA,
   0x7897AB07,   0x7C56B6B0,   0x71159069,   0x75D48DDE,
   0x6B93DDDB,   0x6F52C06C,   0x6211E6B5,   0x66D0FB02,
   0x5E9F46BF,   0x5A5E5B08,   0x571D7DD1,   0x53DC6066,
   0x4D9B3063,   0x495A2DD4,   0x44190B0D,   0x40D816BA,
   0xACA5C697,   0xA864DB20,   0xA527FDF9,   0xA1E6E04E,
   0xBFA1B04B,   0xBB60ADFC,   0xB6238B25,   0xB2E29692,
   0x8AAD2B2F,   0x8E6C3698,   0x832F1041,   0x87EE0DF6,
   0x99A95DF3,   0x9D684044,   0x902B669D,   0x94EA7B2A,
   0xE0B41DE7,   0xE4750050,   0xE9362689,   0xEDF73B3E,
   0xF3B06B3B,   0xF771768C,   0xFA325055,   0xFEF34DE2,
   0xC6BCF05F,   0xC27DEDE8,   0xCF3ECB31,   0xCBFFD686,
   0xD5B88683,   0xD1799B34,   0xDC3ABDED,   0xD8FBA05A,
   0x690CE0EE,   0x6DCDFD59,   0x608EDB80,   0x644FC637,
   0x7A089632,   0x7EC98B85,   0x738AAD5C,   0x774BB0EB,
   0x4F040D56,   0x4BC510E1,   0x46863638,   0x42472B8F,
   0x5C007B8A,   0x58C1663D,   0x558240E4,   0x51435D53,
   0x251D3B9E,   0x21DC2629,   0x2C9F00F0,   0x285E1D47,
   0x36194D42,   0x32D850F5,   0x3F9B762C,   0x3B5A6B9B,
   0x0315D626,   0x07D4CB91,   0x0A97ED48,   0x0E56F0FF,
   0x1011A0FA,   0x14D0BD4D,   0x19939B94,   0x1D528623,
   0xF12F560E,   0xF5EE4BB9,   0xF8AD6D60,   0xFC6C70D7,
   0xE22B20D2,   0xE6EA3D65,   0xEBA91BBC,   0xEF68060B,
   0xD727BBB6,   0xD3E6A601,   0xDEA580D8,   0xDA649D6F,
   0xC423CD6A,   0xC0E2D0DD,   0xCDA1F604,   0xC960EBB3,
   0xBD3E8D7E,   0xB9FF90C9,   0xB4BCB610,   0xB07DABA7,
   0xAE3AFBA2,   0xAAFBE615,   0xA7B8C0CC,   0xA379DD7B,
   0x9B3660C6,   0x9FF77D71,   0x92B45BA8,   0x9675461F,
   0x8832161A,   0x8CF30BAD,   0x81B02D74,   0x857130C3,
   0x5D8A9099,   0x594B8D2E,   0x5408ABF7,   0x50C9B640,
   0x4E8EE645,   0x4A4FFBF2,   0x470CDD2B,   0x43CDC09C,
   0x7B827D21,   0x7F436096,   0x7200464F,   0x76C15BF8,
   0x68860BFD,   0x6C47164A,   0x61043093,   0x65C52D24,
   0x119B4BE9,   0x155A565E,   0x18197087,   0x1CD86D30,
   0x029F3D35,   0x065E2082,   0x0B1D065B,   0x0FDC1BEC,
   0x3793A651,   0x3352BBE6,   0x3E119D3F,   0x3AD08088,
   0x2497D08D,   0x2056CD3A,   0x2D15EBE3,   0x29D4F654,
   0xC5A92679,   0xC1683BCE,   0xCC2B1D17,   0xC8EA00A0,
   0xD6AD50A5,   0xD26C4D12,   0xDF2F6BCB,   0xDBEE767C,
   0xE3A1CBC1,   0xE760D676,   0xEA23F0AF,   0xEEE2ED18,
   0xF0A5BD1D,   0xF464A0AA,   0xF9278673,   0xFDE69BC4,
   0x89B8FD09,   0x8D79E0BE,   0x803AC667,   0x84FBDBD0,
   0x9ABC8BD5,   0x9E7D9662,   0x933EB0BB,   0x97FFAD0C,
   0xAFB010B1,   0xAB710D06,   0xA6322BDF,   0xA2F33668,
   0xBCB4666D,   0xB8757BDA,   0xB5365D03,   0xB1F740B4};
//---------------------------------------------------------------------------
const unsigned char BC[]={0x41, 0x03, 0x31, 0x82, 0x26, 0x04, 0x50, 0x21};
const unsigned char TD[4]={1,3,0,2};
const unsigned char key[16]={
   0x82,0x31,0x04,0x21,0x25,0x00,0x82,0x31,
   0x04,0x21,0x25,0x00,0x82,0x31,0x04,0x21};
const unsigned char T1[256]={
   0x2a,0xe1,0x0b,0x13,0x3e,0x6e,0x32,0x48,
   0xd3,0x31,0x08,0x8c,0x8f,0x95,0xbd,0xd0,
   0xe4,0x6d,0x50,0x81,0x20,0x30,0xbb,0x75,
   0xf5,0xd4,0x7c,0x87,0x2c,0x4e,0xe8,0xf4,
   0xbe,0x24,0x9e,0x4d,0x80,0x37,0xd2,0x5f,
   0xdb,0x04,0x7a,0x3f,0x14,0x72,0x67,0x2d,
   0xcd,0x15,0xa6,0x4c,0x2e,0x3b,0x0c,0x41,
   0x62,0xfa,0xee,0x83,0x1e,0xa2,0x01,0x0e,
   0x7f,0x59,0xc9,0xb9,0xc4,0x9d,0x9b,0x1b,
   0x9c,0xca,0xaf,0x3c,0x73,0x1a,0x65,0xb1,
   0x76,0x84,0x39,0x98,0xe9,0x53,0x94,0xba,
   0x1d,0x29,0xcf,0xb4,0x0d,0x05,0x7d,0xd1,
   0xd7,0x0a,0xa0,0x5c,0x91,0x71,0x92,0x88,
   0xab,0x93,0x11,0x8a,0xd6,0x5a,0x77,0xb5,
   0xc3,0x19,0xc1,0xc7,0x8e,0xf9,0xec,0x35,
   0x4b,0xcc,0xd9,0x4a,0x18,0x23,0x9f,0x52,
   0xdd,0xe3,0xad,0x7b,0x47,0x97,0x60,0x10,
   0x43,0xef,0x07,0xa5,0x49,0xc6,0xb3,0x55,
   0x28,0x51,0x5d,0x64,0x66,0xfc,0x44,0x42,
   0xbc,0x26,0x09,0x74,0x6f,0xf7,0x6b,0x4f,
   0x2f,0xf0,0xea,0xb8,0xae,0xf3,0x63,0x6a,
   0x56,0xb2,0x02,0xd8,0x34,0xa4,0x00,0xe6,
   0x58,0xeb,0xa3,0x82,0x85,0x45,0xe0,0x89,
   0x7e,0xfd,0xf2,0x3a,0x36,0x57,0xff,0x06,
   0x69,0x54,0x79,0x9a,0xb6,0x6c,0xdc,0x8b,
   0xa7,0x1f,0x90,0x03,0x17,0x1c,0xed,0xd5,
   0xaa,0x5e,0xfe,0xda,0x78,0xb0,0xbf,0x12,
   0xa8,0x22,0x21,0x3d,0xc2,0xc0,0xb7,0xa9,
   0xe7,0x33,0xfb,0xf1,0x70,0xe5,0x17,0x96,
   0xf8,0x8d,0x46,0xa1,0x86,0xe2,0x40,0x38,
   0xf6,0x68,0x25,0x16,0xac,0x61,0x27,0xcb,
   0x5b,0xc8,0x2b,0x0f,0x99,0xde,0xce,0xc5};
const unsigned char T2[256]={
   0xbf,0x11,0x6d,0xfa,0x26,0x7f,0xf3,0xc8,
   0x9e,0xdd,0x3f,0x16,0x97,0xbd,0x08,0x80,
   0x51,0x42,0x93,0x49,0x5b,0x64,0x9b,0x25,
   0xf5,0x0f,0x24,0x34,0x44,0xb8,0xee,0x2e,
   0xda,0x8f,0x31,0xcc,0xc0,0x5e,0x8a,0x61,
   0xa1,0x63,0xc7,0xb2,0x58,0x09,0x4d,0x46,
   0x81,0x82,0x68,0x4b,0xf6,0xbc,0x9d,0x03,
   0xac,0x91,0xe8,0x3d,0x94,0x37,0xa0,0xbb,
   0xce,0xeb,0x98,0xd8,0x38,0x56,0xe9,0x6b,
   0x28,0xfd,0x84,0xc6,0xcd,0x5f,0x6e,0xb6,
   0x32,0xf7,0x0e,0xf1,0xf8,0x54,0xc1,0x53,
   0xf0,0xa7,0x95,0x7b,0x19,0x21,0x23,0x7d,
   0xe1,0xa9,0x75,0x3e,0xd6,0xed,0x8e,0x6f,
   0xdb,0xb7,0x07,0x41,0x05,0x77,0xb4,0x2d,
   0x45,0xdf,0x29,0x22,0x43,0x89,0x83,0xfc,
   0xd5,0xa4,0x88,0xd1,0xf4,0x55,0x4f,0x78,
   0x62,0x1e,0x1d,0xb9,0xe0,0x2f,0x01,0x13,
   0x15,0xe6,0x17,0x6a,0x8d,0x0c,0x96,0x7e,
   0x86,0x27,0xa6,0x0d,0xb5,0x73,0x71,0xaa,
   0x36,0xd0,0x06,0x66,0xdc,0xb1,0x2a,0x5a,
   0x72,0xbe,0x3a,0xc5,0x40,0x65,0x1b,0x02,
   0x10,0x9f,0x3b,0xf9,0x2b,0x18,0x5c,0xd7,
   0x12,0x47,0xef,0x1a,0x87,0xd2,0xc2,0x8b,
   0x99,0x9c,0xd3,0x57,0xe4,0x76,0x67,0xca,
   0x3c,0xfb,0x90,0x20,0x14,0x48,0xc9,0x60,
   0xb0,0x70,0x4e,0xa2,0xad,0x35,0xea,0xc4,
   0x74,0xcb,0x39,0xde,0xe7,0xd4,0xa3,0xa5,
   0x04,0x92,0x8c,0xd9,0x7c,0x1c,0x7a,0xa8,
   0x52,0x79,0xf2,0x33,0xba,0x1f,0x30,0x9a,
   0x00,0x50,0x4c,0xff,0xe5,0xcf,0x59,0xc3,
   0xe3,0x0a,0x85,0xb3,0xae,0xec,0x0b,0xfe,
   0xe2,0xab,0x4a,0xaf,0x69,0x6c,0x2c,0x5d};
//---------------------------------------------------------------------------