TSS_RESULT
obj_nvstore_get_writelocalityatrelease(TSS_HNVSTORE hNvstore, UINT32 * writelocalityatrelease)
{
BYTE nv_data_public[MAX_PUBLIC_DATA_SIZE];
UINT32 data_public_size = MAX_PUBLIC_DATA_SIZE;
UINT32 offset;
UINT16 pcrread_sizeOfSelect;
UINT16 pcrwrite_sizeOfSelect;
TPM_LOCALITY_SELECTION locality_value;
TSS_RESULT result;
if ((result = obj_nvstore_get_datapublic(hNvstore, &data_public_size, nv_data_public)))
return result;
offset = sizeof(TPM_STRUCTURE_TAG)+ sizeof(TPM_NV_INDEX);
pcrread_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
offset = offset + sizeof(UINT16) + pcrread_sizeOfSelect
+ sizeof(TPM_LOCALITY_SELECTION)
+ sizeof(TPM_COMPOSITE_HASH);
pcrwrite_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
offset = offset + sizeof(UINT16) + pcrwrite_sizeOfSelect;
locality_value = *((TPM_LOCALITY_SELECTION *)(nv_data_public + offset));
*writelocalityatrelease = locality_value;
return result;
}
TSS_RESULT
obj_nvstore_get_writepcrselection(TSS_HNVSTORE hNvstore, UINT32 *size, BYTE **data)
{
BYTE nv_data_public[MAX_PUBLIC_DATA_SIZE];
UINT32 data_public_size = MAX_PUBLIC_DATA_SIZE;
UINT32 offset;
UINT16 pcrread_sizeOfSelect;
UINT16 pcrwrite_sizeOfSelect;
TSS_HCONTEXT tspContext;
TSS_RESULT result;
if((result = obj_nvstore_get_datapublic(hNvstore, &data_public_size, nv_data_public)))
return result;
if ((result = obj_nvstore_get_tsp_context(hNvstore, &tspContext)))
return result;
offset = sizeof(TPM_STRUCTURE_TAG)+ sizeof(TPM_NV_INDEX);
pcrread_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
offset = offset + sizeof(UINT16) + pcrread_sizeOfSelect
+ sizeof(TPM_LOCALITY_SELECTION)
+ sizeof(TPM_COMPOSITE_HASH);
pcrwrite_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
*size = sizeof(UINT16) + pcrwrite_sizeOfSelect;
*data = calloc_tspi(tspContext, *size);
if (*data == NULL) {
LogError("malloc of %u bytes failed.", *size);
result = TSPERR(TSS_E_OUTOFMEMORY);
return result;
}
memcpy(*data, nv_data_public + offset, *size);
return result;
}
TSS_RESULT
obj_nvstore_get_state_readstclear(TSS_HNVSTORE hNvstore, UINT32 * readstclear)
{
BYTE nv_data_public[MAX_PUBLIC_DATA_SIZE];
UINT32 data_public_size = MAX_PUBLIC_DATA_SIZE;
UINT32 offset;
UINT16 pcrread_sizeOfSelect;
UINT16 pcrwrite_sizeOfSelect;
TPM_BOOL value;
TSS_RESULT result;
if ((result = obj_nvstore_get_datapublic(hNvstore, &data_public_size, nv_data_public)))
return result;
offset = sizeof(TPM_STRUCTURE_TAG)+ sizeof(TPM_NV_INDEX);
pcrread_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
offset = offset + sizeof(UINT16) + pcrread_sizeOfSelect
+ sizeof(TPM_LOCALITY_SELECTION)
+ sizeof(TPM_COMPOSITE_HASH);
pcrwrite_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
offset = offset + sizeof(UINT16) + pcrwrite_sizeOfSelect
+ sizeof(TPM_LOCALITY_SELECTION)
+ sizeof(TPM_COMPOSITE_HASH)
+ sizeof(TPM_NV_ATTRIBUTES);
value = *((TPM_BOOL *)(nv_data_public + offset));
*readstclear = value;
return result;
}
TSS_RESULT
obj_nvstore_get_permission_from_tpm(TSS_HNVSTORE hNvstore, UINT32 * permission)
{
BYTE nv_data_public[MAX_PUBLIC_DATA_SIZE] = {0};
UINT32 data_public_size = MAX_PUBLIC_DATA_SIZE;
UINT32 offset;
UINT16 pcrread_sizeOfSelect;
UINT16 pcrwrite_sizeOfSelect;
TPM_NV_ATTRIBUTES nv_attributes_value;
TSS_HCONTEXT tspContext;
TSS_RESULT result;
if((result = obj_nvstore_get_datapublic(hNvstore, &data_public_size, nv_data_public)))
return result;
if ((result = obj_nvstore_get_tsp_context(hNvstore, &tspContext)))
return result;
offset = 0;
offset = sizeof(TPM_STRUCTURE_TAG)+ sizeof(TPM_NV_INDEX);
pcrread_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
offset = offset + sizeof(UINT16) + pcrread_sizeOfSelect
+ sizeof(TPM_LOCALITY_SELECTION)
+ sizeof(TPM_COMPOSITE_HASH);
pcrwrite_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
offset = offset + sizeof(UINT16) + pcrwrite_sizeOfSelect
+ sizeof(TPM_LOCALITY_SELECTION)
+ sizeof(TPM_COMPOSITE_HASH);
nv_attributes_value.attributes = Decode_UINT32(nv_data_public
+ offset + sizeof(TPM_STRUCTURE_TAG));
*permission = nv_attributes_value.attributes;
return result;
}
int json_2_struct_write_elem(void * node,void * addr,TEMPLATE_ELEM * elem_template)
{
JSON_NODE * json_node = (JSON_NODE *)node;
struct struct_elem_attr * elem_attr;
BYTE * buf;
int retval;
int int_value;
unsigned char char_value;
UINT16 short_value;
long long long_long_value;
int i,j;
BYTE * data;
V_String * vstring;
TEMPLATE_ELEM * elem_define;
int define_value;
retval=0;
elem_attr=elem_template->elem_desc;
switch(elem_attr->type) {
case OS210_TYPE_STRING :
if(json_node->elem_type!=JSON_ELEM_STRING)
return -EINVAL;
retval=elem_attr->size;
memset(addr,0,retval);
strncpy(addr,json_node->value_str,retval);
break;
case OS210_TYPE_INT :
retval=sizeof(int);
if(json_node->elem_type!=JSON_ELEM_NUM)
return -EINVAL;
int_value=atoi(json_node->value_str);
memcpy(addr,&int_value,retval);
break;
case OS210_TYPE_ENUM :
retval=sizeof(int);
if(json_node->elem_type == JSON_ELEM_NUM)
{
int_value=atoi(json_node->value_str);
memcpy(addr,&int_value,retval);
}
else if(json_node->elem_type ==JSON_ELEM_STRING)
{
if(!strcmp(nulstring,json_node->value_str))
{
int_value=0;
}
else
{
NAME2VALUE * EnumList;
if((elem_template->elem_var != NULL) && !IS_ERR(elem_template->elem_var))
EnumList=elem_template->elem_var;
else
EnumList=elem_template->elem_desc->attr;
if((EnumList==NULL)||IS_ERR(EnumList))
return -EINVAL;
char * string=json_node->value_str;
for(i=0;EnumList[i].name!=NULL;i++)
{
if(!strcmp(EnumList[i].name,string))
{
int_value=EnumList[i].value;
memcpy(addr,&int_value,retval);
break;
}
}
if(EnumList[i].name==NULL)
return -EINVAL;
}
}
else
return -EINVAL;
break;
case OS210_TYPE_FLAG :
retval=sizeof(int);
if(json_node->elem_type == JSON_ELEM_NUM)
{
int_value=atoi(json_node->value_str);
memcpy(addr,&int_value,retval);
}
else if(json_node->elem_type ==JSON_ELEM_STRING)
{
if(!strcmp(nulstring,json_node->value_str))
{
int_value=0;
}
else
{
NAME2VALUE * FlagList;
if((elem_template->elem_var != NULL) && !IS_ERR(elem_template->elem_var))
FlagList=elem_template->elem_var;
else
FlagList=elem_template->elem_desc->attr;
if((FlagList==NULL)||IS_ERR(FlagList))
return -EINVAL;
int_value=0;
char temp_string[256];
int stroffset=0;
char * string=json_node->value_str;
for(i=0;string[i]==' ';i++);
if(string[i]==0)
return 0;
for(;i<strlen(string);i++)
{
// duplicate one flag bit string
temp_string[stroffset++]=string[i];
if((string[i+1]!='|') && (string[i+1]!=0))
continue;
i++;
for(;string[i]==' ';i++)
{
if(string[i]==0)
break;
}
temp_string[stroffset]=0;
stroffset=0;
// find the flag's value
for(j=0;FlagList[j].name!=NULL;j++)
{
if(strcmp(FlagList[j].name,temp_string))
continue;
int_value|=FlagList[j].value;
break;
}
if(FlagList[j].name==NULL)
return -EINVAL;
}
memcpy(addr,&int_value,retval);
}
}
else
return -EINVAL;
break;
case TPM_TYPE_UINT32 :
retval=sizeof(int);
if(json_node->elem_type == JSON_ELEM_NUM)
{
int_value=atoi(json_node->value_str);
*(int *)addr=Decode_UINT32(&int_value);
}
else
return -EINVAL;
break;
case OS210_TYPE_TIME :
retval=sizeof(time_t);
// memcpy(addr,elem_data,retval);
break;
case OS210_TYPE_UCHAR :
retval=sizeof(unsigned char);
memcpy(addr,json_node->value_str,retval);
break;
case OS210_TYPE_USHORT :
retval=sizeof(unsigned short);
if(json_node->elem_type == JSON_ELEM_NUM)
{
short_value=atoi(json_node->value_str);
memcpy(addr,&short_value,retval);
}
else
return -EINVAL;
break;
case TPM_TYPE_UINT16 :
retval=sizeof(UINT16);
if(json_node->elem_type == JSON_ELEM_NUM)
{
short_value=atoi(json_node->value_str);
*(UINT16 *)addr=Decode_UINT16(&short_value);
}
else
return -EINVAL;
break;
case OS210_TYPE_LONGLONG:
retval=sizeof(long long);
if(json_node->elem_type == JSON_ELEM_NUM)
{
long_long_value=atoi(json_node->value_str);
memcpy(addr,&long_long_value,retval);
}
else
return -EINVAL;
break;
case TPM_TYPE_UINT64 :
retval=sizeof(UINT64);
if(json_node->elem_type == JSON_ELEM_NUM)
{
long_long_value=atoi(json_node->value_str);
*(UINT64 *)addr=Decode_UINT64(&long_long_value);
}
else
return -EINVAL;
break;
case OS210_TYPE_BINDATA:
if(json_node->elem_type != JSON_ELEM_STRING)
return -EINVAL;
retval=elem_attr->size;
radix64_to_bin(addr,bin_to_radix64_len(retval),json_node->value_str);
break;
case OS210_TYPE_BITMAP:
if(json_node->elem_type != JSON_ELEM_STRING)
return -EINVAL;
{
char * tempstring;
BYTE * tempbuf;
retval=elem_attr->size;
tempbuf=(BYTE * )addr;
tempstring=json_node->value_str;
for(i=0;i<retval;i++)
{
tempbuf[i]=0;
while(*tempstring==' ')
tempstring++;
for(j=0;j<8;j++)
{
if((*tempstring!= '0') &&(*tempstring!='1'))
return -EINVAL;
tempbuf[i]=tempbuf[i]<<1+(*tempstring-'0');
tempstring++;
}
}
}
break;
case OS210_TYPE_HEXDATA:
if(json_node->elem_type != JSON_ELEM_STRING)
return -EINVAL;
{
char * tempstring;
BYTE * tempbuf;
retval=elem_attr->size;
tempbuf=(BYTE * )addr;
tempstring=json_node->value_str;
for(i=0;i<retval;i++)
{
tempbuf[i]=0;
while(*tempstring==' ')
tempstring++;
for(j=0;j<2;j++)
{
if((*tempstring>='0') &&(*tempstring<='9'))
{
tempbuf[i]=tempbuf[i]*0x10+(*tempstring-'0');
}
else if((*tempstring>='A') &&(*tempstring<='F'))
{
tempbuf[i]=tempbuf[i]*0x10+(*tempstring-'A'+9);
}
else if((*tempstring>='a') &&(*tempstring<='f'))
{
tempbuf[i]=tempbuf[i]*0x10+(*tempstring-'a'+9);
}
else
return -EINVAL;
tempstring++;
}
}
}
break;
case OS210_TYPE_BINARRAY:
if(json_node->elem_type != JSON_ELEM_ARRAY)
return -EINVAL;
{
retval=elem_attr->size*(int)(elem_attr->attr);
memset(addr,0,retval);
JSON_VALUE * curr_value;
for(i=0;i<(int)(elem_attr->attr);i++)
{
if(i==0)
curr_value=get_first_json_child(json_node);
else
curr_value=get_next_json_child(json_node);
if(curr_value==NULL)
break;
if(curr_value->value_type!=JSON_ELEM_STRING)
return -EINVAL;
radix64_to_bin(addr+i*elem_attr->size,bin_to_radix64_len(elem_attr->size),json_node->value_str);
}
}
break;
case OS210_TYPE_VSTRING:
if(json_node->elem_type != JSON_ELEM_STRING)
return -EINVAL;
int_value=strlen(json_node->value_str);
vstring = (V_String *)addr;
vstring->length=int_value;
if((vstring->length <0) || vstring->length> OS210_MAX_BUF)
{
retval=-EINVAL;
}
vstring->String=kmalloc(vstring->length,GFP_KERNEL);
if(vstring->String==NULL)
return -ENOMEM;
memcpy(vstring->String,json_node->value_str,vstring->length);
retval=sizeof(V_String);
break;
case OS210_TYPE_ESTRING:
if(json_node->elem_type != JSON_ELEM_STRING)
return -EINVAL;
{
char * estring;
retval=strlen(json_node->value_str);
if(retval<0)
retval=-EINVAL;
if((elem_attr->size!=0) && (retval>elem_attr->size))
retval=-EINVAL;
retval++;
estring=kmalloc(retval,GFP_KERNEL);
if(estring==NULL)
return -ENOMEM;
memcpy(estring,json_node->value_str,retval);
*(char **)addr=estring;
retval=sizeof(char *);
}
break;
case OS210_TYPE_DEFINE:
if(json_node->elem_type != JSON_ELEM_STRING)
return -EINVAL;
elem_define=(TEMPLATE_ELEM *)(elem_template->elem_var);
retval=elem_attr->size*(*(int*)(elem_define->elem_var));
if(retval!=radix64_to_bin(addr,strlen(json_node->value_str),json_node->value_str))
return -EINVAL;
break;
case OS210_TYPE_DEFSTR:
if(json_node->elem_type != JSON_ELEM_STRING)
return -EINVAL;
elem_define=(TEMPLATE_ELEM *)(elem_template->elem_var);
retval=elem_attr->size*(*(int*)(elem_define->elem_var));
{
char * estring;
retval++;
estring=kmalloc(retval,GFP_KERNEL);
if(estring==NULL)
return -ENOMEM;
memcpy(estring,json_node->value_str,retval);
*(char **)addr=estring;
}
retval=sizeof(char *);
break;
case OS210_TYPE_DEFSTRARRAY:
if(json_node->elem_type != JSON_ELEM_ARRAY)
return -EINVAL;
elem_define=(TEMPLATE_ELEM *)(elem_template->elem_var);
define_value=*(int *)elem_define->elem_var;
if(define_value<0)
return -EINVAL;
if(define_value>32768)
return -EINVAL;
retval=elem_attr->size*define_value;
{
char * estring;
estring=kmalloc(retval,GFP_KERNEL);
if(estring==NULL)
return -ENOMEM;
memset(estring,0,retval);
JSON_NODE * curr_node;
// JSON_VALUE * curr_value;
for(i=0;i<define_value;i++)
{
if(i==0)
curr_node=get_first_json_child(json_node);
else
curr_node=get_next_json_child(json_node);
if(curr_node==NULL)
break;
if(curr_node->elem_type!=JSON_ELEM_STRING)
return -EINVAL;
// radix64_to_bin(addr+i*elem_attr->size,bin_to_radix64_len(elem_attr->size),json_node->value_str);
strncpy(estring+i*elem_attr->size,curr_node->value_str,elem_attr->size);
}
*(char **)addr=estring;
}
break;
case OS210_TYPE_ORGCHAIN:
retval= 0;
// retval = os210_struct_size_sum(elem_attr->attr);
break;
case OS210_TYPE_NODATA:
default:
break;
}
return retval;
}
