uclient-http.c

   1 /*
   2  * uclient - ustream based protocol client library
   3  *
   4  * Copyright (C) 2014 Felix Fietkau <nbd@openwrt.org>
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #include <sys/socket.h>
  19 #include <stdio.h>
  20 #include <ctype.h>
  21 #include <unistd.h>
  22 #include <stdint.h>
  23 #include <fcntl.h>
  24
  25 #include <libubox/ustream.h>
  26 #include <libubox/ustream-ssl.h>
  27 #include <libubox/usock.h>
  28 #include <libubox/blobmsg.h>
  29
  30 #include "uclient.h"
  31 #include "uclient-utils.h"
  32 #include "uclient-backend.h"
  33
  34 enum auth_type {
  35         AUTH_TYPE_UNKNOWN,
  36         AUTH_TYPE_NONE,
  37         AUTH_TYPE_BASIC,
  38         AUTH_TYPE_DIGEST,
  39 };
  40
  41 enum request_type {
  42         REQ_GET,
  43         REQ_HEAD,
  44         REQ_POST,
  45         REQ_PUT,
  46         REQ_DELETE,
  47         __REQ_MAX
  48 };
  49
  50 enum http_state {
  51         HTTP_STATE_INIT,
  52         HTTP_STATE_HEADERS_SENT,
  53         HTTP_STATE_REQUEST_DONE,
  54         HTTP_STATE_RECV_HEADERS,
  55         HTTP_STATE_RECV_DATA,
  56         HTTP_STATE_ERROR,
  57 };
  58
  59 static const char * const request_types[__REQ_MAX] = {
  60         [REQ_GET] = "GET",
  61         [REQ_HEAD] = "HEAD",
  62         [REQ_POST] = "POST",
  63         [REQ_PUT] = "PUT",
  64         [REQ_DELETE] = "DELETE",
  65 };
  66
  67 struct uclient_http {
  68         struct uclient uc;
  69
  70         const struct ustream_ssl_ops *ssl_ops;
  71         struct ustream_ssl_ctx *ssl_ctx;
  72         struct ustream *us;
  73
  74         struct ustream_fd ufd;
  75         struct ustream_ssl ussl;
  76
  77         struct uloop_timeout disconnect_t;
  78         unsigned int seq;
  79
  80         bool ssl_require_validation;
  81         bool ssl;
  82         bool eof;
  83         bool connection_close;
  84         bool disconnect;
  85         enum request_type req_type;
  86         enum http_state state;
  87
  88         enum auth_type auth_type;
  89         char *auth_str;
  90
  91         long read_chunked;
  92         long content_length;
  93
  94         int usock_flags;
  95
  96         uint32_t nc;
  97
  98         struct blob_buf headers;
  99         struct blob_buf meta;
 100 };
 101
 102 enum {
 103         PREFIX_HTTP,
 104         PREFIX_HTTPS,
 105         __PREFIX_MAX,
 106 };
 107
 108 static const char * const uclient_http_prefix[] = {
 109         [PREFIX_HTTP] = "http://",
 110         [PREFIX_HTTPS] = "https://",
 111         [__PREFIX_MAX] = NULL
 112 };
 113
 114 static int uclient_http_connect(struct uclient *cl);
 115
 116 static int uclient_do_connect(struct uclient_http *uh, const char *port)
 117 {
 118         socklen_t sl;
 119         int fd;
 120
 121         if (uh->uc.url->port)
 122                 port = uh->uc.url->port;
 123
 124         memset(&uh->uc.remote_addr, 0, sizeof(uh->uc.remote_addr));
 125
 126         fd = usock_inet_timeout(USOCK_TCP | USOCK_NONBLOCK | uh->usock_flags,
 127                                 uh->uc.url->host, port, &uh->uc.remote_addr,
 128                                 uh->uc.timeout_msecs);
 129         if (fd < 0)
 130                 return -1;
 131
 132         fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
 133         ustream_fd_init(&uh->ufd, fd);
 134
 135         sl = sizeof(uh->uc.local_addr);
 136         memset(&uh->uc.local_addr, 0, sl);
 137         getsockname(fd, &uh->uc.local_addr.sa, &sl);
 138
 139         return 0;
 140 }
 141
 142 static void uclient_http_disconnect(struct uclient_http *uh)
 143 {
 144         uloop_timeout_cancel(&uh->disconnect_t);
 145         if (!uh->us)
 146                 return;
 147
 148         if (uh->ssl)
 149                 ustream_free(&uh->ussl.stream);
 150         ustream_free(&uh->ufd.stream);
 151         close(uh->ufd.fd.fd);
 152         uh->us = NULL;
 153 }
 154
 155 static void uclient_http_free_url_state(struct uclient *cl)
 156 {
 157         struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
 158
 159         uh->auth_type = AUTH_TYPE_UNKNOWN;
 160         free(uh->auth_str);
 161         uh->auth_str = NULL;
 162         uclient_http_disconnect(uh);
 163 }
 164
 165 static void uclient_http_error(struct uclient_http *uh, int code)
 166 {
 167         uh->state = HTTP_STATE_ERROR;
 168         uh->us->eof = true;
 169         ustream_state_change(uh->us);
 170         uclient_backend_set_error(&uh->uc, code);
 171 }
 172
 173 static void uclient_http_request_disconnect(struct uclient *cl)
 174 {
 175         struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
 176
 177         if (!uh->us)
 178                 return;
 179
 180         uh->eof = true;
 181         uh->disconnect = true;
 182         uloop_timeout_set(&uh->disconnect_t, 1);
 183 }
 184
 185 static void uclient_notify_eof(struct uclient_http *uh)
 186 {
 187         struct ustream *us = uh->us;
 188
 189         if (uh->disconnect)
 190                 return;
 191
 192         if (!uh->eof) {
 193                 if (!us->eof && !us->write_error)
 194                         return;
 195
 196                 if (ustream_pending_data(us, false))
 197                         return;
 198         }
 199
 200         if (uh->content_length < 0 && uh->read_chunked >= 0)
 201                 uh->uc.data_eof = true;
 202
 203         uclient_backend_set_eof(&uh->uc);
 204
 205         if (uh->connection_close)
 206                 uclient_http_request_disconnect(&uh->uc);
 207 }
 208
 209 static void uclient_http_reset_state(struct uclient_http *uh)
 210 {
 211         uh->seq++;
 212         uclient_backend_reset_state(&uh->uc);
 213         uh->read_chunked = -1;
 214         uh->content_length = -1;
 215         uh->eof = false;
 216         uh->disconnect = false;
 217         uh->connection_close = false;
 218         uh->state = HTTP_STATE_INIT;
 219
 220         if (uh->auth_type == AUTH_TYPE_UNKNOWN && !uh->uc.url->auth)
 221                 uh->auth_type = AUTH_TYPE_NONE;
 222 }
 223
 224 static void uclient_http_init_request(struct uclient_http *uh)
 225 {
 226         uh->seq++;
 227         uclient_http_reset_state(uh);
 228         blob_buf_init(&uh->meta, 0);
 229 }
 230
 231 static enum auth_type
 232 uclient_http_update_auth_type(struct uclient_http *uh)
 233 {
 234         if (!uh->auth_str)
 235                 return AUTH_TYPE_NONE;
 236
 237         if (!strncasecmp(uh->auth_str, "basic", 5))
 238                 return AUTH_TYPE_BASIC;
 239
 240         if (!strncasecmp(uh->auth_str, "digest", 6))
 241                 return AUTH_TYPE_DIGEST;
 242
 243         return AUTH_TYPE_NONE;
 244 }
 245
 246 static void uclient_http_process_headers(struct uclient_http *uh)
 247 {
 248         enum {
 249                 HTTP_HDR_TRANSFER_ENCODING,
 250                 HTTP_HDR_CONNECTION,
 251                 HTTP_HDR_CONTENT_LENGTH,
 252                 HTTP_HDR_AUTH,
 253                 __HTTP_HDR_MAX,
 254         };
 255         static const struct blobmsg_policy hdr_policy[__HTTP_HDR_MAX] = {
 256 #define hdr(_name) { .name = _name, .type = BLOBMSG_TYPE_STRING }
 257                 [HTTP_HDR_TRANSFER_ENCODING] = hdr("transfer-encoding"),
 258                 [HTTP_HDR_CONNECTION] = hdr("connection"),
 259                 [HTTP_HDR_CONTENT_LENGTH] = hdr("content-length"),
 260                 [HTTP_HDR_AUTH] = hdr("www-authenticate"),
 261 #undef hdr
 262         };
 263         struct blob_attr *tb[__HTTP_HDR_MAX];
 264         struct blob_attr *cur;
 265
 266         blobmsg_parse(hdr_policy, __HTTP_HDR_MAX, tb, blob_data(uh->meta.head), blob_len(uh->meta.head));
 267
 268         cur = tb[HTTP_HDR_TRANSFER_ENCODING];
 269         if (cur && strstr(blobmsg_data(cur), "chunked"))
 270                 uh->read_chunked = 0;
 271
 272         cur = tb[HTTP_HDR_CONNECTION];
 273         if (cur && strstr(blobmsg_data(cur), "close"))
 274                 uh->connection_close = true;
 275
 276         cur = tb[HTTP_HDR_CONTENT_LENGTH];
 277         if (cur)
 278                 uh->content_length = strtoul(blobmsg_data(cur), NULL, 10);
 279
 280         cur = tb[HTTP_HDR_AUTH];
 281         if (cur) {
 282                 free(uh->auth_str);
 283                 uh->auth_str = strdup(blobmsg_data(cur));
 284         }
 285
 286         uh->auth_type = uclient_http_update_auth_type(uh);
 287 }
 288
 289 static bool uclient_request_supports_body(enum request_type req_type)
 290 {
 291         switch (req_type) {
 292         case REQ_POST:
 293         case REQ_PUT:
 294         case REQ_DELETE:
 295                 return true;
 296         default:
 297                 return false;
 298         }
 299 }
 300
 301 static void
 302 uclient_http_add_auth_basic(struct uclient_http *uh)
 303 {
 304         struct uclient_url *url = uh->uc.url;
 305         int auth_len = strlen(url->auth);
 306         char *auth_buf;
 307
 308         if (auth_len > 512)
 309                 return;
 310
 311         auth_buf = alloca(base64_len(auth_len) + 1);
 312         base64_encode(url->auth, auth_len, auth_buf);
 313         ustream_printf(uh->us, "Authorization: Basic %s\r\n", auth_buf);
 314 }
 315
 316 static char *digest_unquote_sep(char **str)
 317 {
 318         char *cur = *str + 1;
 319         char *start = cur;
 320         char *out;
 321
 322         if (**str != '"')
 323                 return NULL;
 324
 325         out = cur;
 326         while (1) {
 327                 if (!*cur)
 328                         return NULL;
 329
 330                 if (*cur == '"') {
 331                         cur++;
 332                         break;
 333                 }
 334
 335                 if (*cur == '\\')
 336                         cur++;
 337
 338                 *(out++) = *(cur++);
 339         }
 340
 341         if (*cur == ',')
 342                 cur++;
 343
 344         *out = 0;
 345         *str = cur;
 346
 347         return start;
 348 }
 349
 350 static char *digest_sep(char **str)
 351 {
 352         char *cur, *next;
 353
 354         cur = *str;
 355         next = strchr(*str, ',');
 356         if (next) {
 357             *str = next + 1;
 358             *next = 0;
 359         } else {
 360             *str += strlen(*str);
 361         }
 362
 363         return cur;
 364 }
 365
 366 static bool strmatch(char **str, const char *prefix)
 367 {
 368         int len = strlen(prefix);
 369
 370         if (strncmp(*str, prefix, len) != 0 || (*str)[len] != '=')
 371                 return false;
 372
 373         *str += len + 1;
 374         return true;
 375 }
 376
 377 static void
 378 get_cnonce(char *dest)
 379 {
 380         uint32_t val = 0;
 381         FILE *f;
 382         size_t n;
 383
 384         f = fopen("/dev/urandom", "r");
 385         if (f) {
 386                 n = fread(&val, sizeof(val), 1, f);
 387                 fclose(f);
 388                 if (n != 1)
 389                         return;
 390         }
 391
 392         bin_to_hex(dest, &val, sizeof(val));
 393 }
 394
 395 static void add_field(char **buf, int *ofs, int *len, const char *name, const char *val)
 396 {
 397         int available = *len - *ofs;
 398         int required;
 399         const char *next;
 400         char *cur;
 401
 402         if (*len && !*buf)
 403                 return;
 404
 405         required = strlen(name) + 4 + strlen(val) * 2;
 406         if (required > available)
 407                 *len += required - available + 64;
 408
 409         *buf = realloc(*buf, *len);
 410         if (!*buf)
 411                 return;
 412
 413         cur = *buf + *ofs;
 414         cur += sprintf(cur, ", %s=\"", name);
 415
 416         while ((next = strchr(val, '"'))) {
 417                 if (next > val) {
 418                         memcpy(cur, val, next - val);
 419                         cur += next - val;
 420                 }
 421
 422                 cur += sprintf(cur, "\\\"");
 423                 val = next + 1;
 424         }
 425
 426         cur += sprintf(cur, "%s\"", val);
 427         *ofs = cur - *buf;
 428 }
 429
 430 static void
 431 uclient_http_add_auth_digest(struct uclient_http *uh)
 432 {
 433         struct uclient_url *url = uh->uc.url;
 434         const char *realm = NULL, *opaque = NULL;
 435         const char *user, *password;
 436         char *buf, *next;
 437         int len, ofs;
 438
 439         char cnonce_str[9];
 440         char nc_str[9];
 441         char ahash[33];
 442         char hash[33];
 443
 444         struct http_digest_data data = {
 445                 .nc = nc_str,
 446                 .cnonce = cnonce_str,
 447                 .auth_hash = ahash,
 448         };
 449
 450         len = strlen(uh->auth_str) + 1;
 451         if (len > 512)
 452                 return;
 453
 454         buf = alloca(len);
 455         strcpy(buf, uh->auth_str);
 456
 457         /* skip auth type */
 458         strsep(&buf, " ");
 459
 460         next = buf;
 461         while (*next) {
 462                 const char **dest = NULL;
 463                 const char *tmp;
 464
 465                 while (*next && isspace(*next))
 466                         next++;
 467
 468                 if (strmatch(&next, "realm"))
 469                         dest = &realm;
 470                 else if (strmatch(&next, "qop"))
 471                         dest = &data.qop;
 472                 else if (strmatch(&next, "nonce"))
 473                         dest = &data.nonce;
 474                 else if (strmatch(&next, "opaque"))
 475                         dest = &opaque;
 476                 else if (strmatch(&next, "stale") ||
 477                          strmatch(&next, "algorithm") ||
 478                          strmatch(&next, "auth-param")) {
 479                         digest_sep(&next);
 480                         continue;
 481                 } else if (strmatch(&next, "domain") ||
 482                          strmatch(&next, "qop-options"))
 483                         dest = &tmp;
 484                 else {
 485                         digest_sep(&next);
 486                         continue;
 487                 }
 488
 489                 *dest = digest_unquote_sep(&next);
 490         }
 491
 492         if (!realm || !data.qop || !data.nonce)
 493                 return;
 494
 495         sprintf(nc_str, "%08x", uh->nc++);
 496         get_cnonce(cnonce_str);
 497
 498         data.qop = "auth";
 499         data.uri = url->location;
 500         data.method = request_types[uh->req_type];
 501
 502         password = strchr(url->auth, ':');
 503         if (password) {
 504                 char *user_buf;
 505
 506                 len = password - url->auth;
 507                 if (len > 256)
 508                         return;
 509
 510                 user_buf = alloca(len + 1);
 511                 strncpy(user_buf, url->auth, len);
 512                 user_buf[len] = 0;
 513                 user = user_buf;
 514                 password++;
 515         } else {
 516                 user = url->auth;
 517                 password = "";
 518         }
 519
 520         http_digest_calculate_auth_hash(ahash, user, realm, password);
 521         http_digest_calculate_response(hash, &data);
 522
 523         buf = NULL;
 524         len = 0;
 525         ofs = 0;
 526
 527         add_field(&buf, &ofs, &len, "username", user);
 528         add_field(&buf, &ofs, &len, "realm", realm);
 529         add_field(&buf, &ofs, &len, "nonce", data.nonce);
 530         add_field(&buf, &ofs, &len, "uri", data.uri);
 531         add_field(&buf, &ofs, &len, "cnonce", data.cnonce);
 532         add_field(&buf, &ofs, &len, "response", hash);
 533         if (opaque)
 534                 add_field(&buf, &ofs, &len, "opaque", opaque);
 535
 536         ustream_printf(uh->us, "Authorization: Digest nc=%s, qop=%s%s\r\n", data.nc, data.qop, buf);
 537         free(buf);
 538 }
 539
 540 static void
 541 uclient_http_add_auth_header(struct uclient_http *uh)
 542 {
 543         if (!uh->uc.url->auth)
 544                 return;
 545
 546         switch (uh->auth_type) {
 547         case AUTH_TYPE_UNKNOWN:
 548         case AUTH_TYPE_NONE:
 549                 break;
 550         case AUTH_TYPE_BASIC:
 551                 uclient_http_add_auth_basic(uh);
 552                 break;
 553         case AUTH_TYPE_DIGEST:
 554                 uclient_http_add_auth_digest(uh);
 555                 break;
 556         }
 557 }
 558
 559 static void
 560 uclient_http_send_headers(struct uclient_http *uh)
 561 {
 562         struct uclient_url *url = uh->uc.url;
 563         struct blob_attr *cur;
 564         enum request_type req_type = uh->req_type;
 565         int rem;
 566
 567         if (uh->state >= HTTP_STATE_HEADERS_SENT)
 568                 return;
 569
 570         if (uh->uc.proxy_url)
 571                 url = uh->uc.proxy_url;
 572
 573         ustream_printf(uh->us,
 574                 "%s %s HTTP/1.1\r\n"
 575                 "Host: %s%s%s\r\n",
 576                 request_types[req_type],
 577                 url->location, url->host,
 578                 url->port ? ":" : "",
 579                 url->port ? url->port : "");
 580
 581         blobmsg_for_each_attr(cur, uh->headers.head, rem)
 582                 ustream_printf(uh->us, "%s: %s\r\n", blobmsg_name(cur), (char *) blobmsg_data(cur));
 583
 584         if (uclient_request_supports_body(uh->req_type))
 585                 ustream_printf(uh->us, "Transfer-Encoding: chunked\r\n");
 586
 587         uclient_http_add_auth_header(uh);
 588
 589         ustream_printf(uh->us, "\r\n");
 590
 591         uh->state = HTTP_STATE_HEADERS_SENT;
 592 }
 593
 594 static void uclient_http_headers_complete(struct uclient_http *uh)
 595 {
 596         enum auth_type auth_type = uh->auth_type;
 597         int seq = uh->uc.seq;
 598
 599         uh->state = HTTP_STATE_RECV_DATA;
 600         uh->uc.meta = uh->meta.head;
 601         uclient_http_process_headers(uh);
 602
 603         if (auth_type == AUTH_TYPE_UNKNOWN && uh->uc.status_code == 401 &&
 604             (uh->req_type == REQ_HEAD || uh->req_type == REQ_GET)) {
 605                 uclient_http_connect(&uh->uc);
 606                 uclient_http_send_headers(uh);
 607                 uh->state = HTTP_STATE_REQUEST_DONE;
 608                 return;
 609         }
 610
 611         if (uh->uc.cb->header_done)
 612                 uh->uc.cb->header_done(&uh->uc);
 613
 614         if (uh->eof || seq != uh->uc.seq)
 615                 return;
 616
 617         if (uh->req_type == REQ_HEAD || uh->uc.status_code == 204) {
 618                 uh->eof = true;
 619                 uclient_notify_eof(uh);
 620         }
 621 }
 622
 623 static void uclient_parse_http_line(struct uclient_http *uh, char *data)
 624 {
 625         char *name;
 626         char *sep;
 627
 628         if (uh->state == HTTP_STATE_REQUEST_DONE) {
 629                 char *code;
 630
 631                 if (!strlen(data))
 632                         return;
 633
 634                 /* HTTP/1.1 */
 635                 strsep(&data, " ");
 636
 637                 code = strsep(&data, " ");
 638                 if (!code)
 639                         goto error;
 640
 641                 uh->uc.status_code = strtoul(code, &sep, 10);
 642                 if (sep && *sep)
 643                         goto error;
 644
 645                 uh->state = HTTP_STATE_RECV_HEADERS;
 646                 return;
 647         }
 648
 649         if (!*data) {
 650                 uclient_http_headers_complete(uh);
 651                 return;
 652         }
 653
 654         sep = strchr(data, ':');
 655         if (!sep)
 656                 return;
 657
 658         *(sep++) = 0;
 659
 660         for (name = data; *name; name++)
 661                 *name = tolower(*name);
 662
 663         name = data;
 664         while (isspace(*sep))
 665                 sep++;
 666
 667         blobmsg_add_string(&uh->meta, name, sep);
 668         return;
 669
 670 error:
 671         uh->uc.status_code = 400;
 672         uh->eof = true;
 673         uclient_notify_eof(uh);
 674 }
 675
 676 static void __uclient_notify_read(struct uclient_http *uh)
 677 {
 678         struct uclient *uc = &uh->uc;
 679         unsigned int seq = uh->seq;
 680         char *data;
 681         int len;
 682
 683         if (uh->state < HTTP_STATE_REQUEST_DONE || uh->state == HTTP_STATE_ERROR)
 684                 return;
 685
 686         data = ustream_get_read_buf(uh->us, &len);
 687         if (!data || !len)
 688                 return;
 689
 690         if (uh->state < HTTP_STATE_RECV_DATA) {
 691                 char *sep, *next;
 692                 int cur_len;
 693
 694                 do {
 695                         sep = strchr(data, '\n');
 696                         if (!sep)
 697                                 break;
 698
 699                         next = sep + 1;
 700                         if (sep > data && sep[-1] == '\r')
 701                                 sep--;
 702
 703                         /* Check for multi-line HTTP headers */
 704                         if (sep > data) {
 705                                 if (!*next)
 706                                         return;
 707
 708                                 if (isspace(*next) && *next != '\r' && *next != '\n') {
 709                                         sep[0] = ' ';
 710                                         if (sep + 1 < next)
 711                                                 sep[1] = ' ';
 712                                         continue;
 713                                 }
 714                         }
 715
 716                         *sep = 0;
 717                         cur_len = next - data;
 718                         uclient_parse_http_line(uh, data);
 719                         if (seq != uh->seq)
 720                                 return;
 721
 722                         ustream_consume(uh->us, cur_len);
 723                         len -= cur_len;
 724
 725                         if (uh->eof)
 726                                 return;
 727
 728                         data = ustream_get_read_buf(uh->us, &len);
 729                 } while (data && uh->state < HTTP_STATE_RECV_DATA);
 730
 731                 if (!len)
 732                         return;
 733         }
 734
 735         if (uh->eof)
 736                 return;
 737
 738         if (uh->state == HTTP_STATE_RECV_DATA) {
 739                 /* Now it's uclient user turn to read some data */
 740                 uloop_timeout_cancel(&uc->connection_timeout);
 741
 742                 if (uc->cb->data_read)
 743                         uc->cb->data_read(uc);
 744         }
 745 }
 746
 747 static void __uclient_notify_write(struct uclient_http *uh)
 748 {
 749         struct uclient *uc = &uh->uc;
 750
 751         if (uc->cb->data_sent)
 752                 uc->cb->data_sent(uc);
 753 }
 754
 755 static void uclient_notify_read(struct ustream *us, int bytes)
 756 {
 757         struct uclient_http *uh = container_of(us, struct uclient_http, ufd.stream);
 758
 759         __uclient_notify_read(uh);
 760 }
 761
 762 static void uclient_notify_write(struct ustream *us, int bytes)
 763 {
 764         struct uclient_http *uh = container_of(us, struct uclient_http, ufd.stream);
 765
 766         __uclient_notify_write(uh);
 767 }
 768
 769 static void uclient_notify_state(struct ustream *us)
 770 {
 771         struct uclient_http *uh = container_of(us, struct uclient_http, ufd.stream);
 772
 773         if (uh->ufd.stream.write_error) {
 774                 uclient_http_error(uh, UCLIENT_ERROR_CONNECT);
 775                 return;
 776         }
 777         uclient_notify_eof(uh);
 778 }
 779
 780 static int uclient_setup_http(struct uclient_http *uh)
 781 {
 782         struct ustream *us = &uh->ufd.stream;
 783         int ret;
 784
 785         uh->us = us;
 786         uh->ssl = false;
 787
 788         us->string_data = true;
 789         us->notify_state = uclient_notify_state;
 790         us->notify_read = uclient_notify_read;
 791         us->notify_write = uclient_notify_write;
 792
 793         ret = uclient_do_connect(uh, "80");
 794         if (ret)
 795                 return UCLIENT_ERROR_CONNECT;
 796
 797         return 0;
 798 }
 799
 800 static void uclient_ssl_notify_read(struct ustream *us, int bytes)
 801 {
 802         struct uclient_http *uh = container_of(us, struct uclient_http, ussl.stream);
 803
 804         __uclient_notify_read(uh);
 805 }
 806
 807 static void uclient_ssl_notify_write(struct ustream *us, int bytes)
 808 {
 809         struct uclient_http *uh = container_of(us, struct uclient_http, ussl.stream);
 810
 811         __uclient_notify_write(uh);
 812 }
 813
 814 static void uclient_ssl_notify_state(struct ustream *us)
 815 {
 816         struct uclient_http *uh = container_of(us, struct uclient_http, ussl.stream);
 817
 818         uclient_notify_eof(uh);
 819 }
 820
 821 static void uclient_ssl_notify_error(struct ustream_ssl *ssl, int error, const char *str)
 822 {
 823         struct uclient_http *uh = container_of(ssl, struct uclient_http, ussl);
 824
 825         uclient_http_error(uh, UCLIENT_ERROR_CONNECT);
 826 }
 827
 828 static void uclient_ssl_notify_verify_error(struct ustream_ssl *ssl, int error, const char *str)
 829 {
 830         struct uclient_http *uh = container_of(ssl, struct uclient_http, ussl);
 831
 832         if (!uh->ssl_require_validation)
 833                 return;
 834
 835         uclient_http_error(uh, UCLIENT_ERROR_SSL_INVALID_CERT);
 836 }
 837
 838 static void uclient_ssl_notify_connected(struct ustream_ssl *ssl)
 839 {
 840         struct uclient_http *uh = container_of(ssl, struct uclient_http, ussl);
 841
 842         if (!uh->ssl_require_validation)
 843                 return;
 844
 845         if (!uh->ussl.valid_cn)
 846                 uclient_http_error(uh, UCLIENT_ERROR_SSL_CN_MISMATCH);
 847 }
 848
 849 static int uclient_setup_https(struct uclient_http *uh)
 850 {
 851         struct ustream *us = &uh->ussl.stream;
 852         int ret;
 853
 854         uh->ssl = true;
 855         uh->us = us;
 856
 857         if (!uh->ssl_ctx)
 858                 return UCLIENT_ERROR_MISSING_SSL_CONTEXT;
 859
 860         ret = uclient_do_connect(uh, "443");
 861         if (ret)
 862                 return UCLIENT_ERROR_CONNECT;
 863
 864         us->string_data = true;
 865         us->notify_state = uclient_ssl_notify_state;
 866         us->notify_read = uclient_ssl_notify_read;
 867         us->notify_write = uclient_ssl_notify_write;
 868         uh->ussl.notify_error = uclient_ssl_notify_error;
 869         uh->ussl.notify_verify_error = uclient_ssl_notify_verify_error;
 870         uh->ussl.notify_connected = uclient_ssl_notify_connected;
 871         uh->ussl.server_name = uh->uc.url->host;
 872         uh->ssl_ops->init(&uh->ussl, &uh->ufd.stream, uh->ssl_ctx, false);
 873         uh->ssl_ops->set_peer_cn(&uh->ussl, uh->uc.url->host);
 874
 875         return 0;
 876 }
 877
 878 static int uclient_http_connect(struct uclient *cl)
 879 {
 880         struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
 881         int ret;
 882
 883         if (!cl->eof || uh->disconnect || uh->connection_close)
 884                 uclient_http_disconnect(uh);
 885
 886         uclient_http_init_request(uh);
 887
 888         if (uh->us)
 889                 return 0;
 890
 891         uh->ssl = cl->url->prefix == PREFIX_HTTPS;
 892
 893         if (uh->ssl)
 894                 ret = uclient_setup_https(uh);
 895         else
 896                 ret = uclient_setup_http(uh);
 897
 898         return ret;
 899 }
 900
 901 static void uclient_http_disconnect_cb(struct uloop_timeout *timeout)
 902 {
 903         struct uclient_http *uh = container_of(timeout, struct uclient_http, disconnect_t);
 904
 905         uclient_http_disconnect(uh);
 906 }
 907
 908 static struct uclient *uclient_http_alloc(void)
 909 {
 910         struct uclient_http *uh;
 911
 912         uh = calloc_a(sizeof(*uh));
 913         uh->disconnect_t.cb = uclient_http_disconnect_cb;
 914         blob_buf_init(&uh->headers, 0);
 915
 916         return &uh->uc;
 917 }
 918
 919 static void uclient_http_free_ssl_ctx(struct uclient_http *uh)
 920 {
 921         uh->ssl_ops = NULL;
 922         uh->ssl_ctx = NULL;
 923 }
 924
 925 static void uclient_http_free(struct uclient *cl)
 926 {
 927         struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
 928
 929         uclient_http_free_url_state(cl);
 930         uclient_http_free_ssl_ctx(uh);
 931         blob_buf_free(&uh->headers);
 932         blob_buf_free(&uh->meta);
 933         free(uh);
 934 }
 935
 936 int
 937 uclient_http_set_request_type(struct uclient *cl, const char *type)
 938 {
 939         struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
 940         int i;
 941
 942         if (cl->backend != &uclient_backend_http)
 943                 return -1;
 944
 945         if (uh->state > HTTP_STATE_INIT)
 946                 return -1;
 947
 948         for (i = 0; i < ARRAY_SIZE(request_types); i++) {
 949                 if (strcmp(request_types[i], type) != 0)
 950                         continue;
 951
 952                 uh->req_type = i;
 953                 return 0;
 954         }
 955
 956         return -1;
 957 }
 958
 959 int
 960 uclient_http_reset_headers(struct uclient *cl)
 961 {
 962         struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
 963
 964         blob_buf_init(&uh->headers, 0);
 965
 966         return 0;
 967 }
 968
 969 int
 970 uclient_http_set_header(struct uclient *cl, const char *name, const char *value)
 971 {
 972         struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
 973
 974         if (cl->backend != &uclient_backend_http)
 975                 return -1;
 976
 977         if (uh->state > HTTP_STATE_INIT)
 978                 return -1;
 979
 980         blobmsg_add_string(&uh->headers, name, value);
 981         return 0;
 982 }
 983
 984 static int
 985 uclient_http_send_data(struct uclient *cl, const char *buf, unsigned int len)
 986 {
 987         struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
 988
 989         if (uh->state >= HTTP_STATE_REQUEST_DONE)
 990                 return -1;
 991
 992         uclient_http_send_headers(uh);
 993
 994         if (len > 0) {
 995                 ustream_printf(uh->us, "%X\r\n", len);
 996                 ustream_write(uh->us, buf, len, false);
 997                 ustream_printf(uh->us, "\r\n");
 998         }
 999
1000         return len;
1001 }
1002
1003 static int
1004 uclient_http_request_done(struct uclient *cl)
1005 {
1006         struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
1007
1008         if (uh->state >= HTTP_STATE_REQUEST_DONE)
1009                 return -1;
1010
1011         uclient_http_send_headers(uh);
1012         if (uclient_request_supports_body(uh->req_type))
1013                 ustream_printf(uh->us, "0\r\n\r\n");
1014         uh->state = HTTP_STATE_REQUEST_DONE;
1015
1016         return 0;
1017 }
1018
1019 static int
1020 uclient_http_read(struct uclient *cl, char *buf, unsigned int len)
1021 {
1022         struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
1023         int read_len = 0;
1024         char *data, *data_end;
1025
1026         if (uh->state < HTTP_STATE_RECV_DATA || !uh->us)
1027                 return 0;
1028
1029         data = ustream_get_read_buf(uh->us, &read_len);
1030         if (!data || !read_len)
1031                 return 0;
1032
1033         data_end = data + read_len;
1034         read_len = 0;
1035
1036         if (uh->read_chunked == 0) {
1037                 char *sep;
1038
1039                 if (data[0] == '\r' && data[1] == '\n') {
1040                         data += 2;
1041                         read_len += 2;
1042                 }
1043
1044                 sep = strstr(data, "\r\n");
1045                 if (!sep)
1046                         return 0;
1047
1048                 *sep = 0;
1049                 uh->read_chunked = strtoul(data, NULL, 16);
1050
1051                 read_len += sep + 2 - data;
1052                 data = sep + 2;
1053
1054                 if (!uh->read_chunked) {
1055                         uh->eof = true;
1056                         uh->uc.data_eof = true;
1057                 }
1058         }
1059
1060         if (len > data_end - data)
1061                 len = data_end - data;
1062
1063         if (uh->read_chunked >= 0) {
1064                 if (len > uh->read_chunked)
1065                         len = uh->read_chunked;
1066
1067                 uh->read_chunked -= len;
1068         } else if (uh->content_length >= 0) {
1069                 if (len > uh->content_length)
1070                         len = uh->content_length;
1071
1072                 uh->content_length -= len;
1073                 if (!uh->content_length) {
1074                         uh->eof = true;
1075                         uh->uc.data_eof = true;
1076                 }
1077         }
1078
1079         if (len > 0) {
1080                 read_len += len;
1081                 memcpy(buf, data, len);
1082         }
1083
1084         if (read_len > 0)
1085                 ustream_consume(uh->us, read_len);
1086
1087         uclient_notify_eof(uh);
1088
1089         /* Now that we consumed something and if this isn't EOF, start timer again */
1090         if (!uh->uc.eof && !cl->connection_timeout.pending)
1091                 uloop_timeout_set(&cl->connection_timeout, cl->timeout_msecs);
1092
1093         return len;
1094 }
1095
1096 int uclient_http_redirect(struct uclient *cl)
1097 {
1098         struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
1099         struct blobmsg_policy location = {
1100                 .name = "location",
1101                 .type = BLOBMSG_TYPE_STRING,
1102         };
1103         struct uclient_url *url = cl->url;
1104         struct blob_attr *tb;
1105
1106         if (cl->backend != &uclient_backend_http)
1107                 return false;
1108
1109         switch (cl->status_code) {
1110         case 301:
1111         case 302:
1112         case 307:
1113                 break;
1114         default:
1115                 return false;
1116         }
1117
1118         blobmsg_parse(&location, 1, &tb, blob_data(uh->meta.head), blob_len(uh->meta.head));
1119         if (!tb)
1120                 return false;
1121
1122         url = uclient_get_url_location(url, blobmsg_data(tb));
1123         if (!url)
1124                 return false;
1125
1126         free(cl->url);
1127         cl->url = url;
1128         if (uclient_http_connect(cl))
1129                 return -1;
1130
1131         uclient_http_request_done(cl);
1132
1133         return true;
1134 }
1135
1136 int uclient_http_set_ssl_ctx(struct uclient *cl, const struct ustream_ssl_ops *ops,
1137                              struct ustream_ssl_ctx *ctx, bool require_validation)
1138 {
1139         struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
1140
1141         if (cl->backend != &uclient_backend_http)
1142                 return -1;
1143
1144         uclient_http_free_url_state(cl);
1145
1146         uclient_http_free_ssl_ctx(uh);
1147         uh->ssl_ops = ops;
1148         uh->ssl_ctx = ctx;
1149         uh->ssl_require_validation = !!ctx && require_validation;
1150
1151         return 0;
1152 }
1153
1154 int uclient_http_set_address_family(struct uclient *cl, int af)
1155 {
1156         struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
1157
1158         if (cl->backend != &uclient_backend_http)
1159                 return -1;
1160
1161         switch (af) {
1162         case AF_INET:
1163                 uh->usock_flags = USOCK_IPV4ONLY;
1164                 break;
1165         case AF_INET6:
1166                 uh->usock_flags = USOCK_IPV6ONLY;
1167                 break;
1168         default:
1169                 uh->usock_flags = 0;
1170                 break;
1171         }
1172
1173         return 0;
1174 }
1175
1176 const struct uclient_backend uclient_backend_http = {
1177         .prefix = uclient_http_prefix,
1178
1179         .alloc = uclient_http_alloc,
1180         .free = uclient_http_free,
1181         .connect = uclient_http_connect,
1182         .disconnect = uclient_http_request_disconnect,
1183         .update_url = uclient_http_free_url_state,
1184         .update_proxy_url = uclient_http_free_url_state,
1185
1186         .read = uclient_http_read,
1187         .write = uclient_http_send_data,
1188         .request = uclient_http_request_done,
1189 };