int read_chunkfile(char * chunkfile, char *data){
/* An example chunk file is:
0 b129b015e8a4258dc8c0d0b3a63acaeda8d14cd8
1 8085b28ac91f81435f9108388a3a4c8d9b01e84a
*/
/* This read a chunkfile, convert the string hashvalue into binary value, and write into
"data" parameter, return the size of the "data" parameter
*/
FILE *fp = fopen( chunkfile, "r");
if( fp == NULL ){
printf("%s can not be found\n", chunkfile);
return -1;
}
int index = 0;
char line[40];
memset(line, 0, 40);
int count = 0;
while( fscanf(fp, "%d %s\n", &index, line) > 0 ){
/* the max size of this line should less then 40 */
if( strlen( line ) > 40 )
return -1;
hex2binary((char*)line, 40, (uint8_t *)(data + count));
count += 20;
memset(line, 0, 40);
}
data[count] = '\0';
fclose(fp);
return count;
}
TEST(sml_proc_par_value, parse_time) {
hex2binary("72620472620265000000FF", sml_buf_get_current_buf(buf));
sml_proc_par_value *t = sml_proc_par_value_parse(buf);
TEST_ASSERT_NOT_NULL(t);
TEST_ASSERT_EQUAL(SML_PROC_PAR_VALUE_TAG_TIME, *(t->tag));
TEST_ASSERT_EQUAL(11, buf->cursor);
}
TEST(sml_number, parse_unsigned32_optional) {
hex2binary("01", sml_buf_get_current_buf(buf));
u32 *n = sml_u32_parse(buf);
TEST_ASSERT_NULL(n);
TEST_ASSERT_EQUAL(1, buf->cursor);
sml_u32_free( n );
}
TEST(sml_number, parse_unsigned8) {
hex2binary("6201", sml_buf_get_current_buf(buf));
u8 *n = sml_u8_parse(buf);
TEST_ASSERT_EQUAL(1, *n);
TEST_ASSERT_EQUAL(2, buf->cursor);
sml_u8_free( n );
}
/* @brief First converts decimalNumber from decimal to hex. Next, it passes the
* result to the given hex2binary function.
* @param decimalNumber: Number to be converted.
* @param bytesNeeded: The maximum possible number of hex bytes needed to
* represent the number.
* @param binaryNumber: buffer where the binary number is stored
*/
void dec2hex2binary(int decimalNumber, int bytesNeeded, uint8_t* binaryNumber){
int quotient;
int i=bytesNeeded-1, temp;
char hexadecimalNumber[bytesNeeded];
memset(hexadecimalNumber, 0, bytesNeeded);
quotient = decimalNumber;
while(quotient!=0){
temp = quotient % 16;
if(temp < 10){
temp = temp + 48;
} else {
temp = temp + 55;
}
hexadecimalNumber[i] = temp;
quotient = quotient / 16;
i--;
}
i = 0;
while(i < bytesNeeded){
if(hexadecimalNumber[i] != '\0'){
break;
}
hexadecimalNumber[i] = '0';
i++;
}
hex2binary(hexadecimalNumber, bytesNeeded, binaryNumber);
}
TEST(sml_value, parse_integer64_fewer_bytes) {
hex2binary("58FFFFFFFFFFFF0F", sml_buf_get_current_buf(buf));
sml_value *v = sml_value_parse(buf);
TEST_ASSERT_EQUAL(-241, *(v->data.int64));
TEST_ASSERT_EQUAL((SML_TYPE_INTEGER | SML_TYPE_NUMBER_64), v->type);
}
TEST(sml_value, parse_optional) {
hex2binary("01", sml_buf_get_current_buf(buf));
sml_value *v = sml_value_parse(buf);
TEST_ASSERT_NULL(v);
TEST_ASSERT_EQUAL(1, buf->cursor);
}
TEST(sml_sequence, parse_octet_string) {
hex2binary("720648616C6C6F0648616C6C6F", sml_buf_get_current_buf(buf));
sml_sequence *seq = sml_sequence_parse(buf, (void *) &sml_octet_string_parse, (void (*)(void *))&sml_octet_string_free);
TEST_ASSERT_NOT_NULL(seq);
TEST_ASSERT_EQUAL(2, seq->elems_len);
}
void init_hasChunks(char* has_chunk_file_name) {
FILE* has_chunk_file = fopen(has_chunk_file_name,"r");
int chunk_num = 0;
char read_buffer[CHUNK_FILE_LINE_BUFFER_SIZE];
while (fgets(read_buffer, CHUNK_FILE_LINE_BUFFER_SIZE, has_chunk_file)) {
chunk_num++;
}
/* set the global variable*/
has_chunks_number = chunk_num;
has_chunks = malloc(sizeof(struct chunk_s) * chunk_num);
memset(read_buffer, 0, CHUNK_FILE_LINE_BUFFER_SIZE);
fseek(has_chunk_file, 0, SEEK_SET);
int count = 0;
char hash_buffer[SHA1_HASH_SIZE*2];
while (fgets(read_buffer, CHUNK_FILE_LINE_BUFFER_SIZE, has_chunk_file)) {
sscanf(read_buffer,"%d %s", &(has_chunks[count].id), hash_buffer);
hex2binary(hash_buffer, SHA1_HASH_SIZE * 2, has_chunks[count].hash_binary);
has_chunks[count].data = NULL;
count++;
}
fclose(has_chunk_file);
printf("********CHUNKS I HAVE**********\n");
int i = 0;
for(i = 0; i < chunk_num; i++){
print_chunk(&has_chunks[i]);
}
printf("*******END CHUNKS I HAVE********\n");
}
TEST(sml_status, parse_not_unsigned) {
hex2binary("5001", sml_buf_get_current_buf(buf));
sml_status *s = sml_status_parse(buf);
TEST_ASSERT_NULL(s);
TEST_ASSERT_TRUE(sml_buf_has_errors(buf));
}
char *get_hash_from_master_chunkfile(int offset, bt_config_t* config){
char *hash = malloc(20);
char *master_file = config->chunk_file;
FILE *fp = fopen(master_file, "r");
if( fp == NULL ){
printf("Can not locate file %s\n", hash);
return NULL;
}
char content_path[512];
char temp[40];
int index;
/* read the content path first */
fscanf(fp, "%s %s\n", temp, content_path);
fscanf(fp, "%s\n", temp);
memset(temp,0 , 40);
while( fscanf(fp,"%d %s",&index, temp ) > 0){
if( index == offset ){
/* calculate the binary hash from the master chunk file */
hex2binary((char*)temp, 40, (uint8_t *)(hash));
return hash;
}
}
free(hash);
return NULL;
}
TEST(sml_status, parse_optional) {
hex2binary("01", sml_buf_get_current_buf(buf));
sml_status *s = sml_status_parse(buf);
TEST_ASSERT_NULL(s);
TEST_ASSERT_FALSE(sml_buf_has_errors(buf));
TEST_ASSERT_EQUAL(1, buf->cursor);
}
TEST(sml_tree, parse_with_child) {
hex2binary("730648616C6C6F0171730648616C6C6F0101", sml_buf_get_current_buf(buf));
sml_tree *t = sml_tree_parse(buf);
TEST_ASSERT_NOT_NULL(t);
TEST_ASSERT_NOT_NULL(t->child_list[0]);
TEST_ASSERT_EQUAL(1, t->child_list_len);
}
TEST(sml_tree, parse_with_error_child) {
hex2binary("730648616C6C6F0171720648616C6C6F0101", sml_buf_get_current_buf(buf));
sml_tree *t = sml_tree_parse(buf);
TEST_ASSERT_NULL(t);
sml_tree_free( t );
}
TEST(sml_value, parse_boolean) {
hex2binary("4200", sml_buf_get_current_buf(buf));
sml_value *v = sml_value_parse(buf);
TEST_ASSERT_NOT_NULL(v);
TEST_ASSERT_EQUAL(SML_TYPE_BOOLEAN, v->type);
TEST_ASSERT_FALSE(*(v->data.boolean));
}
TEST(sml_status, parse_status8) {
hex2binary("6201", sml_buf_get_current_buf(buf));
sml_status *s = sml_status_parse(buf);
TEST_ASSERT_NOT_NULL(s);
TEST_ASSERT_EQUAL(1, *(s->data.status8));
TEST_ASSERT_EQUAL((SML_TYPE_UNSIGNED | SML_TYPE_NUMBER_8), s->type);
}
TEST(sml_tree_path, parse) {
hex2binary("720648616C6C6F0264", sml_buf_get_current_buf(buf));
sml_tree_path *t = sml_tree_path_parse(buf);
TEST_ASSERT_NOT_NULL(t);
TEST_ASSERT_EQUAL(2, t->path_entries_len);
TEST_ASSERT_EQUAL(0, sml_octet_string_cmp_with_hex(t->path_entries[0], "48616C6C6F"));
TEST_ASSERT_EQUAL(0, sml_octet_string_cmp_with_hex(t->path_entries[1], "64"));
}
TEST(sml_value, parse_octet_string) {
hex2binary("0648616C6C6F", sml_buf_get_current_buf(buf));
sml_value *v = sml_value_parse(buf);
TEST_ASSERT_NOT_NULL(v);
TEST_ASSERT_EQUAL(SML_TYPE_OCTET_STRING, v->type);
expected_octet_string(v->data.bytes, "Hallo", 5);
}
static int do_update_binary(int argc, char **argv)
{
u8 buf[240];
int r, err = 1, in_len;
int offs;
sc_path_t path;
sc_file_t *file;
char *in_str;
if (argc < 2 || argc > 3)
goto usage;
if (arg_to_path(argv[0], &path, 0) != 0)
goto usage;
offs = strtol(argv[1],NULL,10);
in_str = argv[2];
printf("in: %i; %s\n", offs, in_str);
if (*in_str=='\"') {
in_len = strlen(in_str)-2 >= sizeof(buf) ? sizeof(buf)-1 : strlen(in_str)-2;
strncpy((char *) buf, in_str+1, in_len);
} else {
in_len = hex2binary(buf, sizeof(buf), in_str);
if (!in_len) {
printf("unable to parse hex value\n");
return -1;
}
}
r = sc_select_file(card, &path, &file);
if (r) {
check_ret(r, SC_AC_OP_SELECT, "unable to select file", current_file);
return -1;
}
if (file->ef_structure != SC_FILE_EF_TRANSPARENT) {
printf("EF structure should be SC_FILE_EF_TRANSPARENT\n");
goto err;
}
r = sc_update_binary(card, offs, buf, in_len, 0);
if (r < 0) {
printf("Cannot update %04X; return %i\n", file->id, r);
goto err;
}
printf("Total of %d bytes written to %04X at %i offset.\n",
r, file->id, offs);
err = 0;
err:
sc_file_free(file);
select_current_path_or_die();
return -err;
usage:
printf("Usage: update <file id> offs <hex value> | <'\"' enclosed string>\n");
return -1;
}
char* get_data_from_hash(char *hash , bt_config_t* config){
/* read the master data file and return the 512KB data for a chunk
Two steps:
(1) calculate the offset in the master chunk file based on hashvalue
(2) read the data form master data file based on the offset
*/
char *data = malloc(512 * 1024);
char temp[40];
int index;
char *master_file = config->chunk_file;
FILE *fp = fopen(master_file, "r");
if( fp == NULL ){
printf("Can not locate file %s\n", hash);
return NULL;
}
char content_path[512];
/* read the content path first */
fscanf(fp, "%s %s\n", temp, content_path);
fscanf(fp, "%s\n", temp);
memset(temp,0 , 40);
printf("DEBUG path = %s\n",content_path);
int find = -1;
while( find != 1 && fscanf(fp,"%d %s",&index, temp ) > 0){
char local[20];
/* calculate the binary hash from the master chunk file */
hex2binary((char*)temp, 40, (uint8_t *)(local));
int cmp = 1;
int i;
/* and compare if there is a match of hash values */
for( i = 0;i < 20;i ++){
if( local[i] != hash[i] ){
cmp = 0;
break;
}
}
if( cmp == 1){
printf("find local content for has = %s\n", local);
find = 1;
}
memset(temp, 0, 40);
memset(local, 0 ,20);
}
printf("in Master file offset = %d\n", index);
/* try rb instead of r*/
FILE *content = fopen(content_path, "rb");
fseek(content, 512 * 1024 * index, SEEK_SET );
fread(data,512 * 1024, 1, content);
fclose(content);
fclose(fp);
return data;
}
TEST(sml_list, parse_two_entries) {
hex2binary("727702610101010142000177026101010101420001", sml_buf_get_current_buf(buf));
sml_list *l = sml_list_parse(buf);
TEST_ASSERT_FALSE(sml_buf_has_errors(buf));
TEST_ASSERT_NOT_NULL(l);
TEST_ASSERT_NOT_NULL(l->next);
TEST_ASSERT_EQUAL(0, sml_octet_string_cmp_with_hex(l->obj_name, "61"));
}
TEST(sml_get_profile_pack_request, parse) {
hex2binary("7901010101010101730648616C6C6F0648616C6C6F0648616C6C6F01", sml_buf_get_current_buf(buf));
sml_get_profile_pack_request *r = sml_get_profile_pack_request_parse(buf);
TEST_ASSERT_NOT_NULL(r);
TEST_ASSERT_NOT_NULL(r->object_list);
TEST_ASSERT_NOT_NULL(r->object_list->next);
TEST_ASSERT_NOT_NULL(r->object_list->next->next);
TEST_ASSERT_NULL(r->object_list->next->next->next);
sml_get_profile_pack_request_free( r );
}
TEST(sml_value, parse_unsigned32) {
hex2binary("6500000001", sml_buf_get_current_buf(buf));
sml_value *v = sml_value_parse(buf);
TEST_ASSERT_NOT_NULL(v);
TEST_ASSERT_EQUAL(1, *(v->data.uint32));
TEST_ASSERT_EQUAL((SML_TYPE_UNSIGNED | SML_TYPE_NUMBER_32), v->type);
TEST_ASSERT_EQUAL(5, buf->cursor);
}
static int arg_to_path(const char *arg, sc_path_t *path, int is_id)
{
memset(path, 0, sizeof(sc_path_t));
if (strncasecmp(arg, "aid:", strlen("aid:")) == 0) {
/* DF aid */
const char *p = arg + strlen("aid:");
path->len = hex2binary(path->value, sizeof(path->value), p);
path->type = SC_PATH_TYPE_DF_NAME;
} else {
/* file id */
unsigned int buf[2];
u8 cbuf[2];
if (strlen(arg) != 4) {
printf("Wrong ID length.\n");
return -1;
}
if (sscanf(arg, "%02X%02X", &buf[0], &buf[1]) != 2) {
printf("Invalid ID.\n");
return -1;
}
cbuf[0] = buf[0];
cbuf[1] = buf[1];
if ((cbuf[0] == 0x3F && cbuf[1] == 0x00) || is_id) {
path->len = 2;
memcpy(path->value, cbuf, 2);
if (is_id)
path->type = SC_PATH_TYPE_FILE_ID;
else
path->type = SC_PATH_TYPE_PATH;
} else {
*path = current_path;
if (path->type == SC_PATH_TYPE_DF_NAME) {
if (path->len > sizeof(path->aid.value)) {
printf("Invalid length of DF_NAME path\n");
return -1;
}
memcpy(path->aid.value, path->value, path->len);
path->aid.len = path->len;
path->type = SC_PATH_TYPE_FILE_ID;
path->len = 0;
}
sc_append_path_id(path, cbuf, 2);
}
}
return 0;
}
/**
* Convert string into a bitset. Inverse of bitset_to_str().
*
*/
bitset *str_to_bitset(char *str, char **end)
{
int nbits = 0;
int bytes;
int n;
int pos;
int b;
int len;
bitset *bp;
char dst[1024];
if (!str)
return NULL;
/* hex string has 0x prefix */
if (str[0] == '0' && str[1] == 'x')
str = str + 2;
len = strlen(str);
if (len % 2) {
nbits = (len + 1) << 2;
bytes = NUM_BYTES(nbits);
pos = (bytes << 3) - 5;
} else {
nbits = len << 2;
bytes = NUM_BYTES(nbits);
pos = (bytes << 3) - 1;
}
if (0)
hex2binary(str, dst);
bp = bitset_new(nbits);
for (; *str != '\0' && isxdigit(*str) && pos >= 0; str++) {
b = digittoint(*str);
for (n = 3; n >= 0; n--, pos--) {
if (b & (1 << n)) {
bitset_set(bp, pos);
}
}
}
if (end != NULL)
*end = str - 1;
return bp;
}
int get_off_set_from_master_chunkfile(char *hash, bt_config_t* config){
char *master_file = config->chunk_file;
FILE *fp = fopen(master_file, "r");
if( fp == NULL ){
printf("Can not locate file %s\n", hash);
return -1;
}
char content_path[512];
char temp[40];
int index;
/* read the content path first */
fscanf(fp, "%s %s\n", temp, content_path);
fscanf(fp, "%s\n", temp);
memset(temp,0 , 40);
printf("DEBUG path = %s\n",content_path);
int find = -1;
while( find != 1 && fscanf(fp,"%d %s",&index, temp ) > 0){
char local[20];
/* calculate the binary hash from the master chunk file */
hex2binary((char*)temp, 40, (uint8_t *)(local));
int cmp = 1;
int i;
/* and compare if there is a match of hash values */
for( i = 0;i < 20;i ++){
if( local[i] != hash[i] ){
cmp = 0;
break;
}
}
if( cmp == 1){
printf("find local content for has = %s offset = %d\n", local, index);
return index;
}
}
return -1;
}
TEST(sml_number, parse_unsigned32_fewer_bytes) {
hex2binary("64010001", sml_buf_get_current_buf(buf));
u32 *n = sml_u32_parse(buf);
TEST_ASSERT_EQUAL(65537, *n);
sml_u32_free( n );
}
void decimal2binary(int d, string binary) {
char hex[100];
sprintf(hex, "%04X", d);
hex2binary(hex, binary);
}
rcb_t *load_get_chunks(const char *get_chunk_file, int *cnt)
{
FILE *fp = NULL;
char buff[GET_LINE_LEN + 1];
uint8_t hash[SHA1_HASH_SIZE]; //original hash, not hash string
uint32_t wr_chk_id;
chunk_map_t *map;
int req_cnt = 0;
rcb_t *head = NULL;
rcb_t *p = NULL;
fp = fopen(get_chunk_file, "r");
if(!fp)
{
return NULL;
}
// load the chunks
while(NULL != fgets(buff, GET_LINE_LEN + 1, fp))
{
char *str;
p = create_rcb();
if(NULL == p)
goto err;
str = strtok(buff, " \n");
if(NULL == str)
goto err;
if(0 != str_to_uint32(buff, &wr_chk_id))
goto err;
p->wr_chk_id = wr_chk_id;
str = strtok(NULL, " \n");
if(NULL == str)
goto err;
if(strlen(str) != SHA1_HASH_SIZE * 2)
goto err;
hex2binary(str, SHA1_HASH_SIZE * 2, hash);
HT_FIND(&g_chunkmap_ht, chunk_map_t, hash, hash, map);
if(!map)
{
free(p);
}
else
{
p->chk_map = map;
p->next = head;
head = p;
req_cnt++;
}
}
fclose(fp);
*cnt = req_cnt;
return head;
err:
if(fp)
fclose(fp);
if(p)
free(p);
*cnt = req_cnt;
return head;
}
TEST(sml_number, parse_unsigned64_fewer_bytes) {
hex2binary("67000000000001", sml_buf_get_current_buf(buf));
u64 *n = sml_u64_parse(buf);
TEST_ASSERT_EQUAL(1, *n);
sml_u64_free( n );
}
