1 /** @file
2 * @brief HTTP client API
3 *
4 * An API for applications to send HTTP requests
5 */
6
7 /*
8 * Copyright (c) 2019 Intel Corporation
9 *
10 * SPDX-License-Identifier: Apache-2.0
11 */
12
13 #include <zephyr/logging/log.h>
14 LOG_MODULE_REGISTER(net_http_client, CONFIG_NET_HTTP_LOG_LEVEL);
15
16 #include <zephyr/kernel.h>
17 #include <string.h>
18 #include <strings.h>
19 #include <errno.h>
20 #include <stdbool.h>
21 #include <stdlib.h>
22
23 #include <zephyr/net/net_ip.h>
24 #include <zephyr/net/socket.h>
25 #include <zephyr/net/http/client.h>
26 #include <zephyr/net/http/status.h>
27
28 #include "net_private.h"
29
30 #define HTTP_CONTENT_LEN_SIZE 11
31 #define MAX_SEND_BUF_LEN 192
32
sendall(int sock,const void * buf,size_t len,const k_timepoint_t req_end_timepoint)33 static int sendall(int sock, const void *buf, size_t len,
34 const k_timepoint_t req_end_timepoint)
35 {
36 while (len) {
37 ssize_t out_len = zsock_send(sock, buf, len, 0);
38
39 if ((out_len == 0) || (out_len < 0 && errno == EAGAIN)) {
40 struct zsock_pollfd pfd;
41 int pollres;
42 k_ticks_t req_timeout_ticks =
43 sys_timepoint_timeout(req_end_timepoint).ticks;
44 int req_timeout_ms = k_ticks_to_ms_floor32(req_timeout_ticks);
45
46 pfd.fd = sock;
47 pfd.events = ZSOCK_POLLOUT;
48 pollres = zsock_poll(&pfd, 1, req_timeout_ms);
49 if (pollres == 0) {
50 return -ETIMEDOUT;
51 } else if (pollres > 0) {
52 continue;
53 } else {
54 return -errno;
55 }
56 } else if (out_len < 0) {
57 return -errno;
58 }
59
60 buf = (const char *)buf + out_len;
61 len -= out_len;
62 }
63
64 return 0;
65 }
66
http_send_data(int sock,char * send_buf,size_t send_buf_max_len,size_t * send_buf_pos,const k_timepoint_t req_end_timepoint,...)67 static int http_send_data(int sock, char *send_buf,
68 size_t send_buf_max_len, size_t *send_buf_pos,
69 const k_timepoint_t req_end_timepoint,
70 ...)
71 {
72 const char *data;
73 va_list va;
74 int ret, end_of_send = *send_buf_pos;
75 int end_of_data, remaining_len;
76 int sent = 0;
77
78 va_start(va, req_end_timepoint);
79
80 data = va_arg(va, const char *);
81
82 while (data) {
83 end_of_data = 0;
84
85 do {
86 int to_be_copied;
87
88 remaining_len = strlen(data + end_of_data);
89 to_be_copied = send_buf_max_len - end_of_send;
90
91 if (remaining_len > to_be_copied) {
92 strncpy(send_buf + end_of_send,
93 data + end_of_data,
94 to_be_copied);
95
96 end_of_send += to_be_copied;
97 end_of_data += to_be_copied;
98 remaining_len -= to_be_copied;
99
100 LOG_HEXDUMP_DBG(send_buf, end_of_send,
101 "Data to send");
102
103 ret = sendall(sock, send_buf, end_of_send, req_end_timepoint);
104 if (ret < 0) {
105 NET_DBG("Cannot send %d bytes (%d)",
106 end_of_send, ret);
107 goto err;
108 }
109 sent += end_of_send;
110 end_of_send = 0;
111 continue;
112 } else {
113 memcpy(send_buf + end_of_send,
114 data + end_of_data,
115 remaining_len);
116 end_of_send += remaining_len;
117 remaining_len = 0;
118 }
119 } while (remaining_len > 0);
120
121 data = va_arg(va, const char *);
122 }
123
124 va_end(va);
125
126 if (end_of_send > (int)send_buf_max_len) {
127 NET_ERR("Sending overflow (%d > %zd)", end_of_send,
128 send_buf_max_len);
129 return -EMSGSIZE;
130 }
131
132 *send_buf_pos = end_of_send;
133
134 return sent;
135
136 err:
137 va_end(va);
138
139 return ret;
140 }
141
http_flush_data(int sock,const char * send_buf,size_t send_buf_len,const k_timepoint_t req_end_timepoint)142 static int http_flush_data(int sock, const char *send_buf, size_t send_buf_len,
143 const k_timepoint_t req_end_timepoint)
144 {
145 int ret;
146
147 LOG_HEXDUMP_DBG(send_buf, send_buf_len, "Data to send");
148
149 ret = sendall(sock, send_buf, send_buf_len, req_end_timepoint);
150 if (ret < 0) {
151 return ret;
152 }
153
154 return (int)send_buf_len;
155 }
156
print_header_field(size_t len,const char * str)157 static void print_header_field(size_t len, const char *str)
158 {
159 if (IS_ENABLED(CONFIG_NET_HTTP_LOG_LEVEL_DBG)) {
160 #define MAX_OUTPUT_LEN 128
161 char output[MAX_OUTPUT_LEN];
162
163 /* The value of len does not count \0 so we need to increase it
164 * by one.
165 */
166 if ((len + 1) > sizeof(output)) {
167 len = sizeof(output) - 1;
168 }
169
170 snprintk(output, len + 1, "%s", str);
171
172 NET_DBG("[%zd] %s", len, output);
173 }
174 }
175
on_url(struct http_parser * parser,const char * at,size_t length)176 static int on_url(struct http_parser *parser, const char *at, size_t length)
177 {
178 struct http_request *req = CONTAINER_OF(parser,
179 struct http_request,
180 internal.parser);
181 print_header_field(length, at);
182
183 if (req->internal.response.http_cb &&
184 req->internal.response.http_cb->on_url) {
185 req->internal.response.http_cb->on_url(parser, at, length);
186 }
187
188 return 0;
189 }
190
on_status(struct http_parser * parser,const char * at,size_t length)191 static int on_status(struct http_parser *parser, const char *at, size_t length)
192 {
193 struct http_request *req = CONTAINER_OF(parser,
194 struct http_request,
195 internal.parser);
196 uint16_t len;
197
198 len = MIN(length, sizeof(req->internal.response.http_status) - 1);
199 memcpy(req->internal.response.http_status, at, len);
200 req->internal.response.http_status[len] = 0;
201 req->internal.response.http_status_code =
202 (uint16_t)parser->status_code;
203
204 NET_DBG("HTTP response status %d %s", parser->status_code,
205 req->internal.response.http_status);
206
207 if (req->internal.response.http_cb &&
208 req->internal.response.http_cb->on_status) {
209 req->internal.response.http_cb->on_status(parser, at, length);
210 }
211
212 return 0;
213 }
214
on_header_field(struct http_parser * parser,const char * at,size_t length)215 static int on_header_field(struct http_parser *parser, const char *at,
216 size_t length)
217 {
218 struct http_request *req = CONTAINER_OF(parser,
219 struct http_request,
220 internal.parser);
221 static const char content_len[] = "Content-Length";
222 static const char content_range[] = "Content-Range";
223
224 uint16_t content_len_len = sizeof(content_len) - 1;
225 uint16_t content_range_len = sizeof(content_range) - 1;
226
227 if (length >= content_len_len && strncasecmp(at, content_len, content_len_len) == 0) {
228 req->internal.response.cl_present = true;
229 } else if (length >= content_range_len &&
230 strncasecmp(at, content_range, content_range_len) == 0) {
231 req->internal.response.cr_present = true;
232 }
233
234 print_header_field(length, at);
235
236 if (req->internal.response.http_cb &&
237 req->internal.response.http_cb->on_header_field) {
238 req->internal.response.http_cb->on_header_field(parser, at,
239 length);
240 }
241
242 return 0;
243 }
244
245 #define MAX_NUM_DIGITS 16
246
on_header_value(struct http_parser * parser,const char * at,size_t length)247 static int on_header_value(struct http_parser *parser, const char *at,
248 size_t length)
249 {
250 struct http_request *req = CONTAINER_OF(parser,
251 struct http_request,
252 internal.parser);
253 char str[MAX_NUM_DIGITS];
254
255 if (req->internal.response.cl_present) {
256 if (length <= MAX_NUM_DIGITS - 1) {
257 long int num;
258
259 memcpy(str, at, length);
260 str[length] = 0;
261
262 num = strtol(str, NULL, 10);
263 if (num == LONG_MIN || num == LONG_MAX) {
264 return -EINVAL;
265 }
266
267 req->internal.response.content_length = num;
268 }
269
270 req->internal.response.cl_present = false;
271 }
272
273 if (req->internal.response.cr_present) {
274 req->internal.response.content_range.start = parser->content_range.start;
275 req->internal.response.content_range.end = parser->content_range.end;
276 req->internal.response.content_range.total = parser->content_range.total;
277 req->internal.response.cr_present = false;
278 }
279
280 if (req->internal.response.http_cb &&
281 req->internal.response.http_cb->on_header_value) {
282 req->internal.response.http_cb->on_header_value(parser, at,
283 length);
284 }
285
286 print_header_field(length, at);
287
288 return 0;
289 }
290
on_body(struct http_parser * parser,const char * at,size_t length)291 static int on_body(struct http_parser *parser, const char *at, size_t length)
292 {
293 struct http_request *req = CONTAINER_OF(parser,
294 struct http_request,
295 internal.parser);
296
297 req->internal.response.body_found = 1;
298 req->internal.response.processed += length;
299
300 NET_DBG("Processed %zd length %zd", req->internal.response.processed,
301 length);
302
303 if (req->internal.response.http_cb &&
304 req->internal.response.http_cb->on_body) {
305 req->internal.response.http_cb->on_body(parser, at, length);
306 }
307
308 /* Reset the body_frag_start pointer for each fragment. */
309 if (!req->internal.response.body_frag_start) {
310 req->internal.response.body_frag_start = (uint8_t *)at;
311 }
312
313 /* Calculate the length of the body contained in the recv_buf */
314 req->internal.response.body_frag_len = req->internal.response.data_len -
315 (req->internal.response.body_frag_start - req->internal.response.recv_buf);
316
317 return 0;
318 }
319
on_headers_complete(struct http_parser * parser)320 static int on_headers_complete(struct http_parser *parser)
321 {
322 struct http_request *req = CONTAINER_OF(parser,
323 struct http_request,
324 internal.parser);
325
326 if (req->internal.response.http_cb &&
327 req->internal.response.http_cb->on_headers_complete) {
328 req->internal.response.http_cb->on_headers_complete(parser);
329 }
330
331 if (parser->status_code == HTTP_101_SWITCHING_PROTOCOLS) {
332 NET_DBG("Switching protocols, skipping body");
333 return 1;
334 }
335
336 if (parser->status_code >= 500 && parser->status_code < 600) {
337 NET_DBG("Status %d, skipping body", parser->status_code);
338 return 1;
339 }
340
341 if ((req->method == HTTP_HEAD || req->method == HTTP_OPTIONS) &&
342 req->internal.response.content_length > 0) {
343 NET_DBG("No body expected");
344 return 1;
345 }
346
347 NET_DBG("Headers complete");
348
349 return 0;
350 }
351
on_message_begin(struct http_parser * parser)352 static int on_message_begin(struct http_parser *parser)
353 {
354 struct http_request *req = CONTAINER_OF(parser,
355 struct http_request,
356 internal.parser);
357
358 if (req->internal.response.http_cb &&
359 req->internal.response.http_cb->on_message_begin) {
360 req->internal.response.http_cb->on_message_begin(parser);
361 }
362
363 NET_DBG("-- HTTP %s response (headers) --",
364 http_method_str(req->method));
365
366 return 0;
367 }
368
on_message_complete(struct http_parser * parser)369 static int on_message_complete(struct http_parser *parser)
370 {
371 struct http_request *req = CONTAINER_OF(parser,
372 struct http_request,
373 internal.parser);
374
375 if (req->internal.response.http_cb &&
376 req->internal.response.http_cb->on_message_complete) {
377 req->internal.response.http_cb->on_message_complete(parser);
378 }
379
380 NET_DBG("-- HTTP %s response (complete) --",
381 http_method_str(req->method));
382
383 req->internal.response.message_complete = 1;
384
385 return 0;
386 }
387
on_chunk_header(struct http_parser * parser)388 static int on_chunk_header(struct http_parser *parser)
389 {
390 struct http_request *req = CONTAINER_OF(parser,
391 struct http_request,
392 internal.parser);
393
394 if (req->internal.response.http_cb &&
395 req->internal.response.http_cb->on_chunk_header) {
396 req->internal.response.http_cb->on_chunk_header(parser);
397 }
398
399 return 0;
400 }
401
on_chunk_complete(struct http_parser * parser)402 static int on_chunk_complete(struct http_parser *parser)
403 {
404 struct http_request *req = CONTAINER_OF(parser,
405 struct http_request,
406 internal.parser);
407
408 if (req->internal.response.http_cb &&
409 req->internal.response.http_cb->on_chunk_complete) {
410 req->internal.response.http_cb->on_chunk_complete(parser);
411 }
412
413 return 0;
414 }
415
http_client_init_parser(struct http_parser * parser,struct http_parser_settings * settings)416 static void http_client_init_parser(struct http_parser *parser,
417 struct http_parser_settings *settings)
418 {
419 http_parser_init(parser, HTTP_RESPONSE);
420
421 settings->on_body = on_body;
422 settings->on_chunk_complete = on_chunk_complete;
423 settings->on_chunk_header = on_chunk_header;
424 settings->on_headers_complete = on_headers_complete;
425 settings->on_header_field = on_header_field;
426 settings->on_header_value = on_header_value;
427 settings->on_message_begin = on_message_begin;
428 settings->on_message_complete = on_message_complete;
429 settings->on_status = on_status;
430 settings->on_url = on_url;
431 }
432
433 /* Report a NULL HTTP response to the caller.
434 * A NULL response is when the HTTP server intentionally closes the TLS socket (using FINACK)
435 * without sending any HTTP payload.
436 */
http_report_null(struct http_request * req)437 static void http_report_null(struct http_request *req)
438 {
439 if (req->internal.response.cb) {
440 NET_DBG("Calling callback for Final Data"
441 "(NULL HTTP response)");
442
443 /* Status code 0 representing a null response */
444 req->internal.response.http_status_code = 0;
445
446 /* Zero out related response metrics */
447 req->internal.response.processed = 0;
448 req->internal.response.data_len = 0;
449 req->internal.response.content_length = 0;
450 req->internal.response.body_frag_start = NULL;
451 memset(req->internal.response.http_status, 0, HTTP_STATUS_STR_SIZE);
452
453 req->internal.response.cb(&req->internal.response, HTTP_DATA_FINAL,
454 req->internal.user_data);
455 }
456 }
457
458 /* Report a completed HTTP transaction (with no error) to the caller */
http_report_complete(struct http_request * req)459 static void http_report_complete(struct http_request *req)
460 {
461 if (req->internal.response.cb) {
462 NET_DBG("Calling callback for %zd len data", req->internal.response.data_len);
463 req->internal.response.cb(&req->internal.response, HTTP_DATA_FINAL,
464 req->internal.user_data);
465 }
466 }
467
468 /* Report that some data has been received, but the HTTP transaction is still ongoing. */
http_report_progress(struct http_request * req)469 static void http_report_progress(struct http_request *req)
470 {
471 if (req->internal.response.cb) {
472 NET_DBG("Calling callback for partitioned %zd len data",
473 req->internal.response.data_len);
474
475 req->internal.response.cb(&req->internal.response, HTTP_DATA_MORE,
476 req->internal.user_data);
477 }
478 }
479
http_wait_data(int sock,struct http_request * req,const k_timepoint_t req_end_timepoint)480 static int http_wait_data(int sock, struct http_request *req, const k_timepoint_t req_end_timepoint)
481 {
482 int total_received = 0;
483 size_t offset = 0;
484 int received, ret;
485 struct zsock_pollfd fds[1];
486 int nfds = 1;
487
488 fds[0].fd = sock;
489 fds[0].events = ZSOCK_POLLIN;
490
491 do {
492 k_ticks_t req_timeout_ticks =
493 sys_timepoint_timeout(req_end_timepoint).ticks;
494 int req_timeout_ms = k_ticks_to_ms_floor32(req_timeout_ticks);
495
496 ret = zsock_poll(fds, nfds, req_timeout_ms);
497 if (ret == 0) {
498 LOG_DBG("Timeout");
499 ret = -ETIMEDOUT;
500 goto error;
501 } else if (ret < 0) {
502 ret = -errno;
503 goto error;
504 }
505
506 if (fds[0].revents & ZSOCK_POLLERR) {
507 int sock_err;
508 socklen_t optlen = sizeof(sock_err);
509
510 (void)zsock_getsockopt(sock, SOL_SOCKET, SO_ERROR, &sock_err, &optlen);
511 ret = -sock_err;
512 goto error;
513 } else if (fds[0].revents & ZSOCK_POLLNVAL) {
514 ret = -EBADF;
515 goto error;
516 } else if (fds[0].revents & ZSOCK_POLLHUP) {
517 /* Connection closed */
518 goto closed;
519 } else if (fds[0].revents & ZSOCK_POLLIN) {
520 received = zsock_recv(sock, req->internal.response.recv_buf + offset,
521 req->internal.response.recv_buf_len - offset, 0);
522 if (received == 0) {
523 /* Connection closed */
524 goto closed;
525 } else if (received < 0) {
526 ret = -errno;
527 goto error;
528 } else {
529 req->internal.response.data_len += received;
530
531 (void)http_parser_execute(
532 &req->internal.parser, &req->internal.parser_settings,
533 req->internal.response.recv_buf + offset, received);
534 }
535
536 total_received += received;
537 offset += received;
538
539 if (offset >= req->internal.response.recv_buf_len) {
540 offset = 0;
541 }
542
543 if (req->internal.response.message_complete) {
544 http_report_complete(req);
545 break;
546 } else if (offset == 0) {
547 http_report_progress(req);
548
549 /* Re-use the result buffer and start to fill it again */
550 req->internal.response.data_len = 0;
551 req->internal.response.body_frag_start = NULL;
552 req->internal.response.body_frag_len = 0;
553 }
554 }
555
556 } while (true);
557
558 return total_received;
559
560 closed:
561 LOG_DBG("Connection closed");
562
563 /* If connection was closed with no data sent, this is a NULL response, and is a special
564 * case valid response.
565 */
566 if (total_received == 0) {
567 http_report_null(req);
568 return total_received;
569 }
570
571 /* Otherwise, connection was closed mid-way through response, and this should be
572 * considered an error.
573 */
574 ret = -ECONNRESET;
575
576 error:
577 LOG_DBG("Connection error (%d)", ret);
578 return ret;
579 }
580
http_client_req(int sock,struct http_request * req,int32_t timeout,void * user_data)581 int http_client_req(int sock, struct http_request *req,
582 int32_t timeout, void *user_data)
583 {
584 /* Utilize the network usage by sending data in bigger blocks */
585 char send_buf[MAX_SEND_BUF_LEN];
586 const size_t send_buf_max_len = sizeof(send_buf);
587 size_t send_buf_pos = 0;
588 int total_sent = 0;
589 int ret, total_recv, i;
590 const char *method;
591 k_timeout_t req_timeout = (timeout == SYS_FOREVER_MS) ? K_FOREVER : K_MSEC(timeout);
592 k_timepoint_t req_end_timepoint = sys_timepoint_calc(req_timeout);
593
594 if (sock < 0 || req == NULL || req->response == NULL ||
595 req->recv_buf == NULL || req->recv_buf_len == 0) {
596 return -EINVAL;
597 }
598
599 memset(&req->internal.response, 0, sizeof(req->internal.response));
600
601 req->internal.response.http_cb = req->http_cb;
602 req->internal.response.cb = req->response;
603 req->internal.response.recv_buf = req->recv_buf;
604 req->internal.response.recv_buf_len = req->recv_buf_len;
605 req->internal.user_data = user_data;
606 req->internal.sock = sock;
607
608 method = http_method_str(req->method);
609
610 ret = http_send_data(sock, send_buf, send_buf_max_len, &send_buf_pos,
611 req_end_timepoint, method,
612 " ", req->url, " ", req->protocol,
613 HTTP_CRLF, NULL);
614 if (ret < 0) {
615 goto out;
616 }
617
618 total_sent += ret;
619
620 if (req->port) {
621 ret = http_send_data(sock, send_buf, send_buf_max_len,
622 &send_buf_pos, req_end_timepoint, "Host", ": ", req->host,
623 ":", req->port, HTTP_CRLF, NULL);
624
625 if (ret < 0) {
626 goto out;
627 }
628
629 total_sent += ret;
630 } else {
631 ret = http_send_data(sock, send_buf, send_buf_max_len,
632 &send_buf_pos, req_end_timepoint, "Host", ": ", req->host,
633 HTTP_CRLF, NULL);
634
635 if (ret < 0) {
636 goto out;
637 }
638
639 total_sent += ret;
640 }
641
642 if (req->optional_headers_cb) {
643 ret = http_flush_data(sock, send_buf, send_buf_pos, req_end_timepoint);
644 if (ret < 0) {
645 goto out;
646 }
647
648 send_buf_pos = 0;
649 total_sent += ret;
650
651 ret = req->optional_headers_cb(sock, req, user_data);
652 if (ret < 0) {
653 goto out;
654 }
655
656 total_sent += ret;
657 } else {
658 for (i = 0; req->optional_headers && req->optional_headers[i];
659 i++) {
660 ret = http_send_data(sock, send_buf, send_buf_max_len,
661 &send_buf_pos, req_end_timepoint,
662 req->optional_headers[i], NULL);
663 if (ret < 0) {
664 goto out;
665 }
666
667 total_sent += ret;
668 }
669 }
670
671 for (i = 0; req->header_fields && req->header_fields[i]; i++) {
672 ret = http_send_data(sock, send_buf, send_buf_max_len,
673 &send_buf_pos, req_end_timepoint, req->header_fields[i],
674 NULL);
675 if (ret < 0) {
676 goto out;
677 }
678
679 total_sent += ret;
680 }
681
682 if (req->content_type_value) {
683 ret = http_send_data(sock, send_buf, send_buf_max_len,
684 &send_buf_pos, req_end_timepoint, "Content-Type", ": ",
685 req->content_type_value, HTTP_CRLF, NULL);
686 if (ret < 0) {
687 goto out;
688 }
689
690 total_sent += ret;
691 }
692
693 if (req->payload || req->payload_cb) {
694 if (req->payload_len) {
695 char content_len_str[HTTP_CONTENT_LEN_SIZE];
696
697 ret = snprintk(content_len_str, HTTP_CONTENT_LEN_SIZE,
698 "%zd", req->payload_len);
699 if (ret <= 0 || ret >= HTTP_CONTENT_LEN_SIZE) {
700 ret = -ENOMEM;
701 goto out;
702 }
703
704 ret = http_send_data(sock, send_buf, send_buf_max_len,
705 &send_buf_pos, req_end_timepoint,
706 "Content-Length", ": ",
707 content_len_str, HTTP_CRLF,
708 HTTP_CRLF, NULL);
709 } else {
710 ret = http_send_data(sock, send_buf, send_buf_max_len,
711 &send_buf_pos, req_end_timepoint, HTTP_CRLF, NULL);
712 }
713
714 if (ret < 0) {
715 goto out;
716 }
717
718 total_sent += ret;
719
720 ret = http_flush_data(sock, send_buf, send_buf_pos, req_end_timepoint);
721 if (ret < 0) {
722 goto out;
723 }
724
725 send_buf_pos = 0;
726 total_sent += ret;
727
728 if (req->payload_cb) {
729 ret = req->payload_cb(sock, req, user_data);
730 if (ret < 0) {
731 goto out;
732 }
733
734 total_sent += ret;
735 } else {
736 uint32_t length;
737
738 if (req->payload_len == 0) {
739 length = strlen(req->payload);
740 } else {
741 length = req->payload_len;
742 }
743
744 ret = sendall(sock, req->payload, length, req_end_timepoint);
745 if (ret < 0) {
746 goto out;
747 }
748
749 total_sent += length;
750 }
751 } else {
752 ret = http_send_data(sock, send_buf, send_buf_max_len,
753 &send_buf_pos, req_end_timepoint, HTTP_CRLF, NULL);
754 if (ret < 0) {
755 goto out;
756 }
757
758 total_sent += ret;
759 }
760
761 if (send_buf_pos > 0) {
762 ret = http_flush_data(sock, send_buf, send_buf_pos, req_end_timepoint);
763 if (ret < 0) {
764 goto out;
765 }
766
767 total_sent += ret;
768 }
769
770 NET_DBG("Sent %d bytes", total_sent);
771
772 http_client_init_parser(&req->internal.parser,
773 &req->internal.parser_settings);
774
775 /* Request is sent, now wait data to be received */
776 total_recv = http_wait_data(sock, req, req_end_timepoint);
777 if (total_recv < 0) {
778 NET_DBG("Wait data failure (%d)", total_recv);
779 ret = total_recv;
780 goto out;
781 }
782
783 NET_DBG("Received %d bytes", total_recv);
784
785 return total_sent;
786
787 out:
788 return ret;
789 }
790
