/*--------------------------------------------------------------------------*/
static gbDoc *
xml_to_doc (xmlDocPtr xmldoc,
gbDocXMLStatus *status)
{
xmlNodePtr root;
gbDoc *doc;
gb_debug (DEBUG_XML, "START");
LIBXML_TEST_VERSION;
*status = GB_DOC_XML_OK;
root = xmlDocGetRootElement (xmldoc);
if (!root || !root->name) {
g_warning (_("No document root"));
*status = GB_DOC_XML_ERROR_OPEN_PARSE;
return NULL;
}
doc = xml_parse_doc (root, status);
gb_debug (DEBUG_XML, "END");
return doc;
}
int
check_xml_contents( const char *syntax_dir, const char *file )
{
char *source_file ;
char *doc_str ;
int size = 0 ;
source_file = make_file_name( syntax_dir, file );
doc_str = load_file(source_file);
if( doc_str != NULL )
{
xml_elem_t* doc;
size = strlen( doc_str );
doc = xml_parse_doc(doc_str, DocBookVocabulary);
if( doc->child )
{
if( doc->child->tag_id == DOCBOOK_section_ID && doc->child->child == NULL )
size = 0 ;
else if( doc->child->child )
{
if( doc->child->child->tag_id == XML_CDATA_ID && doc->child->child->next == NULL )
size = 0;
}
}
/* Delete the xml. */
LOCAL_DEBUG_OUT( "xml_elem_delete for doc %p", doc );
xml_elem_delete(NULL, doc);
free( doc_str );
}
free( source_file );
return size;
}
xml_elem_t *
aftershow_parse_xml_doc (const char *doc)
{
if (AfterShowVocabulary == NULL)
aftershow_init_vocabulary (False);
return xml_parse_doc (doc, AfterShowVocabulary);
}
Bool
convert_xml_file( const char *syntax_dir, const char *file, ASXMLInterpreterState *state )
{
char *source_file ;
char *doc_str ;
Bool empty_file = False ;
source_file = make_file_name( syntax_dir, file );
doc_str = load_file(source_file);
LOCAL_DEBUG_OUT( "file %s loaded", source_file );
/*LOCAL_DEBUG_OUT( "file %s loaded into {%s}", source_file, doc_str ); */
if( doc_str != NULL )
{
xml_elem_t* doc;
xml_elem_t* ptr;
if( file[0] == '_' && !get_flags( state->flags, ASXMLI_ProcessingOptions ))
state->pre_options_size += strlen(doc_str) ;
else
set_flags( state->flags, ASXMLI_ProcessingOptions );
doc = xml_parse_doc(doc_str, DocBookVocabulary);
LOCAL_DEBUG_OUT( "file %s parsed, child is %p", source_file, doc->child );
if( doc->child )
{
LOCAL_DEBUG_OUT( "child tag = \"%s\", childs child = %p", doc->child->tag, doc->child->child);
empty_file = ( doc->child->tag_id == DOCBOOK_section_ID &&
doc->child->child == NULL );
if( doc->child->child )
{
empty_file = ( doc->child->child->tag_id == XML_CDATA_ID && doc->child->child->next == NULL );
LOCAL_DEBUG_OUT( "childs child tag = \"%s\", parm = \"%s\"", doc->child->child->tag, doc->child->child->parm);
}
}
LOCAL_DEBUG_OUT( "file %s %s", source_file, empty_file?"empty":"not empty" );
if( !empty_file )
{
for (ptr = doc->child ; ptr ; ptr = ptr->next)
{
LOCAL_DEBUG_OUT( "converting child <%s>", ptr->tag );
convert_xml_tag( ptr, NULL, state );
LOCAL_DEBUG_OUT( "done converting child <%s>", ptr->tag );
}
}
/* Delete the xml. */
LOCAL_DEBUG_OUT( "deleting xml %p", doc );
xml_elem_delete(NULL, doc);
LOCAL_DEBUG_OUT( "freeing doc_str %p", doc_str );
free( doc_str );
}
LOCAL_DEBUG_OUT( "done with %s", source_file );
free( source_file );
fprintf( state->dest_fp, "\n" );
return !empty_file;
}
static void message_retrieve_message(void)
{
int server_socket;
struct sockaddr_in server_addr;
char *header, *xml_request, *default_ns;
char response_buf[1024];
int read_size;
struct xml_node *request_root, *auth_node, *id_node, *secrete_node, *proxy_type_node, *proxy_key_node, *period_node;
char vpn_server_ip[16], cmd_buf[64];
char *pserver_ip_start=NULL;
char *pserver_ip_end=NULL;
int get_server_ip_flag=0;
server_socket = socket(AF_INET, SOCK_STREAM, 0);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr(server_instance);
server_addr.sin_port = ntohs(CLOUD_PORT);
if(connect(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
close(server_socket);
return;
}
//Build XML Request Document Tree
default_ns = (char *) malloc(strlen("http://") + strlen(server_instance) + strlen("/GenericMessage") + 1);
sprintf(default_ns, "http://%s/GenericMessage", server_instance);
request_root = xml_new_element(NULL, "RetrieveMessage", default_ns);
auth_node = xml_new_element(NULL, "Authentication", NULL);
id_node = xml_new_element(NULL, "Id", NULL);
secrete_node = xml_new_element(NULL, "Secrete", NULL);
proxy_type_node = xml_new_element(NULL, "ProxyType", NULL);
proxy_key_node = xml_new_element(NULL, "ProxyKey", NULL);
period_node = xml_new_element(NULL, "AckPeriod", NULL);
xml_add_child(request_root, auth_node);
xml_add_child(auth_node, id_node);
xml_add_child(auth_node, secrete_node);
xml_add_child(id_node, xml_new_text(device_id));
xml_add_child(secrete_node, xml_new_text(device_secrete));
xml_add_child(request_root, proxy_type_node);
xml_add_child(request_root, proxy_key_node);
xml_add_child(request_root, period_node);
xml_add_child(proxy_type_node, xml_new_text("ControllerProxy")); //ProxyType for controller should be "ControllerProxy"
xml_add_child(proxy_key_node, xml_new_text(proxy_key));
xml_add_child(period_node, xml_new_text("30")); //Set ack period in seconds
xml_request = xml_dump_tree(request_root);
xml_delete_tree(request_root);
//Write HTTP
header = http_post_header(server_instance, "/cgi-bin/generic_message", "text/xml", (int) strlen(xml_request));
write(server_socket, header, strlen(header));
dump_msg("\nsend http header:", header, strlen(header));
http_free(header);
write(server_socket, xml_request, strlen(xml_request));
dump_msg("send xml request:", xml_request, strlen(xml_request));
xml_free(xml_request);
//Read HTTP
while(get_server_ip_flag==0 && (read_size = read(server_socket, response_buf, sizeof(response_buf))) != 0) {
struct xml_node *response_root;
struct xml_node_set *node_set;
char *http_header, *http_body;
if((http_header = http_response_header(response_buf, read_size)) != NULL) {
dump_msg("\nrecv http header:", http_header, strlen(http_header));
http_free(http_header);
}
if((http_body = http_response_body(response_buf, read_size)) != NULL) {
dump_msg("recv http body:", http_body, strlen(http_body));
http_free(http_body);
}
if((response_root = xml_parse_doc(response_buf, read_size, NULL, "RetrieveMessageResponse", default_ns)) != NULL) {
int has_message = 0;
node_set = xml_find_path(response_root, "/RetrieveMessageResponse/Message/Id");
if(node_set->count) {
struct xml_node *id_text = xml_text_child(node_set->node[0]);
if(id_text) {
if(strcmp(id_text->text, device_id) == 0)
has_message = 1;
}
}
xml_delete_set(node_set);
if(has_message) {
node_set = xml_find_path(response_root, "/RetrieveMessageResponse/Message/Content");
if(node_set->count) {
struct xml_node *content_node = node_set->node[0];
if(content_node->child) {
char *content_buf = xml_dump_tree(content_node->child);
printf("Receive Application-Dependent Content: %s\n", content_buf);
if(strncmp(content_buf, "<OpenvpnApplication><ServerIpElement>", strlen("<OpenvpnApplication><ServerIpElement>")) == 0)
{
pserver_ip_start=content_buf+strlen("<OpenvpnApplication><ServerIpElement>");
for(pserver_ip_end=pserver_ip_start; pserver_ip_end!=NULL && *pserver_ip_end!='<'; pserver_ip_end++);
strncpy(vpn_server_ip, pserver_ip_start, pserver_ip_end-pserver_ip_start);
vpn_server_ip[pserver_ip_end-pserver_ip_start]=0;
printf("Recv VPN Server IP Address: %s\n", vpn_server_ip);
sprintf(cmd_buf, "echo VpnServerIp:%s > /etc/openvpn/vpn_server_ip", vpn_server_ip);
system(cmd_buf);
get_server_ip_flag=1;
system("/usr/sbin/openvpn_client_start.sh &");
}
xml_free(content_buf);
}
}
xml_delete_set(node_set);
}
else {
node_set = xml_find_path(response_root, "/RetrieveMessageResponse/Result");
if(node_set->count) {
xml_delete_set(node_set);
xml_delete_tree(response_root);
break;
}
xml_delete_set(node_set);
}
xml_delete_tree(response_root);
}
}
free(default_ns);
close(server_socket);
}
static void message_query_status(char *op, char *time1, char *time2, char *limit)
{
int server_socket;
struct sockaddr_in server_addr;
char *header, *xml_request, *default_ns;
char response_buf[4096];
int read_size;
struct xml_node *request_root, *auth_node, *id_node, *secrete_node, *op_node, *time_node, *time1_node, *time2_node, *limit_node;
server_socket = socket(AF_INET, SOCK_STREAM, 0);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr(server_instance);
server_addr.sin_port = ntohs(CLOUD_PORT);
if(connect(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
close(server_socket);
return;
}
//Build XML Request Document Tree
default_ns = (char *) malloc(strlen("http://") + strlen(server_instance) + strlen("/GenericMessage") + 1);
sprintf(default_ns, "http://%s/GenericMessage", server_instance);
request_root = xml_new_element(NULL, "QueryStatus", default_ns);
auth_node = xml_new_element(NULL, "Authentication", NULL);
id_node = xml_new_element(NULL, "Id", NULL);
secrete_node = xml_new_element(NULL, "Secrete", NULL);
op_node = xml_new_element(NULL, "TimeOperation", NULL);
xml_add_child(request_root, auth_node);
xml_add_child(auth_node, id_node);
xml_add_child(auth_node, secrete_node);
xml_add_child(id_node, xml_new_text(device_id));
xml_add_child(secrete_node, xml_new_text(device_secrete));
xml_add_child(request_root, op_node);
xml_add_child(op_node, xml_new_text(op));
if(strcmp(op, "TimeRangeBetween") == 0) {
time_node = xml_new_element(NULL, "TimeRange", NULL);
xml_add_child(request_root, time_node);
time1_node = xml_new_element(NULL, "StartTime", NULL);
time2_node = xml_new_element(NULL, "EndTime", NULL);
xml_add_child(time_node, time1_node);
xml_add_child(time_node, time2_node);
xml_add_child(time1_node, xml_new_text(time1));
xml_add_child(time2_node, xml_new_text(time2));
}
else {
time_node = xml_new_element(NULL, "Time", NULL);
xml_add_child(request_root, time_node);
xml_add_child(time_node, xml_new_text(time1));
if((strcmp(op, "TimeGreaterThan") == 0) || (strcmp(op, "TimeLessThan") == 0)) {
limit_node = xml_new_element(NULL, "QueryLimit", NULL);
xml_add_child(request_root, limit_node);
xml_add_child(limit_node, xml_new_text(limit));
}
}
xml_request = xml_dump_tree(request_root);
xml_delete_tree(request_root);
//Write HTTP
header = http_post_header(server_instance, "/cgi-bin/generic_message", "text/xml", (int) strlen(xml_request));
write(server_socket, header, strlen(header));
dump_msg("\nsend http header:", header, strlen(header));
http_free(header);
write(server_socket, xml_request, strlen(xml_request));
dump_msg("send xml request:", xml_request, strlen(xml_request));
xml_free(xml_request);
//Read HTTP
if((read_size = read(server_socket, response_buf, sizeof(response_buf))) != 0) {
struct xml_node *response_root;
struct xml_node_set *node_set;
char *http_header, *http_body;
if((http_header = http_response_header(response_buf, read_size)) != NULL) {
dump_msg("\nrecv http header:", http_header, strlen(http_header));
http_free(http_header);
}
if((http_body = http_response_body(response_buf, read_size)) != NULL) {
dump_msg("recv http body:", http_body, strlen(http_body));
http_free(http_body);
}
if((response_root = xml_parse_doc(response_buf, read_size, NULL, "QueryStatusResponse", default_ns)) != NULL) {
node_set = xml_find_path(response_root, "/QueryStatusResponse/Status");
if(node_set->count) {
int i;
for(i = 0; i < node_set->count; i ++) {
char *status_buf = xml_dump_tree(node_set->node[i]);
printf("Receive Application-Dependent Statu[%d]: %s\n", i, status_buf);
xml_free(status_buf);
}
}
xml_delete_set(node_set);
xml_delete_tree(response_root);
}
}
free(default_ns);
close(server_socket);
}
static char *loadbalance_lookup_address(void)
{
int server_socket;
struct sockaddr_in server_addr;
char *header, *xml_request, *default_ns, *public_address = NULL;
char response_buf[1024];
int read_size, ret = -1;
struct xml_node *request_root, *auth_node, *id_node, *secrete_node;
server_socket = socket(AF_INET, SOCK_STREAM, 0);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr(server_instance);
server_addr.sin_port = ntohs(CLOUD_PORT);
if(connect(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1)
return NULL;
//Build XML Request Document Tree
default_ns = (char *) malloc(strlen("http://") + strlen(server_instance) + strlen("/Location") + 1);
sprintf(default_ns, "http://%s/Location", server_instance);
request_root = xml_new_element(NULL, "LookupAddress", default_ns);
auth_node = xml_new_element(NULL, "Authentication", NULL);
id_node = xml_new_element(NULL, "Id", NULL);
secrete_node = xml_new_element(NULL, "Secrete", NULL);
xml_add_child(request_root, auth_node);
xml_add_child(auth_node, id_node);
xml_add_child(auth_node, secrete_node);
xml_add_child(id_node, xml_new_text(device_id));
xml_add_child(secrete_node, xml_new_text(device_secrete));
xml_request = xml_dump_tree(request_root);
xml_delete_tree(request_root);
//Write HTTP
header = http_post_header(server_instance, "/cgi-bin/location", "text/xml", (int) strlen(xml_request));
write(server_socket, header, strlen(header));
dump_msg("\nsend http header:", header, strlen(header));
http_free(header);
write(server_socket, xml_request, strlen(xml_request));
dump_msg("send xml request:", xml_request, strlen(xml_request));
xml_free(xml_request);
//Read HTTP
if((read_size = read(server_socket, response_buf, sizeof(response_buf))) != 0) {
struct xml_node *response_root, *address_text;
struct xml_node_set *node_set;
char *http_header, *http_body;
if((http_header = http_response_header(response_buf, read_size)) != NULL) {
dump_msg("\nrecv http header:", http_header, strlen(http_header));
http_free(http_header);
}
if((http_body = http_response_body(response_buf, read_size)) != NULL) {
dump_msg("recv http body:", http_body, strlen(http_body));
http_free(http_body);
}
if((response_root = xml_parse_doc(response_buf, read_size, NULL, "LookupAddressResponse", default_ns)) != NULL) {
node_set = xml_find_path(response_root, "/LookupAddressResponse/PublicAddress");
if(node_set->count) {
address_text = xml_text_child(node_set->node[0]);
if(address_text) {
public_address = (char *) malloc(strlen(address_text->text) + 1);
strcpy(public_address, address_text->text);
}
}
xml_delete_set(node_set);
xml_delete_tree(response_root);
}
}
free(default_ns);
close(server_socket);
return public_address;
}
static void message_forward_message(char *application_content, char *timeout)
{
int server_socket;
struct sockaddr_in server_addr;
char *header, *xml_request, *default_ns, *doc_prefix = NULL, *doc_name = NULL, *doc_uri = NULL;
char response_buf[1024];
int read_size;
struct xml_node *request_root, *auth_node, *id_node, *secrete_node, *message_node, *type_node, *content_node, *application_root, *timeout_node;
if(xml_doc_name(application_content, strlen(application_content), &doc_prefix, &doc_name, &doc_uri) == -1)
return;
if((application_root = xml_parse_doc(application_content, strlen(application_content), doc_prefix, doc_name, doc_uri)) == NULL)
return;
server_socket = socket(AF_INET, SOCK_STREAM, 0);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr(server_instance);
server_addr.sin_port = ntohs(CLOUD_PORT);
if(connect(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
close(server_socket);
return;
}
//Build XML Request Document Tree
default_ns = (char *) malloc(strlen("http://") + strlen(server_instance) + strlen("/GenericMessage") + 1);
sprintf(default_ns, "http://%s/GenericMessage", server_instance);
request_root = xml_new_element(NULL, "ForwardMessage", default_ns);
auth_node = xml_new_element(NULL, "Authentication", NULL);
id_node = xml_new_element(NULL, "Id", NULL);
secrete_node = xml_new_element(NULL, "Secrete", NULL);
message_node = xml_new_element(NULL, "Message", NULL);
type_node = xml_new_element(NULL, "Type", NULL);
content_node = xml_new_element(NULL, "Content", NULL);
xml_add_child(request_root, auth_node);
xml_add_child(auth_node, id_node);
xml_add_child(auth_node, secrete_node);
xml_add_child(id_node, xml_new_text(device_id));
xml_add_child(secrete_node, xml_new_text(device_secrete));
xml_add_child(request_root, message_node);
xml_add_child(message_node, type_node);
xml_add_child(message_node, content_node);
xml_add_child(type_node, xml_new_text("ToDevice")); //For controller, Message/Type should be "ToDevice"
xml_add_child(content_node, application_root); //Add application document root to request content node as child
if(timeout != NULL) {
timeout_node = xml_new_element(NULL, "Timeout", NULL);
xml_add_child(timeout_node, xml_new_text(timeout));
xml_add_child(request_root, timeout_node);
}
xml_request = xml_dump_tree(request_root);
xml_delete_tree(request_root);
//Write HTTP
header = http_post_header(server_instance, "/cgi-bin/generic_message", "text/xml", (int) strlen(xml_request));
write(server_socket, header, strlen(header));
dump_msg("\nsend http header:", header, strlen(header));
http_free(header);
write(server_socket, xml_request, strlen(xml_request));
dump_msg("send xml request:", xml_request, strlen(xml_request));
xml_free(xml_request);
//Read HTTP
if((read_size = read(server_socket, response_buf, sizeof(response_buf))) != 0) {
struct xml_node *response_root, *instance_text;
struct xml_node_set *node_set;
char *http_header, *http_body;
if((http_header = http_response_header(response_buf, read_size)) != NULL) {
dump_msg("\nrecv http header:", http_header, strlen(http_header));
http_free(http_header);
}
if((http_body = http_response_body(response_buf, read_size)) != NULL) {
dump_msg("recv http body:", http_body, strlen(http_body));
http_free(http_body);
}
}
if(doc_prefix)
xml_free(doc_prefix);
if(doc_name)
xml_free(doc_name);
if(doc_uri)
xml_free(doc_uri);
free(default_ns);
close(server_socket);
}
static int message_apply_proxy(void)
{
int server_socket;
struct sockaddr_in server_addr;
char *header, *xml_request, *default_ns;
char response_buf[1024];
int read_size, ret = -1;
struct xml_node *request_root, *auth_node, *id_node, *secrete_node, *proxy_type_node;
server_socket = socket(AF_INET, SOCK_STREAM, 0);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr(server_instance);
server_addr.sin_port = ntohs(CLOUD_PORT);
if(connect(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
close(server_socket);
return -1;
}
//Build XML Request Document Tree
default_ns = (char *) malloc(strlen("http://") + strlen(server_instance) + strlen("/GenericMessage") + 1);
sprintf(default_ns, "http://%s/GenericMessage", server_instance);
request_root = xml_new_element(NULL, "ApplyProxy", default_ns);
auth_node = xml_new_element(NULL, "Authentication", NULL);
id_node = xml_new_element(NULL, "Id", NULL);
secrete_node = xml_new_element(NULL, "Secrete", NULL);
proxy_type_node = xml_new_element(NULL, "ProxyType", NULL);
xml_add_child(request_root, auth_node);
xml_add_child(auth_node, id_node);
xml_add_child(auth_node, secrete_node);
xml_add_child(id_node, xml_new_text(device_id));
xml_add_child(secrete_node, xml_new_text(device_secrete));
xml_add_child(request_root, proxy_type_node);
xml_add_child(proxy_type_node, xml_new_text("ControllerProxy")); //ProxyType for controller should be "ControllerProxy"
xml_request = xml_dump_tree(request_root);
xml_delete_tree(request_root);
//Write HTTP
header = http_post_header(server_instance, "/cgi-bin/generic_message", "text/xml", (int) strlen(xml_request));
write(server_socket, header, strlen(header));
dump_msg("\nsend http header:", header, strlen(header));
http_free(header);
write(server_socket, xml_request, strlen(xml_request));
dump_msg("send xml request:", xml_request, strlen(xml_request));
xml_free(xml_request);
//Read HTTP
if((read_size = read(server_socket, response_buf, sizeof(response_buf))) != 0) {
struct xml_node *response_root;
struct xml_node_set *node_set;
char *http_header, *http_body;
if((http_header = http_response_header(response_buf, read_size)) != NULL) {
dump_msg("\nrecv http header:", http_header, strlen(http_header));
http_free(http_header);
}
if((http_body = http_response_body(response_buf, read_size)) != NULL) {
dump_msg("recv http body:", http_body, strlen(http_body));
http_free(http_body);
}
if((response_root = xml_parse_doc(response_buf, read_size, NULL, "ApplyProxyResponse", default_ns)) != NULL) {
node_set = xml_find_path(response_root, "/ApplyProxyResponse/ProxyKey");
if(node_set->count) {
struct xml_node *proxy_text = xml_text_child(node_set->node[0]);
if(proxy_text) {
proxy_key = (char *) malloc(strlen(proxy_text->text) + 1);
strcpy(proxy_key, proxy_text->text);
ret = 0;
}
}
xml_delete_set(node_set);
xml_delete_tree(response_root);
}
}
free(default_ns);
close(server_socket);
return ret;
}
