Add esp_http_client

Add error handling for http client

set ssid password correct with Example_WIFI test, and clear password before free

Fixed the CI failure due to HTTP errror names

components/esp_http_client/lib/http_auth.c

@@ -0,0 +1,151 @@
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#include "tcpip_adapter.h"
+#include "lwip/sockets.h"
+#include "rom/md5_hash.h"
+#include "mbedtls/base64.h"
+
+#include "esp_system.h"
+#include "esp_log.h"
+
+#include "http_utils.h"
+#include "http_auth.h"
+
+#define MD5_MAX_LEN (33)
+#define HTTP_AUTH_BUF_LEN (1024)
+
+static const char *TAG = "HTTP_AUTH";
+
+/**
+ * @brief      This function hash a formatted string with MD5 and format the result as ascii characters
+ *
+ * @param      md         The buffer will hold the ascii result
+ * @param[in]  fmt        The format
+ *
+ * @return     Length of the result
+ */
+static int md5_printf(char *md, const char *fmt, ...)
+{
+    unsigned char *buf;
+    unsigned char digest[MD5_MAX_LEN];
+    int len, i;
+    struct MD5Context md5_ctx;
+    va_list ap;
+    va_start(ap, fmt);
+    len = vasprintf((char **)&buf, fmt, ap);
+    if (buf == NULL) {
+        return -1;
+    }
+
+    MD5Init(&md5_ctx);
+    MD5Update(&md5_ctx, buf, len);
+    MD5Final(digest, &md5_ctx);
+
+    for (i = 0; i < 16; ++i) {
+        sprintf(&md[i * 2], "%02x", (unsigned int)digest[i]);
+    }
+    va_end(ap);
+
+    free(buf);
+    return MD5_MAX_LEN;
+}
+
+char *http_auth_digest(const char *username, const char *password, esp_http_auth_data_t *auth_data)
+{
+    char *ha1, *ha2 = NULL;
+    char *digest = NULL;
+    char *auth_str = NULL;
+
+    if (username == NULL ||
+        password == NULL ||
+        auth_data->nonce == NULL ||
+        auth_data->uri == NULL ||
+        auth_data->realm == NULL) {
+        return NULL;
+    }
+
+    ha1 = calloc(1, MD5_MAX_LEN);
+    HTTP_MEM_CHECK(TAG, ha1, goto _digest_exit);
+
+    ha2 = calloc(1, MD5_MAX_LEN);
+    HTTP_MEM_CHECK(TAG, ha2, goto _digest_exit);
+
+    digest = calloc(1, MD5_MAX_LEN);
+    HTTP_MEM_CHECK(TAG, digest, goto _digest_exit);
+
+    if (md5_printf(ha1, "%s:%s:%s", username, auth_data->realm, password) <= 0) {
+        goto _digest_exit;
+    }
+
+    ESP_LOGD(TAG, "%s %s %s %s\r\n", "Digest", username, auth_data->realm, password);
+    if (strcasecmp(auth_data->algorithm, "md5-sess") == 0) {
+        if (md5_printf(ha1, "%s:%s:%016llx", ha1, auth_data->nonce, auth_data->cnonce) <= 0) {
+            goto _digest_exit;
+        }
+    }
+    if (md5_printf(ha2, "%s:%s", auth_data->method, auth_data->uri) <= 0) {
+        goto _digest_exit;
+    }
+
+    //support qop = auth
+    if (auth_data->qop && strcasecmp(auth_data->qop, "auth-int") == 0) {
+        if (md5_printf(ha2, "%s:%s", ha2, "entity") <= 0) {
+            goto _digest_exit;
+        }
+    }
+
+    if (auth_data->qop) {
+        // response=MD5(HA1:nonce:nonceCount:cnonce:qop:HA2)
+        if (md5_printf(digest, "%s:%s:%08x:%016llx:%s:%s", ha1, auth_data->nonce, auth_data->nc, auth_data->cnonce, auth_data->qop, ha2) <= 0) {
+            goto _digest_exit;
+        }
+    } else {
+        // response=MD5(HA1:nonce:HA2)
+        if (md5_printf(digest, "%s:%s:%s", ha1, auth_data->nonce, ha2) <= 0) {
+            goto _digest_exit;
+        }
+    }
+    asprintf(&auth_str, "Digest username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", algorithm=\"MD5\", "
+             "response=\"%s\", opaque=\"%s\", qop=%s, nc=%08x, cnonce=\"%016llx\"",
+             username, auth_data->realm, auth_data->nonce, auth_data->uri, digest, auth_data->opaque, auth_data->qop, auth_data->nc, auth_data->cnonce);
+_digest_exit:
+    free(ha1);
+    free(ha2);
+    free(digest);
+    return auth_str;
+}
+
+char *http_auth_basic(const char *username, const char *password)
+{
+    int out;
+    char *user_info = NULL;
+    char *digest = calloc(1, MD5_MAX_LEN + 7);
+    HTTP_MEM_CHECK(TAG, digest, goto _basic_exit);
+    asprintf(&user_info, "%s:%s", username, password);
+    HTTP_MEM_CHECK(TAG, user_info, goto _basic_exit);
+    if (user_info == NULL) {
+        goto _basic_exit;
+    }
+    strcpy(digest, "Basic ");
+    mbedtls_base64_encode((unsigned char *)digest + 6, MD5_MAX_LEN, (size_t *)&out, (const unsigned char *)user_info, strlen(user_info));
+_basic_exit:
+    free(user_info);
+    return digest;
+}

components/esp_http_client/lib/http_header.c

@@ -0,0 +1,239 @@
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include "esp_log.h"
+#include "http_header.h"
+#include "http_utils.h"
+
+static const char *TAG = "HTTP_HEADER";
+#define HEADER_BUFFER (1024)
+
+/**
+ * dictionary item struct, with key-value pair
+ */
+typedef struct http_header_item {
+    char *key;                          /*!< key */
+    char *value;                        /*!< value */
+    STAILQ_ENTRY(http_header_item) next;   /*!< Point to next entry */
+} http_header_item_t;
+
+STAILQ_HEAD(http_header, http_header_item);
+
+
+http_header_handle_t http_header_init()
+{
+    http_header_handle_t header = calloc(1, sizeof(struct http_header));
+    HTTP_MEM_CHECK(TAG, header, return NULL);
+    STAILQ_INIT(header);
+    return header;
+}
+
+esp_err_t http_header_destroy(http_header_handle_t header)
+{
+    esp_err_t err = http_header_clean(header);
+    free(header);
+    return err;
+}
+
+http_header_item_handle_t http_header_get_item(http_header_handle_t header, const char *key)
+{
+    http_header_item_handle_t item;
+    if (header == NULL || key == NULL) {
+        return NULL;
+    }
+    STAILQ_FOREACH(item, header, next) {
+        if (strcasecmp(item->key, key) == 0) {
+            return item;
+        }
+    }
+    return NULL;
+}
+
+esp_err_t http_header_get(http_header_handle_t header, const char *key, char **value)
+{
+    http_header_item_handle_t item;
+
+    item = http_header_get_item(header, key);
+    if (item) {
+        *value = item->value;
+    } else {
+        *value = NULL;
+    }
+
+    return ESP_OK;
+}
+
+static esp_err_t http_header_new_item(http_header_handle_t header, const char *key, const char *value)
+{
+    http_header_item_handle_t item;
+
+    item = calloc(1, sizeof(http_header_item_t));
+    HTTP_MEM_CHECK(TAG, item, return ESP_ERR_NO_MEM);
+    http_utils_assign_string(&item->key, key, 0);
+    HTTP_MEM_CHECK(TAG, item->key, goto _header_new_item_exit);
+    http_utils_trim_whitespace(&item->key);
+    http_utils_assign_string(&item->value, value, 0);
+    HTTP_MEM_CHECK(TAG, item->value, goto _header_new_item_exit);
+    http_utils_trim_whitespace(&item->value);
+    STAILQ_INSERT_TAIL(header, item, next);
+    return ESP_OK;
+_header_new_item_exit:
+    free(item->key);
+    free(item->value);
+    return ESP_ERR_NO_MEM;
+}
+
+esp_err_t http_header_set(http_header_handle_t header, const char *key, const char *value)
+{
+    http_header_item_handle_t item;
+
+    if (value == NULL) {
+        return http_header_delete(header, key);
+    }
+
+    item = http_header_get_item(header, key);
+
+    if (item) {
+        free(item->value);
+        item->value = strdup(value);
+        http_utils_trim_whitespace(&item->value);
+        return ESP_OK;
+    }
+    return http_header_new_item(header, key, value);
+}
+
+esp_err_t http_header_set_from_string(http_header_handle_t header, const char *key_value_data)
+{
+    char *eq_ch;
+    char *p_str;
+
+    p_str = strdup(key_value_data);
+    HTTP_MEM_CHECK(TAG, p_str, return ESP_ERR_NO_MEM);
+    eq_ch = strchr(p_str, ':');
+    if (eq_ch == NULL) {
+        free(p_str);
+        return ESP_ERR_INVALID_ARG;
+    }
+    *eq_ch = 0;
+
+    http_header_set(header, p_str, eq_ch + 1);
+    free(p_str);
+    return ESP_OK;
+}
+
+
+esp_err_t http_header_delete(http_header_handle_t header, const char *key)
+{
+    http_header_item_handle_t item = http_header_get_item(header, key);
+    if (item) {
+        STAILQ_REMOVE(header, item, http_header_item, next);
+        free(item->key);
+        free(item->value);
+        free(item);
+    } else {
+        return ESP_ERR_NOT_FOUND;
+    }
+    return ESP_OK;
+}
+
+
+int http_header_set_format(http_header_handle_t header, const char *key, const char *format, ...)
+{
+    va_list argptr;
+    int len = 0;
+    char *buf = NULL;
+    va_start(argptr, format);
+    len = vasprintf(&buf, format, argptr);
+    HTTP_MEM_CHECK(TAG, buf, return 0);
+    va_end(argptr);
+    if (buf == NULL) {
+        return 0;
+    }
+    http_header_set(header, key, buf);
+    free(buf);
+    return len;
+}
+
+int http_header_generate_string(http_header_handle_t header, int index, char *buffer, int *buffer_len)
+{
+    http_header_item_handle_t item;
+    int siz = 0;
+    int idx = 0;
+    int ret_idx = -1;
+    bool is_end = false;
+    STAILQ_FOREACH(item, header, next) {
+        if (item->value && idx >= index) {
+            siz += strlen(item->key);
+            siz += strlen(item->value);
+            siz += 4; //': ' and '\r\n'
+        }
+        idx ++;
+
+        if (siz + 1 > *buffer_len - 2) {
+            ret_idx = idx - 1;
+        }
+    }
+
+    if (siz == 0) {
+        return 0;
+    }
+    if (ret_idx < 0) {
+        ret_idx = idx;
+        is_end = true;
+    }
+
+    int str_len = 0;
+    idx = 0;
+    STAILQ_FOREACH(item, header, next) {
+        if (item->value && idx >= index && idx < ret_idx) {
+            str_len += snprintf(buffer + str_len, *buffer_len - str_len, "%s: %s\r\n", item->key, item->value);
+        }
+        idx ++;
+    }
+    if (is_end) {
+        str_len += snprintf(buffer + str_len, *buffer_len - str_len, "\r\n");
+    }
+    *buffer_len = str_len;
+    return ret_idx;
+}
+
+esp_err_t http_header_clean(http_header_handle_t header)
+{
+    http_header_item_handle_t item = STAILQ_FIRST(header), tmp;
+    while (item != NULL) {
+        tmp = STAILQ_NEXT(item, next);
+        free(item->key);
+        free(item->value);
+        free(item);
+        item = tmp;
+    }
+    STAILQ_INIT(header);
+    return ESP_OK;
+}
+
+int http_header_count(http_header_handle_t header)
+{
+    http_header_item_handle_t item;
+    int count = 0;
+    STAILQ_FOREACH(item, header, next) {
+        count ++;
+    }
+    return count;
+}

components/esp_http_client/lib/http_utils.c

@@ -0,0 +1,125 @@
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+
+#include "http_utils.h"
+
+#ifndef mem_check
+#define mem_check(x) assert(x)
+#endif
+
+char *http_utils_join_string(const char *first_str, int len_first, const char *second_str, int len_second)
+{
+    int first_str_len = len_first > 0 ? len_first : strlen(first_str);
+    int second_str_len = len_second > 0 ? len_second : strlen(second_str);
+    char *ret = NULL;
+    if (first_str_len + second_str_len > 0) {
+        ret = calloc(1, first_str_len + second_str_len + 1);
+        mem_check(ret);
+        memcpy(ret, first_str, first_str_len);
+        memcpy(ret + first_str_len, second_str, second_str_len);
+    }
+    return ret;
+}
+
+char *http_utils_assign_string(char **str, const char *new_str, int len)
+{
+    int l = len;
+    if (new_str == NULL) {
+        return NULL;
+    }
+    char *old_str = *str;
+    if (l <= 0) {
+        l = strlen(new_str);
+    }
+    if (old_str) {
+        old_str = realloc(old_str, l + 1);
+        mem_check(old_str);
+        old_str[l] = 0;
+    } else {
+        old_str = calloc(1, l + 1);
+        mem_check(old_str);
+    }
+    memcpy(old_str, new_str, l);
+    *str = old_str;
+    return old_str;
+}
+
+void http_utils_trim_whitespace(char **str)
+{
+    char *end;
+    char *start = *str;
+    // Trim leading space
+    while (isspace((unsigned char)*start)) start ++;
+
+    if (*start == 0) {  // All spaces?
+        **str = 0;
+        return;
+    }
+
+    // Trim trailing space
+    end = (char *)(start + strlen(start) - 1);
+    while (end > start && isspace((unsigned char)*end)) {
+        end--;
+    }
+
+    // Write new null terminator
+    *(end + 1) = 0;
+    memmove(*str, start, strlen(start) + 1);
+}
+
+char *http_utils_get_string_between(const char *str, const char *begin, const char *end)
+{
+    char *found = strstr(str, begin);
+    char *ret = NULL;
+    if (found) {
+        found += strlen(begin);
+        char *found_end = strstr(found, end);
+        if (found_end) {
+            ret = calloc(1, found_end - found + 1);
+            mem_check(ret);
+            memcpy(ret, found, found_end - found);
+            return ret;
+        }
+    }
+    return NULL;
+}
+
+int http_utils_str_starts_with(const char *str, const char *start)
+{
+    int i;
+    int match_str_len = strlen(str);
+    int start_len = strlen(start);
+
+    if (start_len > match_str_len) {
+        return -1;
+    }
+    for (i = 0; i < start_len; i++) {
+        if (str[i] != start[i]) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+void http_utils_ms_to_timeval(int timeout_ms, struct timeval *tv)
+{
+    tv->tv_sec = timeout_ms / 1000;
+    tv->tv_usec = (timeout_ms - (tv->tv_sec * 1000)) * 1000;
+}

components/esp_http_client/lib/include/http_auth.h

@@ -0,0 +1,60 @@
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+#ifndef _HTTP_BASIC_AUTH_H_
+#define _HTTP_BASIC_AUTH_H_
+
+/**
+ * HTTP Digest authentication data
+ */
+typedef struct {
+    char *method;       /*!< Request method, example: GET */
+    char *algorithm;    /*!< Authentication algorithm */
+    char *uri;          /*!< URI of request example: /path/to/file.html */
+    char *realm;        /*!< Authentication realm */
+    char *nonce;        /*!< Authentication nonce */
+    char *qop;          /*!< Authentication qop */
+    char *opaque;       /*!< Authentication opaque */
+    uint64_t cnonce;    /*!< Authentication cnonce */
+    int nc;             /*!< Authentication nc */
+} esp_http_auth_data_t;
+
+/**
+ * @brief      This use for Http digest authentication method, create http header for digest authentication.
+ *             The returned string need to free after use
+ *
+ * @param[in]  username   The username
+ * @param[in]  password   The password
+ * @param      auth_data  The auth data
+ *
+ * @return
+ *     - HTTP Header value of Authorization, valid for digest authentication, must be freed after usage
+ *     - NULL
+ */
+char *http_auth_digest(const char *username, const char *password, esp_http_auth_data_t *auth_data);
+
+/**
+ * @brief      This use for Http basic authentication method, create header value for basic http authentication
+ *            The returned string need to free after use
+ *
+ * @param[in]  username  The username
+ * @param[in]  password  The password
+ *
+ * @return
+ *     - HTTP Header value of Authorization, valid for basic authentication, must be free after use
+ *     - NULL
+ */
+char *http_auth_basic(const char *username, const char *password);
+#endif

components/esp_http_client/lib/include/http_header.h

@@ -0,0 +1,128 @@
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef _HTTP_HEADER_H_
+#define _HTTP_HEADER_H_
+
+#include "rom/queue.h"
+#include "esp_err.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct http_header *http_header_handle_t;
+typedef struct http_header_item *http_header_item_handle_t;
+
+/**
+ * @brief      initialize and allocate the memory for the header object
+ *
+ * @return
+ *     - http_header_handle_t
+ *     - NULL if any errors
+ */
+http_header_handle_t http_header_init();
+
+/**
+ * @brief      Cleanup and free all http header pairs
+ *
+ * @param[in]  header  The header
+ *
+ * @return
+ *     - ESP_OK
+ *     - ESP_FAIL
+ */
+esp_err_t http_header_clean(http_header_handle_t header);
+
+/**
+ * @brief      Cleanup with http_header_clean and destroy http header handle object
+ *
+ * @param[in]  header  The header
+ *
+ * @return
+ *     - ESP_OK
+ *     - ESP_FAIL
+ */
+esp_err_t http_header_destroy(http_header_handle_t header);
+
+/**
+ * @brief      Add a key-value pair of http header to the list,
+ *             note that with value = NULL, this function will remove the header with `key` already exists in the list.
+ *
+ * @param[in]  header  The header
+ * @param[in]  key     The key
+ * @param[in]  value   The value
+ *
+ * @return
+ *     - ESP_OK
+ *     - ESP_FAIL
+ */
+esp_err_t http_header_set(http_header_handle_t header, const char *key, const char *value);
+
+/**
+ * @brief      Sample as `http_header_set` but the value can be formated
+ *
+ * @param[in]  header     The header
+ * @param[in]  key        The key
+ * @param[in]  format     The format
+ * @param[in]  ...        format parameters
+ *
+ * @return     Total length of value
+ */
+int http_header_set_format(http_header_handle_t header, const char *key, const char *format, ...);
+
+/**
+ * @brief      Get a value of header in header list
+ *             The address of the value will be assign set to `value` parameter or NULL if no header with the key exists in the list
+ *
+ * @param[in]  header  The header
+ * @param[in]  key     The key
+ * @param[out] value   The value
+ *
+ * @return
+ *     - ESP_OK
+ *     - ESP_FAIL
+ */
+esp_err_t http_header_get(http_header_handle_t header, const char *key, char **value);
+
+/**
+ * @brief      Create HTTP header string from the header with index, output string to buffer with buffer_len
+ *             Also return the last index of header was generated
+ *
+ * @param[in]  header      The header
+ * @param[in]  index       The index
+ * @param      buffer      The buffer
+ * @param      buffer_len  The buffer length
+ *
+ * @return     The last index of header was generated
+ */
+int http_header_generate_string(http_header_handle_t header, int index, char *buffer, int *buffer_len);
+
+/**
+ * @brief      Remove the header with key from the headers list
+ *
+ * @param[in]  header  The header
+ * @param[in]  key     The key
+ *
+ * @return
+ *     - ESP_OK
+ *     - ESP_FAIL
+ */
+esp_err_t http_header_delete(http_header_handle_t header, const char *key);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

components/esp_http_client/lib/include/http_utils.h

@@ -0,0 +1,95 @@
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+#ifndef _HTTP_UTILS_H_
+#define _HTTP_UTILS_H_
+#include <sys/time.h>
+/**
+ * @brief      Assign new_str to *str pointer, and realloc *str if it not NULL
+ *
+ * @param      str      pointer to string pointer
+ * @param      new_str  assign this tring to str
+ * @param      len      length of string, 0 if new_str is zero terminated
+ *
+ * @return
+ *  - new_str pointer
+ *  - NULL
+ */
+char *http_utils_assign_string(char **str, const char *new_str, int len);
+
+/**
+ * @brief      Remove white space at begin and end of string
+ *
+ * @param[in]  str   The string
+ *
+ * @return     New strings have been trimmed
+ */
+void http_utils_trim_whitespace(char **str);
+
+/**
+ * @brief      Gets the string between 2 string.
+ *             It will allocate a new memory space for this string, so you need to free it when no longer use
+ *
+ * @param[in]  str    The source string
+ * @param[in]  begin  The begin string
+ * @param[in]  end    The end string
+ *
+ * @return     The string between begin and end
+ */
+char *http_utils_get_string_between(const char *str, const char *begin, const char *end);
+
+/**
+ * @brief      Join 2 strings to one
+ *             It will allocate a new memory space for this string, so you need to free it when no longer use
+ *
+ * @param[in]  first_str   The first string
+ * @param[in]  len_first   The length first
+ * @param[in]  second_str  The second string
+ * @param[in]  len_second  The length second
+ *
+ * @return
+ * - New string pointer
+ * - NULL: Invalid input
+ */
+char *http_utils_join_string(const char *first_str, int len_first, const char *second_str, int len_second);
+
+/**
+ * @brief      Check if ``str`` is start with ``start``
+ *
+ * @param[in]  str    The string
+ * @param[in]  start  The start
+ *
+ * @return
+ *     - (-1) if length of ``start`` larger than length of ``str``
+ *     - (1) if ``start`` NOT starts with ``start``
+ *     - (0) if ``str`` starts with ``start``
+ */
+int http_utils_str_starts_with(const char *str, const char *start);
+
+/**
+ * @brief      Convert milliseconds to timeval struct
+ *
+ * @param[in]  timeout_ms  The timeout milliseconds
+ * @param[out] tv          Timeval struct
+ */
+void http_utils_ms_to_timeval(int timeout_ms, struct timeval *tv);
+
+#define HTTP_MEM_CHECK(TAG, a, action) if (!(a)) {                                                      \
+        ESP_LOGE(TAG,"%s:%d (%s): %s", __FILE__, __LINE__, __FUNCTION__, "Memory exhausted");       \
+        action;                                                                                         \
+        }
+
+
+#endif

components/esp_http_client/lib/include/transport.h

@@ -0,0 +1,251 @@
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef _TRANSPORT_H_
+#define _TRANSPORT_H_
+
+#include <esp_err.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef struct transport_list_t* transport_list_handle_t;
+typedef struct transport_item_t* transport_handle_t;
+
+typedef int (*connect_func)(transport_handle_t t, const char *host, int port, int timeout_ms);
+typedef int (*io_func)(transport_handle_t t, const char *buffer, int len, int timeout_ms);
+typedef int (*io_read_func)(transport_handle_t t, char *buffer, int len, int timeout_ms);
+typedef int (*trans_func)(transport_handle_t t);
+typedef int (*poll_func)(transport_handle_t t, int timeout_ms);
+
+/**
+ * @brief      Create transport list
+ *
+ * @return     A handle can hold all transports
+ */
+transport_list_handle_t transport_list_init();
+
+/**
+ * @brief      Cleanup and free all transports, include itself,
+ *             this function will invoke transport_destroy of every transport have added this the list
+ *
+ * @param[in]  list  The list
+ *
+ * @return
+ *     - ESP_OK
+ *     - ESP_FAIL
+ */
+esp_err_t transport_list_destroy(transport_list_handle_t list);
+
+/**
+ * @brief      Add a transport to the list, and define a scheme to indentify this transport in the list
+ *
+ * @param[in]  list    The list
+ * @param[in]  t       The Transport
+ * @param[in]  scheme  The scheme
+ *
+ * @return
+ *     - ESP_OK
+ */
+esp_err_t transport_list_add(transport_list_handle_t list, transport_handle_t t, const char *scheme);
+
+/**
+ * @brief      This function will remove all transport from the list,
+ *             invoke transport_destroy of every transport have added this the list
+ *
+ * @param[in]  list  The list
+ *
+ * @return
+ *     - ESP_OK
+ *     - ESP_ERR_INVALID_ARG
+ */
+esp_err_t transport_list_clean(transport_list_handle_t list);
+
+/**
+ * @brief      Get the transport by scheme, which has been defined when calling function `transport_list_add`
+ *
+ * @param[in]  list  The list
+ * @param[in]  tag   The tag
+ *
+ * @return     The transport handle
+ */
+transport_handle_t transport_list_get_transport(transport_list_handle_t list, const char *scheme);
+
+/**
+ * @brief      Initialize a transport handle object
+ *
+ * @return     The transport handle
+ */
+transport_handle_t transport_init();
+
+/**
+ * @brief      Cleanup and free memory the transport
+ *
+ * @param[in]  t     The transport handle
+ *
+ * @return
+ *     - ESP_OK
+ *     - ESP_FAIL
+ */
+esp_err_t transport_destroy(transport_handle_t t);
+
+/**
+ * @brief      Get default port number used by this transport
+ *
+ * @param[in]  t     The transport handle
+ *
+ * @return     the port number
+ */
+int transport_get_default_port(transport_handle_t t);
+
+/**
+ * @brief      Set default port number that can be used by this transport
+ *
+ * @param[in]  t     The transport handle
+ * @param[in]  port  The port number
+ *
+ * @return
+ *     - ESP_OK
+ *     - ESP_FAIL
+ */
+esp_err_t transport_set_default_port(transport_handle_t t, int port);
+
+/**
+ * @brief      Transport connection function, to make a connection to server
+ *
+ * @param      t           The transport handle
+ * @param[in]  host        Hostname
+ * @param[in]  port        Port
+ * @param[in]  timeout_ms  The timeout milliseconds
+ *
+ * @return
+ * - socket for will use by this transport
+ * - (-1) if there are any errors, should check errno
+ */
+int transport_connect(transport_handle_t t, const char *host, int port, int timeout_ms);
+
+/**
+ * @brief      Transport read function
+ *
+ * @param      t           The transport handle
+ * @param      buffer      The buffer
+ * @param[in]  len         The length
+ * @param[in]  timeout_ms  The timeout milliseconds
+ *
+ * @return
+ *  - Number of bytes was read
+ *  - (-1) if there are any errors, should check errno
+ */
+int transport_read(transport_handle_t t, char *buffer, int len, int timeout_ms);
+
+/**
+ * @brief      Poll the transport until readable or timeout
+ *
+ * @param[in]  t           The transport handle
+ * @param[in]  timeout_ms  The timeout milliseconds
+ *
+ * @return
+ *     - 0      Timeout
+ *     - (-1)   If there are any errors, should check errno
+ *     - other  The transport can read
+ */
+int transport_poll_read(transport_handle_t t, int timeout_ms);
+
+/**
+ * @brief      Transport write function
+ *
+ * @param      t           The transport handle
+ * @param      buffer      The buffer
+ * @param[in]  len         The length
+ * @param[in]  timeout_ms  The timeout milliseconds
+ *
+ * @return
+ *  - Number of bytes was written
+ *  - (-1) if there are any errors, should check errno
+ */
+int transport_write(transport_handle_t t, const char *buffer, int len, int timeout_ms);
+
+/**
+ * @brief      Poll the transport until writeable or timeout
+ *
+ * @param[in]  t           The transport handle
+ * @param[in]  timeout_ms  The timeout milliseconds
+ *
+ * @return
+ *     - 0      Timeout
+ *     - (-1)   If there are any errors, should check errno
+ *     - other  The transport can write
+ */
+int transport_poll_write(transport_handle_t t, int timeout_ms);
+
+/**
+ * @brief      Transport close
+ *
+ * @param      t     The transport handle
+ *
+ * @return
+ * - 0 if ok
+ * - (-1) if there are any errors, should check errno
+ */
+int transport_close(transport_handle_t t);
+
+/**
+ * @brief      Get user data context of this transport
+ *
+ * @param[in]  t        The transport handle
+ *
+ * @return     The user data context
+ */
+void *transport_get_context_data(transport_handle_t t);
+
+/**
+ * @brief      Set the user context data for this transport
+ *
+ * @param[in]  t        The transport handle
+ * @param      data     The user data context
+ *
+ * @return
+ *     - ESP_OK
+ */
+esp_err_t transport_set_context_data(transport_handle_t t, void *data);
+
+/**
+ * @brief      Set transport functions for the transport handle
+ *
+ * @param[in]  t            The transport handle
+ * @param[in]  _connect     The connect function pointer
+ * @param[in]  _read        The read function pointer
+ * @param[in]  _write       The write function pointer
+ * @param[in]  _close       The close function pointer
+ * @param[in]  _poll_read   The poll read function pointer
+ * @param[in]  _poll_write  The poll write function pointer
+ * @param[in]  _destroy     The destroy function pointer
+ *
+ * @return
+ *     - ESP_OK
+ */
+esp_err_t transport_set_func(transport_handle_t t,
+                             connect_func _connect,
+                             io_read_func _read,
+                             io_func _write,
+                             trans_func _close,
+                             poll_func _poll_read,
+                             poll_func _poll_write,
+                             trans_func _destroy);
+#ifdef __cplusplus
+}
+#endif
+#endif

components/esp_http_client/lib/include/transport_ssl.h

@@ -0,0 +1,48 @@
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef _TRANSPORT_SSL_H_
+#define _TRANSPORT_SSL_H_
+
+#include "transport.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @brief       Create new SSL transport, the transport handle must be release transport_destroy callback
+ *
+ * @return      the allocated transport_handle_t, or NULL if the handle can not be allocated
+ */
+transport_handle_t transport_ssl_init();
+
+/**
+ * @brief      Set SSL certificate data (as PEM format).
+ *             Note that, this function stores the pointer to data, rather than making a copy.
+ *             So we need to make sure to keep the data lifetime before cleanup the connection
+ *
+ * @param      t     ssl transport
+ * @param[in]  data  The pem data
+ * @param[in]  len   The length
+ */
+void transport_ssl_set_cert_data(transport_handle_t t, const char *data, int len);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+

components/esp_http_client/lib/include/transport_tcp.h

@@ -0,0 +1,36 @@
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef _TRANSPORT_TCP_H_
+#define _TRANSPORT_TCP_H_
+
+#include "transport.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief      Create TCP transport, the transport handle must be release transport_destroy callback
+ *
+ * @return  the allocated transport_handle_t, or NULL if the handle can not be allocated
+ */
+transport_handle_t transport_tcp_init();
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

components/esp_http_client/lib/transport.c

@@ -0,0 +1,232 @@
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "rom/queue.h"
+#include "esp_log.h"
+
+#include "transport.h"
+#include "http_utils.h"
+
+static const char *TAG = "TRANSPORT";
+
+/**
+ * Transport layer structure, which will provide functions, basic properties for transport types
+ */
+struct transport_item_t {
+    int             port;
+    int             socket;         /*!< Socket to use in this transport */
+    char            *scheme;        /*!< Tag name */
+    void            *context;       /*!< Context data */
+    void            *data;          /*!< Additional transport data */
+    connect_func    _connect;       /*!< Connect function of this transport */
+    io_read_func    _read;          /*!< Read */
+    io_func         _write;         /*!< Write */
+    trans_func      _close;         /*!< Close */
+    poll_func       _poll_read;     /*!< Poll and read */
+    poll_func       _poll_write;    /*!< Poll and write */
+    trans_func      _destroy;       /*!< Destroy and free transport */
+    STAILQ_ENTRY(transport_item_t) next;
+};
+
+
+/**
+ * This list will hold all transport available
+ */
+STAILQ_HEAD(transport_list_t, transport_item_t);
+
+
+transport_list_handle_t transport_list_init()
+{
+    transport_list_handle_t list = calloc(1, sizeof(struct transport_list_t));
+    HTTP_MEM_CHECK(TAG, list, return NULL);
+    STAILQ_INIT(list);
+    return list;
+}
+
+esp_err_t transport_list_add(transport_list_handle_t list, transport_handle_t t, const char *scheme)
+{
+    if (list == NULL || t == NULL) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    t->scheme = calloc(1, strlen(scheme) + 1);
+    HTTP_MEM_CHECK(TAG, t->scheme, return ESP_ERR_NO_MEM);
+    strcpy(t->scheme, scheme);
+    STAILQ_INSERT_TAIL(list, t, next);
+    return ESP_OK;
+}
+
+transport_handle_t transport_list_get_transport(transport_list_handle_t list, const char *scheme)
+{
+    if (!list) {
+        return NULL;
+    }
+    if (scheme == NULL) {
+        return STAILQ_FIRST(list);
+    }
+    transport_handle_t item;
+    STAILQ_FOREACH(item, list, next) {
+        if (strcasecmp(item->scheme, scheme) == 0) {
+            return item;
+        }
+    }
+    return NULL;
+}
+
+esp_err_t transport_list_destroy(transport_list_handle_t list)
+{
+    transport_list_clean(list);
+    free(list);
+    return ESP_OK;
+}
+
+esp_err_t transport_list_clean(transport_list_handle_t list)
+{
+    transport_handle_t item = STAILQ_FIRST(list);
+    transport_handle_t tmp;
+    while (item != NULL) {
+        tmp = STAILQ_NEXT(item, next);
+        if (item->_destroy) {
+            item->_destroy(item);
+        }
+        transport_destroy(item);
+        item = tmp;
+    }
+    STAILQ_INIT(list);
+    return ESP_OK;
+}
+
+transport_handle_t transport_init()
+{
+    transport_handle_t t = calloc(1, sizeof(struct transport_item_t));
+    HTTP_MEM_CHECK(TAG, t, return NULL);
+    return t;
+}
+
+esp_err_t transport_destroy(transport_handle_t t)
+{
+    if (t->scheme) {
+        free(t->scheme);
+    }
+    free(t);
+    return ESP_OK;
+}
+
+int transport_connect(transport_handle_t t, const char *host, int port, int timeout_ms)
+{
+    int ret = -1;
+    if (t && t->_connect) {
+        return t->_connect(t, host, port, timeout_ms);
+    }
+    return ret;
+}
+
+int transport_read(transport_handle_t t, char *buffer, int len, int timeout_ms)
+{
+    if (t && t->_read) {
+        return t->_read(t, buffer, len, timeout_ms);
+    }
+    return -1;
+}
+
+int transport_write(transport_handle_t t, const char *buffer, int len, int timeout_ms)
+{
+    if (t && t->_write) {
+        return t->_write(t, buffer, len, timeout_ms);
+    }
+    return -1;
+}
+
+int transport_poll_read(transport_handle_t t, int timeout_ms)
+{
+    if (t && t->_poll_read) {
+        return t->_poll_read(t, timeout_ms);
+    }
+    return -1;
+}
+
+int transport_poll_write(transport_handle_t t, int timeout_ms)
+{
+    if (t && t->_poll_write) {
+        return t->_poll_write(t, timeout_ms);
+    }
+    return -1;
+}
+
+int transport_close(transport_handle_t t)
+{
+    if (t && t->_close) {
+        return t->_close(t);
+    }
+    return 0;
+}
+
+void *transport_get_context_data(transport_handle_t t)
+{
+    if (t) {
+        return t->data;
+    }
+    return NULL;
+}
+
+esp_err_t transport_set_context_data(transport_handle_t t, void *data)
+{
+    if (t) {
+        t->data = data;
+        return ESP_OK;
+    }
+    return ESP_FAIL;
+}
+
+esp_err_t transport_set_func(transport_handle_t t,
+                             connect_func _connect,
+                             io_read_func _read,
+                             io_func _write,
+                             trans_func _close,
+                             poll_func _poll_read,
+                             poll_func _poll_write,
+                             trans_func _destroy)
+{
+    if (t == NULL) {
+        return ESP_FAIL;
+    }
+    t->_connect = _connect;
+    t->_read = _read;
+    t->_write = _write;
+    t->_close = _close;
+    t->_poll_read = _poll_read;
+    t->_poll_write = _poll_write;
+    t->_destroy = _destroy;
+    return ESP_OK;
+}
+
+int transport_get_default_port(transport_handle_t t)
+{
+    if (t == NULL) {
+        return -1;
+    }
+    return t->port;
+}
+
+esp_err_t transport_set_default_port(transport_handle_t t, int port)
+{
+    if (t == NULL) {
+        return ESP_FAIL;
+    }
+    t->port = port;
+    return ESP_OK;
+}

components/esp_http_client/lib/transport_ssl.c

@@ -0,0 +1,267 @@
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "lwip/err.h"
+#include "lwip/sockets.h"
+#include "lwip/sys.h"
+#include "lwip/netdb.h"
+#include "lwip/dns.h"
+
+#include "mbedtls/platform.h"
+#include "mbedtls/net_sockets.h"
+#include "mbedtls/esp_debug.h"
+#include "mbedtls/ssl.h"
+#include "mbedtls/entropy.h"
+#include "mbedtls/ctr_drbg.h"
+#include "mbedtls/error.h"
+#include "mbedtls/certs.h"
+
+
+#include "esp_log.h"
+#include "esp_system.h"
+
+#include "transport.h"
+#include "transport_ssl.h"
+#include "http_utils.h"
+
+static const char *TAG = "TRANS_SSL";
+/**
+ *  mbedtls specific transport data
+ */
+typedef struct {
+    mbedtls_entropy_context  entropy;
+    mbedtls_ctr_drbg_context ctr_drbg;
+    mbedtls_ssl_context      ctx;
+    mbedtls_x509_crt         cacert;
+    mbedtls_ssl_config       conf;
+    mbedtls_net_context      client_fd;
+    void                     *cert_pem_data;
+    int                      cert_pem_len;
+    bool                     ssl_initialized;
+    bool                     verify_server;
+} transport_ssl_t;
+
+static int ssl_close(transport_handle_t t);
+
+static int ssl_connect(transport_handle_t t, const char *host, int port, int timeout_ms)
+{
+    int ret = -1, flags;
+    struct timeval tv;
+    transport_ssl_t *ssl = transport_get_context_data(t);
+
+    if (!ssl) {
+        return -1;
+    }
+    ssl->ssl_initialized = true;
+    mbedtls_ssl_init(&ssl->ctx);
+    mbedtls_ctr_drbg_init(&ssl->ctr_drbg);
+    mbedtls_ssl_config_init(&ssl->conf);
+    mbedtls_entropy_init(&ssl->entropy);
+
+    if ((ret = mbedtls_ssl_config_defaults(&ssl->conf,
+                                           MBEDTLS_SSL_IS_CLIENT,
+                                           MBEDTLS_SSL_TRANSPORT_STREAM,
+                                           MBEDTLS_SSL_PRESET_DEFAULT)) != 0) {
+        ESP_LOGE(TAG, "mbedtls_ssl_config_defaults returned %d", ret);
+        goto exit;
+    }
+
+    if ((ret = mbedtls_ctr_drbg_seed(&ssl->ctr_drbg, mbedtls_entropy_func, &ssl->entropy, NULL, 0)) != 0) {
+        ESP_LOGE(TAG, "mbedtls_ctr_drbg_seed returned %d", ret);
+        goto exit;
+    }
+
+    if (ssl->cert_pem_data) {
+        mbedtls_x509_crt_init(&ssl->cacert);
+        ssl->verify_server = true;
+        if ((ret = mbedtls_x509_crt_parse(&ssl->cacert, ssl->cert_pem_data, ssl->cert_pem_len + 1)) < 0) {
+            ESP_LOGE(TAG, "mbedtls_x509_crt_parse returned -0x%x\n\nDATA=%s,len=%d", -ret, (char*)ssl->cert_pem_data, ssl->cert_pem_len);
+            goto exit;
+        }
+        mbedtls_ssl_conf_ca_chain(&ssl->conf, &ssl->cacert, NULL);
+        mbedtls_ssl_conf_authmode(&ssl->conf, MBEDTLS_SSL_VERIFY_REQUIRED);
+
+        if ((ret = mbedtls_ssl_set_hostname(&ssl->ctx, host)) != 0) {
+            ESP_LOGE(TAG, "mbedtls_ssl_set_hostname returned -0x%x", -ret);
+            goto exit;
+        }
+    } else {
+        mbedtls_ssl_conf_authmode(&ssl->conf, MBEDTLS_SSL_VERIFY_NONE);
+    }
+
+
+    mbedtls_ssl_conf_rng(&ssl->conf, mbedtls_ctr_drbg_random, &ssl->ctr_drbg);
+
+#ifdef CONFIG_MBEDTLS_DEBUG
+    mbedtls_esp_enable_debug_log(&ssl->conf, 4);
+#endif
+
+    if ((ret = mbedtls_ssl_setup(&ssl->ctx, &ssl->conf)) != 0) {
+        ESP_LOGE(TAG, "mbedtls_ssl_setup returned -0x%x\n\n", -ret);
+        goto exit;
+    }
+
+    mbedtls_net_init(&ssl->client_fd);
+
+    http_utils_ms_to_timeval(timeout_ms, &tv);
+
+    setsockopt(ssl->client_fd.fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+    ESP_LOGD(TAG, "Connect to %s:%d", host, port);
+    char port_str[8] = {0};
+    sprintf(port_str, "%d", port);
+    if ((ret = mbedtls_net_connect(&ssl->client_fd, host, port_str, MBEDTLS_NET_PROTO_TCP)) != 0) {
+        ESP_LOGE(TAG, "mbedtls_net_connect returned -%x", -ret);
+        goto exit;
+    }
+
+    mbedtls_ssl_set_bio(&ssl->ctx, &ssl->client_fd, mbedtls_net_send, mbedtls_net_recv, NULL);
+
+    if((ret = mbedtls_ssl_set_hostname(&ssl->ctx, host)) != 0) {
+        ESP_LOGE(TAG, " failed\n  ! mbedtls_ssl_set_hostname returned %d\n\n", ret);
+        goto exit;
+    }
+
+    ESP_LOGD(TAG, "Performing the SSL/TLS handshake...");
+
+    while ((ret = mbedtls_ssl_handshake(&ssl->ctx)) != 0) {
+        if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
+            ESP_LOGE(TAG, "mbedtls_ssl_handshake returned -0x%x", -ret);
+            goto exit;
+        }
+    }
+
+    ESP_LOGD(TAG, "Verifying peer X.509 certificate...");
+
+    if ((flags = mbedtls_ssl_get_verify_result(&ssl->ctx)) != 0) {
+        /* In real life, we probably want to close connection if ret != 0 */
+        ESP_LOGW(TAG, "Failed to verify peer certificate!");
+        if (ssl->cert_pem_data) {
+            goto exit;
+        }
+    } else {
+        ESP_LOGD(TAG, "Certificate verified.");
+    }
+
+    ESP_LOGD(TAG, "Cipher suite is %s", mbedtls_ssl_get_ciphersuite(&ssl->ctx));
+    return ret;
+exit:
+    ssl_close(t);
+    return ret;
+}
+
+static int ssl_poll_read(transport_handle_t t, int timeout_ms)
+{
+    transport_ssl_t *ssl = transport_get_context_data(t);
+    fd_set readset;
+    FD_ZERO(&readset);
+    FD_SET(ssl->client_fd.fd, &readset);
+    struct timeval timeout;
+    http_utils_ms_to_timeval(timeout_ms, &timeout);
+
+    return select(ssl->client_fd.fd + 1, &readset, NULL, NULL, &timeout);
+}
+
+static int ssl_poll_write(transport_handle_t t, int timeout_ms)
+{
+    transport_ssl_t *ssl = transport_get_context_data(t);
+    fd_set writeset;
+    FD_ZERO(&writeset);
+    FD_SET(ssl->client_fd.fd, &writeset);
+    struct timeval timeout;
+    http_utils_ms_to_timeval(timeout_ms, &timeout);
+    return select(ssl->client_fd.fd + 1, NULL, &writeset, NULL, &timeout);
+}
+
+static int ssl_write(transport_handle_t t, const char *buffer, int len, int timeout_ms)
+{
+    int poll, ret;
+    transport_ssl_t *ssl = transport_get_context_data(t);
+
+    if ((poll = transport_poll_write(t, timeout_ms)) <= 0) {
+        ESP_LOGW(TAG, "Poll timeout or error, errno=%s, fd=%d, timeout_ms=%d", strerror(errno), ssl->client_fd.fd, timeout_ms);
+        return poll;
+    }
+    ret = mbedtls_ssl_write(&ssl->ctx, (const unsigned char *) buffer, len);
+    if (ret <= 0) {
+        ESP_LOGE(TAG, "mbedtls_ssl_write error, errno=%s", strerror(errno));
+    }
+    return ret;
+}
+
+static int ssl_read(transport_handle_t t, char *buffer, int len, int timeout_ms)
+{
+    int ret;
+    transport_ssl_t *ssl = transport_get_context_data(t);
+    ret = mbedtls_ssl_read(&ssl->ctx, (unsigned char *)buffer, len);
+    if (ret == 0) {
+        return -1;
+    }
+    return ret;
+}
+
+static int ssl_close(transport_handle_t t)
+{
+    int ret = -1;
+    transport_ssl_t *ssl = transport_get_context_data(t);
+    if (ssl->ssl_initialized) {
+        ESP_LOGD(TAG, "Cleanup mbedtls");
+        mbedtls_ssl_close_notify(&ssl->ctx);
+        mbedtls_ssl_session_reset(&ssl->ctx);
+        mbedtls_net_free(&ssl->client_fd);
+        mbedtls_ssl_config_free(&ssl->conf);
+        if (ssl->verify_server) {
+            mbedtls_x509_crt_free(&ssl->cacert);
+        }
+        mbedtls_ctr_drbg_free(&ssl->ctr_drbg);
+        mbedtls_entropy_free(&ssl->entropy);
+        mbedtls_ssl_free(&ssl->ctx);
+        ssl->ssl_initialized = false;
+        ssl->verify_server = false;
+    }
+    return ret;
+}
+
+static int ssl_destroy(transport_handle_t t)
+{
+    transport_ssl_t *ssl = transport_get_context_data(t);
+    transport_close(t);
+    free(ssl);
+    return 0;
+}
+
+void transport_ssl_set_cert_data(transport_handle_t t, const char *data, int len)
+{
+    transport_ssl_t *ssl = transport_get_context_data(t);
+    if (t && ssl) {
+        ssl->cert_pem_data = (void *)data;
+        ssl->cert_pem_len = len;
+    }
+}
+
+transport_handle_t transport_ssl_init()
+{
+    transport_handle_t t = transport_init();
+    transport_ssl_t *ssl = calloc(1, sizeof(transport_ssl_t));
+    HTTP_MEM_CHECK(TAG, ssl, return NULL);
+    mbedtls_net_init(&ssl->client_fd);
+    transport_set_context_data(t, ssl);
+    transport_set_func(t, ssl_connect, ssl_read, ssl_write, ssl_close, ssl_poll_read, ssl_poll_write, ssl_destroy);
+    return t;
+}
+

components/esp_http_client/lib/transport_tcp.c

@@ -0,0 +1,166 @@
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "lwip/sockets.h"
+#include "lwip/dns.h"
+#include "lwip/netdb.h"
+
+#include "esp_log.h"
+#include "esp_system.h"
+#include "esp_err.h"
+
+#include "http_utils.h"
+#include "transport.h"
+
+static const char *TAG = "TRANS_TCP";
+
+typedef struct {
+    int sock;
+} transport_tcp_t;
+
+static int resolve_dns(const char *host, struct sockaddr_in *ip) {
+
+    struct hostent *he;
+    struct in_addr **addr_list;
+    he = gethostbyname(host);
+    if (he == NULL) {
+        return ESP_FAIL;
+    }
+    addr_list = (struct in_addr **)he->h_addr_list;
+    if (addr_list[0] == NULL) {
+        return ESP_FAIL;
+    }
+    ip->sin_family = AF_INET;
+    memcpy(&ip->sin_addr, addr_list[0], sizeof(ip->sin_addr));
+    return ESP_OK;
+}
+
+static int tcp_connect(transport_handle_t t, const char *host, int port, int timeout_ms)
+{
+    struct sockaddr_in remote_ip;
+    struct timeval tv;
+    transport_tcp_t *tcp = transport_get_context_data(t);
+
+    bzero(&remote_ip, sizeof(struct sockaddr_in));
+
+    //if stream_host is not ip address, resolve it AF_INET,servername,&serveraddr.sin_addr
+    if (inet_pton(AF_INET, host, &remote_ip.sin_addr) != 1) {
+        if (resolve_dns(host, &remote_ip) < 0) {
+            return -1;
+        }
+    }
+
+    tcp->sock = socket(PF_INET, SOCK_STREAM, 0);
+
+    if (tcp->sock < 0) {
+        ESP_LOGE(TAG, "Error create socket");
+        return -1;
+    }
+
+    remote_ip.sin_family = AF_INET;
+    remote_ip.sin_port = htons(port);
+
+    http_utils_ms_to_timeval(timeout_ms, &tv);
+
+    setsockopt(tcp->sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+
+    ESP_LOGD(TAG, "[sock=%d],connecting to server IP:%s,Port:%d...",
+             tcp->sock, ipaddr_ntoa((const ip_addr_t*)&remote_ip.sin_addr.s_addr), port);
+    if (connect(tcp->sock, (struct sockaddr *)(&remote_ip), sizeof(struct sockaddr)) != 0) {
+        close(tcp->sock);
+        tcp->sock = -1;
+        return -1;
+    }
+    return tcp->sock;
+}
+
+static int tcp_write(transport_handle_t t, const char *buffer, int len, int timeout_ms)
+{
+    int poll;
+    transport_tcp_t *tcp = transport_get_context_data(t);
+    if ((poll = transport_poll_write(t, timeout_ms)) <= 0) {
+        return poll;
+    }
+    return write(tcp->sock, buffer, len);
+}
+
+static int tcp_read(transport_handle_t t, char *buffer, int len, int timeout_ms)
+{
+    transport_tcp_t *tcp = transport_get_context_data(t);
+    int poll = -1;
+    if ((poll = transport_poll_read(t, timeout_ms)) <= 0) {
+        return poll;
+    }
+    int read_len = read(tcp->sock, buffer, len);
+    if (read_len == 0) {
+        return -1;
+    }
+    return read_len;
+}
+
+static int tcp_poll_read(transport_handle_t t, int timeout_ms)
+{
+    transport_tcp_t *tcp = transport_get_context_data(t);
+    fd_set readset;
+    FD_ZERO(&readset);
+    FD_SET(tcp->sock, &readset);
+    struct timeval timeout;
+    http_utils_ms_to_timeval(timeout_ms, &timeout);
+    return select(tcp->sock + 1, &readset, NULL, NULL, &timeout);
+}
+
+static int tcp_poll_write(transport_handle_t t, int timeout_ms)
+{
+    transport_tcp_t *tcp = transport_get_context_data(t);
+    fd_set writeset;
+    FD_ZERO(&writeset);
+    FD_SET(tcp->sock, &writeset);
+    struct timeval timeout;
+    http_utils_ms_to_timeval(timeout_ms, &timeout);
+    return select(tcp->sock + 1, NULL, &writeset, NULL, &timeout);
+}
+
+static int tcp_close(transport_handle_t t)
+{
+    transport_tcp_t *tcp = transport_get_context_data(t);
+    int ret = -1;
+    if (tcp->sock >= 0) {
+        ret = close(tcp->sock);
+        tcp->sock = -1;
+    }
+    return ret;
+}
+
+static esp_err_t tcp_destroy(transport_handle_t t)
+{
+    transport_tcp_t *tcp = transport_get_context_data(t);
+    transport_close(t);
+    free(tcp);
+    return 0;
+}
+
+transport_handle_t transport_tcp_init()
+{
+    transport_handle_t t = transport_init();
+    transport_tcp_t *tcp = calloc(1, sizeof(transport_tcp_t));
+    HTTP_MEM_CHECK(TAG, tcp, return NULL);
+    tcp->sock = -1;
+    transport_set_func(t, tcp_connect, tcp_read, tcp_write, tcp_close, tcp_poll_read, tcp_poll_write, tcp_destroy);
+    transport_set_context_data(t, tcp);
+
+    return t;
+}