http: Add support for selecting a request range
[ffmpeg.git] / libavformat / http.c
1 /*
2  * HTTP protocol for avconv client
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "libavutil/avstring.h"
23 #include "avformat.h"
24 #include "internal.h"
25 #include "network.h"
26 #include "http.h"
27 #include "os_support.h"
28 #include "httpauth.h"
29 #include "url.h"
30 #include "libavutil/opt.h"
31
32 #if CONFIG_ZLIB
33 #include <zlib.h>
34 #endif
35
36 /* XXX: POST protocol is not completely implemented because avconv uses
37    only a subset of it. */
38
39 /* The IO buffer size is unrelated to the max URL size in itself, but needs
40  * to be large enough to fit the full request headers (including long
41  * path names).
42  */
43 #define BUFFER_SIZE MAX_URL_SIZE
44 #define MAX_REDIRECTS 8
45
46 typedef struct {
47     const AVClass *class;
48     URLContext *hd;
49     unsigned char buffer[BUFFER_SIZE], *buf_ptr, *buf_end;
50     int line_count;
51     int http_code;
52     /* Used if "Transfer-Encoding: chunked" otherwise -1. */
53     int64_t chunksize;
54     int64_t off, end_off, filesize;
55     char *location;
56     HTTPAuthState auth_state;
57     HTTPAuthState proxy_auth_state;
58     char *headers;
59     char *mime_type;
60     char *user_agent;
61     /* Set if the server correctly handles Connection: close and will close
62      * the connection after feeding us the content. */
63     int willclose;
64     int chunked_post;
65     /* A flag which indicates if the end of chunked encoding has been sent. */
66     int end_chunked_post;
67     /* A flag which indicates we have finished to read POST reply. */
68     int end_header;
69     /* A flag which indicates if we use persistent connections. */
70     int multiple_requests;
71     uint8_t *post_data;
72     int post_datalen;
73     int icy;
74     /* how much data was read since the last ICY metadata packet */
75     int icy_data_read;
76     /* after how many bytes of read data a new metadata packet will be found */
77     int icy_metaint;
78     char *icy_metadata_headers;
79     char *icy_metadata_packet;
80 #if CONFIG_ZLIB
81     int compressed;
82     z_stream inflate_stream;
83     uint8_t *inflate_buffer;
84 #endif
85     AVDictionary *chained_options;
86     int send_expect_100;
87 } HTTPContext;
88
89 #define OFFSET(x) offsetof(HTTPContext, x)
90 #define D AV_OPT_FLAG_DECODING_PARAM
91 #define E AV_OPT_FLAG_ENCODING_PARAM
92 #define DEFAULT_USER_AGENT "Lavf/" AV_STRINGIFY(LIBAVFORMAT_VERSION)
93 static const AVOption options[] = {
94 {"chunked_post", "use chunked transfer-encoding for posts", OFFSET(chunked_post), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, E },
95 {"headers", "custom HTTP headers, can override built in default headers", OFFSET(headers), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
96 {"user_agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = DEFAULT_USER_AGENT}, 0, 0, D },
97 {"user-agent", "override User-Agent header, for compatibility with ffmpeg", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = DEFAULT_USER_AGENT}, 0, 0, D },
98 {"multiple_requests", "use persistent connections", OFFSET(multiple_requests), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, D|E },
99 {"post_data", "custom HTTP post data", OFFSET(post_data), AV_OPT_TYPE_BINARY, .flags = D|E },
100 {"mime_type", "export the MIME type", OFFSET(mime_type), AV_OPT_TYPE_STRING, {0}, 0, 0, AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY  },
101 {"icy", "request ICY metadata", OFFSET(icy), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, D },
102 {"icy_metadata_headers", "return ICY metadata headers", OFFSET(icy_metadata_headers), AV_OPT_TYPE_STRING, {0}, 0, 0, AV_OPT_FLAG_EXPORT },
103 {"icy_metadata_packet", "return current ICY metadata packet", OFFSET(icy_metadata_packet), AV_OPT_TYPE_STRING, {0}, 0, 0, AV_OPT_FLAG_EXPORT },
104 {"auth_type", "HTTP authentication type", OFFSET(auth_state.auth_type), AV_OPT_TYPE_INT, {.i64 = HTTP_AUTH_NONE}, HTTP_AUTH_NONE, HTTP_AUTH_BASIC, D|E, "auth_type" },
105 {"none", "No auth method set, autodetect", 0, AV_OPT_TYPE_CONST, {.i64 = HTTP_AUTH_NONE}, 0, 0, D|E, "auth_type" },
106 {"basic", "HTTP basic authentication", 0, AV_OPT_TYPE_CONST, {.i64 = HTTP_AUTH_BASIC}, 0, 0, D|E, "auth_type" },
107 {"send_expect_100", "Force sending an Expect: 100-continue header for POST", OFFSET(send_expect_100), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, E },
108 {"location", "The actual location of the data received", OFFSET(location), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
109 {"offset", "initial byte offset", OFFSET(off), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, D },
110 {"end_offset", "try to limit the request to bytes preceding this offset", OFFSET(end_off), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, D },
111 {NULL}
112 };
113 #define HTTP_CLASS(flavor)\
114 static const AVClass flavor ## _context_class = {\
115     .class_name     = #flavor,\
116     .item_name      = av_default_item_name,\
117     .option         = options,\
118     .version        = LIBAVUTIL_VERSION_INT,\
119 }
120
121 HTTP_CLASS(http);
122 HTTP_CLASS(https);
123
124 static int http_connect(URLContext *h, const char *path, const char *local_path,
125                         const char *hoststr, const char *auth,
126                         const char *proxyauth, int *new_location);
127
128 void ff_http_init_auth_state(URLContext *dest, const URLContext *src)
129 {
130     memcpy(&((HTTPContext*)dest->priv_data)->auth_state,
131            &((HTTPContext*)src->priv_data)->auth_state, sizeof(HTTPAuthState));
132     memcpy(&((HTTPContext*)dest->priv_data)->proxy_auth_state,
133            &((HTTPContext*)src->priv_data)->proxy_auth_state,
134            sizeof(HTTPAuthState));
135 }
136
137 /* return non zero if error */
138 static int http_open_cnx(URLContext *h, AVDictionary **options)
139 {
140     const char *path, *proxy_path, *lower_proto = "tcp", *local_path;
141     char hostname[1024], hoststr[1024], proto[10];
142     char auth[1024], proxyauth[1024] = "";
143     char path1[MAX_URL_SIZE];
144     char buf[1024], urlbuf[MAX_URL_SIZE];
145     int port, use_proxy, err, location_changed = 0, redirects = 0, attempts = 0;
146     HTTPAuthType cur_auth_type, cur_proxy_auth_type;
147     HTTPContext *s = h->priv_data;
148
149     /* fill the dest addr */
150  redo:
151     /* needed in any case to build the host string */
152     av_url_split(proto, sizeof(proto), auth, sizeof(auth),
153                  hostname, sizeof(hostname), &port,
154                  path1, sizeof(path1), s->location);
155     ff_url_join(hoststr, sizeof(hoststr), NULL, NULL, hostname, port, NULL);
156
157     proxy_path = getenv("http_proxy");
158     use_proxy = !ff_http_match_no_proxy(getenv("no_proxy"), hostname) &&
159                 proxy_path != NULL && av_strstart(proxy_path, "http://", NULL);
160
161     if (!strcmp(proto, "https")) {
162         lower_proto = "tls";
163         use_proxy = 0;
164         if (port < 0)
165             port = 443;
166     }
167     if (port < 0)
168         port = 80;
169
170     if (path1[0] == '\0')
171         path = "/";
172     else
173         path = path1;
174     local_path = path;
175     if (use_proxy) {
176         /* Reassemble the request URL without auth string - we don't
177          * want to leak the auth to the proxy. */
178         ff_url_join(urlbuf, sizeof(urlbuf), proto, NULL, hostname, port, "%s",
179                     path1);
180         path = urlbuf;
181         av_url_split(NULL, 0, proxyauth, sizeof(proxyauth),
182                      hostname, sizeof(hostname), &port, NULL, 0, proxy_path);
183     }
184
185     ff_url_join(buf, sizeof(buf), lower_proto, NULL, hostname, port, NULL);
186
187     if (!s->hd) {
188         err = ffurl_open(&s->hd, buf, AVIO_FLAG_READ_WRITE,
189                          &h->interrupt_callback, options);
190         if (err < 0)
191             goto fail;
192     }
193
194     cur_auth_type = s->auth_state.auth_type;
195     cur_proxy_auth_type = s->auth_state.auth_type;
196     if (http_connect(h, path, local_path, hoststr, auth, proxyauth, &location_changed) < 0)
197         goto fail;
198     attempts++;
199     if (s->http_code == 401) {
200         if ((cur_auth_type == HTTP_AUTH_NONE || s->auth_state.stale) &&
201             s->auth_state.auth_type != HTTP_AUTH_NONE && attempts < 4) {
202             ffurl_close(s->hd);
203             s->hd = NULL;
204             goto redo;
205         } else
206             goto fail;
207     }
208     if (s->http_code == 407) {
209         if ((cur_proxy_auth_type == HTTP_AUTH_NONE || s->proxy_auth_state.stale) &&
210             s->proxy_auth_state.auth_type != HTTP_AUTH_NONE && attempts < 4) {
211             ffurl_close(s->hd);
212             s->hd = NULL;
213             goto redo;
214         } else
215             goto fail;
216     }
217     if ((s->http_code == 301 || s->http_code == 302 || s->http_code == 303 || s->http_code == 307)
218         && location_changed == 1) {
219         /* url moved, get next */
220         ffurl_close(s->hd);
221         s->hd = NULL;
222         if (redirects++ >= MAX_REDIRECTS)
223             return AVERROR(EIO);
224         /* Restart the authentication process with the new target, which
225          * might use a different auth mechanism. */
226         memset(&s->auth_state, 0, sizeof(s->auth_state));
227         attempts = 0;
228         location_changed = 0;
229         goto redo;
230     }
231     return 0;
232  fail:
233     if (s->hd)
234         ffurl_close(s->hd);
235     s->hd = NULL;
236     return AVERROR(EIO);
237 }
238
239 int ff_http_do_new_request(URLContext *h, const char *uri)
240 {
241     HTTPContext *s = h->priv_data;
242     AVDictionary *options = NULL;
243     int ret;
244
245     s->off = 0;
246     s->icy_data_read = 0;
247     av_free(s->location);
248     s->location = av_strdup(uri);
249     if (!s->location)
250         return AVERROR(ENOMEM);
251
252     av_dict_copy(&options, s->chained_options, 0);
253     ret = http_open_cnx(h, &options);
254     av_dict_free(&options);
255     return ret;
256 }
257
258 static int http_open(URLContext *h, const char *uri, int flags,
259                      AVDictionary **options)
260 {
261     HTTPContext *s = h->priv_data;
262     int ret;
263
264     h->is_streamed = 1;
265
266     s->filesize = -1;
267     s->location = av_strdup(uri);
268     if (!s->location)
269         return AVERROR(ENOMEM);
270     if (options)
271         av_dict_copy(&s->chained_options, *options, 0);
272
273     if (s->headers) {
274         int len = strlen(s->headers);
275         if (len < 2 || strcmp("\r\n", s->headers + len - 2))
276             av_log(h, AV_LOG_WARNING, "No trailing CRLF found in HTTP header.\n");
277     }
278
279     ret = http_open_cnx(h, options);
280     if (ret < 0)
281         av_dict_free(&s->chained_options);
282     return ret;
283 }
284 static int http_getc(HTTPContext *s)
285 {
286     int len;
287     if (s->buf_ptr >= s->buf_end) {
288         len = ffurl_read(s->hd, s->buffer, BUFFER_SIZE);
289         if (len < 0) {
290             return len;
291         } else if (len == 0) {
292             return AVERROR_EOF;
293         } else {
294             s->buf_ptr = s->buffer;
295             s->buf_end = s->buffer + len;
296         }
297     }
298     return *s->buf_ptr++;
299 }
300
301 static int http_get_line(HTTPContext *s, char *line, int line_size)
302 {
303     int ch;
304     char *q;
305
306     q = line;
307     for(;;) {
308         ch = http_getc(s);
309         if (ch < 0)
310             return ch;
311         if (ch == '\n') {
312             /* process line */
313             if (q > line && q[-1] == '\r')
314                 q--;
315             *q = '\0';
316
317             return 0;
318         } else {
319             if ((q - line) < line_size - 1)
320                 *q++ = ch;
321         }
322     }
323 }
324
325 static int check_http_code(URLContext *h, int http_code, const char *end)
326 {
327     HTTPContext *s = h->priv_data;
328     /* error codes are 4xx and 5xx, but regard 401 as a success, so we
329      * don't abort until all headers have been parsed. */
330     if (http_code >= 400 && http_code < 600 &&
331         (http_code != 401 || s->auth_state.auth_type != HTTP_AUTH_NONE) &&
332         (http_code != 407 || s->proxy_auth_state.auth_type != HTTP_AUTH_NONE)) {
333         end += strspn(end, SPACE_CHARS);
334         av_log(h, AV_LOG_WARNING, "HTTP error %d %s\n", http_code, end);
335         return AVERROR(EIO);
336     }
337     return 0;
338 }
339
340 static int parse_location(HTTPContext *s, const char *p)
341 {
342     char redirected_location[MAX_URL_SIZE], *new_loc;
343     ff_make_absolute_url(redirected_location, sizeof(redirected_location),
344                          s->location, p);
345     new_loc = av_strdup(redirected_location);
346     if (!new_loc)
347         return AVERROR(ENOMEM);
348     av_free(s->location);
349     s->location = new_loc;
350     return 0;
351 }
352
353 /* "bytes $from-$to/$document_size" */
354 static void parse_content_range(URLContext *h, char *p)
355 {
356     HTTPContext *s = h->priv_data;
357     const char *slash;
358
359     if (!strncmp(p, "bytes ", 6)) {
360         p += 6;
361         s->off = strtoll(p, NULL, 10);
362         if ((slash = strchr(p, '/')) && strlen(slash) > 0)
363             s->filesize = strtoll(slash+1, NULL, 10);
364     }
365     h->is_streamed = 0; /* we _can_ in fact seek */
366 }
367
368 static int parse_content_encoding(URLContext *h, char *p)
369 {
370     HTTPContext *s = h->priv_data;
371
372     if (!av_strncasecmp(p, "gzip", 4) ||
373         !av_strncasecmp(p, "deflate", 7)) {
374 #if CONFIG_ZLIB
375         s->compressed = 1;
376         inflateEnd(&s->inflate_stream);
377         if (inflateInit2(&s->inflate_stream, 32 + 15) != Z_OK) {
378             av_log(h, AV_LOG_WARNING, "Error during zlib initialisation: %s\n",
379                    s->inflate_stream.msg);
380             return AVERROR(ENOSYS);
381         }
382         if (zlibCompileFlags() & (1 << 17)) {
383             av_log(h, AV_LOG_WARNING,
384                    "Your zlib was compiled without gzip support.\n");
385             return AVERROR(ENOSYS);
386         }
387 #else
388         av_log(h, AV_LOG_WARNING,
389                "Compressed (%s) content, need zlib with gzip support\n", p);
390         return AVERROR(ENOSYS);
391 #endif
392     } else if (!av_strncasecmp(p, "identity", 8)) {
393         // The normal, no-encoding case (although servers shouldn't include
394         // the header at all if this is the case).
395     } else {
396         av_log(h, AV_LOG_WARNING, "Unknown content coding: %s\n", p);
397         return AVERROR(ENOSYS);
398     }
399     return 0;
400 }
401
402 // Concat all Icy- header lines
403 static int parse_icy(HTTPContext *s, const char *tag, const char *p)
404 {
405     int len = 4 + strlen(p) + strlen(tag);
406     int ret;
407
408     if (s->icy_metadata_headers)
409         len += strlen(s->icy_metadata_headers);
410
411     if ((ret = av_reallocp(&s->icy_metadata_headers, len)) < 0)
412         return ret;
413
414     av_strlcatf(s->icy_metadata_headers, len, "%s: %s\n", tag, p);
415
416     return 0;
417 }
418
419 static int process_line(URLContext *h, char *line, int line_count,
420                         int *new_location)
421 {
422     HTTPContext *s = h->priv_data;
423     char *tag, *p, *end;
424     int ret;
425
426     /* end of header */
427     if (line[0] == '\0') {
428         s->end_header = 1;
429         return 0;
430     }
431
432     p = line;
433     if (line_count == 0) {
434         while (!av_isspace(*p) && *p != '\0')
435             p++;
436         while (av_isspace(*p))
437             p++;
438         s->http_code = strtol(p, &end, 10);
439
440         av_dlog(NULL, "http_code=%d\n", s->http_code);
441
442         if ((ret = check_http_code(h, s->http_code, end)) < 0)
443             return ret;
444     } else {
445         while (*p != '\0' && *p != ':')
446             p++;
447         if (*p != ':')
448             return 1;
449
450         *p = '\0';
451         tag = line;
452         p++;
453         while (av_isspace(*p))
454             p++;
455         if (!av_strcasecmp(tag, "Location")) {
456             if ((ret = parse_location(s, p)) < 0)
457                 return ret;
458             *new_location = 1;
459         } else if (!av_strcasecmp(tag, "Content-Length") && s->filesize == -1) {
460             s->filesize = strtoll(p, NULL, 10);
461         } else if (!av_strcasecmp(tag, "Content-Range")) {
462             parse_content_range(h, p);
463         } else if (!av_strcasecmp(tag, "Accept-Ranges") &&
464                    !strncmp(p, "bytes", 5)) {
465             h->is_streamed = 0;
466         } else if (!av_strcasecmp(tag, "Transfer-Encoding") &&
467                    !av_strncasecmp(p, "chunked", 7)) {
468             s->filesize = -1;
469             s->chunksize = 0;
470         } else if (!av_strcasecmp(tag, "WWW-Authenticate")) {
471             ff_http_auth_handle_header(&s->auth_state, tag, p);
472         } else if (!av_strcasecmp(tag, "Authentication-Info")) {
473             ff_http_auth_handle_header(&s->auth_state, tag, p);
474         } else if (!av_strcasecmp(tag, "Proxy-Authenticate")) {
475             ff_http_auth_handle_header(&s->proxy_auth_state, tag, p);
476         } else if (!av_strcasecmp(tag, "Connection")) {
477             if (!strcmp(p, "close"))
478                 s->willclose = 1;
479         } else if (!av_strcasecmp (tag, "Content-Type")) {
480             av_free(s->mime_type);
481             s->mime_type = av_strdup(p);
482         } else if (!av_strcasecmp (tag, "Icy-MetaInt")) {
483             s->icy_metaint = strtoll(p, NULL, 10);
484         } else if (!av_strncasecmp(tag, "Icy-", 4)) {
485             if ((ret = parse_icy(s, tag, p)) < 0)
486                 return ret;
487         } else if (!av_strcasecmp(tag, "Content-Encoding")) {
488             if ((ret = parse_content_encoding(h, p)) < 0)
489                 return ret;
490         }
491     }
492     return 1;
493 }
494
495 static inline int has_header(const char *str, const char *header)
496 {
497     /* header + 2 to skip over CRLF prefix. (make sure you have one!) */
498     if (!str)
499         return 0;
500     return av_stristart(str, header + 2, NULL) || av_stristr(str, header);
501 }
502
503 static int http_read_header(URLContext *h, int *new_location)
504 {
505     HTTPContext *s = h->priv_data;
506     char line[MAX_URL_SIZE];
507     int err = 0;
508
509     s->chunksize = -1;
510
511     for (;;) {
512         if ((err = http_get_line(s, line, sizeof(line))) < 0)
513             return err;
514
515         av_dlog(NULL, "header='%s'\n", line);
516
517         err = process_line(h, line, s->line_count, new_location);
518         if (err < 0)
519             return err;
520         if (err == 0)
521             break;
522         s->line_count++;
523     }
524
525     return err;
526 }
527
528 static int http_connect(URLContext *h, const char *path, const char *local_path,
529                         const char *hoststr, const char *auth,
530                         const char *proxyauth, int *new_location)
531 {
532     HTTPContext *s = h->priv_data;
533     int post, err;
534     char headers[1024] = "";
535     char *authstr = NULL, *proxyauthstr = NULL;
536     int64_t off = s->off;
537     int len = 0;
538     const char *method;
539     int send_expect_100 = 0;
540
541
542     /* send http header */
543     post = h->flags & AVIO_FLAG_WRITE;
544
545     if (s->post_data) {
546         /* force POST method and disable chunked encoding when
547          * custom HTTP post data is set */
548         post = 1;
549         s->chunked_post = 0;
550     }
551
552     method = post ? "POST" : "GET";
553     authstr = ff_http_auth_create_response(&s->auth_state, auth, local_path,
554                                            method);
555     proxyauthstr = ff_http_auth_create_response(&s->proxy_auth_state, proxyauth,
556                                                 local_path, method);
557     if (post && !s->post_data) {
558         send_expect_100 = s->send_expect_100;
559         /* The user has supplied authentication but we don't know the auth type,
560          * send Expect: 100-continue to get the 401 response including the
561          * WWW-Authenticate header, or an 100 continue if no auth actually
562          * is needed. */
563         if (auth && *auth &&
564             s->auth_state.auth_type == HTTP_AUTH_NONE &&
565             s->http_code != 401)
566             send_expect_100 = 1;
567     }
568
569     /* set default headers if needed */
570     if (!has_header(s->headers, "\r\nUser-Agent: "))
571         len += av_strlcatf(headers + len, sizeof(headers) - len,
572                            "User-Agent: %s\r\n", s->user_agent);
573     if (!has_header(s->headers, "\r\nAccept: "))
574         len += av_strlcpy(headers + len, "Accept: */*\r\n",
575                           sizeof(headers) - len);
576     // Note: we send this on purpose even when s->off is 0 when we're probing,
577     // since it allows us to detect more reliably if a (non-conforming)
578     // server supports seeking by analysing the reply headers.
579     if (!has_header(s->headers, "\r\nRange: ") && !post) {
580         len += av_strlcatf(headers + len, sizeof(headers) - len,
581                            "Range: bytes=%"PRId64"-", s->off);
582         if (s->end_off)
583             len += av_strlcatf(headers + len, sizeof(headers) - len,
584                                "%"PRId64, s->end_off - 1);
585         len += av_strlcpy(headers + len, "\r\n",
586                           sizeof(headers) - len);
587     }
588     if (send_expect_100 && !has_header(s->headers, "\r\nExpect: "))
589         len += av_strlcatf(headers + len, sizeof(headers) - len,
590                            "Expect: 100-continue\r\n");
591
592     if (!has_header(s->headers, "\r\nConnection: ")) {
593         if (s->multiple_requests) {
594             len += av_strlcpy(headers + len, "Connection: keep-alive\r\n",
595                               sizeof(headers) - len);
596         } else {
597             len += av_strlcpy(headers + len, "Connection: close\r\n",
598                               sizeof(headers) - len);
599         }
600     }
601
602     if (!has_header(s->headers, "\r\nHost: "))
603         len += av_strlcatf(headers + len, sizeof(headers) - len,
604                            "Host: %s\r\n", hoststr);
605     if (!has_header(s->headers, "\r\nContent-Length: ") && s->post_data)
606         len += av_strlcatf(headers + len, sizeof(headers) - len,
607                            "Content-Length: %d\r\n", s->post_datalen);
608     if (!has_header(s->headers, "\r\nIcy-MetaData: ") && s->icy) {
609         len += av_strlcatf(headers + len, sizeof(headers) - len,
610                            "Icy-MetaData: %d\r\n", 1);
611     }
612
613     /* now add in custom headers */
614     if (s->headers)
615         av_strlcpy(headers + len, s->headers, sizeof(headers) - len);
616
617     snprintf(s->buffer, sizeof(s->buffer),
618              "%s %s HTTP/1.1\r\n"
619              "%s"
620              "%s"
621              "%s"
622              "%s%s"
623              "\r\n",
624              method,
625              path,
626              post && s->chunked_post ? "Transfer-Encoding: chunked\r\n" : "",
627              headers,
628              authstr ? authstr : "",
629              proxyauthstr ? "Proxy-" : "", proxyauthstr ? proxyauthstr : "");
630
631     av_freep(&authstr);
632     av_freep(&proxyauthstr);
633     if ((err = ffurl_write(s->hd, s->buffer, strlen(s->buffer))) < 0)
634         return err;
635
636     if (s->post_data)
637         if ((err = ffurl_write(s->hd, s->post_data, s->post_datalen)) < 0)
638             return err;
639
640     /* init input buffer */
641     s->buf_ptr = s->buffer;
642     s->buf_end = s->buffer;
643     s->line_count = 0;
644     s->off = 0;
645     s->icy_data_read = 0;
646     s->filesize = -1;
647     s->willclose = 0;
648     s->end_chunked_post = 0;
649     s->end_header = 0;
650     if (post && !s->post_data && !send_expect_100) {
651         /* Pretend that it did work. We didn't read any header yet, since
652          * we've still to send the POST data, but the code calling this
653          * function will check http_code after we return. */
654         s->http_code = 200;
655         return 0;
656     }
657
658     /* wait for header */
659     err = http_read_header(h, new_location);
660     if (err < 0)
661         return err;
662
663     return (off == s->off) ? 0 : -1;
664 }
665
666
667 static int http_buf_read(URLContext *h, uint8_t *buf, int size)
668 {
669     HTTPContext *s = h->priv_data;
670     int len;
671     /* read bytes from input buffer first */
672     len = s->buf_end - s->buf_ptr;
673     if (len > 0) {
674         if (len > size)
675             len = size;
676         memcpy(buf, s->buf_ptr, len);
677         s->buf_ptr += len;
678     } else {
679         if (!s->willclose && s->filesize >= 0 && s->off >= s->filesize)
680             return AVERROR_EOF;
681         len = ffurl_read(s->hd, buf, size);
682     }
683     if (len > 0) {
684         s->off += len;
685         if (s->chunksize > 0)
686             s->chunksize -= len;
687     }
688     return len;
689 }
690
691 #if CONFIG_ZLIB
692 #define DECOMPRESS_BUF_SIZE (256 * 1024)
693 static int http_buf_read_compressed(URLContext *h, uint8_t *buf, int size)
694 {
695     HTTPContext *s = h->priv_data;
696     int ret;
697
698     if (!s->inflate_buffer) {
699         s->inflate_buffer = av_malloc(DECOMPRESS_BUF_SIZE);
700         if (!s->inflate_buffer)
701             return AVERROR(ENOMEM);
702     }
703
704     if (s->inflate_stream.avail_in == 0) {
705         int read = http_buf_read(h, s->inflate_buffer, DECOMPRESS_BUF_SIZE);
706         if (read <= 0)
707             return read;
708         s->inflate_stream.next_in  = s->inflate_buffer;
709         s->inflate_stream.avail_in = read;
710     }
711
712     s->inflate_stream.avail_out = size;
713     s->inflate_stream.next_out  = buf;
714
715     ret = inflate(&s->inflate_stream, Z_SYNC_FLUSH);
716     if (ret != Z_OK && ret != Z_STREAM_END)
717         av_log(h, AV_LOG_WARNING, "inflate return value: %d, %s\n", ret, s->inflate_stream.msg);
718
719     return size - s->inflate_stream.avail_out;
720 }
721 #endif
722
723 static int http_read_stream(URLContext *h, uint8_t *buf, int size)
724 {
725     HTTPContext *s = h->priv_data;
726     int err, new_location;
727
728     if (!s->hd)
729         return AVERROR_EOF;
730
731     if (s->end_chunked_post && !s->end_header) {
732         err = http_read_header(h, &new_location);
733         if (err < 0)
734             return err;
735     }
736
737     if (s->chunksize >= 0) {
738         if (!s->chunksize) {
739             char line[32];
740
741             for(;;) {
742                 do {
743                     if ((err = http_get_line(s, line, sizeof(line))) < 0)
744                         return err;
745                 } while (!*line);    /* skip CR LF from last chunk */
746
747                 s->chunksize = strtoll(line, NULL, 16);
748
749                 av_dlog(NULL, "Chunked encoding data size: %"PRId64"'\n", s->chunksize);
750
751                 if (!s->chunksize)
752                     return 0;
753                 break;
754             }
755         }
756         size = FFMIN(size, s->chunksize);
757     }
758 #if CONFIG_ZLIB
759     if (s->compressed)
760         return http_buf_read_compressed(h, buf, size);
761 #endif
762     return http_buf_read(h, buf, size);
763 }
764
765 static int http_read_stream_all(URLContext *h, uint8_t *buf, int size)
766 {
767     int pos = 0;
768     while (pos < size) {
769         int len = http_read_stream(h, buf + pos, size - pos);
770         if (len < 0)
771             return len;
772         pos += len;
773     }
774     return pos;
775 }
776
777 static int store_icy(URLContext *h, int size)
778 {
779     HTTPContext *s = h->priv_data;
780     /* until next metadata packet */
781     int remaining = s->icy_metaint - s->icy_data_read;
782
783     if (remaining < 0)
784         return AVERROR_INVALIDDATA;
785
786     if (!remaining) {
787         // The metadata packet is variable sized. It has a 1 byte header
788         // which sets the length of the packet (divided by 16). If it's 0,
789         // the metadata doesn't change. After the packet, icy_metaint bytes
790         // of normal data follow.
791         uint8_t ch;
792         int len = http_read_stream_all(h, &ch, 1);
793         if (len < 0)
794             return len;
795         if (ch > 0) {
796             char data[255 * 16 + 1];
797             int ret;
798             len = ch * 16;
799             ret = http_read_stream_all(h, data, len);
800             if (ret < 0)
801                 return ret;
802             data[len + 1] = 0;
803             if ((ret = av_opt_set(s, "icy_metadata_packet", data, 0)) < 0)
804                 return ret;
805         }
806         s->icy_data_read = 0;
807         remaining = s->icy_metaint;
808     }
809
810     return FFMIN(size, remaining);
811 }
812
813 static int http_read(URLContext *h, uint8_t *buf, int size)
814 {
815     HTTPContext *s = h->priv_data;
816
817     if (s->icy_metaint > 0) {
818         size = store_icy(h, size);
819         if (size < 0)
820             return size;
821     }
822
823     size = http_read_stream(h, buf, size);
824     if (size > 0)
825         s->icy_data_read += size;
826     return size;
827 }
828
829 /* used only when posting data */
830 static int http_write(URLContext *h, const uint8_t *buf, int size)
831 {
832     char temp[11] = "";  /* 32-bit hex + CRLF + nul */
833     int ret;
834     char crlf[] = "\r\n";
835     HTTPContext *s = h->priv_data;
836
837     if (!s->chunked_post) {
838         /* non-chunked data is sent without any special encoding */
839         return ffurl_write(s->hd, buf, size);
840     }
841
842     /* silently ignore zero-size data since chunk encoding that would
843      * signal EOF */
844     if (size > 0) {
845         /* upload data using chunked encoding */
846         snprintf(temp, sizeof(temp), "%x\r\n", size);
847
848         if ((ret = ffurl_write(s->hd, temp, strlen(temp))) < 0 ||
849             (ret = ffurl_write(s->hd, buf, size)) < 0 ||
850             (ret = ffurl_write(s->hd, crlf, sizeof(crlf) - 1)) < 0)
851             return ret;
852     }
853     return size;
854 }
855
856 static int http_shutdown(URLContext *h, int flags)
857 {
858     int ret = 0;
859     char footer[] = "0\r\n\r\n";
860     HTTPContext *s = h->priv_data;
861
862     /* signal end of chunked encoding if used */
863     if ((flags & AVIO_FLAG_WRITE) && s->chunked_post) {
864         ret = ffurl_write(s->hd, footer, sizeof(footer) - 1);
865         ret = ret > 0 ? 0 : ret;
866         s->end_chunked_post = 1;
867     }
868
869     return ret;
870 }
871
872 static int http_close(URLContext *h)
873 {
874     int ret = 0;
875     HTTPContext *s = h->priv_data;
876
877 #if CONFIG_ZLIB
878     inflateEnd(&s->inflate_stream);
879     av_freep(&s->inflate_buffer);
880 #endif
881
882     if (!s->end_chunked_post) {
883         /* Close the write direction by sending the end of chunked encoding. */
884         ret = http_shutdown(h, h->flags);
885     }
886
887     if (s->hd)
888         ffurl_close(s->hd);
889     av_dict_free(&s->chained_options);
890     return ret;
891 }
892
893 static int64_t http_seek(URLContext *h, int64_t off, int whence)
894 {
895     HTTPContext *s = h->priv_data;
896     URLContext *old_hd = s->hd;
897     int64_t old_off = s->off;
898     uint8_t old_buf[BUFFER_SIZE];
899     int old_buf_size, ret;
900     AVDictionary *options = NULL;
901
902     if (whence == AVSEEK_SIZE)
903         return s->filesize;
904     else if ((s->filesize == -1 && whence == SEEK_END) || h->is_streamed)
905         return AVERROR(ENOSYS);
906
907     /* we save the old context in case the seek fails */
908     old_buf_size = s->buf_end - s->buf_ptr;
909     memcpy(old_buf, s->buf_ptr, old_buf_size);
910     s->hd = NULL;
911     if (whence == SEEK_CUR)
912         off += s->off;
913     else if (whence == SEEK_END)
914         off += s->filesize;
915     s->off = off;
916
917     /* if it fails, continue on old connection */
918     av_dict_copy(&options, s->chained_options, 0);
919     if ((ret = http_open_cnx(h, &options)) < 0) {
920         av_dict_free(&options);
921         memcpy(s->buffer, old_buf, old_buf_size);
922         s->buf_ptr = s->buffer;
923         s->buf_end = s->buffer + old_buf_size;
924         s->hd = old_hd;
925         s->off = old_off;
926         return ret;
927     }
928     av_dict_free(&options);
929     ffurl_close(old_hd);
930     return off;
931 }
932
933 static int
934 http_get_file_handle(URLContext *h)
935 {
936     HTTPContext *s = h->priv_data;
937     return ffurl_get_file_handle(s->hd);
938 }
939
940 #if CONFIG_HTTP_PROTOCOL
941 URLProtocol ff_http_protocol = {
942     .name                = "http",
943     .url_open2           = http_open,
944     .url_read            = http_read,
945     .url_write           = http_write,
946     .url_seek            = http_seek,
947     .url_close           = http_close,
948     .url_get_file_handle = http_get_file_handle,
949     .url_shutdown        = http_shutdown,
950     .priv_data_size      = sizeof(HTTPContext),
951     .priv_data_class     = &http_context_class,
952     .flags               = URL_PROTOCOL_FLAG_NETWORK,
953 };
954 #endif
955 #if CONFIG_HTTPS_PROTOCOL
956 URLProtocol ff_https_protocol = {
957     .name                = "https",
958     .url_open2           = http_open,
959     .url_read            = http_read,
960     .url_write           = http_write,
961     .url_seek            = http_seek,
962     .url_close           = http_close,
963     .url_get_file_handle = http_get_file_handle,
964     .url_shutdown        = http_shutdown,
965     .priv_data_size      = sizeof(HTTPContext),
966     .priv_data_class     = &https_context_class,
967     .flags               = URL_PROTOCOL_FLAG_NETWORK,
968 };
969 #endif
970
971 #if CONFIG_HTTPPROXY_PROTOCOL
972 static int http_proxy_close(URLContext *h)
973 {
974     HTTPContext *s = h->priv_data;
975     if (s->hd)
976         ffurl_close(s->hd);
977     return 0;
978 }
979
980 static int http_proxy_open(URLContext *h, const char *uri, int flags)
981 {
982     HTTPContext *s = h->priv_data;
983     char hostname[1024], hoststr[1024];
984     char auth[1024], pathbuf[1024], *path;
985     char lower_url[100];
986     int port, ret = 0, attempts = 0;
987     HTTPAuthType cur_auth_type;
988     char *authstr;
989     int new_loc;
990
991     h->is_streamed = 1;
992
993     av_url_split(NULL, 0, auth, sizeof(auth), hostname, sizeof(hostname), &port,
994                  pathbuf, sizeof(pathbuf), uri);
995     ff_url_join(hoststr, sizeof(hoststr), NULL, NULL, hostname, port, NULL);
996     path = pathbuf;
997     if (*path == '/')
998         path++;
999
1000     ff_url_join(lower_url, sizeof(lower_url), "tcp", NULL, hostname, port,
1001                 NULL);
1002 redo:
1003     ret = ffurl_open(&s->hd, lower_url, AVIO_FLAG_READ_WRITE,
1004                      &h->interrupt_callback, NULL);
1005     if (ret < 0)
1006         return ret;
1007
1008     authstr = ff_http_auth_create_response(&s->proxy_auth_state, auth,
1009                                            path, "CONNECT");
1010     snprintf(s->buffer, sizeof(s->buffer),
1011              "CONNECT %s HTTP/1.1\r\n"
1012              "Host: %s\r\n"
1013              "Connection: close\r\n"
1014              "%s%s"
1015              "\r\n",
1016              path,
1017              hoststr,
1018              authstr ? "Proxy-" : "", authstr ? authstr : "");
1019     av_freep(&authstr);
1020
1021     if ((ret = ffurl_write(s->hd, s->buffer, strlen(s->buffer))) < 0)
1022         goto fail;
1023
1024     s->buf_ptr = s->buffer;
1025     s->buf_end = s->buffer;
1026     s->line_count = 0;
1027     s->filesize = -1;
1028     cur_auth_type = s->proxy_auth_state.auth_type;
1029
1030     /* Note: This uses buffering, potentially reading more than the
1031      * HTTP header. If tunneling a protocol where the server starts
1032      * the conversation, we might buffer part of that here, too.
1033      * Reading that requires using the proper ffurl_read() function
1034      * on this URLContext, not using the fd directly (as the tls
1035      * protocol does). This shouldn't be an issue for tls though,
1036      * since the client starts the conversation there, so there
1037      * is no extra data that we might buffer up here.
1038      */
1039     ret = http_read_header(h, &new_loc);
1040     if (ret < 0)
1041         goto fail;
1042
1043     attempts++;
1044     if (s->http_code == 407 &&
1045         (cur_auth_type == HTTP_AUTH_NONE || s->proxy_auth_state.stale) &&
1046         s->proxy_auth_state.auth_type != HTTP_AUTH_NONE && attempts < 2) {
1047         ffurl_close(s->hd);
1048         s->hd = NULL;
1049         goto redo;
1050     }
1051
1052     if (s->http_code < 400)
1053         return 0;
1054     ret = AVERROR(EIO);
1055
1056 fail:
1057     http_proxy_close(h);
1058     return ret;
1059 }
1060
1061 static int http_proxy_write(URLContext *h, const uint8_t *buf, int size)
1062 {
1063     HTTPContext *s = h->priv_data;
1064     return ffurl_write(s->hd, buf, size);
1065 }
1066
1067 URLProtocol ff_httpproxy_protocol = {
1068     .name                = "httpproxy",
1069     .url_open            = http_proxy_open,
1070     .url_read            = http_buf_read,
1071     .url_write           = http_proxy_write,
1072     .url_close           = http_proxy_close,
1073     .url_get_file_handle = http_get_file_handle,
1074     .priv_data_size      = sizeof(HTTPContext),
1075     .flags               = URL_PROTOCOL_FLAG_NETWORK,
1076 };
1077 #endif