modules/access/http/h1conn.c

   1 /*****************************************************************************
   2  * h1conn.c: HTTP 1.x connection handling
   3  *****************************************************************************
   4  * Copyright © 2015 Rémi Denis-Courmont
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published by
   8  * the Free Software Foundation; either version 2.1 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  19  *****************************************************************************/
  20
  21 #ifdef HAVE_CONFIG_H
  22 # include <config.h>
  23 #endif
  24
  25 #include <assert.h>
  26 #include <errno.h>
  27 #include <inttypes.h>
  28 #include <stdbool.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <vlc_common.h>
  33 #include <vlc_tls.h>
  34 #include <vlc_block.h>
  35
  36 #include "conn.h"
  37 #include "message.h"
  38
  39 static unsigned vlc_http_can_read(const char *buf, size_t len)
  40 {
  41     static const char end[4] = { '\r', '\n', '\r', '\n' };
  42
  43     for (unsigned i = 4; i > 0; i--)
  44         if (len >= i && !memcmp(buf + len - i, end, i))
  45             return 4 - i;
  46     return 4;
  47 }
  48
  49 /**
  50  * Receives HTTP headers.
  51  *
  52  * Receives HTTP 1.x response line and headers.
  53  *
  54  * @return A heap-allocated null-terminated string contained the full
  55  * headers, including the final CRLF.
  56  */
  57 static char *vlc_https_headers_recv(struct vlc_tls *tls, size_t *restrict lenp)
  58 {
  59     size_t size = 0, len = 0, canread;
  60     char *buf = NULL;
  61
  62     while ((canread = vlc_http_can_read(buf, len)) > 0)
  63     {
  64         ssize_t val;
  65
  66         if (len + canread >= size)
  67         {
  68             size += 2048;
  69             if (size > 65536)
  70                 goto fail;
  71
  72             char *newbuf = realloc(buf, size);
  73             if (unlikely(newbuf == NULL))
  74                 goto fail;
  75
  76             buf = newbuf;
  77         }
  78
  79         assert(size - len >= canread);
  80         //vlc_cleanup_push(free, buf);
  81         val = vlc_tls_Read(tls, buf + len, canread, true);
  82         //vlc_cleanup_pop();
  83
  84         if (val != (ssize_t)canread)
  85             goto fail;
  86
  87         len += val;
  88     }
  89
  90     assert(size - len >= 1);
  91     buf[len] = '\0'; /* for convenience */
  92     if (lenp != NULL)
  93         *lenp = len;
  94     return buf;
  95 fail:
  96     free(buf);
  97     return NULL;
  98 }
  99
 100 /** Gets minor HTTP version */
 101 static int vlc_http_minor(const char *msg)
 102 {
 103     int minor;
 104
 105     if (sscanf(msg, "HTTP/1.%1d", &minor) == 1)
 106         return minor;
 107     return -1;
 108 }
 109
 110 struct vlc_h1_conn
 111 {
 112     struct vlc_http_conn conn;
 113     struct vlc_http_stream stream;
 114     uintmax_t content_length;
 115     bool connection_close;
 116     bool active;
 117     bool released;
 118     bool proxy;
 119     void *opaque;
 120 };
 121
 122 #define CO(conn) ((conn)->opaque)
 123
 124 static void vlc_h1_conn_destroy(struct vlc_h1_conn *conn);
 125
 126 static void *vlc_h1_stream_fatal(struct vlc_h1_conn *conn)
 127 {
 128     if (conn->conn.tls != NULL)
 129     {
 130         vlc_http_dbg(CO(conn), "connection failed");
 131         vlc_tls_Shutdown(conn->conn.tls, true);
 132         vlc_tls_Close(conn->conn.tls);
 133         conn->conn.tls = NULL;
 134     }
 135     return NULL;
 136 }
 137
 138 static struct vlc_h1_conn *vlc_h1_stream_conn(struct vlc_http_stream *stream)
 139 {
 140     return container_of(stream, struct vlc_h1_conn, stream);
 141 }
 142
 143 static struct vlc_http_stream *vlc_h1_stream_open(struct vlc_http_conn *c,
 144                                                 const struct vlc_http_msg *req)
 145 {
 146     struct vlc_h1_conn *conn = container_of(c, struct vlc_h1_conn, conn);
 147     size_t len;
 148     ssize_t val;
 149
 150     if (conn->active || conn->conn.tls == NULL)
 151         return NULL;
 152
 153     char *payload = vlc_http_msg_format(req, &len, conn->proxy);
 154     if (unlikely(payload == NULL))
 155         return NULL;
 156
 157     vlc_http_dbg(CO(conn), "outgoing request:\n%.*s", (int)len, payload);
 158     val = vlc_tls_Write(conn->conn.tls, payload, len);
 159     free(payload);
 160
 161     if (val < (ssize_t)len)
 162         return vlc_h1_stream_fatal(conn);
 163
 164     conn->active = true;
 165     conn->content_length = 0;
 166     conn->connection_close = false;
 167     return &conn->stream;
 168 }
 169
 170 static struct vlc_http_msg *vlc_h1_stream_wait(struct vlc_http_stream *stream)
 171 {
 172     struct vlc_h1_conn *conn = vlc_h1_stream_conn(stream);
 173     struct vlc_http_msg *resp;
 174     const char *str;
 175     size_t len;
 176     int minor;
 177
 178     assert(conn->active);
 179
 180     if (conn->conn.tls == NULL)
 181         return NULL;
 182
 183     char *payload = vlc_https_headers_recv(conn->conn.tls, &len);
 184     if (payload == NULL)
 185         return vlc_h1_stream_fatal(conn);
 186
 187     vlc_http_dbg(CO(conn), "incoming response:\n%.*s", (int)len, payload);
 188
 189     resp = vlc_http_msg_headers(payload);
 190     minor = vlc_http_minor(payload);
 191     free(payload);
 192
 193     if (resp == NULL)
 194         return vlc_h1_stream_fatal(conn);
 195
 196     assert(minor >= 0);
 197
 198     conn->content_length = vlc_http_msg_get_size(resp);
 199     conn->connection_close = false;
 200
 201     if (minor >= 1)
 202     {
 203         if (vlc_http_msg_get_token(resp, "Connection", "close") != NULL)
 204             conn->connection_close = true;
 205
 206         str = vlc_http_msg_get_token(resp, "Transfer-Encoding", "chunked");
 207         if (str != NULL)
 208         {
 209             if (vlc_http_next_token(str) != NULL)
 210             {
 211                 vlc_http_msg_destroy(resp);
 212                 return vlc_h1_stream_fatal(conn); /* unsupported TE */
 213             }
 214
 215             assert(conn->content_length == UINTMAX_MAX);
 216             stream = vlc_chunked_open(stream, conn->conn.tls);
 217             if (unlikely(stream == NULL))
 218             {
 219                 vlc_http_msg_destroy(resp);
 220                 return vlc_h1_stream_fatal(conn);
 221             }
 222         }
 223     }
 224     else
 225         conn->connection_close = true;
 226
 227     vlc_http_msg_attach(resp, stream);
 228     return resp;
 229 }
 230
 231 static block_t *vlc_h1_stream_read(struct vlc_http_stream *stream)
 232 {
 233     struct vlc_h1_conn *conn = vlc_h1_stream_conn(stream);
 234     size_t size = 2048;
 235
 236     assert(conn->active);
 237
 238     if (conn->conn.tls == NULL)
 239         return vlc_http_error;
 240
 241     if (size > conn->content_length)
 242         size = conn->content_length;
 243     if (size == 0)
 244         return NULL;
 245
 246     block_t *block = block_Alloc(size);
 247     if (unlikely(block == NULL))
 248         return vlc_http_error;
 249
 250     ssize_t val = vlc_tls_Read(conn->conn.tls, block->p_buffer, size, false);
 251     if (val <= 0)
 252     {
 253         block_Release(block);
 254         if (val < 0)
 255             return vlc_http_error;
 256         if (conn->content_length != UINTMAX_MAX)
 257         {
 258             errno = ECONNRESET;
 259             return vlc_http_error;
 260         }
 261         return NULL;
 262     }
 263
 264     block->i_buffer = val;
 265     if (conn->content_length != UINTMAX_MAX)
 266         conn->content_length -= val;
 267
 268     return block;
 269 }
 270
 271 static void vlc_h1_stream_close(struct vlc_http_stream *stream, bool abort)
 272 {
 273     struct vlc_h1_conn *conn = vlc_h1_stream_conn(stream);
 274
 275     assert(conn->active);
 276
 277     if (abort)
 278         vlc_h1_stream_fatal(conn);
 279
 280     conn->active = false;
 281
 282     if (conn->released)
 283         vlc_h1_conn_destroy(conn);
 284 }
 285
 286 static const struct vlc_http_stream_cbs vlc_h1_stream_callbacks =
 287 {
 288     vlc_h1_stream_wait,
 289     vlc_h1_stream_read,
 290     vlc_h1_stream_close,
 291 };
 292
 293 static void vlc_h1_conn_destroy(struct vlc_h1_conn *conn)
 294 {
 295     assert(!conn->active);
 296     assert(conn->released);
 297
 298     if (conn->conn.tls != NULL)
 299     {
 300         vlc_tls_Shutdown(conn->conn.tls, true);
 301         vlc_tls_Close(conn->conn.tls);
 302     }
 303     free(conn);
 304 }
 305
 306 static void vlc_h1_conn_release(struct vlc_http_conn *c)
 307 {
 308     struct vlc_h1_conn *conn = container_of(c, struct vlc_h1_conn, conn);
 309
 310     assert(!conn->released);
 311     conn->released = true;
 312
 313     if (!conn->active)
 314         vlc_h1_conn_destroy(conn);
 315 }
 316
 317 static const struct vlc_http_conn_cbs vlc_h1_conn_callbacks =
 318 {
 319     vlc_h1_stream_open,
 320     vlc_h1_conn_release,
 321 };
 322
 323 struct vlc_http_conn *vlc_h1_conn_create(void *ctx, vlc_tls_t *tls, bool proxy)
 324 {
 325     struct vlc_h1_conn *conn = malloc(sizeof (*conn));
 326     if (unlikely(conn == NULL))
 327         return NULL;
 328
 329     conn->conn.cbs = &vlc_h1_conn_callbacks;
 330     conn->conn.tls = tls;
 331     conn->stream.cbs = &vlc_h1_stream_callbacks;
 332     conn->active = false;
 333     conn->released = false;
 334     conn->proxy = proxy;
 335     conn->opaque = ctx;
 336
 337     return &conn->conn;
 338 }
 339
 340 struct vlc_http_stream *vlc_h1_request(void *ctx, const char *hostname,
 341                                        unsigned port, bool proxy,
 342                                        const struct vlc_http_msg *req,
 343                                        bool idempotent,
 344                                        struct vlc_http_conn **restrict connp)
 345 {
 346     struct addrinfo hints =
 347     {
 348         .ai_socktype = SOCK_STREAM,
 349         .ai_protocol = IPPROTO_TCP,
 350     }, *res;
 351
 352     vlc_http_dbg(ctx, "resolving %s ...", hostname);
 353
 354     int val = vlc_getaddrinfo_i11e(hostname, port, &hints, &res);
 355     if (val != 0)
 356     {   /* TODO: C locale for gai_strerror() */
 357         vlc_http_err(ctx, "cannot resolve %s: %s", hostname,
 358                      gai_strerror(val));
 359         return NULL;
 360     }
 361
 362     for (const struct addrinfo *p = res; p != NULL; p = p->ai_next)
 363     {
 364         vlc_tls_t *tcp = vlc_tls_SocketOpenAddrInfo(p, idempotent);
 365         if (tcp == NULL)
 366         {
 367             vlc_http_err(ctx, "socket error: %s", vlc_strerror_c(errno));
 368             continue;
 369         }
 370
 371         struct vlc_http_conn *conn = vlc_h1_conn_create(ctx, tcp, proxy);
 372         if (unlikely(conn == NULL))
 373         {
 374             vlc_tls_SessionDelete(tcp);
 375             continue;
 376         }
 377
 378         /* Send the HTTP request */
 379         struct vlc_http_stream *stream = vlc_http_stream_open(conn, req);
 380
 381         if (stream != NULL)
 382         {
 383             if (connp != NULL)
 384                 *connp = conn;
 385             else
 386                 vlc_http_conn_release(conn);
 387
 388             freeaddrinfo(res);
 389             return stream;
 390         }
 391
 392         vlc_http_conn_release(conn);
 393
 394         if (!idempotent)
 395             break; /* If the request is nonidempotent, it cannot be resent. */
 396     }
 397
 398     /* All address info failed. */
 399     freeaddrinfo(res);
 400     return NULL;
 401 }