unsigned char buffer[BUFFER_SIZE], *buf_ptr, *buf_end;
int line_count;
int http_code;
- int64_t chunksize; /**< Used if "Transfer-Encoding: chunked" otherwise -1. */
- int64_t off, filesize;
- char location[MAX_URL_SIZE];
+ /* Used if "Transfer-Encoding: chunked" otherwise -1. */
+ int64_t chunksize;
+ int64_t off, end_off, filesize;
+ char *location;
HTTPAuthState auth_state;
HTTPAuthState proxy_auth_state;
char *headers;
- int willclose; /**< Set if the server correctly handles Connection: close and will close the connection after feeding us the content. */
+ char *mime_type;
+ char *user_agent;
+ char *content_type;
+ /* Set if the server correctly handles Connection: close and will close
+ * the connection after feeding us the content. */
+ int willclose;
int chunked_post;
- int end_chunked_post; /**< A flag which indicates if the end of chunked encoding has been sent. */
- int end_header; /**< A flag which indicates we have finished to read POST reply. */
- int multiple_requests; /**< A flag which indicates if we use persistent connections. */
+ /* A flag which indicates if the end of chunked encoding has been sent. */
+ int end_chunked_post;
+ /* A flag which indicates we have finished to read POST reply. */
+ int end_header;
+ /* A flag which indicates if we use persistent connections. */
+ int multiple_requests;
uint8_t *post_data;
int post_datalen;
+ int icy;
+ /* how much data was read since the last ICY metadata packet */
+ int icy_data_read;
+ /* after how many bytes of read data a new metadata packet will be found */
+ int icy_metaint;
+ char *icy_metadata_headers;
+ char *icy_metadata_packet;
#if CONFIG_ZLIB
int compressed;
z_stream inflate_stream;
#define OFFSET(x) offsetof(HTTPContext, x)
#define D AV_OPT_FLAG_DECODING_PARAM
#define E AV_OPT_FLAG_ENCODING_PARAM
+#define DEFAULT_USER_AGENT "Lavf/" AV_STRINGIFY(LIBAVFORMAT_VERSION)
static const AVOption options[] = {
{"chunked_post", "use chunked transfer-encoding for posts", OFFSET(chunked_post), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, E },
-{"headers", "custom HTTP headers, can override built in default headers", OFFSET(headers), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
+{"headers", "set custom HTTP headers, can override built in default headers", OFFSET(headers), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
+{"content_type", "set a specific content type for the POST messages", OFFSET(content_type), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
+{"user_agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = DEFAULT_USER_AGENT}, 0, 0, D },
+{"user-agent", "override User-Agent header, for compatibility with ffmpeg", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = DEFAULT_USER_AGENT}, 0, 0, D },
{"multiple_requests", "use persistent connections", OFFSET(multiple_requests), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, D|E },
-{"post_data", "custom HTTP post data", OFFSET(post_data), AV_OPT_TYPE_BINARY, .flags = D|E },
+{"post_data", "set custom HTTP post data", OFFSET(post_data), AV_OPT_TYPE_BINARY, .flags = D|E },
+{"mime_type", "export the MIME type", OFFSET(mime_type), AV_OPT_TYPE_STRING, {0}, 0, 0, AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY },
+{"icy", "request ICY metadata", OFFSET(icy), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, D },
+{"icy_metadata_headers", "return ICY metadata headers", OFFSET(icy_metadata_headers), AV_OPT_TYPE_STRING, {0}, 0, 0, AV_OPT_FLAG_EXPORT },
+{"icy_metadata_packet", "return current ICY metadata packet", OFFSET(icy_metadata_packet), AV_OPT_TYPE_STRING, {0}, 0, 0, AV_OPT_FLAG_EXPORT },
{"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" },
{"none", "No auth method set, autodetect", 0, AV_OPT_TYPE_CONST, {.i64 = HTTP_AUTH_NONE}, 0, 0, D|E, "auth_type" },
{"basic", "HTTP basic authentication", 0, AV_OPT_TYPE_CONST, {.i64 = HTTP_AUTH_BASIC}, 0, 0, D|E, "auth_type" },
{"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 },
+{"location", "The actual location of the data received", OFFSET(location), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
+{"offset", "initial byte offset", OFFSET(off), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, D },
+{"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 },
{NULL}
};
#define HTTP_CLASS(flavor)\
int ret;
s->off = 0;
- av_strlcpy(s->location, uri, sizeof(s->location));
+ s->icy_data_read = 0;
+ av_free(s->location);
+ s->location = av_strdup(uri);
+ if (!s->location)
+ return AVERROR(ENOMEM);
av_dict_copy(&options, s->chained_options, 0);
ret = http_open_cnx(h, &options);
h->is_streamed = 1;
s->filesize = -1;
- av_strlcpy(s->location, uri, sizeof(s->location));
+ s->location = av_strdup(uri);
+ if (!s->location)
+ return AVERROR(ENOMEM);
if (options)
av_dict_copy(&s->chained_options, *options, 0);
if (len < 0) {
return len;
} else if (len == 0) {
- return -1;
+ return AVERROR_EOF;
} else {
s->buf_ptr = s->buffer;
s->buf_end = s->buffer + len;
}
}
+static int check_http_code(URLContext *h, int http_code, const char *end)
+{
+ HTTPContext *s = h->priv_data;
+ /* error codes are 4xx and 5xx, but regard 401 as a success, so we
+ * don't abort until all headers have been parsed. */
+ if (http_code >= 400 && http_code < 600 &&
+ (http_code != 401 || s->auth_state.auth_type != HTTP_AUTH_NONE) &&
+ (http_code != 407 || s->proxy_auth_state.auth_type != HTTP_AUTH_NONE)) {
+ end += strspn(end, SPACE_CHARS);
+ av_log(h, AV_LOG_WARNING, "HTTP error %d %s\n", http_code, end);
+ return AVERROR(EIO);
+ }
+ return 0;
+}
+
+static int parse_location(HTTPContext *s, const char *p)
+{
+ char redirected_location[MAX_URL_SIZE], *new_loc;
+ ff_make_absolute_url(redirected_location, sizeof(redirected_location),
+ s->location, p);
+ new_loc = av_strdup(redirected_location);
+ if (!new_loc)
+ return AVERROR(ENOMEM);
+ av_free(s->location);
+ s->location = new_loc;
+ return 0;
+}
+
+/* "bytes $from-$to/$document_size" */
+static void parse_content_range(URLContext *h, const char *p)
+{
+ HTTPContext *s = h->priv_data;
+ const char *slash;
+
+ if (!strncmp(p, "bytes ", 6)) {
+ p += 6;
+ s->off = strtoll(p, NULL, 10);
+ if ((slash = strchr(p, '/')) && strlen(slash) > 0)
+ s->filesize = strtoll(slash+1, NULL, 10);
+ }
+ h->is_streamed = 0; /* we _can_ in fact seek */
+}
+
+static int parse_content_encoding(URLContext *h, const char *p)
+{
+ HTTPContext *s = h->priv_data;
+
+ if (!av_strncasecmp(p, "gzip", 4) ||
+ !av_strncasecmp(p, "deflate", 7)) {
+#if CONFIG_ZLIB
+ s->compressed = 1;
+ inflateEnd(&s->inflate_stream);
+ if (inflateInit2(&s->inflate_stream, 32 + 15) != Z_OK) {
+ av_log(h, AV_LOG_WARNING, "Error during zlib initialisation: %s\n",
+ s->inflate_stream.msg);
+ return AVERROR(ENOSYS);
+ }
+ if (zlibCompileFlags() & (1 << 17)) {
+ av_log(h, AV_LOG_WARNING,
+ "Your zlib was compiled without gzip support.\n");
+ return AVERROR(ENOSYS);
+ }
+#else
+ av_log(h, AV_LOG_WARNING,
+ "Compressed (%s) content, need zlib with gzip support\n", p);
+ return AVERROR(ENOSYS);
+#endif
+ } else if (!av_strncasecmp(p, "identity", 8)) {
+ // The normal, no-encoding case (although servers shouldn't include
+ // the header at all if this is the case).
+ } else {
+ av_log(h, AV_LOG_WARNING, "Unknown content coding: %s\n", p);
+ return AVERROR(ENOSYS);
+ }
+ return 0;
+}
+
+// Concat all Icy- header lines
+static int parse_icy(HTTPContext *s, const char *tag, const char *p)
+{
+ int len = 4 + strlen(p) + strlen(tag);
+ int is_first = !s->icy_metadata_headers;
+ int ret;
+
+ if (s->icy_metadata_headers)
+ len += strlen(s->icy_metadata_headers);
+
+ if ((ret = av_reallocp(&s->icy_metadata_headers, len)) < 0)
+ return ret;
+
+ if (is_first)
+ *s->icy_metadata_headers = '\0';
+
+ av_strlcatf(s->icy_metadata_headers, len, "%s: %s\n", tag, p);
+
+ return 0;
+}
+
static int process_line(URLContext *h, char *line, int line_count,
int *new_location)
{
HTTPContext *s = h->priv_data;
char *tag, *p, *end;
+ int ret;
/* end of header */
if (line[0] == '\0') {
av_dlog(NULL, "http_code=%d\n", s->http_code);
- /* error codes are 4xx and 5xx, but regard 401 as a success, so we
- * don't abort until all headers have been parsed. */
- if (s->http_code >= 400 && s->http_code < 600 && (s->http_code != 401
- || s->auth_state.auth_type != HTTP_AUTH_NONE) &&
- (s->http_code != 407 || s->proxy_auth_state.auth_type != HTTP_AUTH_NONE)) {
- end += strspn(end, SPACE_CHARS);
- av_log(h, AV_LOG_WARNING, "HTTP error %d %s\n",
- s->http_code, end);
- return -1;
- }
+ if ((ret = check_http_code(h, s->http_code, end)) < 0)
+ return ret;
} else {
while (*p != '\0' && *p != ':')
p++;
while (av_isspace(*p))
p++;
if (!av_strcasecmp(tag, "Location")) {
- av_strlcpy(s->location, p, sizeof(s->location));
+ if ((ret = parse_location(s, p)) < 0)
+ return ret;
*new_location = 1;
- } else if (!av_strcasecmp (tag, "Content-Length") && s->filesize == -1) {
+ } else if (!av_strcasecmp(tag, "Content-Length") && s->filesize == -1) {
s->filesize = strtoll(p, NULL, 10);
- } else if (!av_strcasecmp (tag, "Content-Range")) {
- /* "bytes $from-$to/$document_size" */
- const char *slash;
- if (!strncmp (p, "bytes ", 6)) {
- p += 6;
- s->off = strtoll(p, NULL, 10);
- if ((slash = strchr(p, '/')) && strlen(slash) > 0)
- s->filesize = strtoll(slash+1, NULL, 10);
- }
- h->is_streamed = 0; /* we _can_ in fact seek */
- } else if (!av_strcasecmp(tag, "Accept-Ranges") && !strncmp(p, "bytes", 5)) {
+ } else if (!av_strcasecmp(tag, "Content-Range")) {
+ parse_content_range(h, p);
+ } else if (!av_strcasecmp(tag, "Accept-Ranges") &&
+ !strncmp(p, "bytes", 5)) {
h->is_streamed = 0;
- } else if (!av_strcasecmp (tag, "Transfer-Encoding") && !av_strncasecmp(p, "chunked", 7)) {
+ } else if (!av_strcasecmp(tag, "Transfer-Encoding") &&
+ !av_strncasecmp(p, "chunked", 7)) {
s->filesize = -1;
s->chunksize = 0;
- } else if (!av_strcasecmp (tag, "WWW-Authenticate")) {
+ } else if (!av_strcasecmp(tag, "WWW-Authenticate")) {
ff_http_auth_handle_header(&s->auth_state, tag, p);
- } else if (!av_strcasecmp (tag, "Authentication-Info")) {
+ } else if (!av_strcasecmp(tag, "Authentication-Info")) {
ff_http_auth_handle_header(&s->auth_state, tag, p);
- } else if (!av_strcasecmp (tag, "Proxy-Authenticate")) {
+ } else if (!av_strcasecmp(tag, "Proxy-Authenticate")) {
ff_http_auth_handle_header(&s->proxy_auth_state, tag, p);
- } else if (!av_strcasecmp (tag, "Connection")) {
+ } else if (!av_strcasecmp(tag, "Connection")) {
if (!strcmp(p, "close"))
s->willclose = 1;
- } else if (!av_strcasecmp (tag, "Content-Encoding")) {
- if (!av_strncasecmp(p, "gzip", 4) || !av_strncasecmp(p, "deflate", 7)) {
-#if CONFIG_ZLIB
- s->compressed = 1;
- inflateEnd(&s->inflate_stream);
- if (inflateInit2(&s->inflate_stream, 32 + 15) != Z_OK) {
- av_log(h, AV_LOG_WARNING, "Error during zlib initialisation: %s\n",
- s->inflate_stream.msg);
- return AVERROR(ENOSYS);
- }
- if (zlibCompileFlags() & (1 << 17)) {
- av_log(h, AV_LOG_WARNING, "Your zlib was compiled without gzip support.\n");
- return AVERROR(ENOSYS);
- }
-#else
- av_log(h, AV_LOG_WARNING, "Compressed (%s) content, need zlib with gzip support\n", p);
- return AVERROR(ENOSYS);
-#endif
- } else if (!av_strncasecmp(p, "identity", 8)) {
- // The normal, no-encoding case (although servers shouldn't include
- // the header at all if this is the case).
- } else {
- av_log(h, AV_LOG_WARNING, "Unknown content coding: %s\n", p);
- return AVERROR(ENOSYS);
- }
+ } else if (!av_strcasecmp (tag, "Content-Type")) {
+ av_free(s->mime_type);
+ s->mime_type = av_strdup(p);
+ } else if (!av_strcasecmp (tag, "Icy-MetaInt")) {
+ s->icy_metaint = strtoll(p, NULL, 10);
+ } else if (!av_strncasecmp(tag, "Icy-", 4)) {
+ if ((ret = parse_icy(s, tag, p)) < 0)
+ return ret;
+ } else if (!av_strcasecmp(tag, "Content-Encoding")) {
+ if ((ret = parse_content_encoding(h, p)) < 0)
+ return ret;
}
}
return 1;
/* set default headers if needed */
if (!has_header(s->headers, "\r\nUser-Agent: "))
- len += av_strlcatf(headers + len, sizeof(headers) - len,
- "User-Agent: %s\r\n", LIBAVFORMAT_IDENT);
+ len += av_strlcatf(headers + len, sizeof(headers) - len,
+ "User-Agent: %s\r\n", s->user_agent);
if (!has_header(s->headers, "\r\nAccept: "))
len += av_strlcpy(headers + len, "Accept: */*\r\n",
sizeof(headers) - len);
- if (!has_header(s->headers, "\r\nRange: ") && !post)
+ // Note: we send this on purpose even when s->off is 0 when we're probing,
+ // since it allows us to detect more reliably if a (non-conforming)
+ // server supports seeking by analysing the reply headers.
+ if (!has_header(s->headers, "\r\nRange: ") && !post) {
len += av_strlcatf(headers + len, sizeof(headers) - len,
- "Range: bytes=%"PRId64"-\r\n", s->off);
+ "Range: bytes=%"PRId64"-", s->off);
+ if (s->end_off)
+ len += av_strlcatf(headers + len, sizeof(headers) - len,
+ "%"PRId64, s->end_off - 1);
+ len += av_strlcpy(headers + len, "\r\n",
+ sizeof(headers) - len);
+ }
if (send_expect_100 && !has_header(s->headers, "\r\nExpect: "))
len += av_strlcatf(headers + len, sizeof(headers) - len,
"Expect: 100-continue\r\n");
len += av_strlcatf(headers + len, sizeof(headers) - len,
"Content-Length: %d\r\n", s->post_datalen);
+ if (!has_header(s->headers, "\r\nContent-Type: ") && s->content_type)
+ len += av_strlcatf(headers + len, sizeof(headers) - len,
+ "Content-Type: %s\r\n", s->content_type);
+ if (!has_header(s->headers, "\r\nIcy-MetaData: ") && s->icy) {
+ len += av_strlcatf(headers + len, sizeof(headers) - len,
+ "Icy-MetaData: %d\r\n", 1);
+ }
+
/* now add in custom headers */
if (s->headers)
av_strlcpy(headers + len, s->headers, sizeof(headers) - len);
s->buf_end = s->buffer;
s->line_count = 0;
s->off = 0;
+ s->icy_data_read = 0;
s->filesize = -1;
s->willclose = 0;
s->end_chunked_post = 0;
}
#endif
-static int http_read(URLContext *h, uint8_t *buf, int size)
+static int http_read_stream(URLContext *h, uint8_t *buf, int size)
{
HTTPContext *s = h->priv_data;
int err, new_location;
return http_buf_read(h, buf, size);
}
+static int http_read_stream_all(URLContext *h, uint8_t *buf, int size)
+{
+ int pos = 0;
+ while (pos < size) {
+ int len = http_read_stream(h, buf + pos, size - pos);
+ if (len < 0)
+ return len;
+ pos += len;
+ }
+ return pos;
+}
+
+static int store_icy(URLContext *h, int size)
+{
+ HTTPContext *s = h->priv_data;
+ /* until next metadata packet */
+ int remaining = s->icy_metaint - s->icy_data_read;
+
+ if (remaining < 0)
+ return AVERROR_INVALIDDATA;
+
+ if (!remaining) {
+ // The metadata packet is variable sized. It has a 1 byte header
+ // which sets the length of the packet (divided by 16). If it's 0,
+ // the metadata doesn't change. After the packet, icy_metaint bytes
+ // of normal data follow.
+ uint8_t ch;
+ int len = http_read_stream_all(h, &ch, 1);
+ if (len < 0)
+ return len;
+ if (ch > 0) {
+ char data[255 * 16 + 1];
+ int ret;
+ len = ch * 16;
+ ret = http_read_stream_all(h, data, len);
+ if (ret < 0)
+ return ret;
+ data[len + 1] = 0;
+ if ((ret = av_opt_set(s, "icy_metadata_packet", data, 0)) < 0)
+ return ret;
+ }
+ s->icy_data_read = 0;
+ remaining = s->icy_metaint;
+ }
+
+ return FFMIN(size, remaining);
+}
+
+static int http_read(URLContext *h, uint8_t *buf, int size)
+{
+ HTTPContext *s = h->priv_data;
+
+ if (s->icy_metaint > 0) {
+ size = store_icy(h, size);
+ if (size < 0)
+ return size;
+ }
+
+ size = http_read_stream(h, buf, size);
+ if (size > 0)
+ s->icy_data_read += size;
+ return size;
+}
+
/* used only when posting data */
static int http_write(URLContext *h, const uint8_t *buf, int size)
{
URLContext *old_hd = s->hd;
int64_t old_off = s->off;
uint8_t old_buf[BUFFER_SIZE];
- int old_buf_size;
+ int old_buf_size, ret;
AVDictionary *options = NULL;
if (whence == AVSEEK_SIZE)
return s->filesize;
+ else if ((whence == SEEK_CUR && off == 0) ||
+ (whence == SEEK_SET && off == s->off))
+ return s->off;
else if ((s->filesize == -1 && whence == SEEK_END) || h->is_streamed)
- return -1;
+ return AVERROR(ENOSYS);
/* we save the old context in case the seek fails */
old_buf_size = s->buf_end - s->buf_ptr;
/* if it fails, continue on old connection */
av_dict_copy(&options, s->chained_options, 0);
- if (http_open_cnx(h, &options) < 0) {
+ if ((ret = http_open_cnx(h, &options)) < 0) {
av_dict_free(&options);
memcpy(s->buffer, old_buf, old_buf_size);
s->buf_ptr = s->buffer;
s->buf_end = s->buffer + old_buf_size;
s->hd = old_hd;
s->off = old_off;
- return -1;
+ return ret;
}
av_dict_free(&options);
ffurl_close(old_hd);