int read_dispatch_file(char * file_name)
{
int ret;
int fd;
int readlen;
int json_offset;
int count=0;
void * root_node;
void * findlist;
void * memdb_template ;
BYTE uuid[DIGEST_SIZE];
char json_buffer[4096];
void * policy;
fd=open(file_name,O_RDONLY);
if(fd<0)
return fd;
readlen=read(fd,json_buffer,1024);
if(readlen<0)
return -EIO;
json_buffer[readlen]=0;
printf("%s\n",json_buffer);
close(fd);
json_offset=0;
while(json_offset<readlen)
{
ret=json_solve_str(&root_node,json_buffer+json_offset);
if(ret<0)
{
printf("solve json str error!\n");
break;
}
json_offset+=ret;
if(ret<32)
continue;
policy=dispatch_read_policy(root_node);
if(policy==NULL)
{
printf("read %d file error!\n",count);
break;
}
dispatch_policy_add(policy);
count++;
}
printf("read %d policy succeed!\n",count);
return count;
}
int read_json_file(char * file_name)
{
int ret;
int fd;
int readlen;
int json_offset;
int struct_no=0;
void * root_node;
void * findlist;
void * memdb_template ;
BYTE uuid[DIGEST_SIZE];
char json_buffer[4096];
fd=open(file_name,O_RDONLY);
if(fd<0)
return fd;
readlen=read(fd,json_buffer,1024);
if(readlen<0)
return -EIO;
json_buffer[readlen]=0;
printf("%s\n",json_buffer);
close(fd);
json_offset=0;
while(json_offset<readlen)
{
ret=json_solve_str(&root_node,json_buffer+json_offset);
if(ret<0)
{
printf("solve json str error!\n");
break;
}
json_offset+=ret;
if(ret<32)
continue;
ret=memdb_read_desc(root_node,uuid);
if(ret<0)
break;
struct_no++;
}
return struct_no;
}
int read_policy_from_buffer(char * buffer, int max_len)
{
int offset=0;
int ret;
void * root;
int solve_offset;
int count=0;
void * policy;
while(offset<max_len)
{
solve_offset=json_solve_str(&root,buffer+offset);
if(solve_offset<=0)
break;
offset+=solve_offset;
policy=dispatch_read_policy(root);
if(policy==NULL)
break;
count++;
}
return count;
}
int read_policy_from_buffer(char * buffer, int max_len)
{
int offset=0;
int ret;
void * root;
int solve_offset;
int count=0;
void * policy;
while(offset<max_len)
{
solve_offset=json_solve_str(&root,buffer+offset);
if(solve_offset<=0)
break;
offset+=solve_offset;
policy=dispatch_read_policy(root);
if(policy==NULL)
break;
/*
if(dispatch_policy_is_aspect(policy))
{
ret=dispatch_add_rule_policy(&aspect_policy,policy);
}
else
{
ret=dispatch_add_rule_policy(&process_policy,policy);
}
if(ret<0)
return ret;
*/
count++;
}
return count;
}
int json_2_message(char * json_str,void ** message)
{
void * root_node;
void * head_node;
void * tag_node;
void * record_node;
void * curr_record;
void * expand_node;
void * curr_expand;
void * record_value;
void * expand_value;
struct message_box * msg_box;
MSG_HEAD * msg_head;
MSG_EXPAND * msg_expand;
int record_no;
int expand_no;
void * precord;
void * pexpand;
int i;
int ret;
char buffer[DIGEST_SIZE];
int offset;
int type;
int subtype;
offset=json_solve_str(&root_node,json_str);
if(offset<0)
return offset;
// get json node's head
head_node=json_find_elem("HEAD",root_node);
if(head_node==NULL)
head_node=json_find_elem("head",root_node);
if(head_node==NULL)
return -EINVAL;
tag_node=json_find_elem("tag",head_node);
if(tag_node!=NULL) // default tag value is "MESG"
{
ret=json_node_getvalue(tag_node,buffer,10);
if(ret!=4)
return -EINVAL;
if(Memcmp(buffer,"MESG",ret)!=0)
return -EINVAL;
}
msg_box=message_init();
msg_head=message_get_head(msg_box);
json_2_struct(head_node,msg_head,msg_box->head_template);
// get json node's record
// init message box
ret=message_record_init(msg_box);
if(ret<0)
return ret;
record_node=json_find_elem("RECORD",root_node);
if(record_node==NULL)
record_node=json_find_elem("record",root_node);
if(record_node==NULL)
return -EINVAL;
curr_record=json_get_first_child(record_node);
if(curr_record==NULL)
return -EINVAL;
char node_name[DIGEST_SIZE*2];
ret=json_node_getname(curr_record,node_name);
if(!strcmp(node_name,"BIN_FORMAT"))
{
BYTE * radix64_string;
radix64_string=malloc(4096);
if(radix64_string==NULL)
return -ENOMEM;
ret=json_node_getvalue(curr_record,radix64_string,4096);
if(ret<0)
return -EINVAL;
int radix64_len=strnlen(radix64_string,4096);
msg_head->record_size=radix_to_bin_len(radix64_len);
msg_box->blob=malloc(msg_head->record_size);
if(msg_box->blob==NULL)
return -ENOMEM;
ret=radix64_to_bin(msg_box->blob,radix64_len,radix64_string);
}
else
{
for(i=0;i<msg_head->record_num;i++)
{
if(curr_record==NULL)
return -EINVAL;
ret=Galloc0(&precord,struct_size(msg_box->record_template));
if(ret<=0)
return -EINVAL;
json_2_struct(curr_record,precord,msg_box->record_template);
message_add_record(msg_box,precord);
curr_record=json_get_next_child(record_node);
}
}
// get json_node's expand
expand_no=msg_head->expand_num;
msg_head->expand_num=0;
expand_node=json_find_elem("EXPAND",root_node);
if(expand_node==NULL)
expand_node=json_find_elem("expand",root_node);
if(expand_node!=NULL)
{
char buf[20];
void * curr_expand_template;
curr_expand=json_get_first_child(expand_node);
for(i=0;i<expand_no;i++)
{
if(curr_expand==NULL)
return -EINVAL;
ret=Galloc0(&msg_expand,struct_size(message_get_expand_template()));
if(ret<0)
return -ENOMEM;
ret=json_2_struct(curr_expand,&msg_expand,message_get_expand_template());
if(ret<0)
return ret;
void * tempnode;
if((tempnode=json_find_elem(curr_expand,"BIN_DATA"))==NULL)
{
curr_expand_template=memdb_get_template(msg_expand->type,msg_expand->subtype);
if(curr_expand_template==NULL)
return -EINVAL;
struct_free(msg_expand,message_get_expand_template());
ret=Galloc(&msg_expand,struct_size(curr_expand_template));
if(ret<0)
return -ENOMEM;
ret=json_2_struct(curr_expand,msg_expand,curr_expand_template);
if(ret<0)
return ret;
}
message_add_expand(msg_box,msg_expand);
curr_expand=json_get_next_child(expand_node);
}
}
*message=msg_box;
msg_box->box_state = MSG_BOX_RECOVER;
return offset;
}
