Example #1
0
int main(int argc, char **argv) {

  char *buf;
  if(read_json_file(&buf, JSON_FILE)!=0){
    printf("failed to read fixture\n");
    if(buf != NULL){
      free(buf);
    }
    return 1;
  }

  json_context_t ctx;
  json_init_context(&ctx, buf);

  json_obj_t * res = NULL;
  res = json_read_array(NULL, &ctx);

  parse_array(1, res);


  json_object_destroy(res, &ctx);

  if(buf != NULL){
    free(buf);
  }
  return 0;
}
Example #2
0
void read_file(const char *filename)
{
    if (!read_pcap_file(filename))
    {
        read_json_file(filename);
    }
}
Example #3
0
void Model::init_monsters(){
    QJsonObject json_obj= read_json_file(":/map/monster_1.json");
    QJsonArray goomba_array = json_obj.value(QString("monster")).toObject()["goomba"].toArray();
    add_monster(goomba_array,'g');
    QJsonArray koopa_array = json_obj.value(QString("monster")).toObject()["koopa"].toArray();
    add_monster(koopa_array,'k');
    QJsonArray flower_array = json_obj.value(QString("monster")).toObject()["bad_flower"].toArray();
    add_monster(flower_array,'f');
}
Example #4
0
void Model::init_map(){
    QJsonObject json_obj= read_json_file(":/map/map_1.json");
    QJsonArray ground_array = json_obj.value(QString("ground")).toArray();
    QJsonObject ground_obj;
    for(int i = 0; i < ground_array.size(); i++){
        ground_obj = ground_array[i].toObject();
        add_ground(ground_obj["line_beg"].toInt(), ground_obj["line_end"].toInt(),
                ground_obj["column_beg"].toInt(), ground_obj["colum_end"].toInt());
    }
}
Example #5
0
void Model::init_items(){
    QJsonObject json_obj= read_json_file(":/map/items_1.json");
    QJsonArray blocks_array = json_obj.value(QString("items")).toObject()["block"].toArray();
    init_blocks(blocks_array);
    QJsonArray coins_array = json_obj.value(QString("items")).toObject()["coins"].toArray();
    init_coins(coins_array);
    QJsonArray pipes_array = json_obj.value(QString("items")).toObject()["pipes"].toArray();
    init_pipes(pipes_array);
    QJsonArray decor_array = json_obj.value(QString("items")).toObject()["decor"].toArray();
    init_decor(decor_array);
}
Example #6
0
static v7_val_t load_conf(struct v7 *v7, const char *name) {
    v7_val_t res;
    char *f;
    enum v7_err err;
    f = read_json_file(name);
    if (f == NULL) {
        printf("cannot read %s\n", name);
        return v7_create_object(v7);
    }
    err = v7_exec(v7, &res, f);
    free(f);
    if (err != V7_OK) {
        v7_println(v7, res);
        return v7_create_object(v7);
    }
    return res;
}
Example #7
0
int main() {

    static unsigned char alloc_buffer[4096*(1+1+4+1+32+1+256)];
    char json_buffer[4096];
    char print_buffer[4096];
    int ret;
    int readlen;
    int json_offset;
    void * root_node;
    void * findlist;
    void * memdb_template ;
    BYTE uuid[DIGEST_SIZE];
    int i;
    MSG_HEAD * msg_head;
    pthread_t  cube_thread;

    char * baseconfig[] =
    {
        "typelist.json",
        "subtypelist.json",
        "msghead.json",
        "login_struct.json",
        "headrecord.json",
        NULL
    };

    alloc_init(alloc_buffer);
    struct_deal_init();
    memdb_init();

// test namelist reading start

    for(i=0; baseconfig[i]!=NULL; i++)
    {
        ret=read_json_file(baseconfig[i]);
        if(ret<0)
            return ret;
        printf("read %d elem from file %s!\n",ret,baseconfig[i]);
    }

    void * record;

// test struct desc reading start

    msgfunc_init();

    void * message;
    void * policy;

    dispatch_init(NULL);
    policy=dispatch_policy_create();
    if(policy==NULL)
    {
        printf("create policy failed!\n");
        return -EINVAL;
    }

    ret=read_dispatch_file("dispatch_policy.json");

//	routine_start();
//	sleep(100000);

    return 0;

}
Example #8
0
int main() {

  	static unsigned char alloc_buffer[4096*(1+1+4+1+16+1+256)];	
	char json_buffer[4096];
	char print_buffer[4096];
	BYTE bin_buffer[4096];
	int ret;
	int readlen;
	int json_offset;
	void * root_node;
	void * findlist;
	void * memdb_template ;
	BYTE uuid[DIGEST_SIZE];
	int i;
	MSG_HEAD * msg_head;
	
	char * baseconfig[] =
	{
		"namelist.json",
		"typelist.json",
		"subtypelist.json",
		"msghead.json",
		"base_msg.json",
		"expandrecord.json",
		NULL
	};

//	alloc_init(alloc_buffer);
	struct_deal_init();
	memdb_init();

// test namelist reading start

	for(i=0;baseconfig[i]!=NULL;i++)
	{
		ret=read_json_file(baseconfig[i]);
		if(ret<0)
			return ret;
		printf("read %d elem from file %s!\n",ret,baseconfig[i]);
	}

	void * record;

// test struct desc reading start
	
	int msg_type = memdb_get_typeno("MESSAGE");
	if(msg_type<=0)
		return -EINVAL;

	int subtype=memdb_get_subtypeno(msg_type,"HEAD");
	if(subtype<=0)
		return -EINVAL;

	record=memdb_get_first(msg_type,subtype);
	while(record!=NULL)
	{
		ret=memdb_print(record,print_buffer);
		if(ret<0)
			return -EINVAL;
		printf("%s\n",print_buffer);
		record=memdb_get_next(msg_type,subtype);
	}

	msgfunc_init();
	
	void * message;
	struct basic_message base_msg;
	struct expand_flow_trace flow_trace;

	message=message_create(DTYPE_MESSAGE,SUBTYPE_BASE_MSG,NULL);	

	base_msg.message=dup_str("Hello,World!",0);
	
	flow_trace.record_num=1;
	flow_trace.trace_record=Talloc0(DIGEST_SIZE*flow_trace.record_num);
	Strncpy(flow_trace.trace_record,"test_port",DIGEST_SIZE/4*3);

	ret=message_add_record(message,&base_msg);
	if(ret<0)
	{
		printf("add message record failed!\n");
		return ret;
	}	

	ret=message_add_expand_data(message,DTYPE_MSG_EXPAND,SUBTYPE_FLOW_TRACE,&flow_trace);
	if(ret<0)
	{
		printf("add message expand failed!\n");
		return ret;
	}

	ret=message_record_struct2blob(message);
	if(ret<0)
	{
		printf("message struct2blob failed!\n");
		return ret;
	}	

	BYTE * blob;
	
	ret=message_output_json(message,json_buffer);
	if(ret<0)
	{
		printf("message output json failed!\n");
		return ret;
	}

	printf("%s\n",json_buffer);
	
	ret=message_output_blob(message,&blob);
	if(ret<0)
		return ret;
	printf ("output %d data to bin_buffer\n",ret);

	void * new_msg;

	ret=message_read_from_blob(&new_msg,blob,ret);	
	printf ("read %d from bin_buffer\n",ret);

	ret=message_load_record(new_msg);
	if(ret<0)
	{
		printf("load record failed!\n");
		return ret;
	}
	ret=message_load_expand(new_msg);
	if(ret<0)
	{
		printf("load expand failed!\n");
		return ret;
	}


	printf("%s\n",json_buffer);
	
	ret=json_2_message(json_buffer,&new_msg);

	if(ret<0)
		return ret;

	printf ("read %d from json_buffer\n",ret);

	ret=message_output_json(new_msg,json_buffer);
	if(ret<0)
	{
		printf("message output json failed!\n");
		return ret;
	}

	printf("%s\n",json_buffer);
	
	ret=message_output_blob(message,bin_buffer);

	return 0;

}
Example #9
0
int main() {

  	static unsigned char alloc_buffer[4096*(1+1+4+1+32+1+256)];	
	char json_buffer[4096];
	char print_buffer[4096];
	int ret;
	int readlen;
	int json_offset;
	void * root_node;
	void * findlist;
	void * memdb_template ;
	BYTE uuid[DIGEST_SIZE];
	int i;
	MSG_HEAD * msg_head;
	pthread_t  cube_thread;
	
	char * baseconfig[] =
	{
		"namelist.json",
		"dispatchnamelist.json",
		"typelist.json",
		"subtypelist.json",
		"msghead.json",
		"msgrecord.json",
		"expandrecord.json",
		"base_msg.json",
		"dispatchrecord.json",
		NULL
	};

//	alloc_init(alloc_buffer);
	struct_deal_init();
	memdb_init();

// test namelist reading start

	for(i=0;baseconfig[i]!=NULL;i++)
	{
		ret=read_json_file(baseconfig[i]);
		if(ret<0)
			return ret;
		printf("read %d elem from file %s!\n",ret,baseconfig[i]);
	}

	void * record;

// test struct desc reading start

	msgfunc_init();
	dispatch_init();
	
	void * message;
	void * policy;
	
	ret=read_dispatch_file("dispatch_policy.json");

	message=message_create(DTYPE_MESSAGE,SUBTYPE_BASE_MSG,NULL);	

	struct basic_message * base_msg;
	base_msg=Talloc0(sizeof(*base_msg));
	if(base_msg==NULL)
		return -ENOMEM;
	base_msg->message=dup_str("hello",0);

	message_add_record(message,base_msg);	
	ret=message_output_json(message,json_buffer);
	if(ret<0)
	{
		printf("message output json failed!\n");
		return ret;
	}

	printf("%s\n",json_buffer);

	ret=dispatch_policy_getfirst(&policy);
	while(policy!=NULL)
	{
		ret=dispatch_match_message(policy,message);
		if(ret==0)
		{
			printf("this message match the policy!\n");
			break;
		}
		ret=dispatch_policy_getnext(&policy);
	}

	if(policy!=NULL)
	{
		router_set_local_route(message,policy);	
		ret=message_output_json(message,json_buffer);
		if(ret<0)
		{
			printf("message output json failed!\n");
			return ret;
		}

		printf("%s\n",json_buffer);
	}

//	routine_start();
//	sleep(100000);
	
	return 0;

}
Example #10
0
int main() {

  	static unsigned char alloc_buffer[4096*(1+1+4+1+16+1+256)];	
	char json_buffer[4096];
	char print_buffer[4096];
	int ret;
	int readlen;
	int json_offset;
	void * root_node;
	void * findlist;
	void * memdb_template ;
	BYTE uuid[DIGEST_SIZE];
	int i;
	MSG_HEAD * msg_head;
	
	char * baseconfig[] =
	{
		"typelist.json",
		"subtypelist.json",
		"msghead.json",
		"headrecord.json",
		NULL
	};

	alloc_init(alloc_buffer);
	struct_deal_init();
	memdb_init();

// test namelist reading start

	for(i=0;baseconfig[i]!=NULL;i++)
	{
		ret=read_json_file(baseconfig[i]);
		if(ret<0)
			return ret;
		printf("read %d elem from file %s!\n",ret,baseconfig[i]);
	}

	void * record;

// test struct desc reading start
	
	int msg_type = memdb_get_typeno("MESSAGE");
	if(msg_type<=0)
		return -EINVAL;

	int subtype=memdb_get_subtypeno(msg_type,"HEAD");
	if(subtype<=0)
		return -EINVAL;

	record=memdb_get_first(msg_type,subtype);
	while(record!=NULL)
	{
		ret=memdb_print(record,print_buffer);
		if(ret<0)
			return -EINVAL;
		printf("%s\n",print_buffer);
		record=memdb_get_next(msg_type,subtype);
	}

	msgfunc_init();
	
	void * message;

	message=message_create(512,1,NULL);	

	ret=Galloc0(&msg_head,sizeof(MSG_HEAD));
	if(msg_head==NULL)
		return -EINVAL;
	Strcpy(msg_head->sender_uuid,"Test sender");	
	Strcpy(msg_head->receiver_uuid,"Test receiver");
	ret=message_add_record(message,msg_head);
	if(ret<0)
	{
		printf("add message head record failed!\n");
		return ret;
	}	

	ret=message_record_struct2blob(message);
	if(ret<0)
	{
		printf("message struct2blob failed!\n");
		return ret;
	}	

	BYTE * blob;
	
	message_output_blob(message,&blob);
	ret=message_output_json(message,json_buffer);
	if(ret<0)
	{
		printf("message output json failed!\n");
		return ret;
	}

	printf("%s\n",json_buffer);
	
	
	void * new_msg;

	ret=json_2_message(json_buffer,&new_msg);

	if(ret<0)
		return ret;

	printf ("read % from json_buffer\n",ret);

	ret=message_output_json(message,json_buffer);
	if(ret<0)
	{
		printf("message output json failed!\n");
		return ret;
	}

	printf("%s\n",json_buffer);
	

	
	return 0;

}
Example #11
0
int main(int argc,char **argv)
{

    struct tcloud_connector_hub * hub;
    struct tcloud_connector * temp_conn;
    int ret;
    int retval;
    void * message_box;
    int i,j;
    int argv_offset;	
    char namebuffer[DIGEST_SIZE*4];
    char * sys_plugin;		
    char * app_plugin;		
    char * base_define;
    char * cube_output;


    char json_buffer[4096];
    char print_buffer[4096];
    int readlen;
    int json_offset;
    void * memdb_template ;
    BYTE uuid[DIGEST_SIZE];
    void * main_proc; // point to the main proc's subject struct
    void * conn_proc; // point to the conn proc's subject struct
    void * router_proc; // point to the conn proc's subject struct
    char local_uuid[DIGEST_SIZE*2];

    FILE * fp;
    char audit_text[4096];
    char buffer[4096];
    void * root_node;
    void * temp_node;
    PROC_INIT plugin_proc; 

    char * baseconfig[] =
    {
	"namelist.json",
	"dispatchnamelist.json",
	"typelist.json",
	"subtypelist.json",
	"baseflag.json",
	"memdb.json",
	"msghead.json",
	"msgrecord.json",
	"expandrecord.json",
	"base_msg.json",
	"dispatchrecord.json",
	"exmoduledefine.json",
	"sys_conn.json",
	 NULL
    };

    struct start_para start_para;

    start_para.argc=argc;
    start_para.argv=argv;	

    int fd =open(msgaudit_file,O_CREAT|O_RDWR|O_TRUNC,0666);
    close(fd);
    audit_file_init();	
    sys_plugin=getenv("CUBE_SYS_PLUGIN");
//	alloc_init(alloc_buffer);
	struct_deal_init();
	memdb_init();

    	base_define=getenv("CUBE_BASE_DEFINE");
	for(i=0;baseconfig[i]!=NULL;i++)
	{
		Strcpy(namebuffer,base_define);
		Strcat(namebuffer,"/");
		Strcat(namebuffer,baseconfig[i]);
		ret=read_json_file(namebuffer);
		if(ret<0)
			return ret;
		print_cubeaudit("read %d elem from file %s!\n",ret,namebuffer);
	}

	msgfunc_init();
	dispatch_init();
	channel_init();

	ex_module_list_init();

    // init system
    system("mkdir lib");
    // init the main proc struct

    struct lib_para_struct * lib_para=NULL;
    fd=open(sys_config_file,O_RDONLY);
    if(fd>0)
    {

   	 ret=read_json_node(fd,&root_node);
  	 if(ret<0)
		return ret;	
    	 close(fd);
	

    	 ret=read_sys_cfg(&lib_para,root_node,NULL);
    	 if(ret<0)
		return ret;
    }	 		
    fd=open(main_config_file,O_RDONLY);
    if(fd<0)
	return -EINVAL;

    ret=read_json_node(fd,&root_node);
    if(ret<0)
	return ret;	
    close(fd);
	
    ret=read_main_cfg(lib_para,root_node);
    if(ret<0)
	return ret; 		

    ret=get_local_uuid(local_uuid);
    digest_to_uuid(local_uuid,buffer);
    buffer[64]=0;
    print_cubeaudit("this machine's local uuid is %s\n",buffer);
    proc_share_data_setvalue("uuid",local_uuid);

    // init all the proc database

    usleep(time_val.tv_usec);


    // init the connect proc	
    Strcpy(namebuffer,sys_plugin);
    Strcat(namebuffer,"/");
    Strcat(namebuffer,connector_plugin_file);
    plugin_proc.init =main_read_func(namebuffer,"proc_conn_init");
    if(plugin_proc.init==NULL)
	return -EINVAL;
    plugin_proc.start =main_read_func(namebuffer,"proc_conn_start");
    if(plugin_proc.start==NULL)
	return -EINVAL;
     plugin_proc.name=dup_str("connector_proc",0);	
     plugin_proc.type=MOD_TYPE_CONN;
	
     ret=ex_module_create("connector_proc",MOD_TYPE_CONN,NULL,&conn_proc);
    if(ret<0)
	    return ret;

    ex_module_setinitfunc(conn_proc,plugin_proc.init);
    ex_module_setstartfunc(conn_proc,plugin_proc.start);

    ex_module_init(conn_proc,connector_config_file);
    add_ex_module(conn_proc);

    // init the router proc	
    Strcpy(namebuffer,sys_plugin);
    Strcat(namebuffer,"/");
    Strcat(namebuffer,router_plugin_file);
    plugin_proc.init =main_read_func(namebuffer,"proc_router_init");
    if(plugin_proc.init==NULL)
	return -EINVAL;
    plugin_proc.start =main_read_func(namebuffer,"proc_router_start");
    if(plugin_proc.start==NULL)
	return -EINVAL;
     plugin_proc.name=dup_str("router_proc",0);	
     plugin_proc.type=MOD_TYPE_ROUTER;
	
    ret=ex_module_create("router_proc",MOD_TYPE_MONITOR,NULL,&router_proc);
    if(ret<0)
	    return ret;

    ex_module_setinitfunc(router_proc,plugin_proc.init);
    ex_module_setstartfunc(router_proc,plugin_proc.start);

    struct router_init_para
    {
		char * router_file;
		char * aspect_file;
    } router_init;
    router_init.router_file=router_config_file;
    router_init.aspect_file=aspect_config_file;
   	

    ex_module_init(router_proc,&router_init);
	
    print_cubeaudit("prepare the router proc\n");
    ret=add_ex_module(router_proc);
    if(ret<0)
	    return ret;

    // loop to init all the plugin's 

    void * ex_module;	

    fd=open(plugin_config_file,O_RDONLY);
    if(fd>0)
    {	

    	while(read_json_node(fd,&root_node)>0)
    	{  		
		ret=read_plugin_cfg(&ex_module,root_node);
		if(ret>=0)
    			add_ex_module(ex_module);
    	}
    }	
    
/*
    }
  */   
    usleep(time_val.tv_usec);
    print_cubeaudit("prepare the conn proc\n");
    ret=ex_module_start(conn_proc,NULL);
    if(ret<0)
	    return ret;

    // second loop:  start all the monitor process
       	
    ret=get_first_ex_module(&ex_module);

    if(ret<0)
	return ret;
    int active_module_no=0;
    while(ex_module!=NULL)
    {
	  if((ex_module_gettype(ex_module) == MOD_TYPE_MONITOR)
	  	||(ex_module_gettype(ex_module) == MOD_TYPE_PORT))
	  {
  		ret=ex_module_start(ex_module,NULL);
	  	if(ret<0)
  			return ret;
		print_cubeaudit("monitor ex_modulec %s started successfully!\n",ex_module_getname(ex_module));
	  }
	  else if(ex_module_gettype(ex_module) == MOD_TYPE_START)
	  {
  		ret=ex_module_start(ex_module,&start_para);
	  	if(ret<0)
  			return ret;
		print_cubeaudit("start ex_module %s started successfully!\n",ex_module_getname(ex_module));

	  }
	  	
    	  ret= get_next_ex_module(&ex_module);
	  active_module_no++;
    	  if(ret<0)
		return ret;
    }

    if(active_module_no==0)
	return 0;

    proc_share_data_setstate(PROC_LOCAL_START);

    // third loop:  test if any module exit
    int * thread_retval;
    thread_retval=malloc(sizeof(int)*active_module_no);
    if(thread_retval==NULL)
	return NULL;
/*
    i=0;
    while(1)
    {		 
	  usleep(time_val.tv_usec);		
  	  ret=get_first_ex_module(&ex_module);

   	  if(ret<0)
		return ret;
    	 while(ex_module!=NULL)
         {
		if(ex_module_tryjoin(ex_module,&thread_retval[i++])==0)
		{
			print_cubeaudit("monitor ex_modulec %s exited successfully!\n",ex_module_getname(ex_module));
			return thread_retval[i-1];
		}
    	  	ret= get_next_ex_module(&ex_module);
	  }
	  i=0;
	  	
    }
*/
    // third loop:  join all the non_system module 
       	
    ret=get_first_ex_module(&ex_module);

    if(ret<0)
	return ret;
    i=0;
    while(ex_module!=NULL)
    {
	  if((ex_module_gettype(ex_module) == MOD_TYPE_MONITOR)
	  	||(ex_module_gettype(ex_module) == MOD_TYPE_PORT)
	  	||(ex_module_gettype(ex_module) == MOD_TYPE_START))
	  {
		if(Strcmp(ex_module_getname(ex_module),"router_proc")!=0)
		{
    			ret=ex_module_join(ex_module,&thread_retval[i++]);
	  		if(ret<0)
			{
				print_cubeerr("%s module exit!\n",ex_module_getname(ex_module));
  				return ret;
			}
			print_cubeaudit("%s module exit!\n",ex_module_getname(ex_module));
		}
	  }
	  	
    	  ret= get_next_ex_module(&ex_module);
    	  if(ret<0)
		return ret;
    }

    printf("thread return value %d!\n",thread_retval[0]);
    return ret;
}
Example #12
0
int main() {

  	static unsigned char alloc_buffer[4096*(1+1+4+1+16+1+256)];	
	char json_buffer[4096];
	char print_buffer[4096];
	int ret;
	int readlen;
	int json_offset;
	void * root_node;
	void * findlist;
	void * memdb_template ;
	BYTE uuid[DIGEST_SIZE];
	int i;
	MSG_HEAD * msg_head;
	pthread_t  cube_thread;
	
	char * baseconfig[] =
	{
		"typelist.json",
		"subtypelist.json",
		"msghead.json",
		"headrecord.json",
		NULL
	};

	alloc_init(alloc_buffer);
	struct_deal_init();
	memdb_init();

// test namelist reading start

	for(i=0;baseconfig[i]!=NULL;i++)
	{
		ret=read_json_file(baseconfig[i]);
		if(ret<0)
			return ret;
		printf("read %d elem from file %s!\n",ret,baseconfig[i]);
	}

	void * record;

// test struct desc reading start

	msgfunc_init();
	
	void * message;
	routine_init(NULL);

	routine_register("sub1",ROUTINE_SOURCE,&sub1_ops,NULL);
	routine_register("sub2",ROUTINE_SOURCE,&sub2_ops,NULL);

	pthread_create(&cube_thread,NULL,routine_start,NULL);

	int * thread_return;

	ret=pthread_join(cube_thread,&thread_return);

	printf("return value is %d\n",thread_return);
	
//	routine_start();
//	sleep(100000);
	
	return 0;

}