int crawler_crawl(link_crawler_t *crawler, char *url, list_t *link_list)
{
http_url_t http_url;
int status = CRAWLER_NULL;
if(http_url_parse_s(&http_url, url) == URL_RECOGNIZED) {
int port = strlen(http_url.port) != 0 ? atoi(http_url.port) : 80;
char path[4096] = {""};
strlen(http_url.search) == 0 ? sprintf(path, "%s", http_url.path) : sprintf(path, "%s?%s", http_url.path, http_url.search);
if(http_connect(&crawler->http_client, http_url.host, port) == CONNECT_OK) {
int ecode, response_status;
const char *page = NULL;
printf("%s\n", url);
ecode = http_do_get(&crawler->http_client, path);
switch(ecode) {
case RESPONSE_OK:
response_status = http_response_status(&crawler->http_client);
if(response_status == HTTP_OK) {
/* get entity_body pointer */
page = http_response_body(&crawler->http_client);
/* extrack link from buffer and save link into list*/
if(page != NULL) {
extract_absolute_link_s(page, link_list, url);
status = CRAWLER_OK;
} else {
status = CRAWLER_NULL;
fprintf(stderr, "Request %s:%d%s failed, response body is null.\n",
crawler->http_client.connection.host,
crawler->http_client.connection.port, path);
}
} else {
fprintf(stderr, "Request %s:%d%s failed, Status code: %d.\n",
crawler->http_client.connection.host,
crawler->http_client.connection.port, path, response_status);
status = CRAWLER_NONEED;
}
break;
case RESPONSE_OVERFLOW:
fprintf(stderr, "Request %s:%d%s do_get receive overflow.\n",
crawler->http_client.connection.host,
crawler->http_client.connection.port, path);
status = CRAWLER_OVERFLOW;
break;
case RESPONSE_FAILED:
fprintf(stderr, "Request %s:%d%s do_get receive break.\n",
crawler->http_client.connection.host,
crawler->http_client.connection.port, path);
status = CRAWLER_BREAK;
break;
case RESPONSE_TIMEOUT:
fprintf(stderr, "Request %s:%d%s do_get receive timeout.\n",
crawler->http_client.connection.host,
crawler->http_client.connection.port, path);
status = CRAWLER_TIMEOUT;
break;
case REQUEST_FAILED:
fprintf(stderr, "Request %s:%d%s do_get request failed.\n",
http_url.host, port, path);
status = CRAWLER_FAILED;
break;
default:
fprintf(stderr, "Unknown ecode %d.\n", ecode);
status = CRAWLER_UNKNOWN;
break;
}
http_disconnect(&crawler->http_client);
} else {
fprintf(stderr, "Http connect %s:%d failed.\n", http_url.host, port);
status = CRAWLER_UNREACH;
}
} else {
fprintf(stderr, "Unrecognize url: %s\n", url);
status = CRAWLER_UNKNOWN;
}
return status;
}
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);
}
void * do_crawler(void *item)
{
char *url_ptr;
int clientfd ;
static int pages = 0;
static int error = 0;
char *buf = NULL;
urlq_t *url_list_head = NULL, *p, *p_pre;
char cur_dir[256];
hash_table *hash_in, *hash_out;
/* int tid = pthread_self();*/
int j = 0;
int i= 0;
int pos_found = 0;
char temp[256];
int status = 0;
static int a = 0;
static int b = 0;
static int c = 0;
static int d = 0;
static int e = 0;
static int f = 0;
static int g = 0;
while(1){
pthread_mutex_lock(&mutex);
while (urlqueue.head_ptr->next == NULL){
pthread_cond_wait(&ready, &mutex);
}
pthread_mutex_lock(&((threadpool_item *)item)->waitlock);
((threadpool_item *)item)->idle = 0;
pthread_mutex_unlock(&((threadpool_item *)item)->waitlock);
url_ptr = queue_pop(&urlqueue);
g++;
pthread_mutex_unlock(&mutex);
pthread_mutex_lock(&mutex);
/*if not visited, set flag = 1*/
if(has_visited(hash, url_ptr) == 1){
pthread_mutex_unlock(&mutex);
free(url_ptr);
pthread_mutex_lock(&((threadpool_item *)item)->waitlock);
((threadpool_item *)item)->idle =1;
pthread_mutex_unlock(&((threadpool_item *)item)->waitlock);
d++;
continue;
}
hash_out = has_url(hash, url_ptr);
e++;
pthread_mutex_unlock(&mutex);
if (hash_out == NULL){
printf("error\n");
getchar();
}
*temp = '\0';
cur_dir[0] = '\0';
strcpy(cur_dir, url_ptr);
j = strlen(cur_dir);
for (;cur_dir[j] != '/' && j != 0; j--) ;
if(j == 0)
cur_dir[j] = '\0';
else
cur_dir[j+1] = '\0';
for (i = 0; i < 3; i++){
if((clientfd = open_tcp("127.0.0.1", 80)) < 0){
close_fd(clientfd);
continue;
}
if( http_do_get(clientfd, rootdir, "127.0.0.1", url_ptr) < 0){
close_fd(clientfd);
continue;
}
if(recv_line(clientfd, temp) <= 0){
close_fd(clientfd);
continue;
}
if((status = http_response_status(temp)) == 4){
printf("%s error %d\n",url_ptr, error++);
pthread_mutex_lock(&mutex);
set_status(hash, url_ptr, 4);
set_webg_status(webg, hash_out, 4);
pthread_mutex_unlock(&mutex);
pthread_mutex_lock(&((threadpool_item *)item)->waitlock);
((threadpool_item *)item)->idle =1;
pthread_mutex_unlock(&((threadpool_item *)item)->waitlock);
close_fd(clientfd);
break;
}
buf = http_response_body(clientfd);
close_fd(clientfd);
break;
}
if (status == 4)
continue;
if(i == 3){
pthread_mutex_lock(&((threadpool_item *)item)->waitlock);
((threadpool_item *)item)->idle =1;
pthread_mutex_unlock(&((threadpool_item *)item)->waitlock);
close_fd(clientfd);
continue;
}
if (buf == NULL){
pthread_mutex_lock(&((threadpool_item *)item)->waitlock);
((threadpool_item *)item)->idle =1;
pthread_mutex_unlock(&((threadpool_item *)item)->waitlock);
continue;
}
printf("%s pages %d\n", url_ptr,pages++);
extract_link(buf, cur_dir, &url_list_head);
free(buf);
buf = NULL;
p = url_list_head->next;
p_pre = url_list_head;
while (p != NULL){
if(strcmp(url_ptr, p->url_ptr) == 0){
p_pre->next = p->next;
free(p->url_ptr);
free(p);
a++;
p = p_pre->next;
printf("a= %d, b= %d, c= %d, d= %d, e= %d, f= %d, g= %d\n", a,b,c,d,e,f,g);
continue;
}
pthread_mutex_lock(&mutex);
hash_in = has_url(hash, p->url_ptr);
if (hash_in != NULL ){
insert_edge(webg, hash_in, hash_out);
pthread_mutex_unlock(&mutex);
p_pre->next = p->next;
free(p->url_ptr);
free(p);
p = p_pre->next;
b++;
printf("a= %d, b= %d, c= %d, d= %d, e= %d, f= %d, g= %d\n", a,b,c,d,e,f,g);
continue;
}
else{
pos_found = insert_vertex(webg, hash_out, p->url_ptr);
insert_hash_item(hash, p->url_ptr, pos_found, 0);
pthread_mutex_unlock(&mutex);
c++;
p_pre = p;
p = p->next;
printf("a= %d, b= %d, c= %d, d= %d, e= %d, f= %d, g= %d\n", a,b,c,d,e,f,g);
}
}
if(p_pre != url_list_head){
pthread_mutex_lock(&mutex);
queue_push(&urlqueue, url_list_head->next, p_pre);
f++;
pthread_mutex_unlock(&mutex);
}
free(url_list_head);
p = p_pre = url_list_head = NULL;
pthread_mutex_lock(&((threadpool_item *)item)->waitlock);
((threadpool_item *)item)->idle = 1;
pthread_mutex_unlock(&((threadpool_item *)item)->waitlock);
/*printf("next time!\n");*/
}
/*printf("over!\n");*/
return NULL;
}
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 void message_release_proxy(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;
if((proxy_key == NULL) || (server_instance == 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, "ReleaseProxy", 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);
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_add_child(request_root, proxy_key_node);
xml_add_child(proxy_key_node, xml_new_text(proxy_key));
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);
}
}
free(default_ns);
close(server_socket);
}
int main(int argc, char **argv)
{
char *host = "125.211.218.8";
char *path = "/techqq/zt/2007/firacn/topic_html/xsm.htm";
/*
char *host = "10.205.42.139";
char *path = "/techqq/a/20090423/000378.htm";
char *path = "/techqq/a/20120111/000508.htm";
char *path = "/techqq/a/20121008/000013.htm";
char *path = "/techqq/wlyx.htm";
char *path = "/techqq/index.html";
char *path = "/techqq/a/20121008/000048.htm";
10.205.42.139:80/techqq/a/20090423/000378.htm
*/
const char *body_ptr;
int status;
http_client_t http_client1;
http_connect(&http_client1, host, 80);
http_do_get(&http_client1, path);
status = http_response_status(&http_client1);
body_ptr = http_response_body(&http_client1);
printf("---------------------Status-----------------------\n");
printf("%d\n", status);
printf("---------------------Body-----------------------\n");
printf("%p\n", body_ptr);
printf("%s\n", body_ptr);
http_disconnect(&http_client1);
/*
status = http_response_status(&http_client1);
body_ptr = http_response_body(&http_client1);
*/
/*
printf("---------------------Status-----------------------\n");
printf("%d\n", status);
printf("---------------------Body-----------------------\n");
printf("%s\n", body_ptr);
*/
/*
http_client_t http_client2;
http_connect(&http_client2, "ufp.umeng.com", 80);
http_do_get(&http_client2, "/login");
status = http_response_status(&http_client2);
body_ptr = http_response_body(&http_client2);
printf("---------------------Status-----------------------\n");
printf("%d\n", status);
printf("---------------------Body-----------------------\n");
printf("%s\n", body_ptr);
http_disconnect(&http_client2);
http_client_t http_client3;
http_connect(&http_client3, "blog.umeng.com", 80);
http_do_get(&http_client3, "/index.php/category/products/");
status = http_response_status(&http_client3);
body_ptr = http_response_body(&http_client3);
printf("---------------------Status-----------------------\n");
printf("%d\n", status);
printf("---------------------Body-----------------------\n");
printf("%s\n", body_ptr);
http_disconnect(&http_client3);
*/
}
