1145 lines
30 KiB
C
1145 lines
30 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include <stdint.h>
|
|
#include <sys/stat.h>
|
|
#include <arpa/inet.h>
|
|
#include "sha256.h"
|
|
#include "iot_img_hdr.h"
|
|
|
|
char default_hash_iv[]={0x12,0x34,0x56,0x78,0x87,0x65,0x43,0x21,0x5A,0x5A,0x5A,0x5A,0x00,0x7E,0xC3,0x00};
|
|
|
|
#define NEW_LINE "\r\n"
|
|
|
|
#define OK 0
|
|
#define ERROR (-1)
|
|
|
|
#define FUNC_CONSTRUCT "-c"
|
|
#define FUNC_SHOWHEADER "-s"
|
|
|
|
#define PK_NAME_KEY_WORD "iot_flash"
|
|
#define PK_SINGLE_FILE_SIZE 0x1000000 /* sigle file size keeped under 16MB */
|
|
#define MAX_IMAGE_NUM 20
|
|
#define imgHeaderSize HEADER_TOLTAL_SIZE
|
|
|
|
char * global_buffer = NULL;
|
|
|
|
unsigned int CRC32_Update(unsigned int crc, char *buff, int len);
|
|
|
|
typedef unsigned short UINT16;
|
|
typedef unsigned int UINT32;
|
|
|
|
typedef struct
|
|
{
|
|
char *pName;
|
|
int ver;
|
|
int devType;
|
|
int imgType;
|
|
}ftype;
|
|
|
|
enum{
|
|
RET_OK,
|
|
RET_ENV_FAILED,
|
|
RET_BAD_PARA,
|
|
RET_IMAGE_WRONG,
|
|
};
|
|
|
|
#define GET_BYTE1(i) ((i)&0xFF)
|
|
#define GET_BYTE2(i) (((i)>>8)&0xFF)
|
|
#define GET_BYTE3(i) (((i)>>16)&0xFF)
|
|
#define GET_BYTE4(i) (((i)>>24)&0xFF)
|
|
|
|
#define PATH_LENGTH 128
|
|
#define KEYWRD_LENGTH (PATH_LENGTH - 12) /* "20170901.bin" -> 12 bytes */
|
|
typedef struct ah_image_config_
|
|
{
|
|
int image_type;
|
|
int version;
|
|
int offset;
|
|
int length;
|
|
// int pad_enable;
|
|
// int pad;
|
|
char path[PATH_LENGTH];
|
|
char fwpath[PATH_LENGTH];
|
|
}ah_img_cfg;
|
|
|
|
typedef struct ah_device_config_
|
|
{
|
|
int device_type;
|
|
int encrypt_mode;
|
|
int encrypt_pattern;
|
|
int image_num;
|
|
int version;
|
|
int top_header_enable;
|
|
int package_type;
|
|
int img_size;
|
|
int layout_index;
|
|
int lzma_type;
|
|
int fw2_load;
|
|
int img_type;
|
|
int vendor_id;
|
|
int magic_no;
|
|
int crc;
|
|
char key_word[PATH_LENGTH];
|
|
ah_img_cfg image[MAX_IMAGE_NUM];
|
|
}ah_cfg;
|
|
|
|
|
|
#define CH_SPC 0x20
|
|
#define CH_TAB 0x09
|
|
|
|
int ah_funShowHeader(char argc, char *argv[]);
|
|
|
|
int ah_atoi(char * str)
|
|
{
|
|
int value = 0;
|
|
int sign = 1;
|
|
int radix;
|
|
|
|
|
|
if(*str == '-')
|
|
{
|
|
sign = -1;
|
|
str++;
|
|
}
|
|
if(*str == '0' && (*(str+1) == 'x' || *(str+1) == 'X'))
|
|
{
|
|
radix = 16;
|
|
str += 2;
|
|
}
|
|
else if(*str == '0')
|
|
{
|
|
radix = 8;
|
|
str++;
|
|
}
|
|
else
|
|
{
|
|
radix = 10;
|
|
}
|
|
while(*str)
|
|
{
|
|
if(radix == 16)
|
|
{
|
|
if(*str >= '0' && *str <= '9')
|
|
{
|
|
value = value * radix + *str - '0';
|
|
}
|
|
else if(*str >= 'A' && *str <= 'F')
|
|
{
|
|
value = value * radix + *str - 'A' + 10;
|
|
}
|
|
else if(*str >= 'a' && *str <= 'f')
|
|
{
|
|
value = value * radix + *str - 'a' + 10;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else if(radix == 8)
|
|
{
|
|
if(*str >= '0' && *str <= '7')
|
|
{
|
|
value = value * radix + *str - '0';
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(*str >= '0' && *str <= '9')
|
|
{
|
|
value = value * radix + *str - '0';
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
str ++;
|
|
}
|
|
return sign*value;
|
|
}
|
|
|
|
static int ah_isSpace(int c)
|
|
{
|
|
switch (c) {
|
|
case 0x20:
|
|
case 0xD:
|
|
case 0xA:
|
|
case 0x9:
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
#define ISSPACE(c) ah_isSpace(c)
|
|
|
|
/* skip white space */
|
|
char *ah_GetValidString(char *str)
|
|
{
|
|
char *start, *end;
|
|
start = str;
|
|
end = str+strlen(str)-1;
|
|
|
|
while((start<=end) && ISSPACE(*start)) start++;
|
|
|
|
while((start<=end) && ISSPACE(*end)) end--;
|
|
|
|
if(start > end)
|
|
return NULL;
|
|
|
|
*(end+1) = 0x0;
|
|
|
|
return start;
|
|
}
|
|
|
|
char *ah_GetKeyString(FILE *fp, char *title, char *key)
|
|
{
|
|
#define LINE_LENGTH 1024
|
|
int start=0;
|
|
char *pt;
|
|
static char sLine[LINE_LENGTH];
|
|
|
|
fseek(fp, 0, SEEK_SET);
|
|
|
|
while (NULL != fgets(sLine, LINE_LENGTH, fp)) {
|
|
|
|
if (('#' ==sLine[0])
|
|
||(';' ==sLine[0]))
|
|
continue;
|
|
|
|
if('[' ==sLine[0])
|
|
{
|
|
start =0;
|
|
}
|
|
|
|
if(start)
|
|
{
|
|
if((NULL != (pt = strchr(sLine, '=')))
|
|
&&(0 == strncmp(key, sLine, pt-sLine)))
|
|
{
|
|
sLine[LINE_LENGTH-1] = 0x0;
|
|
pt = ah_GetValidString(pt + 1);;
|
|
return pt;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if(0 == strncmp(title, sLine, strlen(title)-1))
|
|
{
|
|
start =1;
|
|
}
|
|
}
|
|
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void ah_help(void)
|
|
{
|
|
printf(NEW_LINE"--Usage of ah:"NEW_LINE);
|
|
printf(NEW_LINE"ah -c config-file");
|
|
printf(NEW_LINE" e.g. ah -c ./ah_config.cfg");
|
|
printf(NEW_LINE"ah -s file");
|
|
printf(NEW_LINE" Show the header(s) of a package."NEW_LINE);
|
|
printf(NEW_LINE);
|
|
|
|
return ;
|
|
}
|
|
|
|
static void ah_Sha256(unsigned char* img, int len, unsigned char* sha256)
|
|
{
|
|
sha256_context ctx;
|
|
|
|
sha256_init( &ctx );
|
|
sha256_starts( &ctx );
|
|
sha256_update( &ctx, img, len );
|
|
sha256_update( &ctx, (unsigned char*)default_hash_iv, 16);
|
|
sha256_finish( &ctx, sha256 );
|
|
sha256_free( &ctx );
|
|
}
|
|
|
|
#define DEVICE_STR "[DEVICE]"
|
|
#define DEVICE_STR_TYPE "device_type"
|
|
#define DEVICE_STR_IMGNUM "image_num"
|
|
#define DEVICE_STR_KEYWRD "key_word"
|
|
#define DEVICE_STR_TOPHDRENA "top_header_enable"
|
|
#define DEVICE_STR_TOPHDRENC "encrypt_mode"
|
|
#define DEVICE_STR_TOPHDRPTN "encrypt_pattern"
|
|
#define DEVICE_STR_TOPHDRVER "version"
|
|
#define DEVICE_STR_PACKAGE_TYPE "package_type"
|
|
#define DEVICE_STR_MAGIC_NO "magic_no"
|
|
#define DEVICE_STR_IMAGE_SIZE "img_size"
|
|
#define DEVICE_STR_LAYOUT_INDEX "layout_index"
|
|
#define DEVICE_STR_LZMA_TYPE "lzma_type"
|
|
#define DEVICE_STR_FW2_LOAD "fw2_load"
|
|
#define DEVICE_STR_IMAGE_TYPE "img_type"
|
|
#define DEVICE_STR_VENDOR_ID "vendor_id"
|
|
|
|
#define IMAGE_STR "[IMAGE_%02d]"
|
|
//#define IMAGE_STR_PADENA "pad_enable"
|
|
//#define IMAGE_STR_PAD "pad"
|
|
#define IMAGE_STR_TYPE "image_type"
|
|
#define IMAGE_STR_VERSION "version"
|
|
#define IMAGE_STR_PATH "path"
|
|
#define IMAGE_STR_OFFSET "offset"
|
|
#define IMAGE_STR_LENGTH "length"
|
|
|
|
int ah_GetConfig(char *pcfgName, ah_cfg *pcfg)
|
|
{
|
|
FILE *fconfig;
|
|
char *pkey;
|
|
char imageName[64];
|
|
ah_cfg *cfg=pcfg;
|
|
int tmp0,tmp1,tmp2,tmp3,i;
|
|
|
|
if(NULL == (fconfig=fopen(pcfgName, "r")))
|
|
{
|
|
printf("\r\n Can not open config: %s!\r\n", pcfgName);
|
|
return -1;
|
|
}
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_TYPE)))
|
|
{
|
|
cfg->device_type = ah_atoi(pkey);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", DEVICE_STR_TYPE, DEVICE_STR);
|
|
return -1;
|
|
}
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_IMGNUM)))
|
|
{
|
|
cfg->image_num = ah_atoi(pkey);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", DEVICE_STR_IMGNUM, DEVICE_STR);
|
|
return -1;
|
|
}
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_KEYWRD)))
|
|
{
|
|
if(strlen(pkey) <= KEYWRD_LENGTH)
|
|
{
|
|
strcpy(cfg->key_word, pkey);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Keywords over length: %s !\r\n", pkey);
|
|
return -1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", DEVICE_STR_KEYWRD, DEVICE_STR);
|
|
return -1;
|
|
}
|
|
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_TOPHDRENA)))
|
|
{
|
|
cfg->top_header_enable = ah_atoi(pkey);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", DEVICE_STR_TOPHDRENA, DEVICE_STR);
|
|
return -1;
|
|
}
|
|
|
|
if(cfg->top_header_enable)
|
|
{
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_TOPHDRENC)))
|
|
{
|
|
cfg->encrypt_mode = ah_atoi(pkey);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", DEVICE_STR_TOPHDRENC, DEVICE_STR);
|
|
return -1;
|
|
}
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_TOPHDRPTN)))
|
|
{
|
|
cfg->encrypt_pattern = ah_atoi(pkey);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", DEVICE_STR_TOPHDRPTN, DEVICE_STR);
|
|
return -1;
|
|
}
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_TOPHDRVER)))
|
|
{
|
|
sscanf(pkey, "%d.%d.%d.%d", &tmp0, &tmp1, &tmp2, &tmp3);
|
|
cfg->version = ((tmp0&0x1F)<<27)|((tmp1&0x7F)<<20)|((tmp2&0xF)<<16)|(tmp3&0xFFFF);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", DEVICE_STR_TOPHDRVER, DEVICE_STR);
|
|
return -1;
|
|
}
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_IMAGE_SIZE)))
|
|
{
|
|
cfg->img_size = ah_atoi(pkey);
|
|
}
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_LAYOUT_INDEX)))
|
|
{
|
|
cfg->layout_index = ah_atoi(pkey);
|
|
}
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_PACKAGE_TYPE)))
|
|
{
|
|
cfg->package_type = ah_atoi(pkey);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", DEVICE_STR_PACKAGE_TYPE, DEVICE_STR);
|
|
return -1;
|
|
}
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_MAGIC_NO)))
|
|
{
|
|
cfg->magic_no = ah_atoi(pkey);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", DEVICE_STR_MAGIC_NO, DEVICE_STR);
|
|
return -1;
|
|
}
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_LZMA_TYPE)))
|
|
{
|
|
cfg->lzma_type = ah_atoi(pkey);
|
|
}
|
|
if (NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_FW2_LOAD)))
|
|
{
|
|
cfg->fw2_load = ah_atoi(pkey);
|
|
}
|
|
if (NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_IMAGE_TYPE)))
|
|
{
|
|
cfg->img_type = ah_atoi(pkey);
|
|
}
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, DEVICE_STR, DEVICE_STR_VENDOR_ID)))
|
|
{
|
|
cfg->vendor_id = ah_atoi(pkey);
|
|
}
|
|
}
|
|
|
|
for(i = 0; i < cfg->image_num; i++)
|
|
{
|
|
sprintf(imageName, IMAGE_STR, i+1);
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, imageName, IMAGE_STR_TYPE)))
|
|
{
|
|
cfg->image[i].image_type = ah_atoi(pkey);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", IMAGE_STR_TYPE, imageName);
|
|
return -1;
|
|
}
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, imageName, IMAGE_STR_VERSION)))
|
|
{
|
|
sscanf(pkey, "%d.%d.%d", &tmp0, &tmp1, &tmp2);
|
|
cfg->image[i].version = ((tmp0&0xF)<<12)|((tmp1&0xF)<<8)|(tmp2&0xFF);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", IMAGE_STR_VERSION, imageName);
|
|
return -1;
|
|
}
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, imageName, IMAGE_STR_PATH)))
|
|
{
|
|
if(strlen(pkey) <= PATH_LENGTH)
|
|
{
|
|
strcpy(cfg->image[i].path, pkey);
|
|
strcpy(cfg->image[i].fwpath, pkey);
|
|
strcat(cfg->image[i].fwpath, ".fw");
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Path over length: %s !\r\n", pkey);
|
|
return -1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", IMAGE_STR_PATH, imageName);
|
|
return -1;
|
|
}
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, imageName, IMAGE_STR_OFFSET)))
|
|
{
|
|
cfg->image[i].offset = ah_atoi(pkey);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", IMAGE_STR_OFFSET, imageName);
|
|
return -1;
|
|
}
|
|
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, imageName, IMAGE_STR_LENGTH)))
|
|
{
|
|
cfg->image[i].length = ah_atoi(pkey);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", IMAGE_STR_LENGTH, imageName);
|
|
return -1;
|
|
}
|
|
|
|
#if 0
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, imageName, IMAGE_STR_PADENA)))
|
|
{
|
|
cfg->image[i].pad_enable = ah_atoi(pkey);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", IMAGE_STR_PADENA, DEVICE_STR);
|
|
return -1;
|
|
}
|
|
|
|
if(cfg->image[i].pad_enable)
|
|
{
|
|
if(NULL != (pkey = ah_GetKeyString(fconfig, imageName, IMAGE_STR_PAD)))
|
|
{
|
|
cfg->image[i].pad = ah_atoi(pkey);
|
|
}
|
|
else
|
|
{
|
|
printf("\r\n Can not find %s in %s !\r\n", IMAGE_STR_PAD, DEVICE_STR);
|
|
return -1;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#define PACKAGE_HEADER_SIZE 96
|
|
|
|
int ah_funConstruct(char argc, char *argv[])
|
|
{
|
|
FILE *fps = NULL, *fpd = NULL;
|
|
int cnt, _CRC, fileSize, crcSize, ret =RET_OK, i;
|
|
char pkName[256];
|
|
time_t rawtime;
|
|
struct tm *timeinfo;
|
|
ah_cfg cfg;
|
|
unsigned char sha[32];
|
|
struct stat st;
|
|
char *sh_argv[3];
|
|
char *p_buf = NULL;
|
|
char *p_saved_buf = NULL;
|
|
iot_pkg_hdr_t *hdr = NULL;
|
|
char *payload = NULL;
|
|
int pad_len = 0;
|
|
int len = 0;
|
|
int offset = 0;
|
|
int total_size = 0;
|
|
char *fw_buffer = NULL;
|
|
uint32_t fw_crc = 0;
|
|
uint32_t fw_size = 0;
|
|
char psram_size = sizeType_max;
|
|
char new_header_version = 0;
|
|
char *psram_str = NULL;
|
|
|
|
if(argc < 3)
|
|
{
|
|
return RET_BAD_PARA;
|
|
}
|
|
|
|
if (argc >= 4) {
|
|
psram_str = (char*)argv[3];
|
|
if ((psram_str[0] == 'p') || (psram_str[0] == 'P')) {
|
|
psram_size = atoi(++psram_str);
|
|
}
|
|
if ((psram_size == sizeType_0MB) || (psram_size == sizeType_2MB)
|
|
|| (psram_size == sizeType_4MB) || (psram_size == sizeType_8MB)) {
|
|
new_header_version = 1;
|
|
}
|
|
}
|
|
|
|
memset(&cfg, 0x0, sizeof(ah_cfg));
|
|
|
|
/* Get local time */
|
|
time ( &rawtime );
|
|
timeinfo = localtime ( &rawtime );
|
|
|
|
/* Get information from input */
|
|
if(NULL == (global_buffer = (char*)malloc(PK_SINGLE_FILE_SIZE)))
|
|
{
|
|
ret = RET_ENV_FAILED;
|
|
goto ERROR_HANDLE;
|
|
}
|
|
|
|
if(NULL == (fw_buffer = (char*)malloc(PK_SINGLE_FILE_SIZE)))
|
|
{
|
|
ret = RET_ENV_FAILED;
|
|
goto ERROR_HANDLE;
|
|
}
|
|
|
|
|
|
if(0 != ah_GetConfig(argv[2], &cfg))
|
|
{
|
|
ret = RET_ENV_FAILED;
|
|
goto ERROR_HANDLE;
|
|
}
|
|
|
|
if(cfg.image_num>MAX_IMAGE_NUM || cfg.image_num<0)
|
|
{
|
|
printf(NEW_LINE"Invalid config file(%s)."NEW_LINE, argv[2]);
|
|
ret = RET_ENV_FAILED;
|
|
goto ERROR_HANDLE;
|
|
}
|
|
|
|
/* make package name */
|
|
sprintf(pkName, "./%s%04d%02d%02d.bin", cfg.key_word,\
|
|
timeinfo->tm_year+1900, timeinfo->tm_mon+1, timeinfo->tm_mday);
|
|
|
|
memset(global_buffer, 0x0, PK_SINGLE_FILE_SIZE);
|
|
|
|
if(cfg.top_header_enable)
|
|
{
|
|
/*image header*/
|
|
hdr = (iot_pkg_hdr_t*)global_buffer;
|
|
hdr->enctype = cfg.encrypt_mode;
|
|
hdr->pattern = cfg.encrypt_pattern;
|
|
hdr->dev_type = htons(cfg.package_type);
|
|
hdr->magic_no = htonl(cfg.magic_no);
|
|
hdr->version = htonl(cfg.version);
|
|
hdr->vendor_id = htons(cfg.vendor_id);
|
|
hdr->img_flag = (cfg.img_size) << 4 | (cfg.lzma_type)<< 2 | (cfg.fw2_load)<< 3;
|
|
hdr->img_type = cfg.img_type;
|
|
|
|
/*image payload*/
|
|
payload = global_buffer + sizeof(iot_pkg_hdr_t);
|
|
}
|
|
else
|
|
{
|
|
/*image payload*/
|
|
payload = global_buffer;
|
|
}
|
|
|
|
p_buf = payload;
|
|
|
|
/* 2400 aligned */
|
|
if((cfg.image_num > 0) &&
|
|
((cfg.image[0].image_type == imgCFG)
|
|
||(cfg.image[0].image_type == imgFRW)
|
|
||(cfg.image[0].image_type == imgCFRW)
|
|
||(cfg.image[0].image_type == imgCFRW1)
|
|
||(cfg.image[0].image_type == imgCFRW4F)
|
|
||(cfg.image[0].image_type == imgCFRW4P)))
|
|
{
|
|
len = p_buf - global_buffer;
|
|
if(len%2400)
|
|
{
|
|
len = 2400 - (len%2400);
|
|
for(i=0; i<len; i++)
|
|
{
|
|
*p_buf = 0;
|
|
p_buf++;
|
|
}
|
|
total_size += len;
|
|
}
|
|
}
|
|
//printf(NEW_LINE"pkName :%s"NEW_LINE, pkName);
|
|
for(cnt = 0; cnt < cfg.image_num; cnt++)
|
|
{
|
|
if((0 != stat(cfg.image[cnt].path, &st))
|
|
||(NULL == (fps=fopen(cfg.image[cnt].path, "r"))))
|
|
{
|
|
printf(NEW_LINE"Cannot open image file(%s)."NEW_LINE, cfg.image[cnt].path);
|
|
ret = RET_ENV_FAILED;
|
|
goto ERROR_HANDLE;
|
|
}
|
|
fw_size = 0;
|
|
|
|
/* Get file size */
|
|
fseek(fps, 0, SEEK_END);
|
|
fileSize = ftell(fps);
|
|
fseek(fps, 0, SEEK_SET);
|
|
|
|
/* Read file into buffer */
|
|
fread(p_buf + imgHeaderSize, 1, fileSize, fps);
|
|
fclose(fps);
|
|
fps = NULL;
|
|
|
|
memset(p_buf, 0x0, imgHeaderSize);
|
|
p_saved_buf = p_buf;
|
|
|
|
if((cfg.image[cnt].image_type == imgSBL)
|
|
||(cfg.image[cnt].image_type == imgOEM)
|
|
||(cfg.image[cnt].image_type == imgCFG))
|
|
{
|
|
//printf(NEW_LINE" add size :%d"NEW_LINE, fileSize);
|
|
if(cfg.image[cnt].length%IMAGE_ALIGNED_SIZE)
|
|
{
|
|
printf(NEW_LINE"Image space length invalid(0x%x)."NEW_LINE, cfg.image[cnt].length);
|
|
}
|
|
if(cfg.image[cnt].length - imgHeaderSize < fileSize)
|
|
{
|
|
printf(NEW_LINE"Image oversize(%s, size:%d, limited:%d)."NEW_LINE,
|
|
cfg.image[cnt].path, fileSize, cfg.image[cnt].length - imgHeaderSize);
|
|
ret = RET_IMAGE_WRONG;
|
|
goto ERROR_HANDLE;
|
|
}
|
|
crcSize = cfg.image[cnt].length - imgHeaderSize;
|
|
pad_len = crcSize - fileSize;
|
|
memset(p_buf + fileSize + imgHeaderSize, 0x0, pad_len);
|
|
fileSize = crcSize;
|
|
}
|
|
else
|
|
{
|
|
pad_len = 0;
|
|
crcSize = IMAGE_LEN_FOR_CRC(fileSize);
|
|
/* Clear pad bytes to '0' */
|
|
memset(p_buf + imgHeaderSize + fileSize, 0x0, crcSize - fileSize);
|
|
}
|
|
|
|
if((crcSize+imgHeaderSize)>cfg.image[cnt].length
|
|
|| (crcSize+imgHeaderSize) > PK_SINGLE_FILE_SIZE)
|
|
{
|
|
printf(NEW_LINE"Image oversize(%s, size:%d, limited:%d)."NEW_LINE,
|
|
cfg.image[cnt].path, crcSize, cfg.image[cnt].length - imgHeaderSize);
|
|
ret = RET_IMAGE_WRONG;
|
|
goto ERROR_HANDLE;
|
|
}
|
|
|
|
/* for CRC */
|
|
_CRC= 0xFFFFFFFF^CRC32_Update(0xFFFFFFFF, p_buf + imgHeaderSize, crcSize);
|
|
|
|
ah_Sha256((unsigned char*)(p_buf + imgHeaderSize), fileSize, sha);
|
|
|
|
if ((cfg.image[cnt].image_type == imgCFRW)
|
|
||(cfg.image[cnt].image_type == imgCFRW1)
|
|
||(cfg.image[cnt].image_type == imgCFRW4F)
|
|
||(cfg.image[cnt].image_type == imgCFRW4P)){
|
|
|
|
if((0 == stat(cfg.image[cnt].fwpath, &st))
|
|
&&(NULL != (fps=fopen(cfg.image[cnt].fwpath, "r")))){
|
|
/* Get file size */
|
|
fseek(fps, 0, SEEK_END);
|
|
fw_size = ftell(fps);
|
|
fseek(fps, 0, SEEK_SET);
|
|
|
|
/* Read file into buffer */
|
|
fread(fw_buffer, 1, fw_size, fps);
|
|
fclose(fps);
|
|
fps = NULL;
|
|
|
|
fw_crc = 0xFFFFFFFF^CRC32_Update(0xFFFFFFFF, fw_buffer, fw_size);
|
|
}
|
|
|
|
}
|
|
|
|
/* Fill header structure */
|
|
/* device type */
|
|
p_buf[0] = (char)GET_BYTE2(cfg.device_type);
|
|
p_buf[1] = (char)GET_BYTE1(cfg.device_type);
|
|
/* image type */
|
|
p_buf[2] = (char)GET_BYTE2(cfg.image[cnt].image_type);
|
|
p_buf[3] = (char)GET_BYTE1(cfg.image[cnt].image_type);
|
|
/* image size */
|
|
p_buf[4] = (char)GET_BYTE4(fileSize);
|
|
p_buf[5] = (char)GET_BYTE3(fileSize);
|
|
p_buf[6] = (char)GET_BYTE2(fileSize);
|
|
p_buf[7] = (char)GET_BYTE1(fileSize);
|
|
/* image version */
|
|
p_buf[8] = (char)GET_BYTE2(cfg.image[cnt].version);
|
|
p_buf[9] = (char)GET_BYTE1(cfg.image[cnt].version);
|
|
|
|
if (new_header_version) {
|
|
/* psram size */
|
|
p_buf[10] = psram_size;
|
|
/* hdr version */
|
|
p_buf[11] = hdrVer_02;
|
|
} else {
|
|
/* psram size */
|
|
p_buf[10] = 0;
|
|
/* hdr version */
|
|
p_buf[11] = 0;
|
|
}
|
|
|
|
/* FW SZIE */
|
|
p_buf[12] = (char)GET_BYTE4(fw_size);
|
|
p_buf[13] = (char)GET_BYTE3(fw_size);
|
|
p_buf[14] = (char)GET_BYTE2(fw_size);
|
|
p_buf[15] = (char)GET_BYTE1(fw_size);
|
|
|
|
/* CRC */
|
|
p_buf[16] = (char)GET_BYTE4(_CRC);
|
|
p_buf[17] = (char)GET_BYTE3(_CRC);
|
|
p_buf[18] = (char)GET_BYTE2(_CRC);
|
|
p_buf[19] = (char)GET_BYTE1(_CRC);
|
|
|
|
/* Guard */
|
|
p_buf[20] = (char)GET_BYTE4(IMAGE_GUARD);
|
|
p_buf[21] = (char)GET_BYTE3(IMAGE_GUARD);
|
|
p_buf[22] = (char)GET_BYTE2(IMAGE_GUARD);
|
|
p_buf[23] = (char)GET_BYTE1(IMAGE_GUARD);
|
|
|
|
/* flash layout index */
|
|
p_buf[24] = cfg.layout_index;
|
|
|
|
/* reserved, default 0 */
|
|
p_buf[25] = 0;
|
|
p_buf[26] = 0;
|
|
p_buf[27] = 0;
|
|
|
|
p_buf[28] = (char)GET_BYTE4(fw_crc);
|
|
p_buf[29] = (char)GET_BYTE3(fw_crc);
|
|
p_buf[30] = (char)GET_BYTE2(fw_crc);
|
|
p_buf[31] = (char)GET_BYTE1(fw_crc);
|
|
|
|
/* SHA256 */
|
|
for(i=32; i<64; i++)
|
|
{
|
|
p_buf[i] = sha[i-32];
|
|
}
|
|
/* write image */
|
|
len = crcSize + imgHeaderSize;
|
|
|
|
/*update buffer pointer*/
|
|
p_buf += len;
|
|
|
|
/*new bin file's size*/
|
|
len = p_buf - p_saved_buf;
|
|
total_size += len;
|
|
|
|
if(cfg.top_header_enable)
|
|
{
|
|
/*update image header*/
|
|
offset = p_saved_buf - global_buffer;
|
|
if(cfg.image[cnt].image_type == imgSP)
|
|
{
|
|
hdr->sp_start = htonl(offset);
|
|
hdr->sp_len = htonl(crcSize+imgHeaderSize);
|
|
}
|
|
if(cfg.image[cnt].image_type == imgSBL)
|
|
{
|
|
hdr->sbl_start = htonl(offset);
|
|
hdr->sbl_len = htonl(crcSize+imgHeaderSize);
|
|
}
|
|
if(cfg.image[cnt].image_type == imgOEM)
|
|
{
|
|
hdr->oem_start = htonl(offset);
|
|
hdr->oem_len = htonl(crcSize+imgHeaderSize);
|
|
}
|
|
if(cfg.image[cnt].image_type == imgCFG)
|
|
{
|
|
hdr->pib_start = htonl(offset);
|
|
hdr->pib_len = htonl(crcSize+imgHeaderSize);
|
|
}
|
|
|
|
if((cfg.image[cnt].image_type == imgFRW)
|
|
||(cfg.image[cnt].image_type == imgCFRW)
|
|
||(cfg.image[cnt].image_type == imgCFRW1)
|
|
||(cfg.image[cnt].image_type == imgCFRW4F)
|
|
||(cfg.image[cnt].image_type == imgCFRW4P))
|
|
{
|
|
static uint8_t fw_packed = 0;
|
|
if(!fw_packed){
|
|
hdr->fw_start = htonl(offset);
|
|
hdr->fw_len = htonl(crcSize+imgHeaderSize);
|
|
fw_packed = 1;
|
|
}else {
|
|
hdr->fw2_start = htonl(offset);
|
|
hdr->fw2_len = htonl(crcSize+imgHeaderSize);
|
|
}
|
|
}
|
|
|
|
if (cfg.image[cnt].image_type == imgFRW2) {
|
|
if (cfg.fw2_load) {
|
|
// fw2 load enable
|
|
hdr->fw2_start = htonl(offset);
|
|
hdr->fw2_len = htonl(crcSize + imgHeaderSize);
|
|
}
|
|
}
|
|
|
|
if(cfg.image[cnt].image_type == imgEFUSE)
|
|
{
|
|
hdr->efuse_start = htonl(offset);
|
|
hdr->efuse_len = htonl(crcSize+imgHeaderSize);
|
|
}
|
|
/* pack reference info */
|
|
if (cfg.image[cnt].image_type == imgREF)
|
|
{
|
|
hdr->ref_start = htonl(offset);
|
|
hdr->ref_len = htonl(crcSize+imgHeaderSize);
|
|
}
|
|
/* pack custom info */
|
|
if (cfg.image[cnt].image_type == imgCUS)
|
|
{
|
|
hdr->cus_start = htonl(offset);
|
|
hdr->cus_len = htonl(crcSize+imgHeaderSize);
|
|
}
|
|
}
|
|
|
|
/* 2400 aligned */
|
|
if((cnt+1 < cfg.image_num)
|
|
&&((cfg.image[cnt+1].image_type == imgCFG)
|
|
||(cfg.image[cnt+1].image_type == imgFRW)
|
|
||(cfg.image[cnt+1].image_type == imgCFRW)
|
|
||(cfg.image[cnt+1].image_type == imgCFRW1)
|
|
||(cfg.image[cnt+1].image_type == imgCFRW4F)
|
|
||(cfg.image[cnt+1].image_type == imgCFRW4P)))
|
|
{
|
|
len = p_buf - global_buffer;
|
|
if(len%2400)
|
|
{
|
|
len = 2400 - (len%2400);
|
|
for(i=0; i<len; i++)
|
|
{
|
|
*p_buf = 0;
|
|
p_buf++;
|
|
}
|
|
total_size += len;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(cfg.top_header_enable)
|
|
{
|
|
char *st = NULL;
|
|
char *end = NULL;
|
|
uint8_t ptn = 0;
|
|
|
|
hdr->file_len = htonl(total_size);
|
|
|
|
/*calculate payload's CRC*/
|
|
cfg.crc = 0xFFFFFFFF^CRC32_Update(0xFFFFFFFF, payload , total_size);
|
|
hdr->file_crc = htonl(cfg.crc);
|
|
|
|
if(1 == cfg.encrypt_mode)
|
|
{
|
|
st = payload;
|
|
end = payload + total_size;
|
|
ptn = (cfg.encrypt_pattern&0xFF);
|
|
while(st <= end){
|
|
*(st) += ptn;
|
|
st++;
|
|
}
|
|
}
|
|
else if(2 == cfg.encrypt_mode)
|
|
{
|
|
st = payload;
|
|
end = payload + total_size;
|
|
ptn = (cfg.encrypt_pattern&0xFF);
|
|
while(st <= end){
|
|
*(st) -= ptn;
|
|
st++;
|
|
}
|
|
}
|
|
else if(3 == cfg.encrypt_mode)
|
|
{
|
|
st = global_buffer;
|
|
end = payload + total_size;
|
|
ptn = (cfg.encrypt_pattern&0xFF);
|
|
while(st <= end) {
|
|
*(st) ^= ptn;
|
|
st++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*write buffer into file*/
|
|
if(NULL == (fpd=fopen(pkName, "w+")))
|
|
{
|
|
printf(NEW_LINE"Cannot open package file(%s)."NEW_LINE, pkName);
|
|
goto ERROR_HANDLE;
|
|
}
|
|
if(cfg.top_header_enable)
|
|
{
|
|
fwrite(global_buffer, 1, total_size + PACKAGE_HEADER_SIZE, fpd);
|
|
}
|
|
else
|
|
{
|
|
fwrite(global_buffer, 1, total_size, fpd);
|
|
}
|
|
fclose(fpd);
|
|
fpd = NULL;
|
|
|
|
/* show info */
|
|
sh_argv[2] = pkName;
|
|
ah_funShowHeader(3, sh_argv);
|
|
printf(NEW_LINE"Package created - %s"NEW_LINE, pkName);
|
|
ret = RET_OK;
|
|
|
|
ERROR_HANDLE:
|
|
|
|
if(global_buffer)
|
|
{
|
|
free(global_buffer);
|
|
global_buffer = NULL;
|
|
}
|
|
if(fpd)
|
|
{
|
|
fclose(fpd);
|
|
if(RET_OK != ret)
|
|
remove(pkName);
|
|
fpd = NULL;
|
|
}
|
|
if(fps)
|
|
{
|
|
fclose(fps);
|
|
fps = NULL;
|
|
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ah_funShowHeader(char argc, char *argv[])
|
|
{
|
|
FILE *fps = NULL;
|
|
char pbuf[imgHeaderSize];
|
|
int imgNo=0, tmp1, tmp2, tmp3, offset, start, device;
|
|
|
|
if(argc < 3)
|
|
{
|
|
return RET_BAD_PARA;
|
|
}
|
|
|
|
if(NULL == (fps=fopen(argv[2], "r")))
|
|
{
|
|
printf(NEW_LINE"Cannot open package file(%s)."NEW_LINE, argv[2]);
|
|
return RET_BAD_PARA;
|
|
}
|
|
|
|
do
|
|
{
|
|
imgNo++;
|
|
|
|
while(32 == (tmp1 = fread(pbuf, 1, 32, fps)))
|
|
{
|
|
if(1==imgNo)
|
|
{
|
|
tmp3 = IMGHDR_GET_GUARD(pbuf);
|
|
if(tmp3 == (((int)IMAGE_GUARD)&0xFFFFFFFF))
|
|
{
|
|
device = IMGHDR_GET_DEVTYPE(pbuf);
|
|
if((((int)devKunlun)&0xFFFF) == device)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tmp2 = IMGHDR_GET_DEVTYPE(pbuf);
|
|
tmp3 = IMGHDR_GET_GUARD(pbuf);
|
|
|
|
if((tmp2 == device)
|
|
&&(tmp3 == (((int)IMAGE_GUARD)&0xFFFFFFFF)))
|
|
break;
|
|
}
|
|
}
|
|
if(32 != tmp1)
|
|
{
|
|
fclose(fps);
|
|
return RET_OK;
|
|
}
|
|
tmp1 = fread(pbuf+32, 1, 32, fps);
|
|
if(32 != tmp1)
|
|
{
|
|
fclose(fps);
|
|
printf(NEW_LINE"Maybe the package is damaged."NEW_LINE NEW_LINE);
|
|
return RET_OK;
|
|
}
|
|
|
|
/* Print headers */
|
|
start = ftell(fps) - imgHeaderSize;
|
|
printf(NEW_LINE"Image NO.%02d @ 0x%08x:", imgNo, start);
|
|
|
|
tmp1 = IMGHDR_GET_DEVTYPE(pbuf);
|
|
printf(NEW_LINE" device:0x%04x", tmp1&0xFFFF);
|
|
|
|
tmp1 = IMGHDR_GET_IMGTYPE(pbuf);
|
|
printf(NEW_LINE" image:0x%04x", tmp1&0xFFFF);
|
|
|
|
tmp1 = IMGHDR_GET_IMGSIZE(pbuf);
|
|
offset = IMAGE_LEN_FOR_CRC(tmp1);
|
|
printf(NEW_LINE" size:%d Bytes", tmp1);
|
|
|
|
tmp1 = IMGHDR_GET_IMGVER(pbuf);
|
|
printf(NEW_LINE" version:%d.%d.%d", (tmp1>>12)&0xF,
|
|
(tmp1>>8)&0xF, tmp1&0xFF);
|
|
|
|
tmp1 = IMGHDR_GET_PSRAMSIZE(pbuf);
|
|
printf(NEW_LINE" psram size:%dM", tmp1);
|
|
|
|
tmp1 = IMGHDR_GET_HDRVER(pbuf);
|
|
printf(NEW_LINE" hdr version:0x%02X", tmp1&0xFF);
|
|
|
|
tmp1 = IMGHDR_GET_FWSIZE(pbuf);
|
|
printf(NEW_LINE" FW Size:0x%08x", tmp1);
|
|
|
|
tmp1 = IMGHDR_GET_LAYOUTIDX(pbuf);
|
|
printf(NEW_LINE" flash layout index:0x%02x", tmp1);
|
|
|
|
tmp1 = IMGHDR_GET_CRC(pbuf);
|
|
printf(NEW_LINE" CRC:0x%08x", tmp1);
|
|
|
|
tmp1 = IMGHDR_GET_FWCRC(pbuf);
|
|
printf(NEW_LINE" FW CRC:0x%08x", tmp1);
|
|
|
|
printf(NEW_LINE" SHA256:");
|
|
for(tmp1 = 32; tmp1 < 64; tmp1++)
|
|
{
|
|
tmp2 = ((int)pbuf[tmp1])&0xFF;
|
|
printf("%02x", tmp2);
|
|
}
|
|
printf(NEW_LINE);
|
|
/* skip size */
|
|
if(fseek(fps, offset, SEEK_CUR))
|
|
{
|
|
fclose(fps);
|
|
return RET_OK;
|
|
}
|
|
|
|
}while(1);
|
|
|
|
return RET_OK;
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int ret = RET_BAD_PARA;
|
|
|
|
if(argc <= 1)
|
|
{
|
|
ah_help();
|
|
goto err_out;
|
|
}
|
|
|
|
if(0 == strcmp(FUNC_CONSTRUCT, argv[1]))
|
|
{
|
|
ret =ah_funConstruct(argc, argv);
|
|
}
|
|
else if(0 == strcmp(FUNC_SHOWHEADER, argv[1]))
|
|
{
|
|
ret =ah_funShowHeader(argc, argv);
|
|
}
|
|
|
|
if(RET_OK == ret)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
err_out:
|
|
printf(NEW_LINE"Something wrong !"NEW_LINE NEW_LINE);
|
|
return ret;
|
|
}
|