49 #define BUFFER_SIZE (MAX_URL_SIZE + HTTP_HEADERS_SIZE)
50 #define MAX_REDIRECTS 8
54 #define WHITESPACES " \n\t\r"
110 z_stream inflate_stream;
131 #define OFFSET(x) offsetof(HTTPContext, x)
132 #define D AV_OPT_FLAG_DECODING_PARAM
133 #define E AV_OPT_FLAG_ENCODING_PARAM
134 #define DEFAULT_USER_AGENT "Lavf/" AV_STRINGIFY(LIBAVFORMAT_VERSION)
137 {
"seekable",
"control seekability of connection",
OFFSET(seekable),
AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1,
D },
138 {
"chunked_post",
"use chunked transfer-encoding for posts",
OFFSET(chunked_post),
AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1,
E },
140 {
"headers",
"set custom HTTP headers, can override built in default headers",
OFFSET(headers),
AV_OPT_TYPE_STRING, { .str =
NULL }, 0, 0,
D |
E },
144 #if FF_API_HTTP_USER_AGENT
147 {
"multiple_requests",
"use persistent connections",
OFFSET(multiple_requests),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
D |
E },
151 {
"cookies",
"set cookies to be sent in applicable future requests, use newline delimited Set-Cookie HTTP field value syntax",
OFFSET(cookies),
AV_OPT_TYPE_STRING, { .str =
NULL }, 0, 0,
D },
157 {
"none",
"No auth method set, autodetect", 0,
AV_OPT_TYPE_CONST, { .i64 =
HTTP_AUTH_NONE }, 0, 0,
D |
E,
"auth_type"},
159 {
"send_expect_100",
"Force sending an Expect: 100-continue header for POST",
OFFSET(send_expect_100),
AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1,
E },
162 {
"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 },
163 {
"method",
"Override the HTTP method or set the expected HTTP method from a client",
OFFSET(method),
AV_OPT_TYPE_STRING, { .str =
NULL }, 0, 0,
D |
E },
164 {
"reconnect",
"auto reconnect after disconnect before EOF",
OFFSET(reconnect),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
D },
165 {
"reconnect_at_eof",
"auto reconnect at EOF",
OFFSET(reconnect_at_eof),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
D },
166 {
"reconnect_on_network_error",
"auto reconnect in case of tcp/tls error during connect",
OFFSET(reconnect_on_network_error),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
D },
167 {
"reconnect_on_http_error",
"list of http status codes to reconnect on",
OFFSET(reconnect_on_http_error),
AV_OPT_TYPE_STRING, { .str =
NULL }, 0, 0,
D },
168 {
"reconnect_streamed",
"auto reconnect streamed / non seekable streams",
OFFSET(reconnect_streamed),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
D },
169 {
"reconnect_delay_max",
"max reconnect delay in seconds after which to give up",
OFFSET(reconnect_delay_max),
AV_OPT_TYPE_INT, { .i64 = 120 }, 0, UINT_MAX/1000/1000,
D },
172 {
"reply_code",
"The http status code to return to a client",
OFFSET(reply_code),
AV_OPT_TYPE_INT, { .i64 = 200}, INT_MIN, 599,
E},
177 const char *hoststr,
const char *auth,
178 const char *proxyauth,
int *new_location);
194 const char *path, *proxy_path, *lower_proto =
"tcp", *local_path;
196 char hostname[1024], hoststr[1024], proto[10];
197 char auth[1024], proxyauth[1024] =
"";
200 int port, use_proxy, err, location_changed = 0;
204 hostname,
sizeof(hostname), &port,
205 path1,
sizeof(path1),
s->location);
208 proxy_path =
s->http_proxy ?
s->http_proxy : getenv(
"http_proxy");
212 if (!strcmp(proto,
"https")) {
227 hashmark = strchr(path1,
'#');
231 if (path1[0] ==
'\0') {
233 }
else if (path1[0] ==
'?') {
234 snprintf(sanitized_path,
sizeof(sanitized_path),
"/%s", path1);
235 path = sanitized_path;
247 hostname,
sizeof(hostname), &port,
NULL, 0, proxy_path);
255 h->protocol_whitelist,
h->protocol_blacklist,
h);
261 auth, proxyauth, &location_changed);
265 return location_changed;
270 const char *status_group;
279 status_group =
"4xx";
283 status_group =
"5xx";
287 return s->reconnect_on_network_error;
290 if (!
s->reconnect_on_http_error)
293 if (
av_match_list(status_group,
s->reconnect_on_http_error,
',') > 0)
296 snprintf(http_code,
sizeof(http_code),
"%d",
s->http_code);
298 return av_match_list(http_code,
s->reconnect_on_http_error,
',') > 0;
306 int location_changed, attempts = 0, redirects = 0;
307 int reconnect_delay = 0;
313 cur_auth_type =
s->auth_state.auth_type;
314 cur_proxy_auth_type =
s->auth_state.auth_type;
318 if (location_changed < 0) {
320 reconnect_delay >
s->reconnect_delay_max)
325 if (location_changed !=
AVERROR(ETIMEDOUT))
327 reconnect_delay = 1 + 2 * reconnect_delay;
337 if (
s->http_code == 401) {
345 if (
s->http_code == 407) {
346 if ((cur_proxy_auth_type ==
HTTP_AUTH_NONE ||
s->proxy_auth_state.stale) &&
353 if ((
s->http_code == 301 ||
s->http_code == 302 ||
354 s->http_code == 303 ||
s->http_code == 307 ||
s->http_code == 308) &&
355 location_changed == 1) {
362 memset(&
s->auth_state, 0,
sizeof(
s->auth_state));
364 location_changed = 0;
372 if (location_changed < 0)
373 return location_changed;
401 char hostname1[1024], hostname2[1024], proto1[10], proto2[10];
405 !(!strcmp(
h->prot->name,
"http") ||
406 !strcmp(
h->prot->name,
"https")))
410 hostname1,
sizeof(hostname1), &port1,
411 NULL, 0,
s->location);
413 hostname2,
sizeof(hostname2), &port2,
415 if (port1 != port2 || strncmp(hostname1, hostname2,
sizeof(hostname2)) != 0) {
416 av_log(
h,
AV_LOG_ERROR,
"Cannot reuse HTTP connection for different host: %s:%d != %s:%d\n",
423 if (!
s->end_chunked_post) {
432 s->end_chunked_post = 0;
435 s->icy_data_read = 0;
452 switch (status_code) {
459 if (status_code >= 400 && status_code <= 499)
461 else if (status_code >= 500)
464 return default_averror;
469 int ret,
body = 0, reply_code, message_len;
470 const char *reply_text, *content_type;
473 content_type =
"text/plain";
477 switch (status_code) {
481 reply_text =
"Bad Request";
486 reply_text =
"Forbidden";
491 reply_text =
"Not Found";
496 content_type =
s->content_type ?
s->content_type :
"application/octet-stream";
501 reply_text =
"Internal server error";
509 "HTTP/1.1 %03d %s\r\n"
510 "Content-Type: %s\r\n"
518 strlen(reply_text) + 6,
519 s->headers ?
s->headers :
"",
525 "HTTP/1.1 %03d %s\r\n"
526 "Content-Type: %s\r\n"
527 "Transfer-Encoding: chunked\r\n"
533 s->headers ?
s->headers :
"");
549 int ret, err, new_location;
587 char hostname[1024], proto[10];
589 const char *lower_proto =
"tcp";
591 av_url_split(proto,
sizeof(proto),
NULL, 0, hostname,
sizeof(hostname), &port,
593 if (!strcmp(proto,
"https"))
595 ff_url_join(lower_url,
sizeof(lower_url), lower_proto,
NULL, hostname, port,
601 h->protocol_whitelist,
h->protocol_blacklist,
h
620 if(
s->seekable == 1 )
625 s->filesize = UINT64_MAX;
633 int len = strlen(
s->headers);
634 if (
len < 2 || strcmp(
"\r\n",
s->headers +
len - 2)) {
636 "No trailing CRLF found in HTTP header. Adding it.\n");
640 s->headers[
len] =
'\r';
641 s->headers[
len + 1] =
'\n';
642 s->headers[
len + 2] =
'\0';
667 cc = (*c)->priv_data;
683 if (
s->buf_ptr >=
s->buf_end) {
687 }
else if (
len == 0) {
690 s->buf_ptr =
s->buffer;
691 s->buf_end =
s->buffer +
len;
694 return *
s->buf_ptr++;
709 if (q >
line && q[-1] ==
'\r')
715 if ((q -
line) < line_size - 1)
726 if (http_code >= 400 && http_code < 600 &&
728 (http_code != 407 ||
s->proxy_auth_state.auth_type !=
HTTP_AUTH_NONE)) {
741 new_loc =
av_strdup(redirected_location);
745 s->location = new_loc;
755 if (!strncmp(p,
"bytes ", 6)) {
757 s->off = strtoull(p,
NULL, 10);
758 if ((slash = strchr(p,
'/')) && strlen(slash) > 0)
759 s->filesize = strtoull(slash + 1,
NULL, 10);
761 if (
s->seekable == -1 && (!
s->is_akamai ||
s->filesize != 2147483647))
773 inflateEnd(&
s->inflate_stream);
774 if (inflateInit2(&
s->inflate_stream, 32 + 15) != Z_OK) {
776 s->inflate_stream.msg);
779 if (zlibCompileFlags() & (1 << 17)) {
781 "Your zlib was compiled without gzip support.\n");
786 "Compressed (%s) content, need zlib with gzip support\n", p);
801 int len = 4 + strlen(p) + strlen(
tag);
802 int is_first = !
s->icy_metadata_headers;
807 if (
s->icy_metadata_headers)
808 len += strlen(
s->icy_metadata_headers);
814 *
s->icy_metadata_headers =
'\0';
828 for (
i = 0, j = 0; exp_str[
i] !=
'\0' && j < exp_buf_len;
i++) {
829 if ((exp_str[
i] >=
'0' && exp_str[
i] <=
'9') ||
830 (exp_str[
i] >=
'A' && exp_str[
i] <=
'Z') ||
831 (exp_str[
i] >=
'a' && exp_str[
i] <=
'z')) {
832 exp_buf[j] = exp_str[
i];
840 while ((*expiry < '0' || *expiry >
'9') && *expiry !=
'\0')
848 char *param, *next_param, *cstr, *back;
849 char *saveptr =
NULL;
858 back = &cstr[strlen(cstr)-1];
867 while ((param =
av_strtok(next_param,
";", &saveptr))) {
895 if (!cookie_entry || !cookie_entry->
value) {
902 struct tm new_tm = {0};
914 if (e2 && e2->
value) {
918 if (e2 && e2->
value) {
919 struct tm old_tm = {0};
936 if (!(eql = strchr(p,
'=')))
return AVERROR(EINVAL);
956 if (*cookies)
av_free(*cookies);
958 if (!*cookies)
return AVERROR(ENOMEM);
973 char *
tag, *p, *end, *method, *resource, *
version;
977 if (
line[0] ==
'\0') {
983 if (line_count == 0) {
984 if (
s->is_connected_server) {
993 av_log(
h,
AV_LOG_ERROR,
"Received and expected HTTP method do not match. (%s expected, %s received)\n",
1002 "(%s autodetected %s received)\n", auto_method, method);
1035 while (*p !=
'/' && *p !=
'\0')
1045 s->http_code = strtol(p, &end, 10);
1053 while (*p !=
'\0' && *p !=
':')
1068 s->filesize == UINT64_MAX) {
1069 s->filesize = strtoull(p,
NULL, 10);
1073 !strncmp(p,
"bytes", 5) &&
1074 s->seekable == -1) {
1078 s->filesize = UINT64_MAX;
1087 if (!strcmp(p,
"close"))
1093 s->is_mediagateway = 1;
1102 s->icy_metaint = strtoull(p,
NULL, 10);
1128 char *cookie, *set_cookies, *next;
1129 char *saveptr =
NULL;
1142 while ((cookie =
av_strtok(next,
"\n", &saveptr)) && !ret) {
1157 if (!cookie_entry || !cookie_entry->
value)
1162 struct tm tm_buf = {0};
1172 int domain_offset = strlen(domain) - strlen(e->
value);
1173 if (domain_offset < 0)
1190 char *
tmp = *cookies;
1220 s->chunksize = UINT64_MAX;
1236 if (
s->seekable == -1 &&
s->is_mediagateway &&
s->filesize == 2000000000)
1255 #define NEEDS_ESCAPE(ch) \
1256 ((ch) <= ' ' || (ch) >= '\x7f' || \
1257 (ch) == '"' || (ch) == '%' || (ch) == '<' || (ch) == '>' || (ch) == '\\' || \
1258 (ch) == '^' || (ch) == '`' || (ch) == '{' || (ch) == '}' || (ch) == '|')
1262 while (*path && q - buf < sizeof(buf) - 4) {
1263 if (path[0] == '%' && av_isxdigit(path[1]) && av_isxdigit(path[2])) {
1267 } else if (NEEDS_ESCAPE(*path)) {
1268 q += snprintf(q, 4, "%%%02X", (uint8_t)*path++);
1273 av_bprint_append_data(bp, buf, q - buf);
1277 static int http_connect(URLContext *h, const char *path, const char *local_path,
1278 const char *hoststr, const char *auth,
1279 const char *proxyauth, int *new_location)
1281 HTTPContext *s = h->priv_data;
1284 char *authstr = NULL, *proxyauthstr = NULL;
1285 uint64_t off = s->off;
1287 int send_expect_100 = 0;
1289 av_bprint_init_for_buffer(&request, s->buffer, sizeof(s->buffer));
1291 /* send http header */
1292 post = h->flags & AVIO_FLAG_WRITE;
1295 /* force POST method and disable chunked encoding when
1296 * custom HTTP post data is set */
1298 s->chunked_post = 0;
1304 method = post ? "POST" : "GET";
1306 authstr = ff_http_auth_create_response(&s->auth_state, auth,
1307 local_path, method);
1308 proxyauthstr = ff_http_auth_create_response(&s->proxy_auth_state, proxyauth,
1309 local_path, method);
1311 if (post && !s->post_data) {
1312 if (s->send_expect_100 != -1) {
1313 send_expect_100 = s->send_expect_100;
1315 send_expect_100 = 0;
1316 /* The user has supplied authentication but we don't know the auth type,
1317 * send Expect: 100-continue to get the 401 response including the
1318 * WWW-Authenticate header, or an 100 continue if no auth actually
1320 if (auth && *auth &&
1321 s->auth_state.auth_type == HTTP_AUTH_NONE &&
1322 s->http_code != 401)
1323 send_expect_100 = 1;
1327 av_bprintf(&request, "%s ", method);
1328 bprint_escaped_path(&request, path);
1329 av_bprintf(&request, " HTTP/1.1\r\n");
1331 if (post && s->chunked_post)
1332 av_bprintf(&request, "Transfer-Encoding: chunked\r\n");
1333 /* set default headers if needed */
1334 if (!has_header(s->headers, "\r\nUser-Agent: "))
1335 av_bprintf(&request, "User-Agent: %s\r\n", s->user_agent);
1337 /* set default headers if needed */
1338 if (!has_header(s->headers, "\r\nReferer: "))
1339 av_bprintf(&request, "Referer: %s\r\n", s->referer);
1341 if (!has_header(s->headers, "\r\nAccept: "))
1342 av_bprintf(&request, "Accept: *
1382 av_bprintf(&request,
"Proxy-%s", proxyauthstr);
1393 if ((err =
ffurl_write(
s->hd, request.str, request.len)) < 0)
1397 if ((err =
ffurl_write(
s->hd,
s->post_data,
s->post_datalen)) < 0)
1401 s->buf_ptr =
s->buffer;
1402 s->buf_end =
s->buffer;
1405 s->icy_data_read = 0;
1406 s->filesize = UINT64_MAX;
1408 s->end_chunked_post = 0;
1413 if (post && !
s->post_data && !send_expect_100) {
1430 err = (off ==
s->off) ? 0 : -1;
1442 if (
s->chunksize != UINT64_MAX) {
1446 if (!
s->chunksize) {
1455 s->chunksize = strtoull(
line,
NULL, 16);
1458 "Chunked encoding data size: %"PRIu64
"\n",
1461 if (!
s->chunksize &&
s->multiple_requests) {
1466 else if (!
s->chunksize) {
1471 else if (
s->chunksize == UINT64_MAX) {
1481 len =
s->buf_end -
s->buf_ptr;
1485 memcpy(buf,
s->buf_ptr,
len);
1488 uint64_t target_end =
s->end_off ?
s->end_off :
s->filesize;
1489 if ((!
s->willclose ||
s->chunksize == UINT64_MAX) &&
s->off >= target_end)
1493 (!
s->willclose ||
s->chunksize == UINT64_MAX) &&
s->off < target_end) {
1495 "Stream ends prematurely at %"PRIu64
", should be %"PRIu64
"\n",
1503 if (
s->chunksize > 0 &&
s->chunksize != UINT64_MAX) {
1505 s->chunksize -=
len;
1512 #define DECOMPRESS_BUF_SIZE (256 * 1024)
1518 if (!
s->inflate_buffer) {
1519 s->inflate_buffer =
av_malloc(DECOMPRESS_BUF_SIZE);
1520 if (!
s->inflate_buffer)
1524 if (
s->inflate_stream.avail_in == 0) {
1528 s->inflate_stream.next_in =
s->inflate_buffer;
1529 s->inflate_stream.avail_in = read;
1532 s->inflate_stream.avail_out =
size;
1533 s->inflate_stream.next_out = buf;
1535 ret =
inflate(&
s->inflate_stream, Z_SYNC_FLUSH);
1536 if (ret != Z_OK && ret != Z_STREAM_END)
1538 ret,
s->inflate_stream.msg);
1540 return size -
s->inflate_stream.avail_out;
1549 int err, new_location, read_ret;
1551 int reconnect_delay = 0;
1556 if (
s->end_chunked_post && !
s->end_header) {
1564 return http_buf_read_compressed(
h, buf,
size);
1567 while (read_ret < 0) {
1568 uint64_t target =
h->is_streamed ? 0 :
s->off;
1573 if (
h->is_streamed && !
s->reconnect_streamed)
1576 if (!(
s->reconnect &&
s->filesize > 0 &&
s->off <
s->filesize) &&
1580 if (reconnect_delay >
s->reconnect_delay_max)
1585 if (err !=
AVERROR(ETIMEDOUT))
1587 reconnect_delay = 1 + 2*reconnect_delay;
1589 if (seek_ret >= 0 && seek_ret != target) {
1627 end = strstr(
val,
"';");
1648 if (
s->icy_metaint <
s->icy_data_read)
1650 remaining =
s->icy_metaint -
s->icy_data_read;
1662 char data[255 * 16 + 1];
1673 s->icy_data_read = 0;
1674 remaining =
s->icy_metaint;
1684 if (
s->icy_metaint > 0) {
1692 s->icy_data_read +=
size;
1701 char crlf[] =
"\r\n";
1704 if (!
s->chunked_post) {
1717 (ret =
ffurl_write(
s->hd, crlf,
sizeof(crlf) - 1)) < 0)
1726 char footer[] =
"0\r\n\r\n";
1733 ret = ret > 0 ? 0 : ret;
1741 if (read_ret < 0 && read_ret !=
AVERROR(EAGAIN)) {
1746 s->end_chunked_post = 1;
1758 inflateEnd(&
s->inflate_stream);
1762 if (
s->hd && !
s->end_chunked_post)
1776 uint64_t old_off =
s->off;
1778 int old_buf_size, ret;
1783 else if (!force_reconnect &&
1784 ((whence == SEEK_CUR && off == 0) ||
1785 (whence == SEEK_SET && off ==
s->off)))
1787 else if ((
s->filesize == UINT64_MAX && whence == SEEK_END))
1790 if (whence == SEEK_CUR)
1792 else if (whence == SEEK_END)
1794 else if (whence != SEEK_SET)
1800 if (
s->off &&
h->is_streamed)
1804 if (
s->end_off ||
s->filesize != UINT64_MAX) {
1805 uint64_t end_pos =
s->end_off ?
s->end_off :
s->filesize;
1806 if (
s->off >= end_pos)
1811 old_buf_size =
s->buf_end -
s->buf_ptr;
1812 memcpy(old_buf,
s->buf_ptr, old_buf_size);
1818 memcpy(
s->buffer, old_buf, old_buf_size);
1819 s->buf_ptr =
s->buffer;
1820 s->buf_end =
s->buffer + old_buf_size;
1847 #define HTTP_CLASS(flavor) \
1848 static const AVClass flavor ## _context_class = { \
1849 .class_name = # flavor, \
1850 .item_name = av_default_item_name, \
1851 .option = options, \
1852 .version = LIBAVUTIL_VERSION_INT, \
1855 #if CONFIG_HTTP_PROTOCOL
1871 .priv_data_class = &http_context_class,
1873 .default_whitelist =
"http,https,tls,rtp,tcp,udp,crypto,httpproxy,data"
1877 #if CONFIG_HTTPS_PROTOCOL
1891 .priv_data_class = &https_context_class,
1893 .default_whitelist =
"http,https,tls,rtp,tcp,udp,crypto,httpproxy"
1897 #if CONFIG_HTTPPROXY_PROTOCOL
1909 char hostname[1024], hoststr[1024];
1910 char auth[1024], pathbuf[1024], *path;
1911 char lower_url[100];
1912 int port, ret = 0, attempts = 0;
1917 if(
s->seekable == 1 )
1922 av_url_split(
NULL, 0, auth,
sizeof(auth), hostname,
sizeof(hostname), &port,
1923 pathbuf,
sizeof(pathbuf), uri);
1929 ff_url_join(lower_url,
sizeof(lower_url),
"tcp",
NULL, hostname, port,
1933 &
h->interrupt_callback,
NULL,
1934 h->protocol_whitelist,
h->protocol_blacklist,
h);
1941 "CONNECT %s HTTP/1.1\r\n"
1943 "Connection: close\r\n"
1948 authstr ?
"Proxy-" :
"", authstr ? authstr :
"");
1951 if ((ret =
ffurl_write(
s->hd,
s->buffer, strlen(
s->buffer))) < 0)
1954 s->buf_ptr =
s->buffer;
1955 s->buf_end =
s->buffer;
1957 s->filesize = UINT64_MAX;
1958 cur_auth_type =
s->proxy_auth_state.auth_type;
1974 if (
s->http_code == 407 &&
1981 if (
s->http_code < 400)
1986 http_proxy_close(
h);
1997 .
name =
"httpproxy",
1998 .url_open = http_proxy_open,
2000 .url_write = http_proxy_write,
2001 .url_close = http_proxy_close,
static double val(void *priv, double ch)
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ffurl_handshake(URLContext *c)
Perform one step of the protocol handshake to accept a new client.
int ffurl_alloc(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb)
Create a URLContext for accessing to the resource indicated by url, but do not initiate the connectio...
int ffurl_read(URLContext *h, unsigned char *buf, int size)
Read up to size bytes from the resource accessed by h, and store the read bytes in buf.
int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options, const char *whitelist, const char *blacklist, URLContext *parent)
Create an URLContext for accessing to the resource indicated by url, and open it.
int ffurl_get_short_seek(URLContext *h)
Return the current short seek threshold value for this URL.
int ffurl_accept(URLContext *s, URLContext **c)
Accept an URLContext c on an URLContext s.
int ffurl_closep(URLContext **hh)
Close the resource accessed by the URLContext h, and free the memory used by it.
int ffurl_close(URLContext *h)
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
Write size bytes from buf to the resource accessed by h.
int ffurl_get_file_handle(URLContext *h)
Return the file descriptor associated with this URL.
#define AVIO_FLAG_READ
read-only
#define AVSEEK_SIZE
ORing this as the "whence" parameter to a seek function causes it to return the filesize without seek...
#define AVIO_FLAG_WRITE
write-only
#define AVIO_FLAG_READ_WRITE
read-write pseudo flag
#define AVIO_FLAG_NONBLOCK
Use non-blocking mode.
char * av_asprintf(const char *fmt,...)
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
void av_bprintf(AVBPrint *buf, const char *fmt,...)
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
#define flags(name, subs,...)
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
@ AV_OPT_TYPE_BINARY
offset must point to a pointer immediately followed by an int for the length
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that's been allocated with av_malloc() or another memory allocation function.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it.
#define AVERROR_HTTP_FORBIDDEN
#define AVERROR_HTTP_BAD_REQUEST
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
#define AVERROR_HTTP_SERVER_ERROR
#define AVERROR_HTTP_OTHER_4XX
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AVERROR_EOF
End of file.
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
#define AVERROR_HTTP_UNAUTHORIZED
#define AVERROR_HTTP_NOT_FOUND
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_VERBOSE
Detailed information.
#define AV_LOG_INFO
Standard information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
char * av_strdup(const char *s)
Duplicate a string.
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
char * av_strndup(const char *s, size_t len)
Duplicate a substring of a string.
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
char * av_stristr(const char *s1, const char *s2)
Locate the first case-independent occurrence in the string haystack of the string needle.
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
static av_const int av_isspace(int c)
Locale-independent conversion of ASCII isspace.
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
int av_stristart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str independent of case.
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
static int http_handshake(URLContext *c)
static int http_open(URLContext *h, const char *uri, int flags, AVDictionary **options)
static int cookie_string(AVDictionary *dict, char **cookies)
static int store_icy(URLContext *h, int size)
static int parse_content_encoding(URLContext *h, const char *p)
static int http_shutdown(URLContext *h, int flags)
int ff_http_do_new_request2(URLContext *h, const char *uri, AVDictionary **opts)
Send a new HTTP request, reusing the old connection.
static int parse_set_cookie(const char *set_cookie, AVDictionary **dict)
static int http_read(URLContext *h, uint8_t *buf, int size)
static int http_getc(HTTPContext *s)
static const AVOption options[]
static int get_cookies(HTTPContext *s, char **cookies, const char *path, const char *domain)
Create a string containing cookie values for use as a HTTP cookie header field value for a particular...
static int http_open_cnx_internal(URLContext *h, AVDictionary **options)
static void parse_content_range(URLContext *h, const char *p)
int ff_http_get_shutdown_status(URLContext *h)
Get the HTTP shutdown response status, be used after http_shutdown.
static void update_metadata(URLContext *h, char *data)
static int64_t http_seek_internal(URLContext *h, int64_t off, int whence, int force_reconnect)
static int http_get_line(HTTPContext *s, char *line, int line_size)
int ff_http_averror(int status_code, int default_averror)
static int http_buf_read(URLContext *h, uint8_t *buf, int size)
static int parse_icy(HTTPContext *s, const char *tag, const char *p)
static int has_header(const char *str, const char *header)
static int http_listen(URLContext *h, const char *uri, int flags, AVDictionary **options)
static int process_line(URLContext *h, char *line, int line_count, int *new_location)
static int check_http_code(URLContext *h, int http_code, const char *end)
static int http_get_short_seek(URLContext *h)
static int http_get_file_handle(URLContext *h)
void ff_http_init_auth_state(URLContext *dest, const URLContext *src)
Initialize the authentication state based on another HTTP URLContext.
static int http_write_reply(URLContext *h, int status_code)
static int http_should_reconnect(HTTPContext *s, int err)
static void handle_http_errors(URLContext *h, int error)
static int http_read_header(URLContext *h, int *new_location)
#define DEFAULT_USER_AGENT
#define HTTP_CLASS(flavor)
static int http_connect(URLContext *h, const char *path, const char *local_path, const char *hoststr, const char *auth, const char *proxyauth, int *new_location)
static int parse_set_cookie_expiry_time(const char *exp_str, struct tm *buf)
static int http_write(URLContext *h, const uint8_t *buf, int size)
static void bprint_escaped_path(AVBPrint *bp, const char *path)
Escape unsafe characters in path in order to pass them safely to the HTTP request.
static int64_t http_seek(URLContext *h, int64_t off, int whence)
static int http_open_cnx(URLContext *h, AVDictionary **options)
static int parse_cookie(HTTPContext *s, const char *p, AVDictionary **cookies)
static int http_close(URLContext *h)
int ff_http_do_new_request(URLContext *h, const char *uri)
Send a new HTTP request, reusing the old connection.
static int http_accept(URLContext *s, URLContext **c)
static int http_read_stream(URLContext *h, uint8_t *buf, int size)
static int http_read_stream_all(URLContext *h, uint8_t *buf, int size)
static int parse_location(HTTPContext *s, const char *p)
char * ff_http_auth_create_response(HTTPAuthState *state, const char *auth, const char *path, const char *method)
void ff_http_auth_handle_header(HTTPAuthState *state, const char *key, const char *value)
HTTPAuthType
Authentication types, ordered from weakest to strongest.
@ HTTP_AUTH_NONE
No authentication specified.
@ HTTP_AUTH_BASIC
HTTP 1.0 Basic auth from RFC 1945 (also in RFC 2617)
common internal API header
static void body(uint32_t ABCD[4], const uint8_t *src, int nblocks)
int ff_network_sleep_interruptible(int64_t timeout, AVIOInterruptCB *int_cb)
Waits for up to 'timeout' microseconds.
int ff_http_match_no_proxy(const char *no_proxy, const char *hostname)
#define AV_OPT_FLAG_READONLY
The option may not be set through the AVOptions API, only read.
#define AV_OPT_FLAG_DEPRECATED
set if option is deprecated, users should refer to AVOption.help text for more information
#define AV_OPT_FLAG_EXPORT
The option is intended for exporting values to the caller.
miscellaneous OS support macros and functions.
char * av_small_strptime(const char *p, const char *fmt, struct tm *dt)
Simplified version of strptime.
time_t av_timegm(struct tm *tm)
Convert the decomposed UTC time in tm to a time_t value.
const URLProtocol ff_https_protocol
const URLProtocol ff_http_protocol
const URLProtocol ff_httpproxy_protocol
static const uint8_t header[24]
Describe the class of an AVClass context structure.
HTTP Authentication state structure.
HandshakeState handshake_step
AVDictionary * chained_options
char * icy_metadata_packet
char * reconnect_on_http_error
int seekable
Control seekability, 0 = disable, 1 = enable, -1 = probe.
unsigned char buffer[BUFFER_SIZE]
int reconnect_on_network_error
char * icy_metadata_headers
HTTPAuthState proxy_auth_state
char * cookies
holds newline ( ) delimited Set-Cookie header field values (without the "Set-Cookie: " field name)
AVDictionary * cookie_dict
AVIOInterruptCB interrupt_callback
static void error(const char *err)
int64_t av_gettime(void)
Get the current time in microseconds.
int ff_make_absolute_url(char *buf, int size, const char *base, const char *rel)
Convert a relative url into an absolute url, given a base url.
int ff_url_join(char *str, int size, const char *proto, const char *authorization, const char *hostname, int port, const char *fmt,...)
unbuffered private I/O API
#define URL_PROTOCOL_FLAG_NETWORK
static void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)