http_client.c 48 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321
  1. // Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. // http://www.apache.org/licenses/LICENSE-2.0
  7. //
  8. // Unless required by applicable law or agreed to in writing, software
  9. // distributed under the License is distributed on an "AS IS" BASIS,
  10. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11. // See the License for the specific language governing permissions and
  12. // limitations under the License.
  13. #include <stdlib.h>
  14. #include "http_client.h"
  15. #include "http_header.h"
  16. #include "http_utils.h"
  17. #include "http_parser.h"
  18. #include "http_auth.h"
  19. #include "transport/transport_tcp.h"
  20. #include "transport/tperrors.h"
  21. #include "ulog/ulog.h"
  22. #include "aos/errno.h"
  23. #include <errno.h>
  24. #include <string.h>
  25. #include <stdio.h>
  26. #ifdef CONFIG_USING_TLS
  27. #include "transport/transport_ssl.h"
  28. #endif
  29. static const char *TAG = "HTTP_CLIENT";
  30. #define ERR_HTTP_BASE (0x3000) /*!< Starting number of HTTP error codes */
  31. #define ERR_HTTP_MAX_REDIRECT (ERR_HTTP_BASE + 1) /*!< The error exceeds the number of HTTP redirects */
  32. #define ERR_HTTP_CONNECT (ERR_HTTP_BASE + 2) /*!< Error open the HTTP connection */
  33. #define ERR_HTTP_WRITE_DATA (ERR_HTTP_BASE + 3) /*!< Error write HTTP data */
  34. #define ERR_HTTP_FETCH_HEADER (ERR_HTTP_BASE + 4) /*!< Error read HTTP header from server */
  35. #define ERR_HTTP_INVALID_TRANSPORT (ERR_HTTP_BASE + 5) /*!< There are no transport support for the input scheme */
  36. #define ERR_HTTP_CONNECTING (ERR_HTTP_BASE + 6) /*!< HTTP connection hasn't been established yet */
  37. #define ERR_HTTP_EAGAIN EAGAIN//(ERR_HTTP_BASE + 7) /*!< Mapping of errno EAGAIN to web_err_t */
  38. /**
  39. * HTTP Buffer
  40. */
  41. typedef struct {
  42. char *data; /*!< The HTTP data received from the server */
  43. int len; /*!< The HTTP data len received from the server */
  44. char *raw_data; /*!< The HTTP data after decoding */
  45. int raw_len; /*!< The HTTP data len after decoding */
  46. char *output_ptr; /*!< The destination address of the data to be copied to after decoding */
  47. } http_buffer_t;
  48. /**
  49. * private HTTP Data structure
  50. */
  51. typedef struct {
  52. http_header_handle_t headers; /*!< http header */
  53. http_buffer_t *buffer; /*!< data buffer as linked list */
  54. int status_code; /*!< status code (integer) */
  55. int content_length; /*!< data length */
  56. int data_offset; /*!< offset to http data (Skip header) */
  57. int data_process; /*!< data processed */
  58. int method; /*!< http method */
  59. bool is_chunked;
  60. } http_data_t;
  61. typedef struct {
  62. char *url;
  63. char *scheme;
  64. char *host;
  65. int port;
  66. char *username;
  67. char *password;
  68. char *path;
  69. char *query;
  70. char *cert_pem;
  71. http_client_method_t method;
  72. http_client_auth_type_t auth_type;
  73. http_client_transport_t transport_type;
  74. int max_store_header_size;
  75. } connection_info_t;
  76. typedef enum {
  77. HTTP_STATE_UNINIT = 0,
  78. HTTP_STATE_INIT,
  79. HTTP_STATE_CONNECTED,
  80. HTTP_STATE_REQ_COMPLETE_HEADER,
  81. HTTP_STATE_REQ_COMPLETE_DATA,
  82. HTTP_STATE_RES_COMPLETE_HEADER,
  83. HTTP_STATE_RES_COMPLETE_DATA,
  84. HTTP_STATE_CLOSE
  85. } http_state_t;
  86. /**
  87. * HTTP client class
  88. */
  89. struct http_client {
  90. int redirect_counter;
  91. int max_redirection_count;
  92. int process_again;
  93. struct http_parser *parser;
  94. struct http_parser_settings *parser_settings;
  95. transport_list_handle_t transport_list;
  96. transport_handle_t transport;
  97. http_data_t *request;
  98. http_data_t *response;
  99. void *user_data;
  100. http_auth_data_t *auth_data;
  101. char *post_data;
  102. char *location;
  103. char *auth_header;
  104. char *current_header_key;
  105. char *current_header_value;
  106. int post_len;
  107. connection_info_t connection_info;
  108. bool is_chunk_complete;
  109. http_state_t state;
  110. http_event_handle_cb event_handler;
  111. int timeout_ms;
  112. int buffer_size;
  113. bool disable_auto_redirect;
  114. http_client_event_t event;
  115. int data_written_index;
  116. int data_write_left;
  117. bool first_line_prepared;
  118. int header_index;
  119. bool is_async;
  120. };
  121. typedef struct http_client http_client_t;
  122. static web_err_t _clear_connection_info(http_client_handle_t client);
  123. /**
  124. * Default settings
  125. */
  126. #define DEFAULT_HTTP_PORT (80)
  127. #define DEFAULT_HTTPS_PORT (443)
  128. #define ASYNC_TRANS_CONNECT_FAIL -1
  129. #define ASYNC_TRANS_CONNECTING 0
  130. #define ASYNC_TRANS_CONNECT_PASS 1
  131. static const char *DEFAULT_HTTP_USER_AGENT = "CK HTTP Client/1.0";
  132. static const char *DEFAULT_HTTP_PROTOCOL = "HTTP/1.1";
  133. static const char *DEFAULT_HTTP_PATH = "/";
  134. static int DEFAULT_MAX_REDIRECT = 10;
  135. static int DEFAULT_TIMEOUT_MS = 5000;
  136. static const char *HTTP_METHOD_MAPPING[] = {
  137. "GET",
  138. "POST",
  139. "PUT",
  140. "PATCH",
  141. "DELETE",
  142. "HEAD",
  143. "NOTIFY",
  144. "SUBSCRIBE",
  145. "UNSUBSCRIBE",
  146. "OPTIONS"
  147. };
  148. static web_err_t http_client_request_send(http_client_handle_t client, int write_len);
  149. static web_err_t http_client_connect(http_client_handle_t client);
  150. static web_err_t http_client_send_post_data(http_client_handle_t client);
  151. static web_err_t http_dispatch_event(http_client_t *client, http_client_event_id_t event_id, void *data, int len)
  152. {
  153. http_client_event_t *event = &client->event;
  154. if (client->event_handler) {
  155. event->event_id = event_id;
  156. event->user_data = client->user_data;
  157. event->data = data;
  158. event->data_len = len;
  159. return client->event_handler(event);
  160. }
  161. return WEB_OK;
  162. }
  163. static int http_on_message_begin(http_parser *parser)
  164. {
  165. http_client_t *client = parser->data;
  166. LOGD(TAG, "on_message_begin");
  167. client->response->is_chunked = false;
  168. client->is_chunk_complete = false;
  169. return 0;
  170. }
  171. static int http_on_url(http_parser *parser, const char *at, size_t length)
  172. {
  173. LOGD(TAG, "http_on_url");
  174. return 0;
  175. }
  176. static int http_on_status(http_parser *parser, const char *at, size_t length)
  177. {
  178. return 0;
  179. }
  180. static int http_on_header_field(http_parser *parser, const char *at, size_t length)
  181. {
  182. http_client_t *client = parser->data;
  183. http_utils_assign_string(&client->current_header_key, at, length);
  184. return 0;
  185. }
  186. static int http_on_header_value(http_parser *parser, const char *at, size_t length)
  187. {
  188. http_client_handle_t client = parser->data;
  189. if (client->current_header_key == NULL) {
  190. return 0;
  191. }
  192. if (strcasecmp(client->current_header_key, "Location") == 0) {
  193. http_utils_assign_string(&client->location, at, length);
  194. } else if (strcasecmp(client->current_header_key, "Transfer-Encoding") == 0
  195. && memcmp(at, "chunked", length) == 0) {
  196. client->response->is_chunked = true;
  197. } else if (strcasecmp(client->current_header_key, "WWW-Authenticate") == 0) {
  198. http_utils_assign_string(&client->auth_header, at, length);
  199. }
  200. http_utils_assign_string(&client->current_header_value, at, length);
  201. LOGD(TAG, "HEADER=%s:%s", client->current_header_key, client->current_header_value);
  202. client->event.header_key = client->current_header_key;
  203. client->event.header_value = client->current_header_value;
  204. http_dispatch_event(client, HTTP_EVENT_ON_HEADER, NULL, 0);
  205. free(client->current_header_key);
  206. free(client->current_header_value);
  207. client->current_header_key = NULL;
  208. client->current_header_value = NULL;
  209. return 0;
  210. }
  211. static int http_on_headers_complete(http_parser *parser)
  212. {
  213. http_client_handle_t client = parser->data;
  214. client->response->status_code = parser->status_code;
  215. client->response->data_offset = parser->nread;
  216. client->response->content_length = parser->content_length;
  217. client->response->data_process = 0;
  218. LOGD(TAG, "http_on_headers_complete, status=%d, offset=%d, nread=%d", parser->status_code, client->response->data_offset, parser->nread);
  219. client->state = HTTP_STATE_RES_COMPLETE_HEADER;
  220. return 0;
  221. }
  222. static int http_on_body(http_parser *parser, const char *at, size_t length)
  223. {
  224. http_client_t *client = parser->data;
  225. // LOGD(TAG, "http_on_body %d", length);
  226. client->response->buffer->raw_data = (char *)at;
  227. if (client->response->buffer->output_ptr) {
  228. memcpy(client->response->buffer->output_ptr, (char *)at, length);
  229. client->response->buffer->output_ptr += length;
  230. }
  231. client->response->data_process += length;
  232. client->response->buffer->raw_len += length;
  233. http_dispatch_event(client, HTTP_EVENT_ON_DATA, (void *)at, length);
  234. return 0;
  235. }
  236. static int http_on_message_complete(http_parser *parser)
  237. {
  238. LOGD(TAG, "http_on_message_complete, parser=0x%lx", (unsigned long)parser);
  239. http_client_handle_t client = parser->data;
  240. client->is_chunk_complete = true;
  241. return 0;
  242. }
  243. static int http_on_chunk_complete(http_parser *parser)
  244. {
  245. LOGD(TAG, "http_on_chunk_complete");
  246. return 0;
  247. }
  248. web_err_t http_client_set_header(http_client_handle_t client, const char *key, const char *value)
  249. {
  250. return http_header_set(client->request->headers, key, value);
  251. }
  252. web_err_t http_client_get_header(http_client_handle_t client, const char *key, char **value)
  253. {
  254. return http_header_get(client->request->headers, key, value);
  255. }
  256. web_err_t http_client_delete_header(http_client_handle_t client, const char *key)
  257. {
  258. return http_header_delete(client->request->headers, key);
  259. }
  260. web_err_t http_client_get_username(http_client_handle_t client, char **value)
  261. {
  262. if (client == NULL || value == NULL) {
  263. LOGE(TAG, "client or value must not be NULL");
  264. return WEB_ERR_INVALID_ARG;
  265. }
  266. *value = client->connection_info.username;
  267. return WEB_OK;
  268. }
  269. web_err_t http_client_get_password(http_client_handle_t client, char **value)
  270. {
  271. if (client == NULL || value == NULL) {
  272. LOGE(TAG, "client or value must not be NULL");
  273. return WEB_ERR_INVALID_ARG;
  274. }
  275. *value = client->connection_info.password;
  276. return WEB_OK;
  277. }
  278. static web_err_t _set_config(http_client_handle_t client, const http_client_config_t *config)
  279. {
  280. client->connection_info.method = config->method;
  281. client->connection_info.port = config->port;
  282. client->connection_info.auth_type = config->auth_type;
  283. client->event_handler = config->event_handler;
  284. client->timeout_ms = config->timeout_ms;
  285. client->max_redirection_count = config->max_redirection_count;
  286. client->user_data = config->user_data;
  287. client->buffer_size = config->buffer_size;
  288. client->disable_auto_redirect = config->disable_auto_redirect;
  289. if (config->buffer_size == 0) {
  290. client->buffer_size = DEFAULT_HTTP_BUF_SIZE;
  291. }
  292. if (client->max_redirection_count == 0) {
  293. client->max_redirection_count = DEFAULT_MAX_REDIRECT;
  294. }
  295. if (config->path) {
  296. client->connection_info.path = strdup(config->path);
  297. } else {
  298. client->connection_info.path = strdup(DEFAULT_HTTP_PATH);
  299. }
  300. HTTP_MEM_CHECK(TAG, client->connection_info.path, {
  301. return WEB_ERR_NO_MEM;
  302. });
  303. if (config->host) {
  304. client->connection_info.host = strdup(config->host);
  305. HTTP_MEM_CHECK(TAG, client->connection_info.host, {
  306. _clear_connection_info(client);
  307. return WEB_ERR_NO_MEM;
  308. });
  309. }
  310. if (config->query) {
  311. client->connection_info.query = strdup(config->query);
  312. HTTP_MEM_CHECK(TAG, client->connection_info.query, {
  313. _clear_connection_info(client);
  314. return WEB_ERR_NO_MEM;
  315. });
  316. }
  317. if (config->username) {
  318. client->connection_info.username = strdup(config->username);
  319. HTTP_MEM_CHECK(TAG, client->connection_info.username, {
  320. _clear_connection_info(client);
  321. return WEB_ERR_NO_MEM;
  322. });
  323. }
  324. if (config->password) {
  325. client->connection_info.password = strdup(config->password);
  326. HTTP_MEM_CHECK(TAG, client->connection_info.password, {
  327. _clear_connection_info(client);
  328. return WEB_ERR_NO_MEM;
  329. });
  330. }
  331. if (config->transport_type == HTTP_TRANSPORT_OVER_SSL) {
  332. http_utils_assign_string(&client->connection_info.scheme, "https", 0);
  333. if (client->connection_info.port == 0) {
  334. client->connection_info.port = DEFAULT_HTTPS_PORT;
  335. }
  336. } else {
  337. http_utils_assign_string(&client->connection_info.scheme, "http", 0);
  338. if (client->connection_info.port == 0) {
  339. client->connection_info.port = DEFAULT_HTTP_PORT;
  340. }
  341. }
  342. if (client->timeout_ms == 0) {
  343. client->timeout_ms = DEFAULT_TIMEOUT_MS;
  344. }
  345. if (config->is_async) {
  346. client->is_async = true;
  347. }
  348. return WEB_OK;
  349. }
  350. static web_err_t _clear_connection_info(http_client_handle_t client)
  351. {
  352. free(client->connection_info.path);
  353. free(client->connection_info.host);
  354. free(client->connection_info.query);
  355. free(client->connection_info.username);
  356. if (client->connection_info.password) {
  357. memset(client->connection_info.password, 0, strlen(client->connection_info.password));
  358. free(client->connection_info.password);
  359. }
  360. free(client->connection_info.scheme);
  361. free(client->connection_info.url);
  362. memset(&client->connection_info, 0, sizeof(connection_info_t));
  363. return WEB_OK;
  364. }
  365. static web_err_t _clear_auth_data(http_client_handle_t client)
  366. {
  367. if (client->auth_data == NULL) {
  368. return WEB_FAIL;
  369. }
  370. free(client->auth_data->method);
  371. free(client->auth_data->realm);
  372. free(client->auth_data->algorithm);
  373. free(client->auth_data->qop);
  374. free(client->auth_data->nonce);
  375. free(client->auth_data->opaque);
  376. memset(client->auth_data, 0, sizeof(http_auth_data_t));
  377. return WEB_OK;
  378. }
  379. static web_err_t http_client_prepare(http_client_handle_t client)
  380. {
  381. client->process_again = 0;
  382. client->response->data_process = 0;
  383. client->first_line_prepared = false;
  384. http_parser_init(client->parser, HTTP_RESPONSE);
  385. if (client->connection_info.username) {
  386. char *auth_response = NULL;
  387. if (client->connection_info.auth_type == HTTP_AUTH_TYPE_BASIC) {
  388. auth_response = http_auth_basic(client->connection_info.username, client->connection_info.password);
  389. }
  390. else if (client->connection_info.auth_type == HTTP_AUTH_TYPE_DIGEST && client->auth_data) {
  391. client->auth_data->uri = client->connection_info.path;
  392. client->auth_data->cnonce = ((uint64_t)rand() << 32) + rand();
  393. auth_response = http_auth_digest(client->connection_info.username, client->connection_info.password, client->auth_data);
  394. client->auth_data->nc ++;
  395. }
  396. if (auth_response) {
  397. LOGD(TAG, "auth_response=%s", auth_response);
  398. http_client_set_header(client, "Authorization", auth_response);
  399. free(auth_response);
  400. }
  401. }
  402. return WEB_OK;
  403. }
  404. http_client_handle_t http_client_init(const http_client_config_t *config)
  405. {
  406. http_client_handle_t client;
  407. transport_handle_t tcp;
  408. bool _success;
  409. _success = (
  410. (client = calloc(1, sizeof(http_client_t))) &&
  411. (client->parser = calloc(1, sizeof(struct http_parser))) &&
  412. (client->parser_settings = calloc(1, sizeof(struct http_parser_settings))) &&
  413. (client->auth_data = calloc(1, sizeof(http_auth_data_t))) &&
  414. (client->request = calloc(1, sizeof(http_data_t))) &&
  415. (client->request->headers = http_header_init()) &&
  416. (client->request->buffer = calloc(1, sizeof(http_buffer_t))) &&
  417. (client->response = calloc(1, sizeof(http_data_t))) &&
  418. (client->response->headers = http_header_init()) &&
  419. (client->response->buffer = calloc(1, sizeof(http_buffer_t)))
  420. );
  421. if (!_success) {
  422. LOGE(TAG, "Error allocate memory");
  423. goto error;
  424. }
  425. _success = (
  426. (client->transport_list = transport_list_init()) &&
  427. (tcp = transport_tcp_init()) &&
  428. (transport_set_default_port(tcp, DEFAULT_HTTP_PORT) == WEB_OK) &&
  429. (transport_list_add(client->transport_list, tcp, "http") == WEB_OK)
  430. );
  431. if (!_success) {
  432. LOGE(TAG, "Error initialize transport");
  433. goto error;
  434. }
  435. #ifdef CONFIG_USING_TLS
  436. transport_handle_t ssl;
  437. _success = (
  438. (ssl = transport_ssl_init()) &&
  439. (transport_set_default_port(ssl, DEFAULT_HTTPS_PORT) == WEB_OK) &&
  440. (transport_list_add(client->transport_list, ssl, "https") == WEB_OK)
  441. );
  442. if (!_success) {
  443. LOGE(TAG, "Error initialize SSL Transport");
  444. goto error;
  445. }
  446. if (config->use_global_ca_store == true) {
  447. transport_ssl_enable_global_ca_store(ssl);
  448. } else if (config->cert_pem) {
  449. transport_ssl_set_cert_data(ssl, config->cert_pem, strlen(config->cert_pem));
  450. }
  451. if (config->client_cert_pem) {
  452. transport_ssl_set_client_cert_data(ssl, config->client_cert_pem, strlen(config->client_cert_pem));
  453. }
  454. if (config->client_key_pem) {
  455. transport_ssl_set_client_key_data(ssl, config->client_key_pem, strlen(config->client_key_pem));
  456. }
  457. #endif
  458. if (_set_config(client, config) != WEB_OK) {
  459. LOGE(TAG, "Error set configurations");
  460. goto error;
  461. }
  462. _success = (
  463. (client->request->buffer->data = malloc(client->buffer_size)) &&
  464. (client->response->buffer->data = malloc(client->buffer_size))
  465. );
  466. if (!_success) {
  467. LOGE(TAG, "Allocation failed");
  468. goto error;
  469. }
  470. if (config->host != NULL && config->path != NULL) {
  471. _success = (
  472. (http_client_set_header(client, "User-Agent", DEFAULT_HTTP_USER_AGENT) == WEB_OK) &&
  473. (http_client_set_header(client, "Host", client->connection_info.host) == WEB_OK)
  474. );
  475. if (!_success) {
  476. LOGE(TAG, "Error while setting default configurations");
  477. goto error;
  478. }
  479. } else if (config->url != NULL) {
  480. _success = (
  481. (http_client_set_url(client, config->url) == WEB_OK) &&
  482. (http_client_set_header(client, "User-Agent", DEFAULT_HTTP_USER_AGENT) == WEB_OK) &&
  483. (http_client_set_header(client, "Host", client->connection_info.host) == WEB_OK)
  484. );
  485. if (!_success) {
  486. LOGE(TAG, "Error while setting default configurations");
  487. goto error;
  488. }
  489. } else {
  490. LOGE(TAG, "config should have either URL or host & path");
  491. goto error;
  492. }
  493. client->parser_settings->on_message_begin = http_on_message_begin;
  494. client->parser_settings->on_url = http_on_url;
  495. client->parser_settings->on_status = http_on_status;
  496. client->parser_settings->on_header_field = http_on_header_field;
  497. client->parser_settings->on_header_value = http_on_header_value;
  498. client->parser_settings->on_headers_complete = http_on_headers_complete;
  499. client->parser_settings->on_body = http_on_body;
  500. client->parser_settings->on_message_complete = http_on_message_complete;
  501. client->parser_settings->on_chunk_complete = http_on_chunk_complete;
  502. client->parser->data = client;
  503. client->event.client = client;
  504. client->state = HTTP_STATE_INIT;
  505. return client;
  506. error:
  507. http_client_cleanup(client);
  508. return NULL;
  509. }
  510. web_err_t http_client_cleanup(http_client_handle_t client)
  511. {
  512. if (client == NULL) {
  513. return WEB_FAIL;
  514. }
  515. http_client_close(client);
  516. transport_list_destroy(client->transport_list);
  517. http_header_destroy(client->request->headers);
  518. free(client->request->buffer->data);
  519. free(client->request->buffer);
  520. free(client->request);
  521. http_header_destroy(client->response->headers);
  522. free(client->response->buffer->data);
  523. free(client->response->buffer);
  524. free(client->response);
  525. free(client->parser);
  526. free(client->parser_settings);
  527. _clear_connection_info(client);
  528. _clear_auth_data(client);
  529. free(client->auth_data);
  530. free(client->current_header_key);
  531. free(client->location);
  532. free(client->auth_header);
  533. free(client);
  534. return WEB_OK;
  535. }
  536. http_errors_t http_client_set_redirection(http_client_handle_t client)
  537. {
  538. if (client == NULL) {
  539. return HTTP_CLI_ERR_INVALID_ARG;
  540. }
  541. if (client->location == NULL) {
  542. return HTTP_CLI_ERR_INVALID_ARG;
  543. }
  544. LOGD(TAG, "Redirect to %s", client->location);
  545. return http_client_set_url(client, client->location);
  546. }
  547. static web_err_t http_check_response(http_client_handle_t client)
  548. {
  549. char *auth_header = NULL;
  550. if (client->redirect_counter >= client->max_redirection_count || client->disable_auto_redirect) {
  551. LOGE(TAG, "Error, reach max_redirection_count count=%d", client->redirect_counter);
  552. return ERR_HTTP_MAX_REDIRECT;
  553. }
  554. switch (client->response->status_code) {
  555. case HttpStatus_MovedPermanently:
  556. case HttpStatus_Found:
  557. case HttpStatus_TemporaryRedirect:
  558. LOGI(TAG, "Redirect to %s", client->location);
  559. http_client_set_url(client, client->location);
  560. client->redirect_counter ++;
  561. client->process_again = 1;
  562. break;
  563. case HttpStatus_Unauthorized:
  564. auth_header = client->auth_header;
  565. if (auth_header) {
  566. http_utils_trim_whitespace(&auth_header);
  567. LOGD(TAG, "UNAUTHORIZED: %s", auth_header);
  568. client->redirect_counter ++;
  569. if (http_utils_str_starts_with(auth_header, "Digest") == 0) {
  570. LOGD(TAG, "type = Digest");
  571. client->connection_info.auth_type = HTTP_AUTH_TYPE_DIGEST;
  572. } else if (http_utils_str_starts_with(auth_header, "Basic") == 0) {
  573. LOGD(TAG, "type = Basic");
  574. client->connection_info.auth_type = HTTP_AUTH_TYPE_BASIC;
  575. } else {
  576. client->connection_info.auth_type = HTTP_AUTH_TYPE_NONE;
  577. LOGE(TAG, "This authentication method is not supported: %s", auth_header);
  578. break;
  579. }
  580. _clear_auth_data(client);
  581. client->auth_data->method = strdup(HTTP_METHOD_MAPPING[client->connection_info.method]);
  582. client->auth_data->nc = 1;
  583. client->auth_data->realm = http_utils_get_string_between(auth_header, "realm=\"", "\"");
  584. client->auth_data->algorithm = http_utils_get_string_between(auth_header, "algorithm=", ",");
  585. client->auth_data->qop = http_utils_get_string_between(auth_header, "qop=\"", "\"");
  586. client->auth_data->nonce = http_utils_get_string_between(auth_header, "nonce=\"", "\"");
  587. client->auth_data->opaque = http_utils_get_string_between(auth_header, "opaque=\"", "\"");
  588. client->process_again = 1;
  589. } else {
  590. client->connection_info.auth_type = HTTP_AUTH_TYPE_NONE;
  591. LOGW(TAG, "This request requires authentication, but does not provide header information for that");
  592. }
  593. }
  594. return WEB_OK;
  595. }
  596. web_err_t http_client_set_url(http_client_handle_t client, const char *url)
  597. {
  598. char *old_host = NULL;
  599. char *old_path = NULL;
  600. struct http_parser_url purl;
  601. int old_port;
  602. if (client == NULL || url == NULL) {
  603. LOGE(TAG, "client or url must not NULL");
  604. return WEB_ERR_INVALID_ARG;
  605. }
  606. http_parser_url_init(&purl);
  607. int parser_status = http_parser_parse_url(url, strlen(url), 0, &purl);
  608. if (parser_status != 0) {
  609. LOGE(TAG, "Error parse url %s", url);
  610. return WEB_ERR_INVALID_ARG;
  611. }
  612. if (client->connection_info.host) {
  613. old_host = strdup(client->connection_info.host);
  614. }
  615. old_port = client->connection_info.port;
  616. // Whether the passed url is absolute or is just a path
  617. bool is_absolute_url = (bool) purl.field_data[UF_HOST].len;
  618. if (is_absolute_url) {
  619. http_utils_assign_string(&client->connection_info.host, url + purl.field_data[UF_HOST].off, purl.field_data[UF_HOST].len);
  620. HTTP_MEM_CHECK(TAG, client->connection_info.host, {
  621. if (old_host) free(old_host);
  622. return WEB_ERR_NO_MEM;
  623. });
  624. }
  625. // Close the connection if host was changed
  626. if (old_host && client->connection_info.host
  627. && strcasecmp(old_host, (const void *)client->connection_info.host) != 0) {
  628. LOGD(TAG, "New host assign = %s", client->connection_info.host);
  629. if (http_client_set_header(client, "Host", client->connection_info.host) != WEB_OK) {
  630. free(old_host);
  631. return WEB_ERR_NO_MEM;
  632. }
  633. http_client_close(client);
  634. }
  635. if (old_host) {
  636. free(old_host);
  637. old_host = NULL;
  638. }
  639. if (purl.field_data[UF_SCHEMA].len) {
  640. http_utils_assign_string(&client->connection_info.scheme, url + purl.field_data[UF_SCHEMA].off, purl.field_data[UF_SCHEMA].len);
  641. HTTP_MEM_CHECK(TAG, client->connection_info.scheme, return WEB_ERR_NO_MEM);
  642. if (strcasecmp(client->connection_info.scheme, "http") == 0) {
  643. client->connection_info.port = DEFAULT_HTTP_PORT;
  644. } else if (strcasecmp(client->connection_info.scheme, "https") == 0) {
  645. client->connection_info.port = DEFAULT_HTTPS_PORT;
  646. }
  647. }
  648. if (purl.field_data[UF_PORT].len) {
  649. client->connection_info.port = strtol((const char*)(url + purl.field_data[UF_PORT].off), NULL, 10);
  650. }
  651. if (old_port != client->connection_info.port) {
  652. http_client_close(client);
  653. }
  654. if (purl.field_data[UF_USERINFO].len) {
  655. char *user_info = NULL;
  656. http_utils_assign_string(&user_info, url + purl.field_data[UF_USERINFO].off, purl.field_data[UF_USERINFO].len);
  657. if (user_info) {
  658. char *username = user_info;
  659. char *password = strchr(user_info, ':');
  660. if (password) {
  661. *password = 0;
  662. password ++;
  663. http_utils_assign_string(&client->connection_info.password, password, 0);
  664. HTTP_MEM_CHECK(TAG, client->connection_info.password, return WEB_ERR_NO_MEM);
  665. }
  666. http_utils_assign_string(&client->connection_info.username, username, 0);
  667. HTTP_MEM_CHECK(TAG, client->connection_info.username, return WEB_ERR_NO_MEM);
  668. free(user_info);
  669. } else {
  670. return WEB_ERR_NO_MEM;
  671. }
  672. } else if (is_absolute_url) {
  673. // Only reset authentication info if the passed URL is full
  674. free(client->connection_info.username);
  675. free(client->connection_info.password);
  676. client->connection_info.username = NULL;
  677. client->connection_info.password = NULL;
  678. }
  679. if (client->connection_info.path) {
  680. old_path = strdup(client->connection_info.path);
  681. }
  682. //Reset path and query if there are no information
  683. if (purl.field_data[UF_PATH].len) {
  684. http_utils_assign_string(&client->connection_info.path, url + purl.field_data[UF_PATH].off, purl.field_data[UF_PATH].len);
  685. } else {
  686. http_utils_assign_string(&client->connection_info.path, "/", 0);
  687. }
  688. LOGD(TAG, "###path:%s", client->connection_info.path);
  689. HTTP_MEM_CHECK(TAG, client->connection_info.path, {
  690. if (old_path) free(old_path);
  691. return WEB_ERR_NO_MEM;
  692. });
  693. // Close the connection if path was changed
  694. if (old_path && client->connection_info.path
  695. && strcasecmp(old_path, (const void *)client->connection_info.path) != 0) {
  696. LOGD(TAG, "New path assign = %s", client->connection_info.path);
  697. http_client_close(client);
  698. }
  699. if (old_path) {
  700. free(old_path);
  701. old_path = NULL;
  702. }
  703. if (purl.field_data[UF_QUERY].len) {
  704. http_utils_assign_string(&client->connection_info.query, url + purl.field_data[UF_QUERY].off, purl.field_data[UF_QUERY].len);
  705. HTTP_MEM_CHECK(TAG, client->connection_info.query, return WEB_ERR_NO_MEM);
  706. } else if (client->connection_info.query) {
  707. free(client->connection_info.query);
  708. client->connection_info.query = NULL;
  709. }
  710. return WEB_OK;
  711. }
  712. web_err_t http_client_set_method(http_client_handle_t client, http_client_method_t method)
  713. {
  714. client->connection_info.method = method;
  715. return WEB_OK;
  716. }
  717. static int http_client_get_data(http_client_handle_t client)
  718. {
  719. if (client->state < HTTP_STATE_RES_COMPLETE_HEADER) {
  720. return WEB_FAIL;
  721. }
  722. if (client->connection_info.method == HTTP_METHOD_HEAD) {
  723. return 0;
  724. }
  725. http_buffer_t *res_buffer = client->response->buffer;
  726. LOGD(TAG, "data_process=%d, content_length=%d", client->response->data_process, client->response->content_length);
  727. int rlen = transport_read(client->transport, res_buffer->data, client->buffer_size, client->timeout_ms);
  728. if (rlen >= 0) {
  729. http_parser_execute(client->parser, client->parser_settings, res_buffer->data, rlen);
  730. }
  731. return rlen;
  732. }
  733. bool http_client_is_complete_data_received(http_client_handle_t client)
  734. {
  735. if (client->response->is_chunked) {
  736. if (!client->is_chunk_complete) {
  737. LOGD(TAG, "Chunks were not completely read");
  738. return false;
  739. }
  740. } else {
  741. if (client->response->data_process != client->response->content_length) {
  742. LOGD(TAG, "Data processed %d != Data specified in content length %d", client->response->data_process, client->response->content_length);
  743. return false;
  744. }
  745. }
  746. return true;
  747. }
  748. int http_client_read(http_client_handle_t client, char *buffer, int len)
  749. {
  750. http_buffer_t *res_buffer = client->response->buffer;
  751. int rlen = WEB_FAIL, ridx = 0;
  752. if (res_buffer->raw_len) {
  753. int remain_len = client->response->buffer->raw_len;
  754. if (remain_len > len) {
  755. remain_len = len;
  756. }
  757. memcpy(buffer, res_buffer->raw_data, remain_len);
  758. res_buffer->raw_len -= remain_len;
  759. res_buffer->raw_data += remain_len;
  760. ridx = remain_len;
  761. }
  762. int need_read = len - ridx;
  763. bool is_data_remain = true;
  764. while (need_read > 0 && is_data_remain) {
  765. if (client->response->is_chunked) {
  766. is_data_remain = !client->is_chunk_complete;
  767. } else {
  768. is_data_remain = client->response->data_process < client->response->content_length;
  769. }
  770. // LOGD(TAG, "is_data_remain=%d, is_chunked=%d", is_data_remain, client->response->is_chunked);
  771. if (!is_data_remain) {
  772. break;
  773. }
  774. int byte_to_read = need_read;
  775. if (byte_to_read > client->buffer_size) {
  776. byte_to_read = client->buffer_size;
  777. }
  778. errno = 0;
  779. rlen = transport_read(client->transport, res_buffer->data, byte_to_read, client->timeout_ms);
  780. // LOGD(TAG, "need_read=%d, byte_to_read=%d, rlen=%d, ridx=%d", need_read, byte_to_read, rlen, ridx);
  781. if (rlen <= 0) {
  782. if (errno != 0) {
  783. /* On connection close from server, recv should ideally return 0 but we have error conversion
  784. * in `tcp_transport` SSL layer which translates it `-1` and hence below additional checks */
  785. if (rlen == -1 && errno == ENOTCONN && client->response->is_chunked) {
  786. /* Explicit call to parser for invoking `message_complete` callback */
  787. http_parser_execute(client->parser, client->parser_settings, res_buffer->data, 0);
  788. /* ...and lowering the message severity, as closed connection from server side is expected in chunked transport */
  789. }
  790. LOGW(TAG, "transport_read returned:%d and errno:%d ", rlen, errno);
  791. }
  792. if (rlen < 0 && ridx == 0 && !http_client_is_complete_data_received(client)) {
  793. return -1;
  794. } else {
  795. return ridx;
  796. }
  797. }
  798. res_buffer->output_ptr = buffer + ridx;
  799. http_parser_execute(client->parser, client->parser_settings, res_buffer->data, rlen);
  800. ridx += res_buffer->raw_len;
  801. need_read -= res_buffer->raw_len;
  802. res_buffer->raw_len = 0; //clear
  803. res_buffer->output_ptr = NULL;
  804. }
  805. return ridx;
  806. }
  807. web_err_t http_client_perform(http_client_handle_t client)
  808. {
  809. web_err_t err;
  810. do {
  811. LOGD(TAG, "client->state: %d, client->process_again: %d", client->state, client->process_again);
  812. if (client->process_again) {
  813. http_client_prepare(client);
  814. }
  815. switch (client->state) {
  816. /* In case of blocking http_client_perform(), the following states will fall through one after the after;
  817. in case of non-blocking http_client_perform(), if there is an error condition, like EINPROGRESS or EAGAIN,
  818. then the http_client_perform() API will return WEB_ERR_HTTP_EAGAIN error. The user may call
  819. http_client_perform API again, and for this reason, we maintain the states */
  820. case HTTP_STATE_INIT:
  821. if ((err = http_client_connect(client)) != WEB_OK) {
  822. if (client->is_async && err == ERR_HTTP_CONNECTING) {
  823. return ERR_HTTP_EAGAIN;
  824. }
  825. return err;
  826. }
  827. LOGD(TAG, "HTTP_STATE_INIT");
  828. /* falls through */
  829. case HTTP_STATE_CONNECTED:
  830. if ((err = http_client_request_send(client, client->post_len)) != WEB_OK) {
  831. if (client->is_async && errno == EAGAIN) {
  832. return ERR_HTTP_EAGAIN;
  833. }
  834. return err;
  835. }
  836. LOGD(TAG, "HTTP_STATE_CONNECTED");
  837. /* falls through */
  838. case HTTP_STATE_REQ_COMPLETE_HEADER:
  839. if ((err = http_client_send_post_data(client)) != WEB_OK) {
  840. if (client->is_async && errno == EAGAIN) {
  841. return ERR_HTTP_EAGAIN;
  842. }
  843. return err;
  844. }
  845. LOGD(TAG, "HTTP_STATE_REQ_COMPLETE_HEADER");
  846. /* falls through */
  847. case HTTP_STATE_REQ_COMPLETE_DATA:
  848. if (http_client_fetch_headers(client) < 0) {
  849. if (client->is_async && errno == EAGAIN) {
  850. return ERR_HTTP_EAGAIN;
  851. }
  852. return ERR_HTTP_FETCH_HEADER;
  853. }
  854. LOGD(TAG, "HTTP_STATE_REQ_COMPLETE_DATA");
  855. /* falls through */
  856. case HTTP_STATE_RES_COMPLETE_HEADER:
  857. if ((err = http_check_response(client)) != WEB_OK) {
  858. LOGE(TAG, "Error response");
  859. return err;
  860. }
  861. while (client->response->is_chunked && !client->is_chunk_complete) {
  862. if (http_client_get_data(client) <= 0) {
  863. if (client->is_async && errno == EAGAIN) {
  864. return ERR_HTTP_EAGAIN;
  865. }
  866. LOGD(TAG, "Read finish or server requests close");
  867. break;
  868. }
  869. }
  870. while (client->response->data_process < client->response->content_length) {
  871. if (http_client_get_data(client) <= 0) {
  872. if (client->is_async && errno == EAGAIN) {
  873. return ERR_HTTP_EAGAIN;
  874. }
  875. LOGD(TAG, "Read finish or server requests close");
  876. break;
  877. }
  878. }
  879. http_dispatch_event(client, HTTP_EVENT_ON_FINISH, NULL, 0);
  880. if (!http_should_keep_alive(client->parser)) {
  881. LOGD(TAG, "Close connection");
  882. http_client_close(client);
  883. } else {
  884. if (client->state > HTTP_STATE_CONNECTED) {
  885. client->state = HTTP_STATE_CONNECTED;
  886. client->first_line_prepared = false;
  887. }
  888. }
  889. LOGD(TAG, "HTTP_STATE_RES_COMPLETE_HEADER");
  890. break;
  891. default:
  892. break;
  893. }
  894. } while (client->process_again);
  895. return WEB_OK;
  896. }
  897. int http_client_fetch_headers(http_client_handle_t client)
  898. {
  899. if (client->state < HTTP_STATE_REQ_COMPLETE_HEADER) {
  900. return WEB_FAIL;
  901. }
  902. client->state = HTTP_STATE_REQ_COMPLETE_DATA;
  903. http_buffer_t *buffer = client->response->buffer;
  904. client->response->status_code = -1;
  905. while (client->state < HTTP_STATE_RES_COMPLETE_HEADER) {
  906. buffer->len = transport_read(client->transport, buffer->data, client->buffer_size, client->timeout_ms);
  907. if (buffer->len <= 0) {
  908. return WEB_FAIL;
  909. }
  910. http_parser_execute(client->parser, client->parser_settings, buffer->data, buffer->len);
  911. }
  912. LOGD(TAG, "content_length = %d", client->response->content_length);
  913. if (client->response->content_length <= 0) {
  914. client->response->is_chunked = true;
  915. return 0;
  916. }
  917. return client->response->content_length;
  918. }
  919. static web_err_t http_client_connect(http_client_handle_t client)
  920. {
  921. web_err_t err;
  922. if (client->state == HTTP_STATE_UNINIT) {
  923. LOGE(TAG, "Client has not been initialized");
  924. return WEB_ERR_INVALID_STATE;
  925. }
  926. if ((err = http_client_prepare(client)) != WEB_OK) {
  927. LOGE(TAG, "Failed to initialize request data");
  928. http_client_close(client);
  929. return err;
  930. }
  931. if (client->state < HTTP_STATE_CONNECTED) {
  932. LOGD(TAG, "Begin connect to: %s://%s:%d", client->connection_info.scheme, client->connection_info.host, client->connection_info.port);
  933. client->transport = transport_list_get_transport(client->transport_list, client->connection_info.scheme);
  934. if (client->transport == NULL) {
  935. LOGE(TAG, "No transport found");
  936. #ifndef CONFIG_USING_TLS
  937. if (strcasecmp(client->connection_info.scheme, "https") == 0) {
  938. LOGE(TAG, "Please enable HTTPS at menuconfig to allow requesting via https");
  939. }
  940. #endif
  941. return ERR_HTTP_INVALID_TRANSPORT;
  942. }
  943. if (!client->is_async) {
  944. if (transport_connect(client->transport, client->connection_info.host, client->connection_info.port, client->timeout_ms) < 0) {
  945. LOGE(TAG, "Connection failed, sock < 0");
  946. return ERR_HTTP_CONNECT;
  947. }
  948. } else {
  949. int ret = transport_connect_async(client->transport, client->connection_info.host, client->connection_info.port, client->timeout_ms);
  950. if (ret == ASYNC_TRANS_CONNECT_FAIL) {
  951. LOGE(TAG, "Connection failed");
  952. if (strcasecmp(client->connection_info.scheme, "http") == 0) {
  953. LOGE(TAG, "Asynchronous mode doesn't work for HTTP based connection");
  954. return WEB_ERR_INVALID_ARG;
  955. }
  956. return ERR_HTTP_CONNECT;
  957. } else if (ret == ASYNC_TRANS_CONNECTING) {
  958. LOGD(TAG, "Connection not yet established");
  959. return ERR_HTTP_CONNECTING;
  960. }
  961. }
  962. client->state = HTTP_STATE_CONNECTED;
  963. http_dispatch_event(client, HTTP_EVENT_ON_CONNECTED, NULL, 0);
  964. }
  965. return WEB_OK;
  966. }
  967. static int http_client_prepare_first_line(http_client_handle_t client, int write_len)
  968. {
  969. if (write_len >= 0) {
  970. http_header_set_format(client->request->headers, "Content-Length", "%d", write_len);
  971. } else {
  972. http_client_set_header(client, "Transfer-Encoding", "chunked");
  973. http_client_set_method(client, HTTP_METHOD_POST);
  974. }
  975. const char *method = HTTP_METHOD_MAPPING[client->connection_info.method];
  976. int first_line_len = snprintf(client->request->buffer->data,
  977. client->buffer_size, "%s %s",
  978. method,
  979. client->connection_info.path);
  980. if (first_line_len >= client->buffer_size) {
  981. LOGE(TAG, "Out of buffer");
  982. return -1;
  983. }
  984. if (client->connection_info.query) {
  985. first_line_len += snprintf(client->request->buffer->data + first_line_len,
  986. client->buffer_size - first_line_len, "?%s", client->connection_info.query);
  987. if (first_line_len >= client->buffer_size) {
  988. LOGE(TAG, "Out of buffer");
  989. return -1;
  990. }
  991. }
  992. first_line_len += snprintf(client->request->buffer->data + first_line_len,
  993. client->buffer_size - first_line_len, " %s\r\n", DEFAULT_HTTP_PROTOCOL);
  994. if (first_line_len >= client->buffer_size) {
  995. LOGE(TAG, "Out of buffer");
  996. return -1;
  997. }
  998. return first_line_len;
  999. }
  1000. static web_err_t http_client_request_send(http_client_handle_t client, int write_len)
  1001. {
  1002. int first_line_len = 0;
  1003. if (!client->first_line_prepared) {
  1004. if ((first_line_len = http_client_prepare_first_line(client, write_len)) < 0) {
  1005. return first_line_len;
  1006. }
  1007. client->first_line_prepared = true;
  1008. client->header_index = 0;
  1009. client->data_written_index = 0;
  1010. client->data_write_left = 0;
  1011. }
  1012. if (client->data_write_left > 0) {
  1013. /* sending leftover data from previous call to http_client_request_send() API */
  1014. int wret = 0;
  1015. if (((wret = http_client_write(client, client->request->buffer->data + client->data_written_index, client->data_write_left)) < 0)) {
  1016. LOGE(TAG, "Error write request");
  1017. return ERR_HTTP_WRITE_DATA;
  1018. }
  1019. client->data_write_left -= wret;
  1020. client->data_written_index += wret;
  1021. if (client->is_async && client->data_write_left > 0) {
  1022. return ERR_HTTP_WRITE_DATA; /* In case of EAGAIN error, we return WEB_ERR_HTTP_WRITE_DATA,
  1023. and the handling of EAGAIN should be done in the higher level APIs. */
  1024. }
  1025. }
  1026. int wlen = client->buffer_size - first_line_len;
  1027. while ((client->header_index = http_header_generate_string(client->request->headers, client->header_index, client->request->buffer->data + first_line_len, &wlen))) {
  1028. if (wlen <= 0) {
  1029. break;
  1030. }
  1031. if (first_line_len) {
  1032. wlen += first_line_len;
  1033. first_line_len = 0;
  1034. }
  1035. client->request->buffer->data[wlen] = 0;
  1036. LOGD(TAG, "Write header[%d]: %s", client->header_index, client->request->buffer->data);
  1037. client->data_write_left = wlen;
  1038. client->data_written_index = 0;
  1039. while (client->data_write_left > 0) {
  1040. int wret = transport_write(client->transport, client->request->buffer->data + client->data_written_index, client->data_write_left, client->timeout_ms);
  1041. if (wret <= 0) {
  1042. LOGE(TAG, "Error write request");
  1043. http_client_close(client);
  1044. return ERR_HTTP_WRITE_DATA;
  1045. }
  1046. client->data_write_left -= wret;
  1047. client->data_written_index += wret;
  1048. }
  1049. wlen = client->buffer_size;
  1050. }
  1051. client->data_written_index = 0;
  1052. client->data_write_left = client->post_len;
  1053. http_dispatch_event(client, HTTP_EVENT_HEADER_SENT, NULL, 0);
  1054. client->state = HTTP_STATE_REQ_COMPLETE_HEADER;
  1055. return WEB_OK;
  1056. }
  1057. static web_err_t http_client_send_post_data(http_client_handle_t client)
  1058. {
  1059. if (client->state != HTTP_STATE_REQ_COMPLETE_HEADER) {
  1060. LOGE(TAG, "Invalid state");
  1061. return WEB_ERR_INVALID_STATE;
  1062. }
  1063. if (!(client->post_data && client->post_len)) {
  1064. goto success;
  1065. }
  1066. int wret = http_client_write(client, client->post_data + client->data_written_index, client->data_write_left);
  1067. if (wret < 0) {
  1068. return wret;
  1069. }
  1070. client->data_write_left -= wret;
  1071. client->data_written_index += wret;
  1072. if (client->data_write_left <= 0) {
  1073. goto success;
  1074. } else {
  1075. return ERR_HTTP_WRITE_DATA;
  1076. }
  1077. success:
  1078. client->state = HTTP_STATE_REQ_COMPLETE_DATA;
  1079. return WEB_OK;
  1080. }
  1081. web_err_t http_client_open(http_client_handle_t client, int write_len)
  1082. {
  1083. client->post_len = write_len;
  1084. web_err_t err;
  1085. if ((err = http_client_connect(client)) != WEB_OK) {
  1086. return err;
  1087. }
  1088. if ((err = http_client_request_send(client, write_len)) != WEB_OK) {
  1089. return err;
  1090. }
  1091. return WEB_OK;
  1092. }
  1093. int http_client_write(http_client_handle_t client, const char *buffer, int len)
  1094. {
  1095. if (client->state < HTTP_STATE_REQ_COMPLETE_HEADER) {
  1096. return WEB_FAIL;
  1097. }
  1098. int wlen = 0, widx = 0;
  1099. while (len > 0) {
  1100. wlen = transport_write(client->transport, buffer + widx, len, client->timeout_ms);
  1101. /* client->async_block is initialised in case of non-blocking IO, and in this case we return how
  1102. much ever data was written by the transport_write() API. */
  1103. if (client->is_async || wlen <= 0) {
  1104. return wlen;
  1105. }
  1106. widx += wlen;
  1107. len -= wlen;
  1108. }
  1109. return widx;
  1110. }
  1111. web_err_t http_client_close(http_client_handle_t client)
  1112. {
  1113. if (client->state >= HTTP_STATE_INIT) {
  1114. http_dispatch_event(client, HTTP_EVENT_DISCONNECTED, NULL, 0);
  1115. client->state = HTTP_STATE_INIT;
  1116. return transport_close(client->transport);
  1117. }
  1118. return WEB_OK;
  1119. }
  1120. web_err_t http_client_set_post_field(http_client_handle_t client, const char *data, int len)
  1121. {
  1122. web_err_t err = WEB_OK;
  1123. client->post_data = (char *)data;
  1124. client->post_len = len;
  1125. LOGD(TAG, "set post file length = %d", len);
  1126. if (client->post_data) {
  1127. char *value = NULL;
  1128. if ((err = http_client_get_header(client, "Content-Type", &value)) != WEB_OK) {
  1129. return err;
  1130. }
  1131. if (value == NULL) {
  1132. err = http_client_set_header(client, "Content-Type", "application/x-www-form-urlencoded");
  1133. }
  1134. } else {
  1135. client->post_len = 0;
  1136. err = http_client_set_header(client, "Content-Type", NULL);
  1137. }
  1138. return err;
  1139. }
  1140. int http_client_get_post_field(http_client_handle_t client, char **data)
  1141. {
  1142. if (client->post_data) {
  1143. *data = client->post_data;
  1144. return client->post_len;
  1145. }
  1146. return 0;
  1147. }
  1148. int http_client_get_status_code(http_client_handle_t client)
  1149. {
  1150. return client->response->status_code;
  1151. }
  1152. int http_client_get_content_length(http_client_handle_t client)
  1153. {
  1154. return client->response->content_length;
  1155. }
  1156. bool http_client_is_chunked_response(http_client_handle_t client)
  1157. {
  1158. return client->response->is_chunked;
  1159. }
  1160. http_client_transport_t http_client_get_transport_type(http_client_handle_t client)
  1161. {
  1162. if (!strcasecmp(client->connection_info.scheme, "https") ) {
  1163. return HTTP_TRANSPORT_OVER_SSL;
  1164. } else if (!strcasecmp(client->connection_info.scheme, "http")) {
  1165. return HTTP_TRANSPORT_OVER_TCP;
  1166. } else {
  1167. return HTTP_TRANSPORT_UNKNOWN;
  1168. }
  1169. }
  1170. int http_client_read_response(http_client_handle_t client, char *buffer, int len)
  1171. {
  1172. int read_len = 0;
  1173. while (read_len < len) {
  1174. int data_read = http_client_read(client, buffer + read_len, len - read_len);
  1175. if (data_read <= 0) {
  1176. return read_len;
  1177. }
  1178. read_len += data_read;
  1179. }
  1180. return read_len;
  1181. }