bool BackupDevice::load_state(EMUFILE* is)
{
u32 version;
if(read32le(&version,is)!=1) return false;
if(version>=0)
{
readbool(&write_enable,is);
read32le(&com,is);
read32le(&addr_size,is);
read32le(&addr_counter,is);
u32 temp;
read32le(&temp,is);
state = (STATE)temp;
readbuffer(data,is);
readbuffer(data_autodetect,is);
}
if(version>=1)
read32le(&addr,is);
if(version>=2)
{
read8le(&motionInitState,is);
read8le(&motionFlag,is);
}
return true;
}
bool BackupDevice::load_state(EMUFILE* is)
{
u32 version;
u32 temp;
std::vector<u8> data;
if(read32le(&version,is)!=1) return false;
if(version>=0)
{
readbool(&write_enable,is);
read32le(&com,is);
read32le(&addr_size,is);
read32le(&addr_counter,is);
read32le(&temp,is);
state = (STATE)temp;
readbuffer(data,is);
readbuffer(data_autodetect,is);
}
if(version>=1)
read32le(&addr,is);
if(version>=2)
{
read8le(&motionInitState,is);
read8le(&motionFlag,is);
}
if(version>=3)
{
readbool(&reset_command_state,is);
}
if(version>=4)
{
read8le(&write_protect,is);
}
fsize = data.size();
#ifndef _DONT_SAVE_BACKUP
fpMC->fseek(0, SEEK_SET);
if(data.size()!=0)
fwrite((char*)&data[0], 1, fsize, fpMC->get_fp());
ensure(data.size(), fpMC);
#endif
if(version>=5)
{
read32le(&temp,is);
fpMC->fseek(temp, SEEK_SET);
}
else
fpMC->fseek(addr, SEEK_SET);
return true;
}
bool BackupDevice::load_state(std::istream* is)
{
int version;
if(read32le(&version,is)!=1) return false;
if(version==0) {
read32le(&write_enable,is);
read32le(&com,is);
read32le(&addr_size,is);
read32le(&addr_counter,is);
u32 temp;
read32le(&temp,is);
state = (STATE)temp;
readbuffer(data,is);
readbuffer(data_autodetect,is);
}
return true;
}
int main(int argc, char **argv)
{
FILE *in, *out;
unsigned char *buffer;
unsigned buffersize, orgbuffersize;
unsigned char pairtable[128][2];
if (argc < 2 || argc > 3)
usage();
if ((in=fopen(argv[1],"rt"))==NULL) {
printf("SCPACK: error opening input %s\n",argv[1]);
usage();
} /* if */
if (argc == 2) {
if ((out=fopen(TEMPFILE,"wt"))==NULL) {
printf("SCPACK: error opening temporary file %s\n",TEMPFILE);
usage();
} /* if */
} else {
if ((out=fopen(argv[2],"wt"))==NULL) {
printf("SCPACK: error opening output file %s\n",argv[2]);
usage();
} /* if */
} /* if */
buffer = (unsigned char *)malloc(MAXSIZE);
if (buffer == NULL) {
printf("SCPACK: error allocating memory\n");
return 1;
} /* if */
/* 1. read the buffer
* 2. compress the buffer
* 3. copy the file, insert the compressed buffer
*/
buffersize = readbuffer(in, buffer);
orgbuffersize = buffersize;
if (buffersize > 0) {
buffersize = compress(buffer, buffersize, pairtable);
writefile(in, out, buffer, buffersize, pairtable);
printf("SCPACK: compression ratio: %ld%% (%d -> %d)\n",
100L-(100L*buffersize)/orgbuffersize, orgbuffersize, buffersize);
} else {
printf("SCPACK: no SCPACK section found, nothing to do\n");
} /* if */
fclose(out);
fclose(in);
/* let the new file replace the old file */
if (buffersize == 0) {
if (argc == 2)
remove(TEMPFILE);
else
remove(argv[2]);
} else if (argc == 2) {
remove(argv[1]);
rename(TEMPFILE,argv[1]);
} /* if */
return 0;
}
/*
* reads a one block from the tar buffer into the tar block stream
* @param tar tar stream to read from
* @return -1 on error
*/
int readblock( TAR* tar )
{
if( tar->eof )
{
return -1;
}
if( tar->blockpos + TAR_BLOCK > tar->bytesRead )
{
if( readbuffer(tar ) < 0 )
{
return -1;
}
}
memcpy( tar->block, tar->buffer + tar->blockpos, TAR_BLOCK);
tar->blockpos += TAR_BLOCK;
return 0;
}
//_______________________________________________________________________________
SXMLFile xmlreader::readbuff(const char* buffer)
{
fFile = TXMLFile::create();
debug("read buffer", '-');
return readbuffer (buffer, this) ? fFile : 0;
}
int sendcommand(int fd,char cmd,void *databuf)
{
int fd1=-1;
int i=0;
char lenb[7];
mcudev_t *mcuinfo=(mcudev_t *)databuf;
char byte=0;
memset(lenb,0,6);
strncpy(lenb,"732\r\n",6);
sbuf[0]=0;
switch(cmd)
{
case 'g':
case 'i':
case 'G':
case 'I':
byte='g';
writebuffer(fd,&byte,1);
usleep(300);
readbuffer(fd,sbuf,MAXBUFLEN);
break;
case 'r':
case 'R':
byte='r';
writebuffer(fd,&byte,1);
byte='h';
writebuffer(fd,&byte,1);
usleep(30);
readbuffer(fd,sbuf,MAXBUFLEN);
break;
case 's':
case 'S':
byte='s';
writebuffer(fd,&byte,1);
usleep(20);
for(i=0;i<5;i++)
{
writebuffer(fd,&lenb[i],1);
usleep(20);
}
usleep(300);
fprintf(stderr,"The code has been released\n");
break;
case 't':
case 'T':
byte='t';
writebuffer(fd,&byte,1);
usleep(100);
break;
case 'e':
case 'E':
byte='e';
writebuffer(fd,&byte,1);
usleep(260000L);
break;
case 'w':
case 'W':
if(mcuinfo == NULL) break;
fd1=fd;
byte='s';
writebuffer(fd1,&byte,1);
usleep(20);
for(i=0;i<5;i++)
{
writebuffer(fd1,&lenb[i],1);
usleep(30);
}
printf("writing file\n\r");
fprintf(stderr,"The code has been released\n");
byte='t';
writebuffer(fd1,&byte,1);
usleep(10);
fprintf(stderr,"Writting counters\n");
byte='e';
writebuffer(fd1,&byte,1);
usleep(250000L);
fprintf(stderr,"Erased\n");
byte='w';
writebuffer(fd1,&byte,1);
usleep(40);
usleep(100000L);
byte=0;
sendihx(fd1,&mcuinfo->image->Filename[0]);
usleep(100000L);
break;
default:
break;
}
}
int main(int argc,char *argv[])
{
int status;
int rem;
int offset;
int len;
char buffer[32];
/* ---------------------------------------*/
/*STEP 2 : initialize the nmea context */
/* ---------------------------------------*/
status = nmeap_init(&nmea,(void *)&user_data);
if (status != 0) {
printf("nmeap_init %d\n",status);
exit(1);
}
/* ---------------------------------------*/
/*STEP 3 : add standard GPGGA parser */
/* -------------------------------------- */
status = nmeap_addParser(&nmea,"GPGGA",nmeap_gpgga,gpgga_callout,&gga);
if (status != 0) {
printf("nmeap_add %d\n",status);
exit(1);
}
/* ---------------------------------------*/
/*STEP 4 : add standard GPRMC parser */
/* -------------------------------------- */
status = nmeap_addParser(&nmea,"GPRMC",nmeap_gprmc,gprmc_callout,&rmc);
if (status != 0) {
printf("nmeap_add %d\n",status);
exit(1);
}
/* ---------------------------------------*/
/*STEP 5 : process input until done */
/* -------------------------------------- */
for(;;) {
/* ---------------------------------------*/
/*STEP 6 : get a buffer of input */
/* -------------------------------------- */
len = rem = readbuffer(buffer,sizeof(buffer));
if (len <= 0) {
break;
}
/* ----------------------------------------------*/
/*STEP 7 : process input until buffer is used up */
/* --------------------------------------------- */
offset = 0;
while(rem > 0) {
/* --------------------------------------- */
/*STEP 8 : pass it to the parser */
/* status indicates whether a complete msg */
/* arrived for this byte */
/* NOTE : in addition to the return status */
/* the message callout will be fired when */
/* a complete message is processed */
/* --------------------------------------- */
status = nmeap_parseBuffer(&nmea,&buffer[offset],&rem);
offset += (len - rem);
/* ---------------------------------------*/
/*STEP 9 : process the return code */
/* -------------------------------------- */
switch(status) {
case NMEAP_GPGGA:
printf("-------------switch\n");
print_gga(&gga);
printf("-------------\n");
break;
case NMEAP_GPRMC:
printf("-------------switch\n");
print_rmc(&rmc);
printf("-------------\n");
break;
default:
break;
}
}
}
return 0;
}
