Exemple #1
0
/// This function points to a scalar reference implementation of the CRC-32C
/// algorithm that yields the correct value. It is optimized for portability,
/// not for speed on modern architectures.
uint32_t Microslice::compute_crc() const {
  assert(content_ptr_);
  assert(desc_ptr_);

  boost::crc_optimal<32, 0x1EDC6F41, 0xFFFFFFFF, 0xFFFFFFFF, true, true> crc_32;
  crc_32.process_bytes(content_ptr_, desc_ptr_->size);
  return crc_32();
}
Exemple #2
0
/**
 * Add a crc to a given data packet.
 *
 * @param data the packet
 * @param len the length of the packet
 * @param offset the offset where we want to write our checksum.
 */
void packet_add_crc(char *data, size_t len, unsigned int offset)
{
	char *ptr = data + offset;
	uint32_t new_crc;
	uint32_t *crc_ptr = (uint32_t *)ptr;
	
	*crc_ptr = 0x00000000;
	new_crc = GUINT32_TO_LE(crc_32(data, len, 0xEDB88320));
	*crc_ptr = new_crc;
}
Exemple #3
0
static bool read_nvram_data(char* buf, int max_len)
{
    unsigned crc32 = 0xffffffff;
    int var_count = 0, i = 0, buf_pos = 0;
#ifndef HAVE_RTC_RAM
    int fd = open(NVRAM_FILE, O_RDONLY);
    int bytes;
    if (fd < 0)
        return false;
    memset(buf,0,max_len);
    bytes = read(fd,buf,max_len);
    close(fd);
    if (bytes < 8) /* min is 8 bytes,magic, ver, vars, crc32 */
        return false;
#else
    memset(buf,0,max_len);
    /* read rtc block */
    for (i=0; i < max_len; i++ )
        buf[i] = rtc_read(0x14+i);
#endif
    /* check magic, version */
    if ((buf[0] != 'R') || (buf[1] != 'b') 
        || (buf[2] != NVRAM_CONFIG_VERSION))
        return false;
    /* check crc32 */
    crc32 = crc_32(&buf[NVRAM_DATA_START],
                    max_len-NVRAM_DATA_START-1,0xffffffff);
    if (memcmp(&crc32,&buf[4],4))
        return false;
    /* all good, so read in the settings */
    var_count = buf[3];
    buf_pos = NVRAM_DATA_START;
    for(i=0; i<nb_settings; i++)
    {
        int nvram_bytes = (settings[i].flags&F_NVRAM_BYTES_MASK)
                                >>F_NVRAM_MASK_SHIFT;
        if (nvram_bytes)
        {
            if ((var_count>0) && (buf_pos<max_len))
            {
                memcpy(settings[i].setting,&buf[buf_pos],nvram_bytes);
                buf_pos += nvram_bytes;
                var_count--;
            }
            else /* should only happen when new items are added to the end */
            {
                memcpy(settings[i].setting, &settings[i].default_val, nvram_bytes);
            }
        }
    }
    return true;
}
Exemple #4
0
static bool write_nvram_data(char* buf, int max_len)
{
    unsigned crc32 = 0xffffffff;
    int i = 0, buf_pos = 0;
    char var_count = 0;
#ifndef HAVE_RTC_RAM
    int fd;
#endif
    memset(buf,0,max_len);
    /* magic, version */
    buf[0] = 'R';
    buf[1] = 'b';
    buf[2] = NVRAM_CONFIG_VERSION;
    buf_pos = NVRAM_DATA_START;
    for(i=0; (i<nb_settings) && (buf_pos<max_len); i++)
    {
        int nvram_bytes = (settings[i].flags&F_NVRAM_BYTES_MASK)
                          >>F_NVRAM_MASK_SHIFT;
        if (nvram_bytes)
        {
            memcpy(&buf[buf_pos],settings[i].setting,nvram_bytes);
            buf_pos += nvram_bytes;
            var_count++;
        }
    }
    /* count and crc32 */
    buf[3] = var_count;
    crc32 = crc_32(&buf[NVRAM_DATA_START],
                   max_len-NVRAM_DATA_START-1,0xffffffff);
    memcpy(&buf[4],&crc32,4);
#ifndef HAVE_RTC_RAM
    fd = open(NVRAM_FILE,O_CREAT|O_TRUNC|O_WRONLY, 0666);
    if (fd >= 0)
    {
        int len = write(fd,buf,max_len);
        close(fd);
        if (len < 8)
            return false;
    }
#else
    /* FIXME: okay, it _would_ be cleaner and faster to implement rtc_write so
       that it would write a number of bytes at a time since the RTC chip
       supports that, but this will have to do for now 8-) */
    for (i=0; i < NVRAM_BLOCK_SIZE; i++ ) {
        int r = rtc_write(0x14+i, buf[i]);
        if (r)
            return false;
    }
#endif
    return true;
}
Exemple #5
0
void printChosen(char* s, unsigned size, struct information info) {
    printf("Length: %u bytes\n", size-1);
    if(info.hex) {
        if(info.doXor)
            printf("XOR: 0x%02x\n", xor_hash(s, size));
        if(info.doCrc16)
            printf("CRC-16: 0x%04x\n", crc_16(s, size));
        if(info.doCrc32)
            printf("CRC-32: 0x%08x\n", crc_32(s, size));
    } else {
        if(info.doXor)
            printf("XOR: %u\n", xor_hash(s, size));
        if(info.doCrc16)
            printf("CRC-16: %u\n", crc_16(s, size));
        if(info.doCrc32)
            printf("CRC-32: %u\n", crc_32(s, size));
    }
    if(info.doMd5) {
        printf("MD5: ");
        printMD5(s, size);
        printf("\n");
    }
}
Exemple #6
0
/* ts A90830 : changed return type to int
   @return 0= failure
           1= success
*/
int sector_headers(struct burn_write_opts *o, unsigned char *out,
		    int mode, int leadin)
{

#ifdef Libburn_ecma130ab_includeD

	struct burn_drive *d = o->drive;
	unsigned int crc;
	int min, sec, frame;
	int modebyte = -1;
	int ret;

	ret = sector_headers_is_ok(o, mode);
	if (ret != 2)
		return !!ret;
	modebyte = 1;

	out[0] = 0;
	memset(out + 1, 0xFF, 10);	/* sync */
	out[11] = 0;

	if (leadin) {
		burn_lba_to_msf(d->rlba, &min, &sec, &frame);
		out[12] = dec_to_bcd(min) + 0xA0;
		out[13] = dec_to_bcd(sec);
		out[14] = dec_to_bcd(frame);
		out[15] = modebyte;
	} else {
		burn_lba_to_msf(d->alba, &min, &sec, &frame);
		out[12] = dec_to_bcd(min);
		out[13] = dec_to_bcd(sec);
		out[14] = dec_to_bcd(frame);
		out[15] = modebyte;
	}
	if (mode & BURN_MODE1) {

#ifdef Libburn_no_crc_C
		crc = 0; /* dummy */
#else
		crc = crc_32(out, 2064);
#endif

		out[2064] = crc & 0xFF;
		crc >>= 8;
		out[2065] = crc & 0xFF;
		crc >>= 8;
		out[2066] = crc & 0xFF;
		crc >>= 8;
		out[2067] = crc & 0xFF;
	}
/* No need to access it from outside */
static struct message1 * encode_connection_request(struct connection_request * req) {
  struct message1 * msg;
  msg = (struct message1 *)calloc(1, sizeof(struct message1));

  msg->function = GUINT32_TO_LE(0x0003bef4);
  msg->counter = GUINT32_TO_LE(1);

  msg->client_size = 9;
  memcpy(msg->client, "TeamSpeak", 9);

  /* cut machine if too long */
  if(strlen(req->machine) > 29)
    req->machine[29] = '\0';
  msg->machine_size = (uint8_t)strlen(req->machine);
  memcpy(msg->machine, req->machine, strlen(req->machine));

  msg->data1 = GUINT32_TO_LE(0x02000000);
  msg->data2 = GUINT32_TO_LE(0x20003C00);

  msg->assign_nick = req->assign_nick;
  msg->always1 = 0x01;

  /* Insert login */
  if(strlen(req->login) > 29)
    req->login[29] = '\0';
  msg->login_size = (uint8_t)strlen(req->login);
  memcpy(msg->login, req->login, strlen(req->login));

  /* Insert password */
  if(strlen(req->pass) > 29)
    req->pass[29] = '\0';
  msg->pass_size = (uint8_t)strlen(req->pass);
  memcpy(msg->pass, req->pass, strlen(req->pass));

  /* Insert nick */
  if(strlen(req->nick) > 29)
    req->nick[29] = '\0';
  msg->nick_size = (uint8_t)strlen(req->nick);
  memcpy(msg->nick, req->nick, strlen(req->nick));

  msg->checksum = GINT32_TO_LE(crc_32(msg, sizeof(struct message1), 0xEDB88320));

  return msg;
}
Exemple #8
0
/**
 * Check the crc of a packet
 *
 * @param data the packet
 * @param len the length of the packet
 * @param offset the offset where the checksum is located.
 */
int packet_check_crc(char *data, size_t len, unsigned int offset)
{
	char *buff, *ptr;
	uint32_t old_crc;
	uint32_t new_crc;
	uint32_t *crc_ptr;

	buff = (char *)calloc(len, sizeof(char));
	if (buff == NULL) {
		printf("(WW) packet_check_crc, buffer allocation failed : %s.\n", strerror(errno));
		return 0;
	}
	memcpy(buff, data, len);
	ptr = buff + offset;
	crc_ptr = (uint32_t *)ptr;

	old_crc = *crc_ptr;
	*crc_ptr = 0x00000000;
	new_crc = GUINT32_TO_LE(crc_32(buff, len, 0xEDB88320));
	
	free(buff);
	return new_crc == old_crc;
}
Exemple #9
0
int make_LUH()
{
    FILE *fp_luh,*f_su;
	struct multi_file_crc files;
	int k,i,m;
	int luh_file_length;
	int luh_fpos;
	int len,ret;
	uint64_t len_64;

	
	unsigned int su_len;
	unsigned short length,nu_tar,nu_with,nu_posi,nu_file;
	unsigned short file_num;
	unsigned short load_count;
	
	unsigned short check_type,check_type_temp;
	unsigned short crc_type_8,crc_type_16,crc_type_32;
	
	unsigned short data_crc_8[10],sup_crc_8[10],multi_crc8;
	
	unsigned short data_crc_16[10],sup_crc_16[10];
	unsigned short sup_total_crc_16,multi_crc16,header_file_crc;
	
	unsigned int data_crc_32[10],sup_crc_32[10];
	unsigned int multi_crc32,load_crc;

	char *ch;
	char s[15]="load_";
	char path_name[50],luh_name[70],data_name[70],sup_name[70];


	char target_ID[10][30]=
	{
	 	"luh_target_ID_001","luh_target_ID_002","luh_target_ID_003", "luh_target_ID_004","luh_target_ID_005",
	 	"luh_target_ID_006","luh_target_ID_007","luh_target_ID_008", "luh_target_ID_009","luh_target_ID_010"
	};

	char target_with_position[10][40]=
	{
	 	"luh_target_with_position_001","luh_target_with_position_002","luh_target_with_position_003", "luh_target_with_position_004","luh_target_with_position_005",
	 	"luh_target_with_position_006","luh_target_with_position_007","luh_target_with_position_008", "luh_target_with_position_009","luh_target_with_position_010"
	};

	char number_target_position[10][40]=
	{
	 	"luh_number_target_position_001","luh_number_target_position_002","luh_number_target_position_003", "luh_number_target_position_004","luh_number_target_position_005",
	 	"luh_number_target_position_006","luh_number_target_position_007","luh_number_target_position_008", "luh_number_target_position_009","luh_number_target_position_010"
	};

	char position[10][5][30]=
	{
		{"luh_position_001_001","luh_position_001_002","luh_position_001_003","luh_position_001_004","luh_position_001_005"},	
		{"luh_position_002_001","luh_position_002_002","luh_position_002_003","luh_position_002_004","luh_position_002_005"},
        {"luh_position_003_001","luh_position_003_002","luh_position_003_003","luh_position_003_004","luh_position_003_005"},
		{"luh_position_004_001","luh_position_004_002","luh_position_004_003","luh_position_004_004","luh_position_004_005"},
		{"luh_position_005_001","luh_position_005_002","luh_position_005_003","luh_position_005_004","luh_position_005_005"},
		{"luh_position_006_001","luh_position_006_002","luh_position_006_003","luh_position_006_004","luh_position_006_005"},
		{"luh_position_007_001","luh_position_007_002","luh_position_007_003","luh_position_007_004","luh_position_007_005"},
		{"luh_position_008_001","luh_position_008_002","luh_position_008_003","luh_position_008_004","luh_position_008_005"},
		{"luh_position_009_001","luh_position_009_002","luh_position_009_003","luh_position_009_004","luh_position_009_005"},
		{"luh_position_010_001","luh_position_010_002","luh_position_010_003","luh_position_010_004","luh_position_010_005"}
	};


		/***************data file*******************/
		
	char data_file_p[10][30]=
	{
	 	"0x0000","0x0000","0x0000", "0x0000","0x0000",
	 	"0x0000","0x0000","0x0000", "0x0000","0x0000"
	};

	char data_file_name[10][30]=
	{
		"luh_data_file_name_001","luh_data_file_name_002","luh_data_file_name_003", "luh_data_file_name_004","luh_data_file_name_005",
		"luh_data_file_name_006","luh_data_file_name_007","luh_data_file_name_008", "luh_data_file_name_009","luh_data_file_name_010"
	};

	char data_file_PN[10][30]=
	{
		"luh_data_file_PN_001","luh_data_file_PN_002","luh_data_file_PN_003", "luh_data_file_PN_004","luh_data_file_PN_005",
		"luh_data_file_PN_006","luh_data_file_PN_007","luh_data_file_PN_008", "luh_data_file_PN_009","luh_data_file_PN_010"
	};

	char data_check_value_type[10][40]=
	{
	 	"luh_data_file_check_value_type_001","luh_data_file_check_value_type_002","luh_data_file_check_value_type_003", "luh_data_file_check_value_type_004","luh_data_file_check_value_type_005",
		"luh_data_file_check_value_type_006","luh_data_file_check_value_type_007","luh_data_file_check_value_type_008", "luh_data_file_check_value_type_009","luh_data_file_check_value_type_010"
	};



	/***************support file*******************/

	char support_file_p[10][30]=
	{
	 	"0x0000","0x0000","0x0000", "0x0000","0x0000",
	 	"0x0000","0x0000","0x0000", "0x0000","0x0000"
	};

	char support_file_name[10][30]=
	{
	 	"luh_support_file_name_001","luh_support_file_name_002","luh_support_file_name_003", "luh_support_file_name_004","luh_support_file_name_005",
	 	"luh_support_file_name_006","luh_support_file_name_007","luh_support_file_name_008", "luh_support_file_name_009","luh_support_file_name_010"
	};

	char support_file_PN[10][30]=
	{
	 	"luh_support_file_PN_001","luh_support_file_PN_002","luh_support_file_PN_003", "luh_support_file_PN_004","luh_support_file_PN_005",
	 	"luh_support_file_PN_006","luh_support_file_PN_007","luh_support_file_PN_008", "luh_support_file_PN_009","luh_support_file_PN_010"
	};


	 char support_check_value_type[10][40]=
	{
	 	"luh_support_file_check_value_type_001","luh_support_file_check_value_type_002","luh_support_file_check_value_type_003", "luh_support_file_check_value_type_004","luh_support_file_check_value_type_005",
	 	"luh_support_file_check_value_type_006","luh_support_file_check_value_type_007","luh_support_file_check_value_type_008", "luh_support_file_check_value_type_009","luh_support_file_check_value_type_010"
	};


	 ret=select_section("[media_set]");
	 if(FAILED==ret)
	 {
	 	printf("select_section error\n");
		return FAILED;
	 }
	 ch=get_config_var("load_count");
	 if(ch==NULL)
	 {
		printf("get load_count error\n");
		return FAILED;
	 }
	 load_count=htoi(ch);
	 for(m=1;m<=load_count;m++)//make multi luh files
	 {		
		sprintf(s,"[load_%.3d]",m);
	 	//printf("s=%s\n",s);
		ret=select_section(s);
		if(FAILED==ret)
	 	{
			printf("select_section error\n");
			return FAILED;
		}
		strcpy(path_name,"./media665-3");
		ch=get_config_var("load_path");
		if(ch==NULL)
	 	{
			printf("get load_path error\n");
			return FAILED;
	 	}
		change_symbol(ch);
		strcat(path_name,ch);
		ch=get_config_var("head_file_name");
		if(ch==NULL)
	 	{
			printf("get head_file_name error\n");
			return FAILED;
	 	}
		strcpy(luh_name,path_name);
		strcat(luh_name,ch);
		fp_luh=fopen(luh_name, "wb+");
		if (NULL == fp_luh)
		{		
			printf("can't open '%s' as config file:%s\n",fp_luh,strerror(errno));
			goto EXIT;
		}

	
				/********make LUH**********/
		fseek(fp_luh,4,0);//the leading four bytes is file length
		ch=get_config_var("luh_file_version");
		if(ch==NULL)
	 	{
			printf("get luh_file_version error\n");
			return FAILED;
	 	}
		ret=fwrite_atohex(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}
		ch=get_config_var("luh_part_flags");
		if(ch==NULL)
	 	{
			printf("get luh_part_flags error\n");
			return FAILED;
	 	}
		ret=fwrite_atohex(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}
		ch=get_config_var("luh_p_PN_length");
		if(ch==NULL)
	 	{
			printf("get luh_p_PN_length error\n");
			return FAILED;
	 	}
		ret=fwrite_atohex(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}
		ch=get_config_var("luh_p_target_ID");
		if(ch==NULL)
	 	{
			printf("get luh_p_target_ID error\n");
			return FAILED;
	 	}
		ret=fwrite_atohex(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}
		ch=get_config_var("luh_p_number_data_file");
		if(ch==NULL)
	 	{
			printf("get luh_p_number_data_file error\n");
			return FAILED;
	 	}
		ret=fwrite_atohex(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}
		ch=get_config_var("luh_p_number_support_file");
		if(ch==NULL)
	 	{
			printf("get luh_p_number_support_file error\n");
			return FAILED;
	 	}
		ret=fwrite_atohex(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}
		ch=get_config_var("luh_p_user_defined_data");
		if(ch==NULL)
	 	{
			printf("get luh_p_user_defined_data error\n");
			return FAILED;
	 	}
		ret=fwrite_atohex(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}
		ch=get_config_var("luh_p_type_description_length");
		if(ch==NULL)
	 	{
			printf("get luh_p_type_description_length error\n");
			return FAILED;
	 	}
		ret=fwrite_atohex(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}
		ch=get_config_var("luh_p_number_target_positions");
		if(ch==NULL)
	 	{
			printf("get luh_p_number_target_positions error\n");
			return FAILED;
	 	}
		ret=fwrite_atohex(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}
		ch=get_config_var("luh_p_check_value_length");
		if(ch==NULL)
	 	{
			printf("get luh_p_check_value_length error\n");
			return FAILED;
	 	}
		ret=fwrite_atohex(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}

		ch=get_config_var("luh_load_PN");
		if(ch==NULL)
	 	{
			printf("get luh_load_PN error\n");
			return FAILED;
	 	}
		length=htons(strlen(ch));
		ret=fwrite(&length,sizeof(short),1,fp_luh);//write PN length
		if(ret<0)
		{
			printf("fwrite error\n");
			return FAILED;
		}
		ret=fwrite_chars(ch,fp_luh);//write load PN
		if(ret<0)
		{
			printf("fwrite_chars error\n");
			return FAILED;
		}
		if((strlen(ch)%2)!=0)
			{
				ret=fwrite_atohex("0x00",fp_luh);				
				if(ret<0)
				{
					printf("fwrite_atohex error\n");
					return FAILED;
				}
			}//if odd ,add 0x00
			
		ch=get_config_var("luh_type_description");
		if(ch==NULL)
	 	{
			printf("get luh_type_description error\n");
	 	}
		length=htons(strlen(ch));
		fwrite(&length,sizeof(short),1,fp_luh);//write description length
		if(ret<0)
		{
			printf("fwrite error\n");
		}
		ret=fwrite_chars(ch,fp_luh);//write description		
		if(ret<0)
		{
			printf("fwrite_chars error\n");
			return FAILED;
		}
		if(strlen(ch)%2!=0)       
		{
			ret=fwrite_atohex("0x00",fp_luh);
			if(ret<0)
			{
				printf("fwrite_atohex error\n");
				return FAILED;
			}									
		}
			
		ch=get_config_var("luh_type_ID");
		if(ch==NULL)
	 	{
			printf("get luh_type_ID error\n");
			return FAILED;
	 	}
		ret=fwrite_atohex(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}
		ch=get_config_var("luh_number_target_ID");
		if(ch==NULL)
	 	{
			printf("get luh_number_target_ID error\n");
			return FAILED;
	 	}
		ret=fwrite_atohex(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}
		nu_tar=htoi(ch);
		for(k=0;k<nu_tar;k++)      //number of target HW ID
		{
			ch=get_config_var(target_ID[k]);
			if(ch==NULL)
	 		{
				printf("get target_ID error\n");
				return FAILED;
	 		}
			length=htons(strlen(ch));
			fwrite(&length,sizeof(short),1,fp_luh);//write position length
			if(ret<0)
			{
				printf("fwrite error\n");
				return FAILED;
			}
			ret=fwrite_chars(ch,fp_luh);//write target id
			if(ret<0)
			{
				printf("fwrite_chars error\n");
				return FAILED;
			}
			if(strlen(ch)%2!=0)        
			{
				ret=fwrite_atohex("0x00",fp_luh);	
				if(ret<0)
				{
					printf("fwrite_atohex error\n");
					return FAILED;
				}		
			}
				
		}

		ch=get_config_var("luh_number_target_with_position");
		if(ch==NULL)
	 	{
			printf("get luh_number_target_with_position error\n");
			return FAILED;
	 	}
		ret=fwrite_atohex(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}
		nu_with=htoi(ch);
		for(k=0;k<nu_with;k++)        //number of target HW ID with position循环
		{
			ch=get_config_var(target_with_position[k]);
			if(ch==NULL)
	 		{
				printf("get target_with_position error\n");
				return FAILED;
	 		}
			length=htons(strlen(ch));
			fwrite(&length,sizeof(short),1,fp_luh);//write length
			if(ret<0)
			{
				printf("fwrite error\n");
				return FAILED;
			}
			ret=fwrite_chars(ch,fp_luh);//write target with position
			if(ret<0)
			{
				printf("fwrite_chars error\n");
				return FAILED;
			}
			if(strlen(ch)%2!=0)         
			{
				ret=fwrite_atohex("0x00",fp_luh);	
				if(ret<0)
				{
					printf("fwrite_atohex error\n");
					return FAILED;
				}
				
			}


			ch=get_config_var(number_target_position[k]);
			if(ch==NULL)
	 		{
				printf("get number_target_position error\n");
				return FAILED;
	 		}
			ret=fwrite_atohex(ch,fp_luh);
			if(ret<0)
			{
				printf("fwrite_atohex error\n");
				return FAILED;
			}
			
			nu_posi=htoi(ch);
			for(i=0;i<nu_posi;i++)     //number of target HW ID position
			{
				ch=get_config_var(position[k][i]);
				if(ch==NULL)
	 			{
					printf("get position error\n");
					return FAILED;
	 			}
				length=htons(strlen(ch));
				fwrite(&length,sizeof(short),1,fp_luh);//write length
				if(ret<0)
				{
					printf("fwrite error\n");
					return FAILED;
				}
				ret=fwrite_chars(ch,fp_luh);//write position
				if(ret<0)
				{
					printf("fwrite_chars error\n");
					return FAILED;
				}
				if(strlen(ch)%2!=0)         
				{
					ret=fwrite_atohex("0x00",fp_luh);	
					if(ret<0)
					{
						printf("fwrite_atohex error\n");
						return FAILED;
					}			
				}
			}
		
		}

		crc_type_8=htons(CRC_8_TYPE);
		crc_type_16=htons(CRC_16_TYPE);
		crc_type_32=htons(CRC_32_TYPE);
		
		/***************data file*******************/
#if 1
		ch=get_config_var("luh_number_data_file");
		if(ch==NULL)
		{
			printf("get luh_number_data_file error\n");
			return FAILED;
		}

		ret=fwrite_atohex(ch,fp_luh);		
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}
		file_num=htoi(ch);

		for(k=0;k<file_num;k++)
		{
			ret=fwrite_atohex(data_file_p[k],fp_luh);
			if(ret<0)
			{
				printf("fwrite_atohex error\n");
				return FAILED;
			}
			ch=get_config_var(data_file_name[k]);
			if(ch==NULL)
	 		{
				printf("get data_file_name error\n");
				return FAILED;
	 		}
			//printf("k=%d\n",k);			
			strcpy(data_name,path_name);
			strcat(data_name,ch);
			//printf("data_name=%s\n",data_name);
			strcpy(files.data_file_name[k],data_name);

			length=htons(strlen(ch));
			ret=fwrite(&length,sizeof(short),1,fp_luh);//write file name length
			if(ret<0)
			{
				printf("fwrite error\n");
				return FAILED;
			}
			ret=fwrite_chars(ch,fp_luh);//write name
			if(ret<0)
			{
				printf("fwrite_chars error\n");
				return FAILED;
			}
			if(strlen(ch)%2!=0)        
			{
				ret=fwrite_atohex("0x00",fp_luh);
				if(ret<0)
				{
					printf("fwrite_atohex error\n");
					return FAILED;
				}
				
			}

			ch=get_config_var(data_file_PN[k]);
			if(ch==NULL)
	 		{
				printf("get data_file_PN error\n");
				return FAILED;
	 		}
			length=htons(strlen(ch));
			ret=fwrite(&length,sizeof(short),1,fp_luh);//write data PN length
			if(ret<0)
			{
				printf("fwrite error\n");
				return FAILED;
			}
			ret=fwrite_chars(ch,fp_luh);//write data PN
			if(ret<0)
			{
				printf("fwrite_chars error\n");
				return FAILED;
			}
			if(strlen(ch)%2!=0) 		
			{
				ret=fwrite_atohex("0x00",fp_luh);	
				if(ret<0)
				{
					printf("fwrite_atohex error\n");
					return FAILED;
				}
				
			}
			
			len=calculate_file_length_32(data_name);
			if(len%2!=0)
			{
				len=(len+1)/2;
			}
			else 
			{
				len=len/2;
			}
				
			len=htonl(len);
			ret=fwrite(&len,sizeof(int),1,fp_luh);//write data file length
			if(ret<0)
			{
				printf("fwrite error\n");
				return FAILED;
			}
			
			data_crc_16[k]=crc_16(data_name);                         //CRC_16校验
			printf("data_crc_16[%d]=0x%x\n",k,data_crc_16[k]);
			data_crc_16[k]=htons(data_crc_16[k]);       
			ret=fwrite(&data_crc_16[k],sizeof(short),1,fp_luh);
			if(ret<0)
			{
				printf("fwrite error\n");
				return FAILED;
			}
								
			len_64=calculate_file_length_64(data_name);
			//printf("*****data file length_64: %x\n",len);
			len_64=hton64(len_64);//big end or small end
			//printf("*****change data file length_64: %llx\n",len);
			ret=fwrite(&len_64,sizeof(char),8,fp_luh);   //write data file length in bytes
			if(ret<0)
			{
				printf("fwrite error\n");
				return FAILED;
			}
		
			ch=get_config_var(data_check_value_type[k]);
			if(ch==NULL)
	 		{
				printf("get data_check_value_type error\n");
				return FAILED;
	 		}
			check_type=chtoshort_hex(ch);
			//printf("data file check type=0x%x\n",check_type);
			check_type_temp=htons(check_type);
		
			switch(check_type)
			{
				case 1:
					    ret=fwrite(&crc_type_8,sizeof(short),1,fp_luh);//write data check value length	
					    if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						ret=fwrite(&check_type_temp,sizeof(short),1,fp_luh);//write data check value type			
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						data_crc_8[k]=crc_8(data_name);
						//printf("data_crc_8[%d]=0x%x\n",k,data_crc_8[k]);
						data_crc_8[k]=htonl(data_crc_8[k]);
						ret=fwrite(&data_crc_8[k],sizeof(char),1,fp_luh);//write data check value									
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						break;
				case 2:
						ret=fwrite(&crc_type_16,sizeof(short),1,fp_luh);//write data check value length
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						ret=fwrite(&check_type_temp,sizeof(short),1,fp_luh);//write data check value type		
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						ret=fwrite(&data_crc_16[k],sizeof(short),1,fp_luh);//write  data check value				
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						break;
				case 3:
						ret=fwrite(&crc_type_32,sizeof(short),1,fp_luh);//write data check value length					
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						ret=fwrite(&check_type_temp,sizeof(short),1,fp_luh);//write data check value type		
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						data_crc_32[k]=crc_32(data_name);
						//printf("data_crc_32[%d]=0x%x\n",k,data_crc_32[k]);
						data_crc_32[k]=htonl(data_crc_32[k]);
						ret=fwrite(&data_crc_32[k],sizeof(int),1,fp_luh);//write data check value					
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						break;
				default:
							;
			}	
		}
#endif

			/*******support file*********/
		ch=get_config_var("luh_number_support_file");
		if(ch==NULL)
		{
			printf("get luh_number_support_file error\n");
			return FAILED;
		}

		ret=fwrite_atohex(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_atohex error\n");
			return FAILED;
		}
		nu_file=htoi(ch);
		for(k=0;k<nu_file;k++)              //number of support files 
		{
			ret=fwrite_atohex(support_file_p[k],fp_luh);				
			if(ret<0)
			{
				printf("fwrite_atohex error\n");
				return FAILED;
			}
			ch=get_config_var(support_file_name[k]);
			if(ch==NULL)
	 		{
				printf("get support_file_name error\n");
				return FAILED;
	 		}
			strcpy(sup_name,path_name);
			strcat(sup_name,ch);
			//printf("sup_name=%s\n",sup_name);
			strcpy(files.su_file_name[k],sup_name);
			f_su=fopen(sup_name,"r");
			if(f_su==NULL)
			{
				printf("can`t open support file\n");
				return FAILED;
			}
			length=htons(strlen(ch));
			ret=fwrite(&length,sizeof(short),1,fp_luh);//write support file name length
			if(ret<0)
			{
				printf("fwrite error\n");
				return FAILED;
			}
			ret=fwrite_chars(ch,fp_luh);//write name
			if(ret<0)
			{
				printf("fwrite_chars error\n");
				return FAILED;
			}
			if(strlen(ch)%2!=0)        
			{
				ret=fwrite_atohex("0x00",fp_luh);
				if(ret<0)
				{
					printf("fwrite_atohex error\n");
					return FAILED;
				}				
			}
			
			ch=get_config_var(support_file_PN[k]);
			if(ch==NULL)
	 		{
				printf("get support_file_PN error\n");
				return FAILED;
	 		}
			length=htons(strlen(ch));
			ret=fwrite(&length,sizeof(short),1,fp_luh);//write PN length
			if(ret<0)
			{
				printf("fwrite error\n");
				return FAILED;
			}
			ret=fwrite_chars(ch,fp_luh);//write PN
			if(ret<0)
			{
				printf("fwrite_chars error\n");
				return FAILED;
			}
			if(strlen(ch)%2!=0) 		
			{
				ret=fwrite_atohex("0x00",fp_luh);	
				if(ret<0)
				{
					printf("fwrite_atohex error\n");
					return FAILED;
				}								
			}

			fseek(f_su,0,2);//move to the file end
			su_len=ftell(f_su);
			su_len=htonl(su_len);


			ret=fwrite(&su_len,sizeof(unsigned int),1,fp_luh);//write support file length
			if(ret<0)
			{
				printf("fwrite error\n");
				return FAILED;
			}
			rewind(f_su);//move to the file start
			fclose(f_su);

			sup_crc_16[k]=crc_16(sup_name);
			sup_crc_16[k]=htons(sup_crc_16[k]);
			ret=fwrite(&sup_crc_16[k],sizeof(short),1,fp_luh);//write support file crc
			if(ret<0)
			{
				printf("fwrite error\n");
				return FAILED;
			}
			//printf("sup_crc_16[%d]=0x%x\n",k,sup_crc_16[k]);

			ch=get_config_var(support_check_value_type[k]);
			if(ch==NULL)
	 		{
				printf("get support_check_value_type error\n");
				return FAILED;
	 		}
			check_type=chtoshort_hex(ch);
			//printf("support file check type=0x%x\n",check_type);
			check_type_temp=htons(check_type);
		
			switch(check_type)
			{
				case 1:
				   	 	ret=fwrite(&crc_type_8,sizeof(short),1,fp_luh);
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						ret=fwrite(&check_type_temp,sizeof(short),1,fp_luh);		
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						sup_crc_8[k]=crc_8(sup_name);
						//printf("sup_crc_8[%d]=0x%x\n",k,sup_crc_8[k]);
						sup_crc_8[k]=htonl(sup_crc_8[k]);
						ret=fwrite(&sup_crc_8[k],sizeof(char),1,fp_luh);	
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						break;
				case 2:
						ret=fwrite(&crc_type_16,sizeof(short),1,fp_luh);//write support check value length
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						ret=fwrite(&check_type_temp,sizeof(short),1,fp_luh);//write support check value type		
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						
						ret=fwrite(&sup_crc_16[k],sizeof(short),1,fp_luh);//write  support check value
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						break;
				case 3:
						ret=fwrite(&crc_type_32,sizeof(short),1,fp_luh);//write support check value length					
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						ret=fwrite(&check_type_temp,sizeof(short),1,fp_luh);//write support check value type		
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						sup_crc_32[k]=crc_32(sup_name);
					//	printf("sup_crc_32[%d]=0x%x\n",k,sup_crc_32[k]);
						sup_crc_32[k]=htonl(sup_crc_32[k]);
						ret=fwrite(&sup_crc_32[k],sizeof(int),1,fp_luh);//write  support check value
						if(ret<0)
						{
							printf("fwrite error\n");
							return FAILED;
						}
						break;
				default:
							 ;
			}
		}

		ch=get_config_var("luh_user_defined_data");
		if(ch==NULL)
	 	{
			printf("get luh_user_defined_data error\n");
			return FAILED;
	 	}
		ret=fwrite_chars(ch,fp_luh);
		if(ret<0)
		{
			printf("fwrite_chars error\n");
			return FAILED;
		}
		luh_fpos=ftell(fp_luh);
		files.data_file_num=file_num;
		files.su_file_num=nu_file;
		strcpy(files.luh_file_name,luh_name);
		files.luh_length=luh_fpos;

		ch=get_config_var("luh_load_check_value_type");
		if(ch==NULL)
	 	{
			printf("get luh_load_check_value_type error\n");
			return FAILED;
	 	}
		check_type=chtoshort_hex(ch);
		//printf("load check type=0x%x\n",check_type);
		check_type_temp=htons(check_type);
		switch(check_type)
		{
			case 1:
			 		ret=fwrite(&crc_type_8,sizeof(short),1,fp_luh);//write load crc check value length	
			 		if(ret<0)
					{
						printf("fwrite error\n");
						return FAILED;
					}
					ret=fwrite(&check_type_temp,sizeof(short),1,fp_luh);//write load crc check value type		
					if(ret<0)
					{
						printf("fwrite error\n");
						return FAILED;
					}
					multi_crc8=multi_crc_8(files);
					//printf("multi_crc8=0x%x\n",multi_crc8);
					multi_crc8=htons(multi_crc8);
					ret=fwrite(&multi_crc8,sizeof(short),1,fp_luh);//write  load crc check value
					if(ret<0)
					{
						printf("fwrite error\n");
						return FAILED;
					}
					break;
				
			case 2:
					ret=fwrite(&crc_type_16,sizeof(short),1,fp_luh);//write load crc check value length
					if(ret<0)
					{
						printf("fwrite error\n");
						return FAILED;
					}
					ret=fwrite(&check_type_temp,sizeof(short),1,fp_luh);//write load crc check value type	
					if(ret<0)
					{
						printf("fwrite error\n");
						return FAILED;
					}
					multi_crc16=multi_crc_16(files);
					//printf("multi_crc16=0x%x\n",multi_crc16);
					multi_crc16=htons(multi_crc16);
					ret=fwrite(&multi_crc16,sizeof(short),1,fp_luh);//write  load crc check value
					if(ret<0)
					{
						printf("fwrite error\n");
						return FAILED;
					}
					break;
			case 3:
					ret=fwrite(&crc_type_32,sizeof(short),1,fp_luh);//write load crc check value length					
					if(ret<0)
					{
						printf("fwrite error\n");
						return FAILED;
					}
					ret=fwrite(&check_type_temp,sizeof(short),1,fp_luh);//write load crc check value type		
					if(ret<0)
					{
						printf("fwrite error\n");
						return FAILED;
					}
					multi_crc32=multi_crc_32(files);
					//printf("multi_crc32=0x%x\n",multi_crc32);
					multi_crc32=htonl(multi_crc32);
					ret=fwrite(&multi_crc32,sizeof(int),1,fp_luh);//write load crc check value
					if(ret<0)
					{
						printf("fwrite error\n");
						return FAILED;
					}
					break;
			default:
						 ;
		}
		luh_fpos=ftell(fp_luh);
		header_file_crc=crc_file_pos_16(luh_name,luh_fpos);
		printf("header_file_crc=0x%x\n",header_file_crc);
		header_file_crc=htons(header_file_crc);
		ret=fwrite(&header_file_crc,sizeof(short),1,fp_luh);//header file crc
		if(ret<0)
		{
			printf("fwrite error\n");
			return FAILED;
		}
					
		luh_fpos=ftell(fp_luh);
		load_crc=crc_file_pos_32(luh_name,luh_fpos);
		printf("load_crc=0x%x\n",load_crc);
		load_crc=htons(load_crc);
		ret=fwrite(&load_crc,sizeof(int),1,fp_luh);//load crc
		if(ret<0)
		{
			printf("fwrite error\n");
			return FAILED;
		}
					
		fseek(fp_luh,0,2);//move to the file end
		luh_file_length=ftell(fp_luh);
		luh_file_length=htonl(luh_file_length);
		rewind(fp_luh);//move to the file start
		ret=fwrite(&luh_file_length,sizeof(long),1,fp_luh);
		if(ret<0)
		{
			printf("fwrite error\n");
			return FAILED;
		}
		EXIT:
			  fclose(fp_luh);
			  return FAILED;
	 }
	 return OK;
}
Exemple #10
0
bool dbg_hw_info(void)
{
#ifndef HAVE_LCD_BITMAP
    int button;
    int currval = 0;
#else
    int bitmask = HW_MASK;
#endif
    int rom_version = ROM_VERSION;
    unsigned manu, id; /* flash IDs */
    bool got_id; /* flag if we managed to get the flash IDs */
    unsigned rom_crc = 0xffffffff; /* CRC32 of the boot ROM */
    bool has_bootrom; /* flag for boot ROM present */
    int oldmode;  /* saved memory guard mode */

    oldmode = system_memory_guard(MEMGUARD_NONE);  /* disable memory guard */

    /* get flash ROM type */
    got_id = dbg_flash_id(&manu, &id, 0x5555, 0x2AAA); /* try SST, Atmel, NexFlash */
    if (!got_id)
        got_id = dbg_flash_id(&manu, &id, 0x555, 0x2AA); /* try AMD, Macronix */

    /* check if the boot ROM area is a flash mirror */
    has_bootrom = (memcmp((char*)0, (char*)0x02000000, 64*1024) != 0);
    if (has_bootrom)  /* if ROM and Flash different */
    {
        /* calculate CRC16 checksum of boot ROM */
        rom_crc = crc_32((unsigned char*)0x0000, 64*1024, 0xffffffff);
    }

    system_memory_guard(oldmode);  /* re-enable memory guard */

    lcd_clear_display();

#ifdef HAVE_LCD_BITMAP
    lcd_setfont(FONT_SYSFIXED);

    lcd_puts(0, 0, "[Hardware info]");

    lcd_putsf(0, 1, "ROM: %d.%02d", rom_version/100, rom_version%100);

    lcd_putsf(0, 2, "Mask: 0x%04x", bitmask);
    if (got_id)
        lcd_putsf(0, 3, "Flash: M=%02x D=%02x", manu, id);
    else
        lcd_puts(0, 3, "Flash: M=?? D=??"); /* unknown, sorry */

    if (has_bootrom)
    {
        if (rom_crc == 0x56DBA4EE) /* known Version 1 */
            lcd_puts(0, 4, "Boot ROM: V1");
        else
            lcd_putsf(0, 4, "ROMcrc: 0x%08x", rom_crc);
    }
    else
    {
        lcd_puts(0, 4, "Boot ROM: none");
    }

    lcd_update();

    /* wait for exit */
    while (button_get_w_tmo(HZ/10) != (DEBUG_CANCEL|BUTTON_REL));

    lcd_setfont(FONT_UI);

#else /* !HAVE_LCD_BITMAP */
    lcd_puts(0, 0, "[HW Info]");
    while(1)
    {
        switch(currval)
        {
        case 0:
            lcd_putsf(0, 1, "ROM: %d.%02d",
                      rom_version/100, rom_version%100);
            break;
        case 1:
            if (got_id)
                lcd_putsf(0, 1, "Flash:%02x,%02x", manu, id);
            else
                lcd_puts(0, 1, "Flash:??,??"); /* unknown, sorry */
            break;
        case 2:
            if (has_bootrom)
            {
                if (rom_crc == 0x56DBA4EE) /* known Version 1 */
                    lcd_puts(0, 1, "BootROM: V1");
                else if (rom_crc == 0x358099E8)
                    lcd_puts(0, 1, "BootROM: V2");
                /* alternative boot ROM found in one single player so far */
                else
                    lcd_putsf(0, 1, "R: %08x", rom_crc);
            }
            else
                lcd_puts(0, 1, "BootROM: no");
        }

        lcd_update();

        button = button_get_w_tmo(HZ/10);

        switch(button)
        {
        case BUTTON_STOP:
            return false;

        case BUTTON_LEFT:
            currval--;
            if(currval < 0)
                currval = 2;
            break;

        case BUTTON_RIGHT:
            currval++;
            if(currval > 2)
                currval = 0;
            break;
        }
    }
#endif
    return false;
}
Exemple #11
0
 @total_records uint16 
 transform uint16_depend (@this_records @total_records)
 @directory_size uint32 
 @directory_start uint32
 $dirstr1 transform offset_u32 ($filestream @directory_start) 
 $directory_stream transform size_u32 ($dirstr1 @directory_size)
 @comment_length uint16
 comment n_of @comment_length uint8
 files apply $directory_stream n_of @total_directory_records dir_fileheader($filestream)
}
dir_fileheader($filestream) = {  /*cut for brevity*/
 uint32 = 0x02014b50/*...*/
 @compressed_size uint16 /*...*/
 @crc32 uint32/*...*/
 @file_name_len uint16/*...*/
 @off uint32
 filename n_of @file_name_len uint8/*...*/
 $contentstream transform offset_u32 ($filestream @off)
 contents apply $contentstream fileentry(@crc32,@compressed_size /*...*/)
}
fileentry(@crc32 uint32,@size uint32/*...*/) = {
 uint32 = 0x04034b50/*...*/
 @crc_local uint32/*...*/
 $compressed transform size_u32 ($current @size)
 $uncompressed transform zip_compression ($compressed @size/*...*/)
 transform crc_32 ($uncompressed @crc32)
 contents apply $uncompressed many uint8
 
 transform uint16_depend (@crc_local @crc32)/*...*/
}