Signed-off-by: Derek Buitenhuis <derek.buitenhuis@gmail.com>tags/n3.1
@@ -10,6 +10,7 @@ version <next>: | |||
- datascope filter | |||
- bench and abench filters | |||
- ciescope filter | |||
- protocol blacklisting API | |||
version 3.0: | |||
@@ -15,6 +15,9 @@ libavutil: 2015-08-28 | |||
API changes, most recent first: | |||
2016-XX-XX - xxxxxxx - lavf 57.28.100 | |||
Add protocol blacklisting API | |||
2016-02-28 - xxxxxxx - lavc 57.27.101 | |||
Validate AVFrame returned by get_buffer2 to have required | |||
planes not NULL and unused planes set to NULL as crashes | |||
@@ -251,7 +251,7 @@ static int async_open(URLContext *h, const char *arg, int flags, AVDictionary ** | |||
/* wrap interrupt callback */ | |||
c->interrupt_callback = h->interrupt_callback; | |||
ret = ffurl_open_whitelist(&c->inner, arg, flags, &interrupt_callback, options, h->protocol_whitelist); | |||
ret = ffurl_open_whitelist(&c->inner, arg, flags, &interrupt_callback, options, h->protocol_whitelist, h->protocol_blacklist); | |||
if (ret != 0) { | |||
av_log(h, AV_LOG_ERROR, "ffurl_open failed : %s, %s\n", av_err2str(ret), arg); | |||
goto url_fail; | |||
@@ -1832,11 +1832,11 @@ typedef struct AVFormatContext { | |||
#endif | |||
/** | |||
* ',' separated list of allowed protocols. | |||
* ',' separated list of disallowed protocols. | |||
* - encoding: unused | |||
* - decoding: set by user through AVOptions (NO direct access) | |||
*/ | |||
char *protocol_whitelist; | |||
char *protocol_blacklist; | |||
/* | |||
* A callback for opening new IO streams. | |||
@@ -1865,6 +1865,13 @@ typedef struct AVFormatContext { | |||
* A callback for closing the streams opened with AVFormatContext.io_open(). | |||
*/ | |||
void (*io_close)(struct AVFormatContext *s, AVIOContext *pb); | |||
/** | |||
* ',' separated list of disallowed protocols. | |||
* - encoding: unused | |||
* - decoding: set by user through AVOptions (NO direct access) | |||
*/ | |||
char *protocol_blacklist; | |||
} AVFormatContext; | |||
int av_format_get_probe_score(const AVFormatContext *s); | |||
@@ -1089,7 +1089,7 @@ static int read_gab2_sub(AVFormatContext *s, AVStream *st, AVPacket *pkt) | |||
ast->sub_ctx->pb = pb; | |||
if (ff_copy_whitelists(ast->sub_ctx, s) < 0) | |||
if (ff_copy_whiteblacklists(ast->sub_ctx, s) < 0) | |||
goto error; | |||
if (!avformat_open_input(&ast->sub_ctx, "", sub_demuxer, NULL)) { | |||
@@ -55,6 +55,7 @@ static void *urlcontext_child_next(void *obj, void *prev) | |||
#define D AV_OPT_FLAG_DECODING_PARAM | |||
static const AVOption options[] = { | |||
{"protocol_whitelist", "List of protocols that are allowed to be used", OFFSET(protocol_whitelist), AV_OPT_TYPE_STRING, { .str = NULL }, CHAR_MIN, CHAR_MAX, D }, | |||
{"protocol_blacklist", "List of protocols that are not allowed to be used", OFFSET(protocol_blacklist), AV_OPT_TYPE_STRING, { .str = NULL }, CHAR_MIN, CHAR_MAX, D }, | |||
{ NULL } | |||
}; | |||
@@ -173,12 +174,19 @@ int ffurl_connect(URLContext *uc, AVDictionary **options) | |||
// Check that URLContext was initialized correctly and lists are matching if set | |||
av_assert0(!(e=av_dict_get(*options, "protocol_whitelist", NULL, 0)) || | |||
(uc->protocol_whitelist && !strcmp(uc->protocol_whitelist, e->value))); | |||
av_assert0(!(e=av_dict_get(*options, "protocol_blacklist", NULL, 0)) || | |||
(uc->protocol_blacklist && !strcmp(uc->protocol_blacklist, e->value))); | |||
if (uc->protocol_whitelist && av_match_list(uc->prot->name, uc->protocol_whitelist, ',') <= 0) { | |||
av_log(uc, AV_LOG_ERROR, "Protocol not on whitelist \'%s\'!\n", uc->protocol_whitelist); | |||
return AVERROR(EINVAL); | |||
} | |||
if (uc->protocol_blacklist && av_match_list(uc->prot->name, uc->protocol_blacklist, ',') > 0) { | |||
av_log(uc, AV_LOG_ERROR, "Protocol blacklisted \'%s\'!\n", uc->protocol_blacklist); | |||
return AVERROR(EINVAL); | |||
} | |||
if (!uc->protocol_whitelist && uc->prot->default_whitelist) { | |||
av_log(uc, AV_LOG_DEBUG, "Setting default whitelist '%s'\n", uc->prot->default_whitelist); | |||
uc->protocol_whitelist = av_strdup(uc->prot->default_whitelist); | |||
@@ -190,6 +198,8 @@ int ffurl_connect(URLContext *uc, AVDictionary **options) | |||
if ((err = av_dict_set(options, "protocol_whitelist", uc->protocol_whitelist, 0)) < 0) | |||
return err; | |||
if ((err = av_dict_set(options, "protocol_blacklist", uc->protocol_blacklist, 0)) < 0) | |||
return err; | |||
err = | |||
uc->prot->url_open2 ? uc->prot->url_open2(uc, | |||
@@ -199,6 +209,7 @@ int ffurl_connect(URLContext *uc, AVDictionary **options) | |||
uc->prot->url_open(uc, uc->filename, uc->flags); | |||
av_dict_set(options, "protocol_whitelist", NULL, 0); | |||
av_dict_set(options, "protocol_blacklist", NULL, 0); | |||
if (err) | |||
return err; | |||
@@ -290,7 +301,8 @@ int ffurl_alloc(URLContext **puc, const char *filename, int flags, | |||
} | |||
int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags, | |||
const AVIOInterruptCB *int_cb, AVDictionary **options, const char *whitelist) | |||
const AVIOInterruptCB *int_cb, AVDictionary **options, | |||
const char *whitelist, const char* blacklist) | |||
{ | |||
AVDictionary *tmp_opts = NULL; | |||
AVDictionaryEntry *e; | |||
@@ -307,10 +319,16 @@ int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags, | |||
av_assert0(!whitelist || | |||
!(e=av_dict_get(*options, "protocol_whitelist", NULL, 0)) || | |||
!strcmp(whitelist, e->value)); | |||
av_assert0(!blacklist || | |||
!(e=av_dict_get(*options, "protocol_blacklist", NULL, 0)) || | |||
!strcmp(blacklist, e->value)); | |||
if ((ret = av_dict_set(options, "protocol_whitelist", whitelist, 0)) < 0) | |||
goto fail; | |||
if ((ret = av_dict_set(options, "protocol_blacklist", blacklist, 0)) < 0) | |||
goto fail; | |||
if ((ret = av_opt_set_dict(*puc, options)) < 0) | |||
goto fail; | |||
@@ -328,7 +346,7 @@ int ffurl_open(URLContext **puc, const char *filename, int flags, | |||
const AVIOInterruptCB *int_cb, AVDictionary **options) | |||
{ | |||
return ffurl_open_whitelist(puc, filename, flags, | |||
int_cb, options, NULL); | |||
int_cb, options, NULL, NULL); | |||
} | |||
static inline int retry_transfer_wrapper(URLContext *h, uint8_t *buf, | |||
@@ -254,6 +254,11 @@ typedef struct AVIOContext { | |||
* ',' separated list of allowed protocols. | |||
*/ | |||
const char *protocol_whitelist; | |||
/** | |||
* ',' separated list of disallowed protocols. | |||
*/ | |||
const char *protocol_blacklist; | |||
} AVIOContext; | |||
/* unbuffered I/O */ | |||
@@ -155,7 +155,7 @@ int ffio_open_null_buf(AVIOContext **s); | |||
int ffio_open_whitelist(AVIOContext **s, const char *url, int flags, | |||
const AVIOInterruptCB *int_cb, AVDictionary **options, | |||
const char *whitelist); | |||
const char *whitelist, const char *blacklist); | |||
/** | |||
* Close a null buffer. | |||
@@ -848,6 +848,11 @@ int ffio_fdopen(AVIOContext **s, URLContext *h) | |||
avio_closep(s); | |||
goto fail; | |||
} | |||
(*s)->protocol_blacklist = av_strdup(h->protocol_blacklist); | |||
if (!(*s)->protocol_blacklist && h->protocol_blacklist) { | |||
avio_closep(s); | |||
goto fail; | |||
} | |||
(*s)->direct = h->flags & AVIO_FLAG_DIRECT; | |||
(*s)->seekable = h->is_streamed ? 0 : AVIO_SEEKABLE_NORMAL; | |||
@@ -974,13 +979,13 @@ int avio_open(AVIOContext **s, const char *filename, int flags) | |||
int ffio_open_whitelist(AVIOContext **s, const char *filename, int flags, | |||
const AVIOInterruptCB *int_cb, AVDictionary **options, | |||
const char *whitelist | |||
const char *whitelist, const char *blacklist | |||
) | |||
{ | |||
URLContext *h; | |||
int err; | |||
err = ffurl_open_whitelist(&h, filename, flags, int_cb, options, whitelist); | |||
err = ffurl_open_whitelist(&h, filename, flags, int_cb, options, whitelist, blacklist); | |||
if (err < 0) | |||
return err; | |||
err = ffio_fdopen(s, h); | |||
@@ -994,13 +999,13 @@ int ffio_open_whitelist(AVIOContext **s, const char *filename, int flags, | |||
int avio_open2(AVIOContext **s, const char *filename, int flags, | |||
const AVIOInterruptCB *int_cb, AVDictionary **options) | |||
{ | |||
return ffio_open_whitelist(s, filename, flags, int_cb, options, NULL); | |||
return ffio_open_whitelist(s, filename, flags, int_cb, options, NULL, NULL); | |||
} | |||
int ffio_open2_wrapper(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, | |||
const AVIOInterruptCB *int_cb, AVDictionary **options) | |||
{ | |||
return ffio_open_whitelist(pb, url, flags, int_cb, options, s->protocol_whitelist); | |||
return ffio_open_whitelist(pb, url, flags, int_cb, options, s->protocol_whitelist, s->protocol_blacklist); | |||
} | |||
int avio_close(AVIOContext *s) | |||
@@ -87,7 +87,7 @@ static int cache_open(URLContext *h, const char *arg, int flags, AVDictionary ** | |||
av_freep(&buffername); | |||
return ffurl_open_whitelist(&c->inner, arg, flags, &h->interrupt_callback, | |||
options, h->protocol_whitelist); | |||
options, h->protocol_whitelist, h->protocol_blacklist); | |||
} | |||
static int add_entry(URLContext *h, const unsigned char *buf, int size) | |||
@@ -98,7 +98,7 @@ static av_cold int concat_open(URLContext *h, const char *uri, int flags) | |||
/* creating URLContext */ | |||
err = ffurl_open_whitelist(&uc, node_uri, flags, | |||
&h->interrupt_callback, NULL, h->protocol_whitelist); | |||
&h->interrupt_callback, NULL, h->protocol_whitelist, h->protocol_blacklist); | |||
if (err < 0) | |||
break; | |||
@@ -301,7 +301,7 @@ static int open_file(AVFormatContext *avf, unsigned fileno) | |||
cat->avf->interrupt_callback = avf->interrupt_callback; | |||
if ((ret = ff_copy_whitelists(cat->avf, avf)) < 0) | |||
if ((ret = ff_copy_whiteblacklists(cat->avf, avf)) < 0) | |||
return ret; | |||
if ((ret = avformat_open_input(&cat->avf, file->url, NULL, NULL)) < 0 || | |||
@@ -138,7 +138,7 @@ static int crypto_open2(URLContext *h, const char *uri, int flags, AVDictionary | |||
if ((ret = ffurl_open_whitelist(&c->hd, nested_url, flags, | |||
&h->interrupt_callback, options, | |||
h->protocol_whitelist)) < 0) { | |||
h->protocol_whitelist, h->protocol_blacklist)) < 0) { | |||
av_log(h, AV_LOG_ERROR, "Unable to open resource: %s\n", nested_url); | |||
goto err; | |||
} | |||
@@ -539,7 +539,7 @@ static int ftp_connect_control_connection(URLContext *h) | |||
} /* if option is not given, don't pass it and let tcp use its own default */ | |||
err = ffurl_open_whitelist(&s->conn_control, buf, AVIO_FLAG_READ_WRITE, | |||
&h->interrupt_callback, &opts, | |||
h->protocol_whitelist); | |||
h->protocol_whitelist, h->protocol_blacklist); | |||
av_dict_free(&opts); | |||
if (err < 0) { | |||
av_log(h, AV_LOG_ERROR, "Cannot open control connection\n"); | |||
@@ -593,7 +593,7 @@ static int ftp_connect_data_connection(URLContext *h) | |||
} /* if option is not given, don't pass it and let tcp use its own default */ | |||
err = ffurl_open_whitelist(&s->conn_data, buf, h->flags, | |||
&h->interrupt_callback, &opts, | |||
h->protocol_whitelist); | |||
h->protocol_whitelist, h->protocol_blacklist); | |||
av_dict_free(&opts); | |||
if (err < 0) | |||
return err; | |||
@@ -94,7 +94,7 @@ static int gopher_open(URLContext *h, const char *uri, int flags) | |||
s->hd = NULL; | |||
err = ffurl_open_whitelist(&s->hd, buf, AVIO_FLAG_READ_WRITE, | |||
&h->interrupt_callback, NULL, h->protocol_whitelist); | |||
&h->interrupt_callback, NULL, h->protocol_whitelist, h->protocol_blacklist); | |||
if (err < 0) | |||
goto fail; | |||
@@ -1619,7 +1619,7 @@ static int hls_read_header(AVFormatContext *s) | |||
pls->ctx->io_open = nested_io_open; | |||
pls->stream_offset = stream_offset; | |||
if ((ret = ff_copy_whitelists(pls->ctx, s)) < 0) | |||
if ((ret = ff_copy_whiteblacklists(pls->ctx, s)) < 0) | |||
goto fail; | |||
ret = avformat_open_input(&pls->ctx, pls->segments[0]->url, in_fmt, NULL); | |||
@@ -119,7 +119,7 @@ static int parse_playlist(URLContext *h, const char *url) | |||
if ((ret = ffio_open_whitelist(&in, url, AVIO_FLAG_READ, | |||
&h->interrupt_callback, NULL, | |||
h->protocol_whitelist)) < 0) | |||
h->protocol_whitelist, h->protocol_blacklist)) < 0) | |||
return ret; | |||
read_chomp_line(in, line, sizeof(line)); | |||
@@ -307,7 +307,7 @@ retry: | |||
av_log(h, AV_LOG_DEBUG, "opening %s\n", url); | |||
ret = ffurl_open_whitelist(&s->seg_hd, url, AVIO_FLAG_READ, | |||
&h->interrupt_callback, NULL, | |||
h->protocol_whitelist); | |||
h->protocol_whitelist, h->protocol_blacklist); | |||
if (ret < 0) { | |||
if (ff_check_interrupt(&h->interrupt_callback)) | |||
return AVERROR_EXIT; | |||
@@ -221,7 +221,7 @@ static int http_open_cnx_internal(URLContext *h, AVDictionary **options) | |||
if (!s->hd) { | |||
err = ffurl_open_whitelist(&s->hd, buf, AVIO_FLAG_READ_WRITE, | |||
&h->interrupt_callback, options, | |||
h->protocol_whitelist); | |||
h->protocol_whitelist, h->protocol_blacklist); | |||
if (err < 0) | |||
return err; | |||
} | |||
@@ -456,7 +456,7 @@ static int http_listen(URLContext *h, const char *uri, int flags, | |||
goto fail; | |||
if ((ret = ffurl_open_whitelist(&s->hd, lower_url, AVIO_FLAG_READ_WRITE, | |||
&h->interrupt_callback, options, | |||
h->protocol_whitelist | |||
h->protocol_whitelist, h->protocol_blacklist | |||
)) < 0) | |||
goto fail; | |||
s->handshake_step = LOWER_PROTO; | |||
@@ -1582,7 +1582,7 @@ static int http_proxy_open(URLContext *h, const char *uri, int flags) | |||
redo: | |||
ret = ffurl_open_whitelist(&s->hd, lower_url, AVIO_FLAG_READ_WRITE, | |||
&h->interrupt_callback, NULL, | |||
h->protocol_whitelist); | |||
h->protocol_whitelist, h->protocol_blacklist); | |||
if (ret < 0) | |||
return ret; | |||
@@ -165,7 +165,7 @@ static int icecast_open(URLContext *h, const char *uri, int flags) | |||
ff_url_join(h_url, sizeof(h_url), "http", auth, host, port, "%s", path); | |||
// Finally open http proto handler | |||
ret = ffurl_open_whitelist(&s->hd, h_url, AVIO_FLAG_READ_WRITE, NULL, | |||
&opt_dict, h->protocol_whitelist); | |||
&opt_dict, h->protocol_whitelist, h->protocol_blacklist); | |||
cleanup: | |||
av_freep(&user); | |||
@@ -532,7 +532,7 @@ enum AVWriteUncodedFrameFlags { | |||
/** | |||
* Copies the whilelists from one context to the other | |||
*/ | |||
int ff_copy_whitelists(AVFormatContext *dst, AVFormatContext *src); | |||
int ff_copy_whiteblacklists(AVFormatContext *dst, AVFormatContext *src); | |||
int ffio_open2_wrapper(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, | |||
const AVIOInterruptCB *int_cb, AVDictionary **options); | |||
@@ -71,7 +71,7 @@ static int md5_close(URLContext *h) | |||
if (*filename) { | |||
err = ffurl_open_whitelist(&out, filename, AVIO_FLAG_WRITE, | |||
&h->interrupt_callback, NULL, | |||
h->protocol_whitelist); | |||
h->protocol_whitelist, h->protocol_blacklist); | |||
if (err) | |||
return err; | |||
err = ffurl_write(out, buf, i*2+1); | |||
@@ -530,7 +530,7 @@ static int mms_open(URLContext *h, const char *uri, int flags) | |||
ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, mmst->host, port, NULL); | |||
err = ffurl_open_whitelist(&mms->mms_hd, tcpname, AVIO_FLAG_READ_WRITE, | |||
&h->interrupt_callback, NULL, | |||
h->protocol_whitelist); | |||
h->protocol_whitelist, h->protocol_blacklist); | |||
if (err) | |||
goto fail; | |||
@@ -732,7 +732,7 @@ static int vobsub_read_header(AVFormatContext *s) | |||
goto end; | |||
} | |||
if ((ret = ff_copy_whitelists(vobsub->sub_ctx, s)) < 0) | |||
if ((ret = ff_copy_whiteblacklists(vobsub->sub_ctx, s)) < 0) | |||
goto end; | |||
ret = avformat_open_input(&vobsub->sub_ctx, vobsub->sub_name, iformat, NULL); | |||
@@ -109,7 +109,7 @@ FF_DISABLE_DEPRECATION_WARNINGS | |||
FF_ENABLE_DEPRECATION_WARNINGS | |||
#endif | |||
return ffio_open_whitelist(pb, url, flags, &s->interrupt_callback, options, s->protocol_whitelist); | |||
return ffio_open_whitelist(pb, url, flags, &s->interrupt_callback, options, s->protocol_whitelist, s->protocol_blacklist); | |||
} | |||
static void io_close_default(AVFormatContext *s, AVIOContext *pb) | |||
@@ -101,6 +101,7 @@ static const AVOption avformat_options[] = { | |||
{"codec_whitelist", "List of decoders that are allowed to be used", OFFSET(codec_whitelist), AV_OPT_TYPE_STRING, { .str = NULL }, CHAR_MIN, CHAR_MAX, D }, | |||
{"format_whitelist", "List of demuxers that are allowed to be used", OFFSET(format_whitelist), AV_OPT_TYPE_STRING, { .str = NULL }, CHAR_MIN, CHAR_MAX, D }, | |||
{"protocol_whitelist", "List of protocols that are allowed to be used", OFFSET(protocol_whitelist), AV_OPT_TYPE_STRING, { .str = NULL }, CHAR_MIN, CHAR_MAX, D }, | |||
{"protocol_blacklist", "List of protocols that are not allowed to be used", OFFSET(protocol_blacklist), AV_OPT_TYPE_STRING, { .str = NULL }, CHAR_MIN, CHAR_MAX, D }, | |||
{NULL}, | |||
}; | |||
@@ -531,7 +531,7 @@ static av_cold int rdt_init(AVFormatContext *s, int st_index, PayloadContext *rd | |||
if (!rdt->rmctx) | |||
return AVERROR(ENOMEM); | |||
if ((ret = ff_copy_whitelists(rdt->rmctx, s)) < 0) | |||
if ((ret = ff_copy_whiteblacklists(rdt->rmctx, s)) < 0) | |||
return ret; | |||
return avformat_open_input(&rdt->rmctx, "", &ff_rdt_demuxer, NULL); | |||
@@ -266,7 +266,7 @@ static int rtmpe_open(URLContext *h, const char *uri, int flags) | |||
/* open the tcp or ffrtmphttp connection */ | |||
if ((ret = ffurl_open_whitelist(&rt->stream, url, AVIO_FLAG_READ_WRITE, | |||
&h->interrupt_callback, NULL, | |||
h->protocol_whitelist)) < 0) { | |||
h->protocol_whitelist, h->protocol_blacklist)) < 0) { | |||
rtmpe_close(h); | |||
return ret; | |||
} | |||
@@ -1120,7 +1120,7 @@ static int rtmp_calc_swfhash(URLContext *s) | |||
/* Get the SWF player file. */ | |||
if ((ret = ffurl_open_whitelist(&stream, rt->swfverify, AVIO_FLAG_READ, | |||
&s->interrupt_callback, NULL, | |||
s->protocol_whitelist)) < 0) { | |||
s->protocol_whitelist, s->protocol_blacklist)) < 0) { | |||
av_log(s, AV_LOG_ERROR, "Cannot open connection %s.\n", rt->swfverify); | |||
goto fail; | |||
} | |||
@@ -2650,7 +2650,7 @@ static int rtmp_open(URLContext *s, const char *uri, int flags) | |||
reconnect: | |||
if ((ret = ffurl_open_whitelist(&rt->stream, buf, AVIO_FLAG_READ_WRITE, | |||
&s->interrupt_callback, &opts, | |||
s->protocol_whitelist)) < 0) { | |||
s->protocol_whitelist, s->protocol_blacklist)) < 0) { | |||
av_log(s , AV_LOG_ERROR, "Cannot open connection %s\n", buf); | |||
goto fail; | |||
} | |||
@@ -131,7 +131,7 @@ int ff_wms_parse_sdp_a_line(AVFormatContext *s, const char *p) | |||
rt->asf_ctx->pb = &pb; | |||
av_dict_set(&opts, "no_resync_search", "1", 0); | |||
if ((ret = ff_copy_whitelists(rt->asf_ctx, s)) < 0) { | |||
if ((ret = ff_copy_whiteblacklists(rt->asf_ctx, s)) < 0) { | |||
av_dict_free(&opts); | |||
return ret; | |||
} | |||
@@ -381,7 +381,7 @@ static int rtp_open(URLContext *h, const char *uri, int flags) | |||
hostname, rtp_port, s->local_rtpport, | |||
sources, block); | |||
if (ffurl_open_whitelist(&s->rtp_hd, buf, flags, &h->interrupt_callback, | |||
NULL, h->protocol_whitelist) < 0) | |||
NULL, h->protocol_whitelist, h->protocol_blacklist) < 0) | |||
goto fail; | |||
s->local_rtpport = ff_udp_get_local_port(s->rtp_hd); | |||
if(s->local_rtpport == 65535) { | |||
@@ -395,7 +395,7 @@ static int rtp_open(URLContext *h, const char *uri, int flags) | |||
sources, block); | |||
if (ffurl_open_whitelist(&s->rtcp_hd, buf, flags, | |||
&h->interrupt_callback, NULL, | |||
h->protocol_whitelist) < 0) { | |||
h->protocol_whitelist, h->protocol_blacklist) < 0) { | |||
s->local_rtpport = s->local_rtcpport = -1; | |||
continue; | |||
} | |||
@@ -405,7 +405,7 @@ static int rtp_open(URLContext *h, const char *uri, int flags) | |||
hostname, s->rtcp_port, s->local_rtcpport, | |||
sources, block); | |||
if (ffurl_open_whitelist(&s->rtcp_hd, buf, flags, &h->interrupt_callback, | |||
NULL, h->protocol_whitelist) < 0) | |||
NULL, h->protocol_whitelist, h->protocol_blacklist) < 0) | |||
goto fail; | |||
break; | |||
} | |||
@@ -1469,7 +1469,7 @@ int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port, | |||
/* we will use two ports per rtp stream (rtp and rtcp) */ | |||
j += 2; | |||
err = ffurl_open_whitelist(&rtsp_st->rtp_handle, buf, AVIO_FLAG_READ_WRITE, | |||
&s->interrupt_callback, &opts, s->protocol_whitelist); | |||
&s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist); | |||
av_dict_free(&opts); | |||
@@ -1612,7 +1612,7 @@ int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port, | |||
ff_url_join(url, sizeof(url), "rtp", NULL, namebuf, | |||
port, "%s", optbuf); | |||
if (ffurl_open_whitelist(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE, | |||
&s->interrupt_callback, NULL, s->protocol_whitelist) < 0) { | |||
&s->interrupt_callback, NULL, s->protocol_whitelist, s->protocol_blacklist) < 0) { | |||
err = AVERROR_INVALIDDATA; | |||
goto fail; | |||
} | |||
@@ -1801,7 +1801,7 @@ redirect: | |||
host, port, | |||
"?timeout=%d", rt->stimeout); | |||
if ((ret = ffurl_open_whitelist(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE, | |||
&s->interrupt_callback, NULL, s->protocol_whitelist)) < 0) { | |||
&s->interrupt_callback, NULL, s->protocol_whitelist, s->protocol_blacklist)) < 0) { | |||
err = ret; | |||
goto fail; | |||
} | |||
@@ -2317,7 +2317,7 @@ static int sdp_read_header(AVFormatContext *s) | |||
rtsp_st->nb_exclude_source_addrs, | |||
rtsp_st->exclude_source_addrs); | |||
err = ffurl_open_whitelist(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE, | |||
&s->interrupt_callback, &opts, s->protocol_whitelist); | |||
&s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist); | |||
av_dict_free(&opts); | |||
@@ -2387,7 +2387,7 @@ static int rtp_read_header(AVFormatContext *s) | |||
return AVERROR(EIO); | |||
ret = ffurl_open_whitelist(&in, s->filename, AVIO_FLAG_READ, | |||
&s->interrupt_callback, NULL, s->protocol_whitelist); | |||
&s->interrupt_callback, NULL, s->protocol_whitelist, s->protocol_blacklist); | |||
if (ret) | |||
goto fail; | |||
@@ -296,7 +296,7 @@ static int rtsp_read_setup(AVFormatContext *s, char* host, char *controlurl) | |||
av_log(s, AV_LOG_TRACE, "Opening: %s", url); | |||
ret = ffurl_open_whitelist(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE, | |||
&s->interrupt_callback, &opts, | |||
s->protocol_whitelist); | |||
s->protocol_whitelist, s->protocol_blacklist); | |||
av_dict_free(&opts); | |||
if (ret) | |||
localport += 2; | |||
@@ -665,7 +665,7 @@ static int rtsp_listen(AVFormatContext *s) | |||
if (ret = ffurl_open_whitelist(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE, | |||
&s->interrupt_callback, NULL, | |||
s->protocol_whitelist)) { | |||
s->protocol_whitelist, s->protocol_blacklist)) { | |||
av_log(s, AV_LOG_ERROR, "Unable to open RTSP for listening\n"); | |||
return ret; | |||
} | |||
@@ -87,7 +87,7 @@ static int sap_read_header(AVFormatContext *s) | |||
port); | |||
ret = ffurl_open_whitelist(&sap->ann_fd, url, AVIO_FLAG_READ, | |||
&s->interrupt_callback, NULL, | |||
s->protocol_whitelist); | |||
s->protocol_whitelist, s->protocol_blacklist); | |||
if (ret) | |||
goto fail; | |||
@@ -161,7 +161,7 @@ static int sap_read_header(AVFormatContext *s) | |||
sap->sdp_ctx->pb = &sap->sdp_pb; | |||
sap->sdp_ctx->interrupt_callback = s->interrupt_callback; | |||
if ((ret = ff_copy_whitelists(sap->sdp_ctx, s)) < 0) | |||
if ((ret = ff_copy_whiteblacklists(sap->sdp_ctx, s)) < 0) | |||
goto fail; | |||
ret = avformat_open_input(&sap->sdp_ctx, "temp.sdp", infmt, NULL); | |||
@@ -151,7 +151,7 @@ static int sap_write_header(AVFormatContext *s) | |||
base_port += 2; | |||
ret = ffurl_open_whitelist(&fd, url, AVIO_FLAG_WRITE, | |||
&s->interrupt_callback, NULL, | |||
s->protocol_whitelist); | |||
s->protocol_whitelist, s->protocol_blacklist); | |||
if (ret) { | |||
ret = AVERROR(EIO); | |||
goto fail; | |||
@@ -171,7 +171,7 @@ static int sap_write_header(AVFormatContext *s) | |||
"?ttl=%d&connect=1", ttl); | |||
ret = ffurl_open_whitelist(&sap->ann_fd, url, AVIO_FLAG_WRITE, | |||
&s->interrupt_callback, NULL, | |||
s->protocol_whitelist); | |||
s->protocol_whitelist, s->protocol_blacklist); | |||
if (ret) { | |||
ret = AVERROR(EIO); | |||
goto fail; | |||
@@ -123,7 +123,7 @@ static int64_t ism_seek(void *opaque, int64_t offset, int whence) | |||
os->tail_out = os->out; | |||
av_dict_set(&opts, "truncate", "0", 0); | |||
ret = ffurl_open_whitelist(&os->out, frag->file, AVIO_FLAG_WRITE, | |||
&os->ctx->interrupt_callback, &opts, os->ctx->protocol_whitelist); | |||
&os->ctx->interrupt_callback, &opts, os->ctx->protocol_whitelist, os->ctx->protocol_blacklist); | |||
av_dict_free(&opts); | |||
if (ret < 0) { | |||
os->out = os->tail_out; | |||
@@ -132,7 +132,7 @@ static int64_t ism_seek(void *opaque, int64_t offset, int whence) | |||
} | |||
av_dict_set(&opts, "truncate", "0", 0); | |||
ffurl_open_whitelist(&os->out2, frag->infofile, AVIO_FLAG_WRITE, | |||
&os->ctx->interrupt_callback, &opts, os->ctx->protocol_whitelist); | |||
&os->ctx->interrupt_callback, &opts, os->ctx->protocol_whitelist, os->ctx->protocol_blacklist); | |||
av_dict_free(&opts); | |||
ffurl_seek(os->out, offset - frag->start_pos, SEEK_SET); | |||
if (os->out2) | |||
@@ -332,7 +332,7 @@ static int ism_write_header(AVFormatContext *s) | |||
} | |||
ctx = avformat_alloc_context(); | |||
if (!ctx || ff_copy_whitelists(ctx, s) < 0) { | |||
if (!ctx || ff_copy_whiteblacklists(ctx, s) < 0) { | |||
ret = AVERROR(ENOMEM); | |||
goto fail; | |||
} | |||
@@ -526,7 +526,7 @@ static int ism_flush(AVFormatContext *s, int final) | |||
continue; | |||
snprintf(filename, sizeof(filename), "%s/temp", os->dirname); | |||
ret = ffurl_open_whitelist(&os->out, filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL, s->protocol_whitelist); | |||
ret = ffurl_open_whitelist(&os->out, filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL, s->protocol_whitelist, s->protocol_blacklist); | |||
if (ret < 0) | |||
break; | |||
os->cur_start_pos = os->tail_pos; | |||
@@ -81,7 +81,7 @@ static int srtp_open(URLContext *h, const char *uri, int flags) | |||
path, sizeof(path), uri); | |||
ff_url_join(buf, sizeof(buf), "rtp", NULL, hostname, rtp_port, "%s", path); | |||
if ((ret = ffurl_open_whitelist(&s->rtp_hd, buf, flags, &h->interrupt_callback, | |||
NULL, h->protocol_whitelist)) < 0) | |||
NULL, h->protocol_whitelist, h->protocol_blacklist)) < 0) | |||
goto fail; | |||
h->max_packet_size = FFMIN(s->rtp_hd->max_packet_size, | |||
@@ -78,7 +78,7 @@ static int subfile_open(URLContext *h, const char *filename, int flags, | |||
} | |||
av_strstart(filename, "subfile:", &filename); | |||
ret = ffurl_open_whitelist(&c->h, filename, flags, &h->interrupt_callback, | |||
options, h->protocol_whitelist); | |||
options, h->protocol_whitelist, h->protocol_blacklist); | |||
if (ret < 0) | |||
return ret; | |||
c->pos = c->start; | |||
@@ -106,5 +106,5 @@ int ff_tls_open_underlying(TLSShared *c, URLContext *parent, const char *uri, AV | |||
return ffurl_open_whitelist(&c->tcp, buf, AVIO_FLAG_READ_WRITE, | |||
&parent->interrupt_callback, options, | |||
parent->protocol_whitelist); | |||
parent->protocol_whitelist, parent->protocol_blacklist); | |||
} |
@@ -83,7 +83,7 @@ static int import_pem(URLContext *h, char *path, CFArrayRef *array) | |||
if ((ret = ffio_open_whitelist(&s, path, AVIO_FLAG_READ, | |||
&h->interrupt_callback, NULL, | |||
h->protocol_whitelist)) < 0) | |||
h->protocol_whitelist, h->protocol_blacklist)) < 0) | |||
goto end; | |||
if ((ret = avio_size(s)) < 0) | |||
@@ -47,6 +47,7 @@ typedef struct URLContext { | |||
AVIOInterruptCB interrupt_callback; | |||
int64_t rw_timeout; /**< maximum time to wait for (network) read/write operation completion, in mcs */ | |||
const char *protocol_whitelist; | |||
const char *protocol_blacklist; | |||
} URLContext; | |||
typedef struct URLProtocol { | |||
@@ -140,7 +141,7 @@ int ffurl_connect(URLContext *uc, AVDictionary **options); | |||
*/ | |||
int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags, | |||
const AVIOInterruptCB *int_cb, AVDictionary **options, | |||
const char *whitelist); | |||
const char *whitelist, const char* blacklist); | |||
int ffurl_open(URLContext **puc, const char *filename, int flags, | |||
const AVIOInterruptCB *int_cb, AVDictionary **options); | |||
@@ -142,18 +142,21 @@ void av_format_inject_global_side_data(AVFormatContext *s) | |||
} | |||
} | |||
int ff_copy_whitelists(AVFormatContext *dst, AVFormatContext *src) | |||
int ff_copy_whiteblacklists(AVFormatContext *dst, AVFormatContext *src) | |||
{ | |||
av_assert0(!dst->codec_whitelist && | |||
!dst->format_whitelist && | |||
!dst->protocol_whitelist); | |||
!dst->protocol_whitelist && | |||
!dst->protocol_blacklist); | |||
dst-> codec_whitelist = av_strdup(src->codec_whitelist); | |||
dst->format_whitelist = av_strdup(src->format_whitelist); | |||
dst->protocol_whitelist = av_strdup(src->protocol_whitelist); | |||
dst->protocol_blacklist = av_strdup(src->protocol_blacklist); | |||
if ( (src-> codec_whitelist && !dst-> codec_whitelist) | |||
|| (src-> format_whitelist && !dst-> format_whitelist) | |||
|| (src->protocol_whitelist && !dst->protocol_whitelist)) { | |||
av_log(dst, AV_LOG_ERROR, "Failed to duplicate whitelist\n"); | |||
|| (src->protocol_whitelist && !dst->protocol_whitelist) | |||
|| (src->protocol_blacklist && !dst->protocol_blacklist)) { | |||
av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n"); | |||
return AVERROR(ENOMEM); | |||
} | |||
return 0; | |||
@@ -460,6 +463,14 @@ int avformat_open_input(AVFormatContext **ps, const char *filename, | |||
} | |||
} | |||
if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) { | |||
s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist); | |||
if (!s->protocol_blacklist) { | |||
ret = AVERROR(ENOMEM); | |||
goto fail; | |||
} | |||
} | |||
if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) { | |||
av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist); | |||
ret = AVERROR(EINVAL); | |||
@@ -30,8 +30,8 @@ | |||
#include "libavutil/version.h" | |||
#define LIBAVFORMAT_VERSION_MAJOR 57 | |||
#define LIBAVFORMAT_VERSION_MINOR 27 | |||
#define LIBAVFORMAT_VERSION_MICRO 102 | |||
#define LIBAVFORMAT_VERSION_MINOR 28 | |||
#define LIBAVFORMAT_VERSION_MICRO 100 | |||
#define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \ | |||
LIBAVFORMAT_VERSION_MINOR, \ | |||