--- /dev/null
+/*
+ * Copyright (c) 2017, Shane Bryldt
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "blade.h"
+
+struct blade_webrequest_s {
+ const char *action;
+ const char *path;
+
+ ks_hash_t *query;
+ ks_hash_t *headers;
+
+ ks_sb_t *content;
+};
+
+struct blade_webresponse_s {
+ const char *status_code;
+ const char *status_message;
+
+ ks_hash_t *headers;
+
+ ks_sb_t *content;
+};
+
+static void blade_webrequest_cleanup(void *ptr, void *arg, ks_pool_cleanup_action_t action, ks_pool_cleanup_type_t type)
+{
+ blade_webrequest_t *bwreq = (blade_webrequest_t *)ptr;
+
+ ks_assert(bwreq);
+
+ switch (action) {
+ case KS_MPCL_ANNOUNCE:
+ break;
+ case KS_MPCL_TEARDOWN:
+ break;
+ case KS_MPCL_DESTROY:
+ break;
+ }
+}
+
+static void blade_webresponse_cleanup(void *ptr, void *arg, ks_pool_cleanup_action_t action, ks_pool_cleanup_type_t type)
+{
+ blade_webresponse_t *bwres = (blade_webresponse_t *)ptr;
+
+ ks_assert(bwres);
+
+ switch (action) {
+ case KS_MPCL_ANNOUNCE:
+ break;
+ case KS_MPCL_TEARDOWN:
+ break;
+ case KS_MPCL_DESTROY:
+ break;
+ }
+}
+
+KS_DECLARE(ks_status_t) blade_webrequest_create(blade_webrequest_t **bwreqP, const char *action, const char *path)
+{
+ ks_pool_t *pool = NULL;
+ blade_webrequest_t *bwreq = NULL;
+
+ ks_assert(bwreqP);
+ ks_assert(action);
+ ks_assert(path);
+
+ ks_pool_open(&pool);
+ ks_assert(pool);
+
+ bwreq = ks_pool_alloc(pool, sizeof(blade_webrequest_t));
+
+ bwreq->action = ks_pstrdup(pool, action);
+ bwreq->path = ks_pstrdup(pool, path);
+
+ ks_hash_create(&bwreq->query, KS_HASH_MODE_CASE_INSENSITIVE, KS_HASH_FLAG_NOLOCK | KS_HASH_FLAG_DUP_CHECK | KS_HASH_FLAG_FREE_KEY | KS_HASH_FLAG_FREE_VALUE, pool);
+ ks_assert(bwreq->query);
+
+ ks_hash_create(&bwreq->headers, KS_HASH_MODE_CASE_INSENSITIVE, KS_HASH_FLAG_NOLOCK | KS_HASH_FLAG_DUP_CHECK | KS_HASH_FLAG_FREE_KEY | KS_HASH_FLAG_FREE_VALUE, pool);
+ ks_assert(bwreq->headers);
+
+ ks_sb_create(&bwreq->content, pool, 0);
+ ks_assert(bwreq->content);
+
+ ks_pool_set_cleanup(bwreq, NULL, blade_webrequest_cleanup);
+
+ *bwreqP = bwreq;
+
+ blade_webrequest_header_add(bwreq, "Content-Type", "application/x-www-form-urlencoded");
+
+ return KS_STATUS_SUCCESS;
+}
+
+KS_DECLARE(ks_status_t) blade_webrequest_load(blade_webrequest_t **bwreqP, struct mg_connection *conn)
+{
+ ks_status_t ret = KS_STATUS_SUCCESS;
+ ks_pool_t *pool = NULL;
+ blade_webrequest_t *bwreq = NULL;
+ struct mg_request_info *info = NULL;
+ char buf[1024];
+ int bytes = 0;
+
+ ks_assert(bwreqP);
+ ks_assert(conn);
+
+ info = mg_get_request_info(conn);
+
+ ks_pool_open(&pool);
+ ks_assert(pool);
+
+ bwreq = ks_pool_alloc(pool, sizeof(blade_webrequest_t));
+
+ bwreq->action = ks_pstrdup(pool, info->request_method);
+ bwreq->path = ks_pstrdup(pool, info->request_uri);
+
+ ks_hash_create(&bwreq->query, KS_HASH_MODE_CASE_INSENSITIVE, KS_HASH_FLAG_NOLOCK | KS_HASH_FLAG_DUP_CHECK | KS_HASH_FLAG_FREE_KEY | KS_HASH_FLAG_FREE_VALUE, pool);
+ ks_assert(bwreq->query);
+
+ ks_hash_create(&bwreq->headers, KS_HASH_MODE_CASE_INSENSITIVE, KS_HASH_FLAG_NOLOCK | KS_HASH_FLAG_DUP_CHECK | KS_HASH_FLAG_FREE_KEY | KS_HASH_FLAG_FREE_VALUE, pool);
+ ks_assert(bwreq->headers);
+
+ ks_sb_create(&bwreq->content, pool, 0);
+ ks_assert(bwreq->content);
+
+ ks_pool_set_cleanup(bwreq, NULL, blade_webrequest_cleanup);
+
+ if (info->query_string && info->query_string[0]) {
+ char *query = ks_pstrdup(pool, info->query_string);
+ char *start = query;
+ char *end = NULL;
+
+ do {
+ char *key = start;
+ char *value = NULL;
+
+ end = strchr(start, '&');
+ if (end) *end = '\0';
+
+ value = strchr(start, '=');
+ if (value) {
+ *value = '\0';
+ value++;
+
+ if (*key && *value) {
+ ks_hash_insert(bwreq->query, (void *)ks_pstrdup(pool, key), (void *)ks_pstrdup(pool, value));
+ }
+ }
+
+ if (end) start = ++end;
+ else start = NULL;
+ } while (start);
+
+ ks_pool_free(&query);
+ }
+
+ for (int index = 0; index < info->num_headers; ++index) {
+ struct mg_header *header = &info->http_headers[index];
+ ks_hash_insert(bwreq->headers, (void *)ks_pstrdup(pool, header->name), (void *)ks_pstrdup(pool, header->value));
+ }
+
+ while ((bytes = mg_read(conn, buf, sizeof(buf))) > 0) ks_sb_append_ex(bwreq->content, buf, bytes);
+ if (bytes < 0) {
+ blade_webrequest_destroy(&bwreq);
+ ret = KS_STATUS_FAIL;
+ }
+ else *bwreqP = bwreq;
+
+ return ret;
+}
+
+KS_DECLARE(ks_status_t) blade_webrequest_destroy(blade_webrequest_t **bwreqP)
+{
+ blade_webrequest_t *bwreq = NULL;
+ ks_pool_t *pool;
+
+ ks_assert(bwreqP);
+ ks_assert(*bwreqP);
+
+ bwreq = *bwreqP;
+ *bwreqP = NULL;
+
+ pool = ks_pool_get(bwreq);
+
+ ks_pool_close(&pool);
+
+ return KS_STATUS_SUCCESS;
+}
+
+KS_DECLARE(const char *) blade_webrequest_action_get(blade_webrequest_t *bwreq)
+{
+ ks_assert(bwreq);
+ return bwreq->action;
+}
+
+KS_DECLARE(const char *) blade_webrequest_path_get(blade_webrequest_t *bwreq)
+{
+ ks_assert(bwreq);
+ return bwreq->path;
+}
+
+KS_DECLARE(ks_status_t) blade_webrequest_query_add(blade_webrequest_t *bwreq, const char *name, const char *value)
+{
+ ks_assert(bwreq);
+ ks_assert(name);
+ ks_assert(value);
+
+ ks_hash_insert(bwreq->query, (void *)ks_pstrdup(ks_pool_get(bwreq), name), (void *)ks_pstrdup(ks_pool_get(bwreq), value));
+
+ return KS_STATUS_SUCCESS;
+}
+
+KS_DECLARE(const char *) blade_webrequest_query_get(blade_webrequest_t *bwreq, const char *name)
+{
+ ks_assert(bwreq);
+ ks_assert(name);
+
+ return (const char *)ks_hash_search(bwreq->query, (void *)name, KS_UNLOCKED);
+}
+
+KS_DECLARE(ks_status_t) blade_webrequest_header_add(blade_webrequest_t *bwreq, const char *header, const char *value)
+{
+ ks_assert(bwreq);
+ ks_assert(header);
+ ks_assert(value);
+
+ ks_hash_insert(bwreq->headers, (void *)ks_pstrdup(ks_pool_get(bwreq), header), (void *)ks_pstrdup(ks_pool_get(bwreq), value));
+
+ return KS_STATUS_SUCCESS;
+}
+
+KS_DECLARE(ks_status_t) blade_webrequest_header_printf(blade_webrequest_t *bwreq, const char *header, const char *fmt, ...)
+{
+ va_list ap;
+ char *result = NULL;
+
+ ks_assert(bwreq);
+ ks_assert(header);
+ ks_assert(fmt);
+
+ va_start(ap, fmt);
+ result = ks_vpprintf(ks_pool_get(bwreq), fmt, ap);
+ va_end(ap);
+
+ ks_hash_insert(bwreq->headers, (void *)ks_pstrdup(ks_pool_get(bwreq), header), (void *)result);
+
+ return KS_STATUS_SUCCESS;
+}
+
+KS_DECLARE(const char *) blade_webrequest_header_get(blade_webrequest_t *bwreq, const char *header)
+{
+ ks_assert(bwreq);
+ ks_assert(header);
+
+ return (const char *)ks_hash_search(bwreq->headers, (void *)header, KS_UNLOCKED);
+}
+
+KS_DECLARE(ks_status_t) blade_webrequest_content_json_append(blade_webrequest_t *bwreq, cJSON *json)
+{
+ ks_assert(bwreq);
+ ks_assert(json);
+
+ blade_webrequest_header_add(bwreq, "Content-Type", "application/json");
+
+ ks_sb_json(bwreq->content, json);
+
+ return KS_STATUS_SUCCESS;
+}
+
+KS_DECLARE(ks_status_t) blade_webrequest_content_string_append(blade_webrequest_t *bwreq, const char *str)
+{
+ ks_assert(bwreq);
+ ks_assert(str);
+
+ ks_sb_append(bwreq->content, str);
+
+ return KS_STATUS_SUCCESS;
+}
+
+KS_DECLARE(ks_status_t) blade_webrequest_send(blade_webrequest_t *bwreq, ks_bool_t secure, const char *host, ks_port_t port, blade_webresponse_t **bwresP)
+{
+ ks_status_t ret = KS_STATUS_SUCCESS;
+ char buf[1024];
+ struct mg_connection *conn = NULL;
+ const char *path = NULL;
+ ks_sb_t *pathAndQuery = NULL;
+
+ ks_assert(bwreq);
+ ks_assert(host);
+ ks_assert(bwresP);
+
+ if (port == 0) port = secure ? 443 : 80;
+
+ conn = mg_connect_client(host, port, secure, buf, sizeof(buf));
+ if (!conn) {
+ ret = KS_STATUS_FAIL;
+ goto done;
+ }
+
+ path = bwreq->path;
+ if (ks_hash_count(bwreq->query) > 0) {
+ ks_bool_t firstQuery = KS_TRUE;
+
+ ks_sb_create(&pathAndQuery, NULL, 0);
+ ks_sb_append(pathAndQuery, bwreq->path);
+ for (ks_hash_iterator_t *it = ks_hash_first(bwreq->query, KS_UNLOCKED); it; it = ks_hash_next(&it)) {
+ const char *key;
+ const char *value;
+
+ ks_hash_this(it, (const void **)&key, NULL, (void **)&value);
+
+ // @todo make sure key and value are URL encoded
+ mg_url_encode(key, buf, sizeof(buf));
+ ks_sb_printf(pathAndQuery, "%c%s=", firstQuery ? '?' : '&', buf);
+
+ mg_url_encode(value, buf, sizeof(buf));
+ ks_sb_append(pathAndQuery, buf);
+
+ firstQuery = KS_FALSE;
+ }
+
+ path = ks_sb_cstr(pathAndQuery);
+ }
+
+ mg_printf(conn,
+ "%s %s HTTP/1.1\r\n"
+ "Host: %s\r\n"
+ "Content-Length: %lu\r\n",
+ bwreq->action,
+ path,
+ host,
+ ks_sb_length(bwreq->content));
+
+ if (pathAndQuery) ks_sb_destroy(&pathAndQuery);
+
+ for (ks_hash_iterator_t *it = ks_hash_first(bwreq->headers, KS_UNLOCKED); it; it = ks_hash_next(&it)) {
+ const char *key;
+ const char *value;
+
+ ks_hash_this(it, (const void **)&key, NULL, (void **)&value);
+ mg_printf(conn, "%s: %s\r\n", key, value);
+ }
+
+ mg_write(conn, "\r\n", 2);
+
+ mg_write(conn, ks_sb_cstr(bwreq->content), ks_sb_length(bwreq->content));
+
+ if (mg_get_response(conn, buf, sizeof(buf), 1000) <= 0) {
+ ret = KS_STATUS_FAIL;
+ goto done;
+ }
+
+ ret = blade_webresponse_load(bwresP, conn);
+
+done:
+ if (conn) mg_close_connection(conn);
+ return ret;
+}
+
+KS_DECLARE(ks_status_t) blade_webrequest_oauth2_token_by_credentials_send(ks_bool_t secure, const char *host, ks_port_t port, const char *path, const char *client_id, const char *client_secret, const char **token)
+{
+ ks_status_t ret = KS_STATUS_SUCCESS;
+ blade_webrequest_t *bwreq = NULL;
+ blade_webresponse_t *bwres = NULL;
+ cJSON *json = NULL;
+ char *auth = NULL;
+ char encoded[1024];
+ ks_pool_t *pool = NULL;
+ char *tok = NULL;
+
+ ks_assert(host);
+ ks_assert(path);
+ ks_assert(client_id);
+ ks_assert(client_secret);
+ ks_assert(token);
+
+ blade_webrequest_create(&bwreq, "POST", path);
+
+ auth = ks_psprintf(ks_pool_get(bwreq), "%s:%s", client_id, client_secret);
+ ks_b64_encode((unsigned char *)auth, strlen(auth), (unsigned char *)encoded, sizeof(encoded));
+ ks_pool_free(&auth);
+
+ blade_webrequest_header_printf(bwreq, "Authorization", "Basic %s", encoded);
+
+ json = cJSON_CreateObject();
+ cJSON_AddStringToObject(json, "grant_type", "client_credentials");
+ blade_webrequest_content_json_append(bwreq, json);
+ cJSON_Delete(json);
+
+ if ((ret = blade_webrequest_send(bwreq, secure, host, port, &bwres)) != KS_STATUS_SUCCESS) goto done;
+
+ if ((ret = blade_webresponse_content_json_get(bwres, &json)) != KS_STATUS_SUCCESS) goto done;
+
+ if ((tok = cJSON_GetObjectCstr(json, "access_token")) == NULL) {
+ ret = KS_STATUS_FAIL;
+ goto done;
+ }
+
+ ks_pool_open(&pool);
+ *token = ks_pstrdup(pool, tok);
+
+done:
+ if (json) cJSON_Delete(json);
+ blade_webrequest_destroy(&bwreq);
+ if (bwres) blade_webresponse_destroy(&bwres);
+
+ return ret;
+}
+
+KS_DECLARE(ks_status_t) blade_webrequest_oauth2_token_by_code_send(ks_bool_t secure, const char *host, ks_port_t port, const char *path, const char *client_id, const char *client_secret, const char *code, const char **token)
+{
+ ks_status_t ret = KS_STATUS_SUCCESS;
+ blade_webrequest_t *bwreq = NULL;
+ blade_webresponse_t *bwres = NULL;
+ cJSON *json = NULL;
+ char *auth = NULL;
+ char encoded[1024];
+ ks_pool_t *pool = NULL;
+ char *tok = NULL;
+
+ ks_assert(host);
+ ks_assert(path);
+ ks_assert(client_id);
+ ks_assert(client_secret);
+ ks_assert(code);
+ ks_assert(token);
+
+ blade_webrequest_create(&bwreq, "POST", path);
+
+ auth = ks_psprintf(ks_pool_get(bwreq), "%s:%s", client_id, client_secret);
+ ks_b64_encode((unsigned char *)auth, strlen(auth), (unsigned char *)encoded, sizeof(encoded));
+ ks_pool_free(&auth);
+
+ blade_webrequest_header_printf(bwreq, "Authorization", "Basic %s", encoded);
+
+ json = cJSON_CreateObject();
+ cJSON_AddStringToObject(json, "grant_type", "authorization_code");
+ cJSON_AddStringToObject(json, "code", code);
+ blade_webrequest_content_json_append(bwreq, json);
+ cJSON_Delete(json);
+
+ if ((ret = blade_webrequest_send(bwreq, secure, host, port, &bwres)) != KS_STATUS_SUCCESS) goto done;
+
+ if ((ret = blade_webresponse_content_json_get(bwres, &json)) != KS_STATUS_SUCCESS) goto done;
+
+ if ((tok = cJSON_GetObjectCstr(json, "access_token")) == NULL) {
+ ret = KS_STATUS_FAIL;
+ goto done;
+ }
+
+ ks_pool_open(&pool);
+ *token = ks_pstrdup(pool, tok);
+
+done:
+ if (json) cJSON_Delete(json);
+ blade_webrequest_destroy(&bwreq);
+ if (bwres) blade_webresponse_destroy(&bwres);
+
+ return ret;
+}
+
+
+KS_DECLARE(ks_status_t) blade_webresponse_create(blade_webresponse_t **bwresP, const char *status)
+{
+ ks_pool_t *pool = NULL;
+ blade_webresponse_t *bwres = NULL;
+
+ ks_assert(bwresP);
+ ks_assert(status);
+
+ ks_pool_open(&pool);
+ ks_assert(pool);
+
+ bwres = ks_pool_alloc(pool, sizeof(blade_webresponse_t));
+
+ bwres->status_code = ks_pstrdup(pool, status);
+ bwres->status_message = ks_pstrdup(pool, mg_get_response_code_text(NULL, atoi(status)));
+
+ ks_hash_create(&bwres->headers, KS_HASH_MODE_CASE_INSENSITIVE, KS_HASH_FLAG_NOLOCK | KS_HASH_FLAG_DUP_CHECK | KS_HASH_FLAG_FREE_KEY | KS_HASH_FLAG_FREE_VALUE, pool);
+ ks_assert(bwres->headers);
+
+ ks_sb_create(&bwres->content, pool, 0);
+ ks_assert(bwres->content);
+
+ ks_pool_set_cleanup(bwres, NULL, blade_webresponse_cleanup);
+
+ *bwresP = bwres;
+
+ blade_webresponse_header_add(bwres, "Content-Type", "application/x-www-form-urlencoded");
+
+ return KS_STATUS_SUCCESS;
+}
+
+KS_DECLARE(ks_status_t) blade_webresponse_load(blade_webresponse_t **bwresP, struct mg_connection *conn)
+{
+ ks_status_t ret = KS_STATUS_SUCCESS;
+ ks_pool_t *pool = NULL;
+ blade_webresponse_t *bwres = NULL;
+ struct mg_request_info *info = NULL;
+ char buf[1024];
+ int bytes = 0;
+
+ ks_assert(bwresP);
+ ks_assert(conn);
+
+ info = mg_get_request_info(conn);
+
+ ks_pool_open(&pool);
+ ks_assert(pool);
+
+ bwres = ks_pool_alloc(pool, sizeof(blade_webrequest_t));
+
+ bwres->status_code = ks_pstrdup(pool, info->request_uri);
+ bwres->status_message = ks_pstrdup(pool, info->http_version);
+
+ ks_hash_create(&bwres->headers, KS_HASH_MODE_CASE_INSENSITIVE, KS_HASH_FLAG_NOLOCK | KS_HASH_FLAG_DUP_CHECK | KS_HASH_FLAG_FREE_KEY | KS_HASH_FLAG_FREE_VALUE, pool);
+ ks_assert(bwres->headers);
+
+ ks_sb_create(&bwres->content, pool, 0);
+ ks_assert(bwres->content);
+
+ ks_pool_set_cleanup(bwres, NULL, blade_webresponse_cleanup);
+
+ for (int index = 0; index < info->num_headers; ++index) {
+ struct mg_header *header = &info->http_headers[index];
+ ks_hash_insert(bwres->headers, (void *)ks_pstrdup(pool, header->name), (void *)ks_pstrdup(pool, header->value));
+ }
+
+ while ((bytes = mg_read(conn, buf, sizeof(buf))) > 0) ks_sb_append_ex(bwres->content, buf, bytes);
+ if (bytes < 0) {
+ blade_webresponse_destroy(&bwres);
+ ret = KS_STATUS_FAIL;
+ }
+ else *bwresP = bwres;
+
+ return ret;
+}
+
+KS_DECLARE(ks_status_t) blade_webresponse_destroy(blade_webresponse_t **bwresP)
+{
+ blade_webresponse_t *bwres = NULL;
+ ks_pool_t *pool;
+
+ ks_assert(bwresP);
+ ks_assert(*bwresP);
+
+ bwres = *bwresP;
+ *bwresP = NULL;
+
+ pool = ks_pool_get(bwres);
+
+ ks_pool_close(&pool);
+
+ return KS_STATUS_SUCCESS;
+}
+
+KS_DECLARE(ks_status_t) blade_webresponse_header_add(blade_webresponse_t *bwres, const char *header, const char *value)
+{
+ ks_assert(bwres);
+ ks_assert(header);
+ ks_assert(value);
+
+ ks_hash_insert(bwres->headers, (void *)ks_pstrdup(ks_pool_get(bwres), header), (void *)ks_pstrdup(ks_pool_get(bwres), value));
+
+ return KS_STATUS_SUCCESS;
+}
+
+KS_DECLARE(const char *) blade_webresponse_header_get(blade_webresponse_t *bwres, const char *header)
+{
+ ks_assert(bwres);
+ ks_assert(header);
+
+ return (const char *)ks_hash_search(bwres->headers, (void *)header, KS_UNLOCKED);
+}
+
+KS_DECLARE(ks_status_t) blade_webresponse_content_json_append(blade_webresponse_t *bwres, cJSON *json)
+{
+ ks_assert(bwres);
+ ks_assert(json);
+
+ blade_webresponse_header_add(bwres, "Content-Type", "application/json");
+
+ ks_sb_json(bwres->content, json);
+
+ return KS_STATUS_SUCCESS;
+}
+
+KS_DECLARE(ks_status_t) blade_webresponse_content_string_append(blade_webresponse_t *bwres, const char *str)
+{
+ ks_assert(bwres);
+ ks_assert(str);
+
+ ks_sb_append(bwres->content, str);
+
+ return KS_STATUS_SUCCESS;
+}
+
+KS_DECLARE(ks_status_t) blade_webresponse_content_json_get(blade_webresponse_t *bwres, cJSON **json)
+{
+ ks_status_t ret = KS_STATUS_SUCCESS;
+
+ ks_assert(bwres);
+ ks_assert(json);
+
+ if (!(*json = cJSON_Parse(ks_sb_cstr(bwres->content)))) ret = KS_STATUS_FAIL;
+
+ return ret;
+}
+
+KS_DECLARE(ks_status_t) blade_webresponse_send(blade_webresponse_t *bwres, struct mg_connection *conn)
+{
+ ks_assert(bwres);
+ ks_assert(conn);
+
+ mg_printf(conn,
+ "HTTP/1.1 %s %s\r\n"
+ "Content-Length: %lu\r\n"
+ "Connection: close\r\n",
+ bwres->status_code,
+ bwres->status_message,
+ ks_sb_length(bwres->content));
+
+ for (ks_hash_iterator_t *it = ks_hash_first(bwres->headers, KS_UNLOCKED); it; it = ks_hash_next(&it)) {
+ const char *key;
+ const char *value;
+
+ ks_hash_this(it, (const void **)&key, NULL, (void **)&value);
+ mg_printf(conn, "%s: %s\r\n", key, value);
+ }
+
+ mg_write(conn, "\r\n", 2);
+
+ mg_write(conn, ks_sb_cstr(bwres->content), ks_sb_length(bwres->content));
+
+ return KS_STATUS_SUCCESS;
+}
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet:
+ */
--- /dev/null
+/*
+ * Copyright (c) 2017, Shane Bryldt
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _BLADE_WEB_H_
+#define _BLADE_WEB_H_
+#include <blade.h>
+
+KS_BEGIN_EXTERN_C
+KS_DECLARE(ks_status_t) blade_webrequest_create(blade_webrequest_t **bwreqP, const char *action, const char *path);
+KS_DECLARE(ks_status_t) blade_webrequest_load(blade_webrequest_t **bwreqP, struct mg_connection *conn);
+KS_DECLARE(ks_status_t) blade_webrequest_destroy(blade_webrequest_t **bwreqP);
+KS_DECLARE(const char *) blade_webrequest_action_get(blade_webrequest_t *bwreq);
+KS_DECLARE(const char *) blade_webrequest_path_get(blade_webrequest_t *bwreq);
+KS_DECLARE(ks_status_t) blade_webrequest_query_add(blade_webrequest_t *bwreq, const char *name, const char *value);
+KS_DECLARE(const char *) blade_webrequest_query_get(blade_webrequest_t *bwreq, const char *name);
+KS_DECLARE(ks_status_t) blade_webrequest_header_add(blade_webrequest_t *bwreq, const char *header, const char *value);
+KS_DECLARE(ks_status_t) blade_webrequest_header_printf(blade_webrequest_t *bwreq, const char *header, const char *fmt, ...);
+KS_DECLARE(const char *) blade_webrequest_header_get(blade_webrequest_t *bwreq, const char *header);
+KS_DECLARE(ks_status_t) blade_webrequest_content_json_append(blade_webrequest_t *bwreq, cJSON *json);
+KS_DECLARE(ks_status_t) blade_webrequest_content_string_append(blade_webrequest_t *bwreq, const char *str);
+KS_DECLARE(ks_status_t) blade_webrequest_send(blade_webrequest_t *bwreq, ks_bool_t secure, const char *host, ks_port_t port, blade_webresponse_t **bwresP);
+
+KS_DECLARE(ks_status_t) blade_webrequest_oauth2_token_by_credentials_send(ks_bool_t secure, const char *host, ks_port_t port, const char *path, const char *client_id, const char *client_secret, const char **token);
+KS_DECLARE(ks_status_t) blade_webrequest_oauth2_token_by_code_send(ks_bool_t secure, const char *host, ks_port_t port, const char *path, const char *client_id, const char *client_secret, const char *code, const char **token);
+
+
+KS_DECLARE(ks_status_t) blade_webresponse_create(blade_webresponse_t **bwresP, const char *status);
+KS_DECLARE(ks_status_t) blade_webresponse_load(blade_webresponse_t **bwresP, struct mg_connection *conn);
+KS_DECLARE(ks_status_t) blade_webresponse_destroy(blade_webresponse_t **bwresP);
+KS_DECLARE(ks_status_t) blade_webresponse_header_add(blade_webresponse_t *bwres, const char *header, const char *value);
+KS_DECLARE(const char *) blade_webresponse_header_get(blade_webresponse_t *bwres, const char *header);
+KS_DECLARE(ks_status_t) blade_webresponse_content_json_append(blade_webresponse_t *bwres, cJSON *json);
+KS_DECLARE(ks_status_t) blade_webresponse_content_string_append(blade_webresponse_t *bwres, const char *str);
+KS_DECLARE(ks_status_t) blade_webresponse_content_json_get(blade_webresponse_t *bwres, cJSON **json);
+KS_DECLARE(ks_status_t) blade_webresponse_send(blade_webresponse_t *bwres, struct mg_connection *conn);
+
+KS_END_EXTERN_C
+
+#endif
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet:
+ */
projects / thirdparty / freeswitch.git / commitdiff
