int serve_style_css(struct http_request *req) { char *date; time_t tstamp; tstamp = 0; if (http_request_header(req, "if-modified-since", &date)) { tstamp = kore_date_to_time(date); kore_mem_free(date); kore_debug("header was present with %ld", tstamp); } if (tstamp != 0 && tstamp <= asset_mtime_style_css) { http_response(req, 304, NULL, 0); } else { date = kore_time_to_date(asset_mtime_style_css); if (date != NULL) http_response_header(req, "last-modified", date); http_response_header(req, "content-type", "text/css"); http_response(req, 200, asset_style_css, asset_len_style_css); } return (KORE_RESULT_OK); }
int serve_private(struct http_request *req) { http_response_header(req, "content-type", "text/html"); http_response_header(req, "set-cookie", "session_id=test123"); http_response(req, 200, asset_private_html, asset_len_private_html); return (KORE_RESULT_OK); }
static void swift_head_account(struct http_request *req, const char *account) { int ret; ret = kv_read_account_meta(req, account); if (ret == SD_RES_SUCCESS) http_response_header(req, NO_CONTENT); else http_response_header(req, UNAUTHORIZED); }
static void swift_put_account(struct http_request *req, const char *account) { int ret; ret = kv_create_account(account); if (ret == SD_RES_SUCCESS) http_response_header(req, CREATED); else if (ret == SD_RES_VDI_EXIST) http_response_header(req, ACCEPTED); else http_response_header(req, INTERNAL_SERVER_ERROR); }
int blog_posts(struct http_request *req) { if (req->method != HTTP_METHOD_GET) { http_response_header(req, "allow", "GET"); http_response(req, 405, NULL, 0); return (KORE_RESULT_OK); } http_response_header(req, "content-type", "application/json"); http_response(req, 200, asset_home_json, asset_len_home_json); kore_log(LOG_NOTICE, "GET BLOG POSTS"); return (KORE_RESULT_OK); }
static int onode_read_data(struct kv_onode *onode, struct http_request *req) { int ret; uint64_t off = 0, len = onode->size; if (req->offset || req->data_length) { off = req->offset; len = req->data_length; if ((off + len - 1) > onode->size) { if (onode->size > off) len = onode->size - off; else len = 0; } } req->data_length = len; if (!len) return SD_RES_INVALID_PARMS; http_response_header(req, OK); if (!onode->inlined) return onode_read_extents(onode, req); ret = http_request_write(req, onode->data + off, len); if (ret != len) return SD_RES_SYSTEM_ERROR; return SD_RES_SUCCESS; }
static void swift_put_container(struct http_request *req, const char *account, const char *container) { int ret; ret = kv_create_bucket(account, container); switch (ret) { case SD_RES_SUCCESS: http_response_header(req, CREATED); break; case SD_RES_VDI_EXIST: http_response_header(req, ACCEPTED); break; default: http_response_header(req, INTERNAL_SERVER_ERROR); break; } }
int serve_intro(struct http_request *req) { http_response_header(req, "content-type", "image/jpg"); http_response(req, 200, asset_intro_jpg, asset_len_intro_jpg); return (KORE_RESULT_OK); }
int serve_index(struct http_request *req) { http_response_header(req, "content-type", "text/html"); http_response(req, 200, asset_index_html, asset_len_index_html); return (KORE_RESULT_OK); }
static void swift_get_object(struct http_request *req, const char *account, const char *container, const char *object) { int ret; ret = kv_read_object(req, account, container, object); switch (ret) { case SD_RES_SUCCESS: break; case SD_RES_NO_VDI: case SD_RES_NO_OBJ: http_response_header(req, NOT_FOUND); break; default: http_response_header(req, INTERNAL_SERVER_ERROR); break; } }
static void swift_put_object(struct http_request *req, const char *account, const char *container, const char *object) { int ret; ret = kv_create_object(req, account, container, object); switch (ret) { case SD_RES_SUCCESS: http_response_header(req, CREATED); break; case SD_RES_NO_VDI: http_response_header(req, NOT_FOUND); break; case SD_RES_NO_SPACE: http_response_header(req, SERVICE_UNAVAILABLE); default: http_response_header(req, INTERNAL_SERVER_ERROR); break; } }
static void swift_delete_account(struct http_request *req, const char *account) { int ret; ret = kv_delete_account(req, account); switch (ret) { case SD_RES_SUCCESS: http_response_header(req, NO_CONTENT); break; case SD_RES_NO_VDI: case SD_RES_NO_OBJ: http_response_header(req, NOT_FOUND); break; case SD_RES_VDI_NOT_EMPTY: http_response_header(req, CONFLICT); break; default: http_response_header(req, INTERNAL_SERVER_ERROR); break; } }
static void swift_get_account(struct http_request *req, const char *account) { struct strbuf buf = STRBUF_INIT; int ret; ret = kv_iterate_bucket(account, swift_get_account_cb, &buf); switch (ret) { case SD_RES_SUCCESS: req->data_length = buf.len; http_response_header(req, OK); http_request_write(req, buf.buf, buf.len); break; case SD_RES_NO_VDI: http_response_header(req, NOT_FOUND); break; default: http_response_header(req, INTERNAL_SERVER_ERROR); break; } strbuf_release(&buf); }
/** * @brief Display the statistics page to the requesting connection. * @param con a pointer to the connection object across which the server statistics will be transmitted. * @return This function returns no value. */ void statistics_process(connection_t *con) { time_t sm_time; chr_t buffer[256]; stringer_t *raw; struct tm tm_time; http_page_t *page; if (!(page = http_page_get("statistics/statistics"))) { http_print_500(con); return; } statistics_refresh(); if ((sm_time = time(NULL)) == ((time_t)-1) || !localtime_r(&sm_time, &tm_time) || strftime(buffer, 256, "These statistics were last updated %A, %B %e, %Y at %I:%M:%S %p %Z.", &tm_time) <= 0) { log_pedantic("Unable to build the time string."); } else { // Update the time. xml_set_xpath_ns(page->xpath_ctx, (xmlChar *)"//xhtml:p[@id='time']", (uchr_t *)buffer); } xml_set_xpath_uint64(page->xpath_ctx, (xmlChar *)"//xhtml:td[@id='total_users']", portal_stats[portal_stat_total_users].val); xml_set_xpath_uint64(page->xpath_ctx, (xmlChar *)"//xhtml:td[@id='checked_email_today']", portal_stats[portal_stat_users_checked_email_today].val); xml_set_xpath_uint64(page->xpath_ctx, (xmlChar *)"//xhtml:td[@id='checked_email_week']", portal_stats[portal_stat_users_checked_email_week].val); xml_set_xpath_uint64(page->xpath_ctx, (xmlChar *)"//xhtml:td[@id='sent_email_today']", portal_stats[portal_stat_users_sent_email_today].val); xml_set_xpath_uint64(page->xpath_ctx, (xmlChar *)"//xhtml:td[@id='sent_email_week']", portal_stats[portal_stat_users_sent_email_week].val); xml_set_xpath_uint64(page->xpath_ctx, (xmlChar *)"//xhtml:td[@id='emails_received_today']", portal_stats[portal_stat_emails_received_today].val); xml_set_xpath_uint64(page->xpath_ctx, (xmlChar *)"//xhtml:td[@id='emails_received_week']", portal_stats[portal_stat_emails_received_week].val); xml_set_xpath_uint64(page->xpath_ctx, (xmlChar *)"//xhtml:td[@id='emails_sent_today']", portal_stats[portal_stat_emails_sent_today].val); xml_set_xpath_uint64(page->xpath_ctx, (xmlChar *)"//xhtml:td[@id='emails_sent_week']", portal_stats[portal_stat_emails_sent_week].val); xml_set_xpath_uint64(page->xpath_ctx, (xmlChar *)"//xhtml:td[@id='users_registered_today']", portal_stats[portal_stat_users_registered_today].val); xml_set_xpath_uint64(page->xpath_ctx, (xmlChar *)"//xhtml:td[@id='users_registered_week']", portal_stats[portal_stat_users_registered_week].val); if (!(raw = xml_dump_doc(page->doc_obj))) { http_print_500(con); http_page_free(page); return; } http_response_header(con, 200, page->content->type, st_length_get(raw)); con_write_st(con, raw); http_page_free(page); st_free(raw); return; }
static void swift_handle_request(struct http_request *req, void (*a_handler)(struct http_request *req, const char *account), void (*c_handler)(struct http_request *req, const char *account, const char *container), void (*o_handler)(struct http_request *req, const char *account, const char *container, const char *object)) { char *args[4] = {}; char *version, *account, *container, *object; split_path(req->uri, ARRAY_SIZE(args), args); version = args[0]; account = args[1]; container = args[2]; object = args[3]; sd_info("%s", str_http_req(req)); if (account == NULL) { sd_info("invalid uri: %s", req->uri); http_response_header(req, NOT_FOUND); } else if (container == NULL) { sd_info("account operation, %s", account); a_handler(req, account); } else if (object == NULL) { sd_info("container operation, %s, %s", account, container); c_handler(req, account, container); } else { sd_info("object operation, %s, %s, %s", account, container, object); o_handler(req, account, container, object); } sd_info("%s", str_http_req(req)); free(version); free(account); free(container); free(object); }
int serve_file_upload(struct http_request *req) { u_int8_t *d; struct kore_buf *b; struct http_file *f; size_t len; char *name, buf[BUFSIZ]; b = kore_buf_alloc(asset_len_upload_html); kore_buf_append(b, asset_upload_html, asset_len_upload_html); if (req->method == HTTP_METHOD_POST) { if (req->http_body_fd != -1) kore_log(LOG_NOTICE, "file is on disk"); http_populate_multipart_form(req); if (http_argument_get_string(req, "firstname", &name)) { kore_buf_replace_string(b, "$firstname$", name, strlen(name)); } else { kore_buf_replace_string(b, "$firstname$", NULL, 0); } if ((f = http_file_lookup(req, "file")) != NULL) { (void)snprintf(buf, sizeof(buf), "%s is %ld bytes", f->filename, f->length); kore_buf_replace_string(b, "$upload$", buf, strlen(buf)); } else { kore_buf_replace_string(b, "$upload$", NULL, 0); } } else { kore_buf_replace_string(b, "$upload$", NULL, 0); kore_buf_replace_string(b, "$firstname$", NULL, 0); } d = kore_buf_release(b, &len); http_response_header(req, "content-type", "text/html"); http_response(req, 200, d, len); kore_free(d); return (KORE_RESULT_OK); }
int serve_b64test(struct http_request *req) { int i; u_int32_t len; struct kore_buf *res; u_int8_t *data; res = kore_buf_create(1024); for (i = 0; b64tests[i] != NULL; i++) test_base64((u_int8_t *)b64tests[i], strlen(b64tests[i]), res); data = kore_buf_release(res, &len); http_response_header(req, "content-type", "text/plain"); http_response(req, 200, data, len); kore_mem_free(data); return (KORE_RESULT_OK); }
int serve_file_upload(struct http_request *req) { int r; u_int8_t *d; struct kore_buf *b; u_int32_t len; char *name, buf[BUFSIZ]; b = kore_buf_create(asset_len_upload_html); kore_buf_append(b, asset_upload_html, asset_len_upload_html); if (req->method == HTTP_METHOD_POST) { http_populate_multipart_form(req, &r); if (http_argument_get_string("firstname", &name, &len)) { kore_buf_replace_string(b, "$firstname$", name, len); } else { kore_buf_replace_string(b, "$firstname$", NULL, 0); } if (http_file_lookup(req, "file", &name, &d, &len)) { (void)snprintf(buf, sizeof(buf), "%s is %d bytes", name, len); kore_buf_replace_string(b, "$upload$", buf, strlen(buf)); } else { kore_buf_replace_string(b, "$upload$", NULL, 0); } } else { kore_buf_replace_string(b, "$upload$", NULL, 0); kore_buf_replace_string(b, "$firstname$", NULL, 0); } d = kore_buf_release(b, &len); http_response_header(req, "content-type", "text/html"); http_response(req, 200, d, len); kore_mem_free(d); return (KORE_RESULT_OK); }
static void swift_post_object(struct http_request *req, const char *account, const char *container, const char *object) { http_response_header(req, NOT_IMPLEMENTED); }
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 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; }
int serve_params_test(struct http_request *req) { struct kore_buf *b; u_int8_t *d; u_int32_t len; int r, i; char *test, name[10]; http_populate_arguments(req); b = kore_buf_create(asset_len_params_html); kore_buf_append(b, asset_params_html, asset_len_params_html); /* * The GET parameters will be filtered out on POST. */ if (http_argument_get_string("arg1", &test, &len)) { kore_buf_replace_string(b, "$arg1$", test, len); } else { kore_buf_replace_string(b, "$arg1$", NULL, 0); } if (http_argument_get_string("arg2", &test, &len)) { kore_buf_replace_string(b, "$arg2$", test, len); } else { kore_buf_replace_string(b, "$arg2$", NULL, 0); } if (req->method == HTTP_METHOD_GET) { kore_buf_replace_string(b, "$test1$", NULL, 0); kore_buf_replace_string(b, "$test2$", NULL, 0); kore_buf_replace_string(b, "$test3$", NULL, 0); if (http_argument_get_uint16("id", &r)) kore_log(LOG_NOTICE, "id: %d", r); else kore_log(LOG_NOTICE, "No id set"); http_response_header(req, "content-type", "text/html"); d = kore_buf_release(b, &len); http_response(req, 200, d, len); kore_mem_free(d); return (KORE_RESULT_OK); } for (i = 1; i < 4; i++) { (void)snprintf(name, sizeof(name), "test%d", i); if (http_argument_get_string(name, &test, &len)) { (void)snprintf(name, sizeof(name), "$test%d$", i); kore_buf_replace_string(b, name, test, len); } else { (void)snprintf(name, sizeof(name), "$test%d$", i); kore_buf_replace_string(b, name, NULL, 0); } } http_response_header(req, "content-type", "text/html"); d = kore_buf_release(b, &len); http_response(req, 200, d, len); kore_mem_free(d); return (KORE_RESULT_OK); }
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 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); }
int v1(struct http_request *http_req) { struct jsonrpc_request req; int ret; /* We only allow POST/PUT methods. */ if (http_req->method != HTTP_METHOD_POST && http_req->method != HTTP_METHOD_PUT) { http_response_header(http_req, "allow", "POST, PUT"); http_response(http_req, HTTP_STATUS_METHOD_NOT_ALLOWED, NULL, 0); return (KORE_RESULT_OK); } /* Read JSON-RPC request. */ if ((ret = jsonrpc_read_request(http_req, &req)) != 0) return jsonrpc_error(&req, ret, NULL); /* Echo command takes and gives back params. */ if (strcmp(req.method, "echo") == 0) { if (!YAJL_IS_ARRAY(req.params)) { jsonrpc_log(&req, LOG_ERR, "Echo only accepts positional params"); return jsonrpc_error(&req, JSONRPC_INVALID_PARAMS, NULL); } for (size_t i = 0; i < req.params->u.array.len; i++) { yajl_val v = req.params->u.array.values[i]; if (!YAJL_IS_STRING(v)) { jsonrpc_log(&req, -3, "Echo only accepts strings"); return jsonrpc_error(&req, JSONRPC_INVALID_PARAMS, NULL); } } return jsonrpc_result(&req, write_string_array_params, NULL); } /* Date command displays date and time according to parameters. */ if (strcmp(req.method, "date") == 0) { time_t time_value; struct tm time_info; char timestamp[33]; struct tm *(*gettm)(const time_t *, struct tm *) = localtime_r; if (YAJL_IS_OBJECT(req.params)) { const char *path[] = {"local", NULL}; yajl_val bf; bf = yajl_tree_get(req.params, path, yajl_t_false); if (bf != NULL) gettm = gmtime_r; } else if (req.params != NULL) { jsonrpc_log(&req, LOG_ERR, "Date only accepts named params"); return jsonrpc_error(&req, JSONRPC_INVALID_PARAMS, NULL); } if ((time_value = time(NULL)) == -1) return jsonrpc_error(&req, -2, "Failed to get date time"); if (gettm(&time_value, &time_info) == NULL) return jsonrpc_error(&req, -3, "Failed to get date time info"); memset(timestamp, 0, sizeof(timestamp)); if (strftime_l(timestamp, sizeof(timestamp) - 1, "%c", &time_info, LC_GLOBAL_LOCALE) == 0) return jsonrpc_error(&req, -4, "Failed to get printable date time"); return jsonrpc_result(&req, write_string, timestamp); } return jsonrpc_error(&req, JSONRPC_METHOD_NOT_FOUND, NULL); }
static void swift_post_account(struct http_request *req, const char *account) { http_response_header(req, NOT_IMPLEMENTED); }
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); }