modules/access/http/message.c

   1 /*****************************************************************************
   2  * message.c: HTTP request/response
   3  *****************************************************************************
   4  * Copyright (C) 2015 Rémi Denis-Courmont
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it 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 <stdarg.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <time.h>
  32
  33 #include <vlc_common.h>
  34 #include <vlc_http.h>
  35 #include "message.h"
  36 #include "h2frame.h"
  37
  38 struct vlc_http_msg
  39 {
  40     short status;
  41     char *method;
  42     char *scheme;
  43     char *authority;
  44     char *path;
  45     char *(*headers)[2];
  46     unsigned count;
  47     struct vlc_http_stream *payload;
  48 };
  49
  50 static bool vlc_http_is_token(const char *);
  51
  52 static ssize_t vlc_http_msg_find_header(const struct vlc_http_msg *m,
  53                                         const char *name)
  54 {
  55     for (unsigned i = 0; i < m->count; i++)
  56         if (!strcasecmp(m->headers[i][0], name))
  57             return i;
  58     return -1;
  59 }
  60
  61 static int vlc_http_msg_vadd_header(struct vlc_http_msg *m, const char *name,
  62                                     const char *fmt, va_list ap)
  63 {
  64     if (!vlc_http_is_token(name))
  65     {   /* Not a valid field name, i.e. not an HTTP token */
  66         errno = EINVAL;
  67         return -1;
  68     }
  69
  70     char *value;
  71     int len = vasprintf(&value, fmt, ap);
  72     if (unlikely(len < 0))
  73         return -1;
  74
  75     /* IETF RFC7230 §3.2.4 */
  76     for (char *p = value; *p; p++)
  77         if (*p == '\r' || *p == '\n')
  78             *p = ' ';
  79
  80     /* Discard leading OWS */
  81     size_t crop = strspn(value, "\t ");
  82     if (crop > 0)
  83     {
  84         assert((unsigned)len >= crop);
  85         memmove(value, value + crop, len - crop + 1);
  86         len -= crop;
  87     }
  88
  89     /* Discard trailing OWS */
  90     while (len > 0 && (value[len - 1] == '\t' || value[len - 1] == ' '))
  91         value[--len] = '\0';
  92
  93     /* Fold identically named header field values. This is unfortunately not
  94      * possible for Set-Cookie, while Cookie requires a special separator. */
  95     ssize_t idx = vlc_http_msg_find_header(m, name);
  96     if (idx >= 0 && strcasecmp(name, "Set-Cookie"))
  97     {
  98         char *merged;
  99         char sep = strcasecmp(name, "Cookie") ? ',' : ';';
 100
 101         int val = asprintf(&merged, "%s%c %s", m->headers[idx][1], sep, value);
 102
 103         free(value);
 104
 105         if (unlikely(val == -1))
 106             return -1;
 107
 108         free(m->headers[idx][1]);
 109         m->headers[idx][1] = merged;
 110         return 0;
 111     }
 112
 113     char *(*h)[2] = realloc(m->headers, sizeof (char *[2]) * (m->count + 1));
 114     if (unlikely(h == NULL))
 115     {
 116         free(value);
 117         return -1;
 118     }
 119
 120     m->headers = h;
 121     h += m->count;
 122
 123     h[0][0] = strdup(name);
 124     if (unlikely(h[0][0] == NULL))
 125     {
 126         free(value);
 127         return -1;
 128     }
 129
 130     h[0][1] = value;
 131     m->count++;
 132     return 0;
 133 }
 134
 135 int vlc_http_msg_add_header(struct vlc_http_msg *m, const char *name,
 136                             const char *fmt, ...)
 137 {
 138     va_list ap;
 139     int ret;
 140
 141     va_start(ap, fmt);
 142     ret = vlc_http_msg_vadd_header(m, name, fmt, ap);
 143     va_end(ap);
 144     return ret;
 145 }
 146
 147 /* TODO: merge identically named headers (not really needed yet) */
 148
 149 const char *vlc_http_msg_get_header(const struct vlc_http_msg *m,
 150                                     const char *name)
 151 {
 152     ssize_t idx = vlc_http_msg_find_header(m, name);
 153     if (idx < 0)
 154     {
 155         errno = ENOENT;
 156         return NULL;
 157     }
 158     return m->headers[idx][1];
 159 }
 160
 161 int vlc_http_msg_get_status(const struct vlc_http_msg *m)
 162 {
 163     return m->status;
 164 }
 165
 166 const char *vlc_http_msg_get_method(const struct vlc_http_msg *m)
 167 {
 168     return m->method;
 169 }
 170
 171 const char *vlc_http_msg_get_scheme(const struct vlc_http_msg *m)
 172 {
 173     return m->scheme;
 174 }
 175
 176 const char *vlc_http_msg_get_authority(const struct vlc_http_msg *m)
 177 {
 178     return m->authority;
 179 }
 180
 181 const char *vlc_http_msg_get_path(const struct vlc_http_msg *m)
 182 {
 183     return m->path;
 184 }
 185
 186 void vlc_http_msg_destroy(struct vlc_http_msg *m)
 187 {
 188     if (m->payload != NULL)
 189         vlc_http_stream_close(m->payload, false);
 190
 191     for (unsigned i = 0; i < m->count; i++)
 192     {
 193         free(m->headers[i][0]);
 194         free(m->headers[i][1]);
 195     }
 196
 197     free(m->headers);
 198     free(m->path);
 199     free(m->authority);
 200     free(m->scheme);
 201     free(m->method);
 202     free(m);
 203 }
 204
 205 struct vlc_http_msg *
 206 vlc_http_req_create(const char *method, const char *scheme,
 207                     const char *authority, const char *path)
 208 {
 209     struct vlc_http_msg *m = malloc(sizeof (*m));
 210     if (unlikely(m == NULL))
 211         return NULL;
 212
 213     assert(method != NULL);
 214     m->status = -1;
 215     m->method = strdup(method);
 216     m->scheme = (scheme != NULL) ? strdup(scheme) : NULL;
 217     m->authority = (authority != NULL) ? strdup(authority) : NULL;
 218     m->path = (path != NULL) ? strdup(path) : NULL;
 219     m->count = 0;
 220     m->headers = NULL;
 221     m->payload = NULL;
 222
 223     if (unlikely(m->method == NULL
 224               || (scheme != NULL && m->scheme == NULL)
 225               || (authority != NULL && m->authority == NULL)
 226               || (path != NULL && m->path == NULL)))
 227     {
 228         vlc_http_msg_destroy(m);
 229         m = NULL;
 230     }
 231     return m;
 232 }
 233
 234 struct vlc_http_msg *vlc_http_resp_create(unsigned status)
 235 {
 236     struct vlc_http_msg *m = malloc(sizeof (*m));
 237     if (unlikely(m == NULL))
 238         return NULL;
 239
 240     assert(status < 1000);
 241     m->status = status;
 242     m->method = NULL;
 243     m->scheme = NULL;
 244     m->authority = NULL;
 245     m->path = NULL;
 246     m->count = 0;
 247     m->headers = NULL;
 248     m->payload = NULL;
 249     return m;
 250 }
 251
 252 void vlc_http_msg_attach(struct vlc_http_msg *m, struct vlc_http_stream *s)
 253 {
 254     assert(m->payload == NULL);
 255     m->payload = s;
 256 }
 257
 258 struct vlc_http_msg *vlc_http_msg_iterate(struct vlc_http_msg *m)
 259 {
 260     struct vlc_http_msg *next = vlc_http_stream_read_headers(m->payload);
 261
 262     m->payload = NULL;
 263     vlc_http_msg_destroy(m);
 264     return next;
 265 }
 266
 267 struct vlc_http_msg *vlc_http_msg_get_final(struct vlc_http_msg *m)
 268 {
 269     while (m != NULL && (vlc_http_msg_get_status(m) / 100) == 1)
 270         m = vlc_http_msg_iterate(m);
 271     return m;
 272 }
 273
 274 block_t *vlc_http_msg_read(struct vlc_http_msg *m)
 275 {
 276     if (m->payload == NULL)
 277         return NULL;
 278
 279     return vlc_http_stream_read(m->payload);
 280 }
 281
 282 /* Serialization and deserialization */
 283
 284 char *vlc_http_msg_format(const struct vlc_http_msg *m, size_t *restrict lenp)
 285 {
 286     size_t len;
 287
 288     if (m->status < 0)
 289     {
 290         len = sizeof ("  HTTP/1.1\r\nHost: \r\n\r\n");
 291         len += strlen(m->method);
 292         len += strlen(m->path ? m->path : m->authority);
 293         len += strlen(m->authority);
 294     }
 295     else
 296         len = sizeof ("HTTP/1.1 123 .\r\n\r\n");
 297
 298     for (unsigned i = 0; i < m->count; i++)
 299         len += 4 + strlen(m->headers[i][0]) + strlen(m->headers[i][1]);
 300
 301     char *buf = malloc(len + 1);
 302     if (unlikely(buf == NULL))
 303         return NULL;
 304
 305     len = 0;
 306
 307     if (m->status < 0)
 308         len += sprintf(buf, "%s %s HTTP/1.1\r\nHost: %s\r\n", m->method,
 309                        m->path ? m->path : m->authority, m->authority);
 310     else
 311         len += sprintf(buf, "HTTP/1.1 %03hd .\r\n", m->status);
 312
 313     for (unsigned i = 0; i < m->count; i++)
 314         len += sprintf(buf + len, "%s: %s\r\n",
 315                        m->headers[i][0], m->headers[i][1]);
 316
 317     len += sprintf(buf + len, "\r\n");
 318     if (lenp != NULL)
 319         *lenp = len;
 320     return buf;
 321 }
 322
 323 struct vlc_http_msg *vlc_http_msg_headers(const char *msg)
 324 {
 325     struct vlc_http_msg *m;
 326     unsigned short code;
 327
 328     /* TODO: handle HTTP/1.0 differently */
 329     if (sscanf(msg, "HTTP/1.%*1u %3hu %*s", &code) == 1)
 330     {
 331         m = vlc_http_resp_create(code);
 332         if (unlikely(m == NULL))
 333             return NULL;
 334     }
 335     else
 336         return NULL; /* TODO: request support */
 337
 338     msg = strstr(msg, "\r\n");
 339     if (msg == NULL)
 340         goto error;
 341
 342     while (strcmp(msg + 2, "\r\n"))
 343     {
 344         const char *eol = msg;
 345
 346         do
 347         {
 348             eol = strstr(eol + 2, "\r\n");
 349             if (eol == NULL)
 350                 goto error;
 351         }   /* Deal with legacy obs-fold (i.e. multi-line header) */
 352         while (eol[2] == ' ' || eol[2] == '\t');
 353
 354         msg += 2; /* skip CRLF */
 355
 356         const char *colon = memchr(msg, ':', eol - msg);
 357         if (colon == NULL || colon == msg)
 358             goto error;
 359
 360         char *name = strndup(msg, colon - msg);
 361         if (unlikely(name == NULL))
 362             goto error;
 363
 364         colon++;
 365         colon += strspn(colon, " \t");
 366
 367         if (unlikely(vlc_http_msg_add_header(m, name, "%.*s",
 368                                              (int)(eol - colon), colon)))
 369         {
 370             free(name);
 371             goto error;
 372         }
 373         free(name);
 374         msg = eol;
 375     }
 376
 377     return m;
 378 error:
 379     vlc_http_msg_destroy(m);
 380     return NULL;
 381 }
 382
 383 struct vlc_h2_frame *vlc_http_msg_h2_frame(const struct vlc_http_msg *m,
 384                                            uint_fast32_t stream_id, bool eos)
 385 {
 386     for (unsigned j = 0; j < m->count; j++)
 387     {   /* No HTTP 1 specific headers */
 388         assert(strcasecmp(m->headers[j][0], "Connection"));
 389         assert(strcasecmp(m->headers[j][0], "Upgrade"));
 390         assert(strcasecmp(m->headers[j][0], "HTTP2-Settings"));
 391     }
 392
 393     const char *(*headers)[2] = malloc((m->count + 5) * sizeof (char *[2]));
 394     if (unlikely(headers == NULL))
 395         return NULL;
 396
 397     struct vlc_h2_frame *f;
 398     unsigned i = 0;
 399     char status[4];
 400
 401     if (m->status >= 0)
 402     {
 403         assert(m->status < 1000);
 404         sprintf(status, "%hd", m->status);
 405         headers[i][0] = ":status";
 406         headers[i][1] = status;
 407         i++;
 408     }
 409     if (m->method != NULL)
 410     {
 411         headers[i][0] = ":method";
 412         headers[i][1] = m->method;
 413         i++;
 414     }
 415     if (m->scheme != NULL)
 416     {
 417         headers[i][0] = ":scheme";
 418         headers[i][1] = m->scheme;
 419         i++;
 420     }
 421     if (m->authority != NULL)
 422     {
 423         headers[i][0] = ":authority";
 424         headers[i][1] = m->authority;
 425         i++;
 426     }
 427     if (m->path != NULL)
 428     {
 429         headers[i][0] = ":path";
 430         headers[i][1] = m->path;
 431         i++;
 432     }
 433     if (m->count > 0)
 434     {
 435         memcpy(headers + i, m->headers, m->count * sizeof (*headers));
 436         i += m->count;
 437     }
 438
 439     f = vlc_h2_frame_headers(stream_id, VLC_H2_DEFAULT_MAX_FRAME, eos,
 440                              i, headers);
 441     free(headers);
 442     return f;
 443 }
 444
 445 struct vlc_http_msg *vlc_http_msg_h2_headers(unsigned n,
 446                                              const char *const hdrs[][2])
 447 {
 448     struct vlc_http_msg *m = vlc_http_resp_create(0);
 449     if (unlikely(m == NULL))
 450         return NULL;
 451
 452     for (unsigned i = 0; i < n; i++)
 453     {
 454         const char *name = hdrs[i][0];
 455         const char *value = hdrs[i][1];
 456
 457         /* NOTE: HPACK always returns lower-case names, so strcmp() is fine. */
 458         if (!strcmp(name, ":status"))
 459         {
 460             char *end;
 461             unsigned long status = strtoul(value, &end, 10);
 462
 463             if (m->status != 0 || status > 999 || *end != '\0')
 464                 goto error; /* Not a three decimal digits status! */
 465
 466             m->status = status;
 467             continue;
 468         }
 469
 470         if (!strcmp(name, ":method"))
 471         {
 472             if (m->method != NULL)
 473                 goto error;
 474
 475             m->method = strdup(value);
 476             if (unlikely(m->method == NULL))
 477                 goto error;
 478
 479             m->status = -1; /* this is a request */
 480             continue;
 481         }
 482
 483         if (!strcmp(name, ":scheme"))
 484         {
 485             if (m->scheme != NULL)
 486                 goto error;
 487
 488             m->scheme = strdup(value);
 489             if (unlikely(m->scheme == NULL))
 490                 goto error;
 491             continue;
 492         }
 493
 494         if (!strcmp(name, ":authority"))
 495         {
 496             if (m->authority != NULL)
 497                 goto error;
 498
 499             m->authority = strdup(value);
 500             if (unlikely(m->authority == NULL))
 501                 goto error;
 502             continue;
 503         }
 504
 505         if (!strcmp(name, ":path"))
 506         {
 507             if (m->path != NULL)
 508                 goto error;
 509
 510             m->path = strdup(value);
 511             if (unlikely(m->path == NULL))
 512                 goto error;
 513             continue;
 514         }
 515
 516         if (vlc_http_msg_add_header(m, name, "%s", value))
 517             goto error;
 518     }
 519
 520     if ((m->status < 0) == (m->method == NULL))
 521     {   /* Must be either a request or response. Not both, not neither. */
 522 error:
 523         vlc_http_msg_destroy(m);
 524         m = NULL;
 525     }
 526     return m;
 527 }
 528
 529 /* Header helpers */
 530
 531 static int vlc_http_istoken(int c)
 532 {   /* IETF RFC7230 §3.2.6 */
 533     return (c >= '0' && c <= '9')
 534         || (c >= 'a' && c <= 'z')
 535         || (c >= 'A' && c <= 'Z')
 536         || (c && strchr("!#$%&'*+-.^_`|~", c) != NULL);
 537 }
 538
 539 static int vlc_http_isctext(int c)
 540 {   /* IETF RFC7230 §3.2.6 */
 541     return (c == '\t') || (c == ' ') || (c >= 0x21 && c <= 0x27)
 542         || (c >= 0x2A && c <= 0x5B) || (c >= 0x5D && c <= 0x7E)
 543         || (c >= 0x80);
 544 }
 545
 546 static size_t vlc_http_token_length(const char *str)
 547 {
 548     size_t i = 0;
 549
 550     while (vlc_http_istoken(str[i]))
 551         i++;
 552     return i;
 553 }
 554
 555 static size_t vlc_http_quoted_length(const char *str)
 556 {
 557     size_t i = 0;
 558     unsigned char c;
 559
 560     if (str[i++] != '"')
 561         return 0;
 562
 563     do
 564     {
 565         c = str[i++];
 566
 567         if (c == '\0')
 568             return 0;
 569
 570         if (c == '\\') /* Quoted pair */
 571         {
 572             unsigned char q = str[i++];
 573             if (q < 32 && q != '\t')
 574                 return 0;
 575         }
 576     }
 577     while (c != '"');
 578
 579     return i;
 580 }
 581
 582 static bool vlc_http_is_token(const char *str)
 583 {
 584     size_t len = vlc_http_token_length(str);
 585     return len > 0 && str[len] == '\0';
 586 }
 587
 588 const char *vlc_http_next_token(const char *value)
 589 {   /* We handle either token or token = token / quoted-string */
 590     value += strcspn(value, ",\"");
 591     if (!*value)
 592         return NULL;
 593
 594     value += vlc_http_quoted_length(value);
 595     return value + strspn(value, "\t ,");
 596 }
 597
 598 const char *vlc_http_msg_get_token(const struct vlc_http_msg *msg,
 599                                    const char *field, const char *token)
 600 {
 601     const char *value = vlc_http_msg_get_header(msg, field);
 602     const size_t length = strlen(token);
 603
 604     while (value != NULL)
 605     {
 606         if (vlc_http_token_length(value) == length
 607          && !strncasecmp(token, value, length))
 608             return value;
 609
 610         value = vlc_http_next_token(value);
 611     }
 612
 613     return NULL;
 614 }
 615
 616 static size_t vlc_http_comment_length(const char *str)
 617 {   /* IETF RFC7230 §3.2.6 */
 618     if (*str != '(')
 619         return 0;
 620
 621     size_t i = 1;
 622
 623     for (size_t nested = 1; nested > 0; i++)
 624     {
 625         unsigned char c = str[i];
 626
 627         if (c == ')')
 628             nested--;
 629         else
 630         if (c == '(') /* Nested comment */
 631             nested++;
 632         else
 633         if (c == '\\') /* Quoted pair */
 634         {
 635             i++;
 636             if (str[i] < 32)
 637                 return 0;
 638         }
 639         else
 640         if (!vlc_http_isctext(c))
 641             return 0;
 642     }
 643     return i;
 644 }
 645
 646 static bool vlc_http_is_agent(const char *s)
 647 {   /* IETF RFC7231 §5.5.3 and §7.4.2 */
 648     if (!vlc_http_istoken(*s))
 649         return false;
 650
 651     for (;;)
 652     {
 653         size_t l = vlc_http_token_length(s);
 654         if (l != 0) /* product */
 655         {
 656             if (s[l] == '/') /* product version */
 657             {
 658                 s += l + 1;
 659                 l = vlc_http_token_length(s);
 660             }
 661         }
 662         else
 663             l = vlc_http_comment_length(s);
 664
 665         if (l == 0)
 666             break;
 667
 668         s += l;
 669
 670         if (*s == '\0')
 671             return true;
 672
 673         l = strspn(s, "\t "); /* RWS */
 674
 675         if (l == 0)
 676             break;
 677
 678         s += l;
 679     }
 680
 681     return false;
 682 }
 683
 684 int vlc_http_msg_add_agent(struct vlc_http_msg *m, const char *str)
 685 {
 686     const char *hname = (m->status < 0) ? "User-Agent" : "Server";
 687
 688     if (!vlc_http_is_agent(str))
 689     {
 690         errno = EINVAL;
 691         return -1;
 692     }
 693     return vlc_http_msg_add_header(m, hname, "%s", str);
 694 }
 695
 696 const char *vlc_http_msg_get_agent(const struct vlc_http_msg *m)
 697 {
 698     const char *hname = (m->status < 0) ? "User-Agent" : "Server";
 699     const char *str = vlc_http_msg_get_header(m, hname);
 700
 701     return (str != NULL && vlc_http_is_agent(str)) ? str : NULL;
 702 }
 703
 704 static const char vlc_http_days[7][4] = {
 705     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
 706 };
 707 static const char vlc_http_months[12][4] = {
 708     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 709     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
 710 };
 711
 712 int vlc_http_msg_add_time(struct vlc_http_msg *m, const char *hname,
 713                           const time_t *t)
 714 {
 715     struct tm tm;
 716
 717     if (gmtime_r(t, &tm) == NULL)
 718         return -1;
 719     return vlc_http_msg_add_header(m, hname,
 720                                    "%s, %02d %s %04d %02d:%02d:%02d GMT",
 721                                    vlc_http_days[tm.tm_wday], tm.tm_mday,
 722                                    vlc_http_months[tm.tm_mon],
 723                                    1900 + tm.tm_year,
 724                                    tm.tm_hour, tm.tm_min, tm.tm_sec);
 725 }
 726
 727 int vlc_http_msg_add_atime(struct vlc_http_msg *m)
 728 {
 729     time_t now;
 730
 731     time(&now);
 732     return vlc_http_msg_add_time(m, "Date", &now);
 733 }
 734
 735 static time_t vlc_http_mktime(const char *str)
 736 {   /* IETF RFC7231 §7.1.1.1 */
 737     struct tm tm;
 738     char mon[4];
 739
 740     /* Internet Message Format date */
 741     if (sscanf(str, "%*c%*c%*c, %2d %3s %4d %2d:%2d:%2d", &tm.tm_mday, mon,
 742                &tm.tm_year, &tm.tm_hour, &tm.tm_min, &tm.tm_sec) == 6
 743     /* ANSI C format */
 744      || sscanf(str, "%*3s %3s %2d %2d:%2d:%2d %4d", mon, &tm.tm_mday,
 745                &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &tm.tm_year) == 6)
 746         tm.tm_year -= 1900;
 747     /* RFC850 date */
 748     else if (sscanf(str, "%*[^,], %2d-%3s-%2d %2d:%2d:%2d", &tm.tm_mday, mon,
 749                     &tm.tm_year, &tm.tm_hour, &tm.tm_min, &tm.tm_sec) == 6)
 750     {
 751         if (tm.tm_year <= 75)
 752             tm.tm_year += 100; /* Y2K compat, sort of */
 753     }
 754     else /* Unknown format */
 755         goto error;
 756
 757     for (tm.tm_mon = 0; tm.tm_mon < 12; tm.tm_mon++)
 758         if (!strcmp(mon, vlc_http_months[tm.tm_mon])) /* found month */
 759             return timegm(&tm);
 760 error:
 761     errno = EINVAL;
 762     return -1; /* invalid month */
 763 }
 764
 765 time_t vlc_http_msg_get_time(const struct vlc_http_msg *m, const char *name)
 766 {
 767     const char *str = vlc_http_msg_get_header(m, name);
 768     if (str == NULL)
 769         return -1;
 770     return vlc_http_mktime(str);
 771 }
 772
 773 time_t vlc_http_msg_get_atime(const struct vlc_http_msg *m)
 774 {
 775     return vlc_http_msg_get_time(m, "Date");
 776 }
 777
 778 time_t vlc_http_msg_get_mtime(const struct vlc_http_msg *m)
 779 {
 780     return vlc_http_msg_get_time(m, "Last-Modified");
 781 }
 782
 783 unsigned vlc_http_msg_get_retry_after(const struct vlc_http_msg *m)
 784 {
 785     const char *str = vlc_http_msg_get_header(m, "Retry-After");
 786     if (str == NULL)
 787         return 0;
 788
 789     char *end;
 790     unsigned long delay = strtoul(str, &end, 10);
 791     if (end != str && *end == '\0')
 792         return delay;
 793
 794     time_t t = vlc_http_mktime(str);
 795     if (t != (time_t)-1)
 796     {
 797         time_t now;
 798
 799         time(&now);
 800         if (t >= now)
 801             return t - now;
 802     }
 803     return 0;
 804 }
 805
 806 uintmax_t vlc_http_msg_get_size(const struct vlc_http_msg *m)
 807 {   /* IETF RFC7230 §3.3.3 */
 808     if ((m->status / 100) == 1 /* Informational 1xx (implicitly void) */
 809      || m->status == 204 /* No Content (implicitly void) */
 810      || m->status == 205 /* Reset Content (must be explicitly void) */
 811      || m->status == 304 /* Not Modified */)
 812         return 0;
 813
 814     const char *str = vlc_http_msg_get_header(m, "Transfer-Encoding");
 815     if (str != NULL) /* Transfer-Encoding preempts Content-Length */
 816         return -1;
 817
 818     str = vlc_http_msg_get_header(m, "Content-Length");
 819     if (str == NULL)
 820     {
 821         if (m->status < 0)
 822             return 0; /* Requests are void by default */
 823         return -1; /* Response of unknown size (e.g. chunked) */
 824     }
 825
 826     uintmax_t length;
 827
 828     if (sscanf(str, "%ju", &length) == 1)
 829         return length;
 830
 831     errno = EINVAL;
 832     return -1;
 833 }
 834
 835 void vlc_http_msg_get_cookies(const struct vlc_http_msg *m,
 836                               vlc_http_cookie_jar_t *jar, bool secure,
 837                               const char *host, const char *path)
 838 {
 839     for (unsigned i = 0; i < m->count; i++)
 840         if (!strcasecmp(m->headers[i][0], "Set-Cookie"))
 841             vlc_http_cookies_store(jar, m->headers[i][1], secure, host, path);
 842 }
 843
 844 int vlc_http_msg_add_cookies(struct vlc_http_msg *m,
 845                              vlc_http_cookie_jar_t *jar)
 846 {
 847     char *host, *cookies;
 848     int val = 0;
 849     bool secure;
 850
 851     if (m->scheme == NULL || m->authority == NULL || m->path == NULL)
 852     {
 853         errno = EINVAL;
 854         return -1;
 855     }
 856
 857     if (!strcasecmp(m->scheme, "https"))
 858         secure = true;
 859     else if (!strcasecmp(m->scheme, "http"))
 860         secure = false;
 861     else
 862         return 0;
 863
 864     if (m->authority[0] == '[')
 865         host = strndup(m->authority + 1, strcspn(m->authority + 1, "]"));
 866     else
 867         host = strndup(m->authority, strcspn(m->authority, ":"));
 868     if (unlikely(host == NULL))
 869         return -1;
 870
 871     cookies = vlc_http_cookies_fetch(jar, secure, host, m->path);
 872     free(host);
 873
 874     if (cookies != NULL)
 875     {
 876         val = vlc_http_msg_add_header(m, "Cookie", "%s", cookies);
 877         free(cookies);
 878     }
 879     return val;
 880 }