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; }
int json_port_start(void * sub_proc,void * para) { int ret; int retval; void * message_box; void * context; struct tcloud_connector_hub * port_hub; struct tcloud_connector * port_conn; struct tcloud_connector * recv_conn; struct tcloud_connector * channel_conn; int i; struct timeval conn_val; conn_val.tv_usec=time_val.tv_usec; char local_uuid[DIGEST_SIZE*2+1]; char proc_name[DIGEST_SIZE*2+1]; char buffer[4096]; memset(buffer,0,4096); int stroffset; printf("begin json server process!\n"); ret=proc_share_data_getvalue("uuid",local_uuid); if(ret<0) return ret; ret=proc_share_data_getvalue("proc_name",proc_name); if(ret<0) return ret; struct json_server_context * server_context; ret=sec_subject_getcontext(sub_proc,&context); server_context=sec_object_getpointer(context); port_hub=server_context->json_port_hub; port_conn=hub_get_connector(server_context->json_port_hub,"json_server"); if(port_conn==NULL) return -EINVAL; channel_conn=NULL; for(i=0;i<500*1000;i++) { ret=port_hub->hub_ops->select(port_hub,&conn_val); usleep(conn_val.tv_usec); conn_val.tv_usec=time_val.tv_usec; if(ret>0) { do{ recv_conn=port_hub->hub_ops->getactiveread(port_hub); if(recv_conn==NULL) break; if(connector_get_type(recv_conn)==CONN_SERVER) { channel_conn=recv_conn->conn_ops->accept(recv_conn); if(channel_conn==NULL) { printf("error: json_server connector accept error %x!\n",channel_conn); continue; } printf("create a new channel %x!\n",channel_conn); // build a server syn message with service name,uuid and proc_name channel_conn->conn_ops->write(channel_conn, server_context->json_message, server_context->message_len); port_hub->hub_ops->add_connector(port_hub,channel_conn,NULL); } else if(connector_get_type(recv_conn)==CONN_CHANNEL) { char * buffer=malloc(65535); int offset=0; do { ret=recv_conn->conn_ops->read(recv_conn,buffer+offset,4096); if(ret<0) break; offset+=ret; }while(ret==4096); void * message; ret=json_2_message(buffer,&message); if(ret>=0) { if(message_get_state(message)==0) message_set_state(message,MSG_FLOW_INIT); set_message_head(message,"sender_uuid",local_uuid); sec_subject_sendmsg(sub_proc,message); } } }while(1); } // send message to the remote while(sec_subject_recvmsg(sub_proc,&message_box)>=0) { if(message_box==NULL) break; stroffset=message_2_json(message_box,buffer); if(channel_conn!=NULL) { channel_conn->conn_ops->write(channel_conn, buffer,stroffset); printf("json port send %d data !",stroffset); } } } return 0; }
int json_port_init(void * sub_proc,void * para) { int ret; struct json_server_context * sub_context; struct message_box * msg_box; struct message_box * new_msg; struct tcloud_connector_hub * port_hub; MESSAGE_HEAD * msg_head; char local_uuid[DIGEST_SIZE*2+1]; char proc_name[DIGEST_SIZE*2+1]; ret=proc_share_data_getvalue("uuid",local_uuid); if(ret<0) return ret; ret=proc_share_data_getvalue("proc_name",proc_name); register_record_type("SYNI",connect_syn_desc); // process init sub_context=malloc(sizeof(struct json_server_context)); if(sub_context==NULL) return -ENOMEM; memset(sub_context,0,sizeof(struct json_server_context)); void * context; ret=sec_subject_getcontext(sub_proc,&context); if(ret<0) return ret; sec_object_setpointer(context,sub_context); // parameter deal with char * server_name="json_server"; char * server_uuid=local_uuid; char * service=sec_subject_getname(sub_proc); char * server_addr=local_jsonserver_addr; char * nonce="AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; struct connect_syn * syn_info; syn_info=malloc(sizeof(struct connect_syn)); if(syn_info==NULL) return -ENOMEM; memset(syn_info,0,sizeof(struct connect_syn)); char buffer[1024]; memset(buffer,0,1024); int stroffset=0; msg_box=build_server_syn_message(service,local_uuid,proc_name); stroffset=message_2_json(msg_box,buffer); printf("json message size is %d\n",stroffset); printf("json message:%s\n",buffer); ret=json_2_message(buffer,&new_msg); if(ret<0) return -EINVAL; sub_context->json_message=dup_str(buffer,0); sub_context->message_len=strlen(buffer); port_hub=get_connector_hub(); sub_context->json_port_hub=port_hub; struct tcloud_connector * temp_conn; temp_conn=get_connector(CONN_SERVER,AF_INET); if((temp_conn ==NULL) || IS_ERR(temp_conn)) { printf("get json server conn failed!\n"); return -EINVAL; } ret=temp_conn->conn_ops->init(temp_conn,server_name,server_addr); if(ret<0) { printf("init conn json_server failed!\n"); return -EINVAL; } port_hub->hub_ops->add_connector(port_hub,temp_conn,NULL); ret=temp_conn->conn_ops->listen(temp_conn); if(ret<0) return -EINVAL; return 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; }