#include "libavfilter/avfilter.h"
#include "libavfilter/avfiltergraph.h"
#include "libavfilter/buffersink.h"
+#include "libavformat/avio_internal.h"
#include "libavformat/internal.h"
#include "avdevice.h"
if (lavfi->graph_filename) {
AVBPrint graph_file_pb;
AVIOContext *avio = NULL;
- ret = avio_open(&avio, lavfi->graph_filename, AVIO_FLAG_READ);
+ AVDictionary *options = NULL;
+ if (avctx->protocol_whitelist && (ret = av_dict_set(&options, "protocol_whitelist", avctx->protocol_whitelist, 0)) < 0)
+ goto end;
+ ret = avio_open2(&avio, lavfi->graph_filename, AVIO_FLAG_READ, &avctx->interrupt_callback, &options);
+ av_dict_set(&options, "protocol_whitelist", NULL, 0);
if (ret < 0)
goto end;
av_bprint_init(&graph_file_pb, 0, AV_BPRINT_SIZE_UNLIMITED);
/* wrap interrupt callback */
c->interrupt_callback = h->interrupt_callback;
- ret = ffurl_open(&c->inner, arg, flags, &interrupt_callback, options);
+ ret = ffurl_open_whitelist(&c->inner, arg, flags, &interrupt_callback, options, h->protocol_whitelist);
if (ret != 0) {
av_log(h, AV_LOG_ERROR, "ffurl_open failed : %s, %s\n", av_err2str(ret), arg);
goto url_fail;
unlink(buffername);
av_freep(&buffername);
- return ffurl_open(&c->inner, arg, flags, &h->interrupt_callback, options);
+ return ffurl_open_whitelist(&c->inner, arg, flags, &h->interrupt_callback,
+ options, h->protocol_whitelist);
}
static int add_entry(URLContext *h, const unsigned char *buf, int size)
uri += len + strspn(uri + len, AV_CAT_SEPARATOR);
/* creating URLContext */
- if ((err = ffurl_open(&uc, node_uri, flags,
- &h->interrupt_callback, NULL)) < 0)
+ err = ffurl_open_whitelist(&uc, node_uri, flags,
+ &h->interrupt_callback, NULL, h->protocol_whitelist);
+ if (err < 0)
break;
/* creating size */
.url_seek = concat_seek,
.url_close = concat_close,
.priv_data_size = sizeof(struct concat_data),
+ .default_whitelist = "concat,file,subfile",
};
goto err;
}
- if ((ret = ffurl_open(&c->hd, nested_url, flags,
- &h->interrupt_callback, options)) < 0) {
+ if ((ret = ffurl_open_whitelist(&c->hd, nested_url, flags,
+ &h->interrupt_callback, options,
+ h->protocol_whitelist)) < 0) {
av_log(h, AV_LOG_ERROR, "Unable to open resource: %s\n", nested_url);
goto err;
}
AVDictionaryEntry *title = av_dict_get(s->metadata, "title", NULL, 0);
snprintf(temp_filename, sizeof(temp_filename), "%s.tmp", s->filename);
- ret = avio_open2(&out, temp_filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL);
+ ret = ffio_open_whitelist(&out, temp_filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, NULL, s->protocol_whitelist);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "Unable to open %s for writing\n", temp_filename);
return ret;
dash_fill_tmpl_params(os->initfile, sizeof(os->initfile), c->init_seg_name, i, 0, os->bit_rate, 0);
}
snprintf(filename, sizeof(filename), "%s%s", c->dirname, os->initfile);
- ret = ffurl_open(&os->out, filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL);
+ ret = ffurl_open_whitelist(&os->out, filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL, s->protocol_whitelist);
if (ret < 0)
goto fail;
os->init_start_pos = 0;
URLContext *fd;
int ret;
- ret = ffurl_open(&fd, full_path, AVIO_FLAG_READ, &s->interrupt_callback, NULL);
+ ret = ffurl_open_whitelist(&fd, full_path, AVIO_FLAG_READ, &s->interrupt_callback, NULL, s->protocol_whitelist);
if (ret < 0)
return;
if (ffurl_seek(fd, pos, SEEK_SET) != pos) {
dash_fill_tmpl_params(filename, sizeof(filename), c->media_seg_name, i, os->segment_index, os->bit_rate, os->start_pts);
snprintf(full_path, sizeof(full_path), "%s%s", c->dirname, filename);
snprintf(temp_path, sizeof(temp_path), "%s.tmp", full_path);
- ret = ffurl_open(&os->out, temp_path, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL);
+ ret = ffurl_open_whitelist(&os->out, temp_path, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL, s->protocol_whitelist);
if (ret < 0)
break;
write_styp(os->ctx->pb);
.url_open_dir = file_open_dir,
.url_read_dir = file_read_dir,
.url_close_dir = file_close_dir,
+ .default_whitelist = "file"
};
#endif /* CONFIG_FILE_PROTOCOL */
.url_check = file_check,
.priv_data_size = sizeof(FileContext),
.priv_data_class = &pipe_class,
+ .default_whitelist = "none"
};
#endif /* CONFIG_PIPE_PROTOCOL */
if (s->rw_timeout != -1) {
av_dict_set_int(&opts, "timeout", s->rw_timeout, 0);
} /* if option is not given, don't pass it and let tcp use its own default */
- err = ffurl_open(&s->conn_control, buf, AVIO_FLAG_READ_WRITE,
- &h->interrupt_callback, &opts);
+ err = ffurl_open_whitelist(&s->conn_control, buf, AVIO_FLAG_READ_WRITE,
+ &h->interrupt_callback, &opts,
+ h->protocol_whitelist);
av_dict_free(&opts);
if (err < 0) {
av_log(h, AV_LOG_ERROR, "Cannot open control connection\n");
if (s->rw_timeout != -1) {
av_dict_set_int(&opts, "timeout", s->rw_timeout, 0);
} /* if option is not given, don't pass it and let tcp use its own default */
- err = ffurl_open(&s->conn_data, buf, h->flags,
- &h->interrupt_callback, &opts);
+ err = ffurl_open_whitelist(&s->conn_data, buf, h->flags,
+ &h->interrupt_callback, &opts,
+ h->protocol_whitelist);
av_dict_free(&opts);
if (err < 0)
return err;
.url_delete = ftp_delete,
.url_move = ftp_move,
.flags = URL_PROTOCOL_FLAG_NETWORK,
+ .default_whitelist = "tcp",
};
ff_url_join(buf, sizeof(buf), "tcp", NULL, hostname, port, NULL);
s->hd = NULL;
- err = ffurl_open(&s->hd, buf, AVIO_FLAG_READ_WRITE,
- &h->interrupt_callback, NULL);
+ err = ffurl_open_whitelist(&s->hd, buf, AVIO_FLAG_READ_WRITE,
+ &h->interrupt_callback, NULL, h->protocol_whitelist);
if (err < 0)
goto fail;
#endif
#include "avformat.h"
+#include "avio_internal.h"
#include "internal.h"
#include "os_support.h"
snprintf(filename, sizeof(filename), "%s/index.f4m", s->filename);
snprintf(temp_filename, sizeof(temp_filename), "%s/index.f4m.tmp", s->filename);
- ret = avio_open2(&out, temp_filename, AVIO_FLAG_WRITE,
- &s->interrupt_callback, NULL);
+ ret = ffio_open_whitelist(&out, temp_filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, NULL, s->protocol_whitelist);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "Unable to open %s for writing\n", temp_filename);
return ret;
"%s/stream%d.abst", s->filename, index);
snprintf(temp_filename, sizeof(temp_filename),
"%s/stream%d.abst.tmp", s->filename, index);
- ret = avio_open2(&out, temp_filename, AVIO_FLAG_WRITE,
- &s->interrupt_callback, NULL);
+ ret = ffio_open_whitelist(&out, temp_filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, NULL, s->protocol_whitelist);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "Unable to open %s for writing\n", temp_filename);
return ret;
static int init_file(AVFormatContext *s, OutputStream *os, int64_t start_ts)
{
int ret, i;
- ret = avio_open2(&os->out, os->temp_filename, AVIO_FLAG_WRITE,
- &s->interrupt_callback, NULL);
+ ret = ffio_open_whitelist(&os->out, os->temp_filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, NULL, s->protocol_whitelist);
if (ret < 0)
return ret;
avio_wb32(os->out, 0);
typedef struct HLSContext {
AVClass *class;
+ AVFormatContext *avfmt;
int n_variants;
struct variant **variants;
int n_playlists;
av_dict_copy(&tmp, opts, 0);
av_dict_copy(&tmp, opts2, 0);
+ if (pls->parent->protocol_whitelist) {
+ pls->input->protocol_whitelist = av_strdup(pls->parent->protocol_whitelist);
+ if (!pls->input->protocol_whitelist) {
+ av_dict_free(&tmp);
+ return AVERROR(ENOMEM);
+ }
+ }
+
if ((ret = ffurl_connect(pls->input, &tmp)) < 0) {
ffurl_close(pls->input);
pls->input = NULL;
av_dict_copy(&tmp, c->avio_opts, 0);
av_dict_copy(&tmp, opts, 0);
- ret = ffurl_open(uc, url, AVIO_FLAG_READ, c->interrupt_callback, &tmp);
+ ret = ffurl_open_whitelist(uc, url, AVIO_FLAG_READ, c->interrupt_callback, &tmp, c->avfmt->protocol_whitelist);
if( ret >= 0) {
// update cookies on http response with setcookies.
URLContext *u = *uc;
av_dict_set(&opts, "headers", c->headers, 0);
av_dict_set(&opts, "http_proxy", c->http_proxy, 0);
- ret = avio_open2(&in, url, AVIO_FLAG_READ,
- c->interrupt_callback, &opts);
+ ret = ffio_open_whitelist(&in, url, AVIO_FLAG_READ,
+ c->interrupt_callback, &opts, c->avfmt->protocol_whitelist);
av_dict_free(&opts);
if (ret < 0)
return ret;
HLSContext *c = s->priv_data;
int ret = 0, i, j, stream_offset = 0;
+ c->avfmt = s;
c->interrupt_callback = &s->interrupt_callback;
c->strict_std_compliance = s->strict_std_compliance;
#include "libavutil/time_internal.h"
#include "avformat.h"
+#include "avio_internal.h"
#include "internal.h"
#include "os_support.h"
AVIOContext *pb;
uint8_t key[KEYSIZE];
- if ((ret = avio_open2(&pb, hls->key_info_file, AVIO_FLAG_READ,
- &s->interrupt_callback, NULL)) < 0) {
+ if ((ret = ffio_open_whitelist(&pb, hls->key_info_file, AVIO_FLAG_READ,
+ &s->interrupt_callback, NULL, s->protocol_whitelist)) < 0) {
av_log(hls, AV_LOG_ERROR,
"error opening key info file %s\n", hls->key_info_file);
return ret;
return AVERROR(EINVAL);
}
- if ((ret = avio_open2(&pb, hls->key_file, AVIO_FLAG_READ,
- &s->interrupt_callback, NULL)) < 0) {
+ if ((ret = ffio_open_whitelist(&pb, hls->key_file, AVIO_FLAG_READ,
+ &s->interrupt_callback, NULL, s->protocol_whitelist)) < 0) {
av_log(hls, AV_LOG_ERROR, "error opening key file %s\n", hls->key_file);
return ret;
}
set_http_options(&options, hls);
snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", s->filename);
- if ((ret = avio_open2(&out, temp_filename, AVIO_FLAG_WRITE,
- &s->interrupt_callback, &options)) < 0)
+ if ((ret = ffio_open_whitelist(&out, temp_filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, &options, s->protocol_whitelist)) < 0)
goto fail;
for (en = hls->segments; en; en = en->next) {
avio_printf(out, "#EXT-X-ENDLIST\n");
if( hls->vtt_m3u8_name ) {
- if ((ret = avio_open2(&sub_out, hls->vtt_m3u8_name, AVIO_FLAG_WRITE,
- &s->interrupt_callback, &options)) < 0)
+ if ((ret = ffio_open_whitelist(&sub_out, hls->vtt_m3u8_name, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, &options, s->protocol_whitelist)) < 0)
goto fail;
avio_printf(sub_out, "#EXTM3U\n");
avio_printf(sub_out, "#EXT-X-VERSION:%d\n", version);
err = AVERROR(ENOMEM);
goto fail;
}
- err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
- &s->interrupt_callback, &options);
+ err = ffio_open_whitelist(&oc->pb, filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, &options, s->protocol_whitelist);
av_free(filename);
av_dict_free(&options);
if (err < 0)
return err;
} else
- if ((err = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
- &s->interrupt_callback, &options)) < 0)
+ if ((err = ffio_open_whitelist(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, &options, s->protocol_whitelist)) < 0)
goto fail;
if (c->vtt_basename) {
set_http_options(&options, c);
- if ((err = avio_open2(&vtt_oc->pb, vtt_oc->filename, AVIO_FLAG_WRITE,
- &s->interrupt_callback, &options)) < 0)
+ if ((err = ffio_open_whitelist(&vtt_oc->pb, vtt_oc->filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, &options, s->protocol_whitelist)) < 0)
goto fail;
}
av_dict_free(&options);
#include "libavutil/avstring.h"
#include "libavutil/time.h"
#include "avformat.h"
+#include "avio_internal.h"
#include "internal.h"
#include "url.h"
#include "version.h"
char line[1024];
const char *ptr;
- if ((ret = avio_open2(&in, url, AVIO_FLAG_READ,
- &h->interrupt_callback, NULL)) < 0)
+ if ((ret = ffio_open_whitelist(&in, url, AVIO_FLAG_READ,
+ &h->interrupt_callback, NULL,
+ h->protocol_whitelist)) < 0)
return ret;
read_chomp_line(in, line, sizeof(line));
}
url = s->segments[s->cur_seq_no - s->start_seq_no]->url,
av_log(h, AV_LOG_DEBUG, "opening %s\n", url);
- ret = ffurl_open(&s->seg_hd, url, AVIO_FLAG_READ,
- &h->interrupt_callback, NULL);
+ ret = ffurl_open_whitelist(&s->seg_hd, url, AVIO_FLAG_READ,
+ &h->interrupt_callback, NULL,
+ h->protocol_whitelist);
if (ret < 0) {
if (ff_check_interrupt(&h->interrupt_callback))
return AVERROR_EXIT;
ff_url_join(buf, sizeof(buf), lower_proto, NULL, hostname, port, NULL);
if (!s->hd) {
- err = ffurl_open(&s->hd, buf, AVIO_FLAG_READ_WRITE,
- &h->interrupt_callback, options);
+ err = ffurl_open_whitelist(&s->hd, buf, AVIO_FLAG_READ_WRITE,
+ &h->interrupt_callback, options,
+ h->protocol_whitelist);
if (err < 0)
return err;
}
NULL);
if ((ret = av_dict_set_int(options, "listen", s->listen, 0)) < 0)
goto fail;
- if ((ret = ffurl_open(&s->hd, lower_url, AVIO_FLAG_READ_WRITE,
- &h->interrupt_callback, options)) < 0)
+ if ((ret = ffurl_open_whitelist(&s->hd, lower_url, AVIO_FLAG_READ_WRITE,
+ &h->interrupt_callback, options,
+ h->protocol_whitelist
+ )) < 0)
goto fail;
s->handshake_step = LOWER_PROTO;
if (s->listen == HTTP_SINGLE) { /* single client */
.priv_data_size = sizeof(HTTPContext),
.priv_data_class = &http_context_class,
.flags = URL_PROTOCOL_FLAG_NETWORK,
+ .default_whitelist = "http,https,tls,rtp,tcp,udp"
};
#endif /* CONFIG_HTTP_PROTOCOL */
.priv_data_size = sizeof(HTTPContext),
.priv_data_class = &https_context_class,
.flags = URL_PROTOCOL_FLAG_NETWORK,
+ .default_whitelist = "http,https,tls,rtp,tcp,udp"
};
#endif /* CONFIG_HTTPS_PROTOCOL */
ff_url_join(lower_url, sizeof(lower_url), "tcp", NULL, hostname, port,
NULL);
redo:
- ret = ffurl_open(&s->hd, lower_url, AVIO_FLAG_READ_WRITE,
- &h->interrupt_callback, NULL);
+ ret = ffurl_open_whitelist(&s->hd, lower_url, AVIO_FLAG_READ_WRITE,
+ &h->interrupt_callback, NULL,
+ h->protocol_whitelist);
if (ret < 0)
return ret;
// Build new URI for passing to http protocol
ff_url_join(h_url, sizeof(h_url), "http", auth, host, port, "%s", path);
// Finally open http proto handler
- ret = ffurl_open(&s->hd, h_url, AVIO_FLAG_READ_WRITE, NULL, &opt_dict);
+ ret = ffurl_open_whitelist(&s->hd, h_url, AVIO_FLAG_READ_WRITE, NULL,
+ &opt_dict, h->protocol_whitelist);
cleanup:
av_freep(&user);
av_strstart(filename, "md5:", &filename);
if (*filename) {
- err = ffurl_open(&out, filename, AVIO_FLAG_WRITE,
- &h->interrupt_callback, NULL);
+ err = ffurl_open_whitelist(&out, filename, AVIO_FLAG_WRITE,
+ &h->interrupt_callback, NULL,
+ h->protocol_whitelist);
if (err)
return err;
err = ffurl_write(out, buf, i*2+1);
// establish tcp connection.
ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, mmst->host, port, NULL);
- err = ffurl_open(&mms->mms_hd, tcpname, AVIO_FLAG_READ_WRITE,
- &h->interrupt_callback, NULL);
+ err = ffurl_open_whitelist(&mms->mms_hd, tcpname, AVIO_FLAG_READ_WRITE,
+ &h->interrupt_callback, NULL,
+ h->protocol_whitelist);
if (err)
goto fail;
* writing, so we re-open the same output, but for reading. It also avoids
* a read/seek/write/seek back and forth. */
avio_flush(s->pb);
- ret = avio_open(&read_pb, s->filename, AVIO_FLAG_READ);
+ ret = ffio_open_whitelist(&read_pb, s->filename, AVIO_FLAG_READ, &s->interrupt_callback, NULL, s->protocol_whitelist);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "Unable to re-open %s output file for "
"the second pass (faststart)\n", s->filename);
}
/* open the tcp or ffrtmphttp connection */
- if ((ret = ffurl_open(&rt->stream, url, AVIO_FLAG_READ_WRITE,
- &h->interrupt_callback, NULL)) < 0) {
+ if ((ret = ffurl_open_whitelist(&rt->stream, url, AVIO_FLAG_READ_WRITE,
+ &h->interrupt_callback, NULL,
+ h->protocol_whitelist)) < 0) {
rtmpe_close(h);
return ret;
}
int ret = 0;
/* Get the SWF player file. */
- if ((ret = ffurl_open(&stream, rt->swfverify, AVIO_FLAG_READ,
- &s->interrupt_callback, NULL)) < 0) {
+ if ((ret = ffurl_open_whitelist(&stream, rt->swfverify, AVIO_FLAG_READ,
+ &s->interrupt_callback, NULL,
+ s->protocol_whitelist)) < 0) {
av_log(s, AV_LOG_ERROR, "Cannot open connection %s.\n", rt->swfverify);
goto fail;
}
}
reconnect:
- if ((ret = ffurl_open(&rt->stream, buf, AVIO_FLAG_READ_WRITE,
- &s->interrupt_callback, &opts)) < 0) {
+ if ((ret = ffurl_open_whitelist(&rt->stream, buf, AVIO_FLAG_READ_WRITE,
+ &s->interrupt_callback, &opts,
+ s->protocol_whitelist)) < 0) {
av_log(s , AV_LOG_ERROR, "Cannot open connection %s\n", buf);
goto fail;
}
build_udp_url(s, buf, sizeof(buf),
hostname, rtp_port, s->local_rtpport,
sources, block);
- if (ffurl_open(&s->rtp_hd, buf, flags, &h->interrupt_callback, NULL) < 0)
+ if (ffurl_open_whitelist(&s->rtp_hd, buf, flags, &h->interrupt_callback,
+ NULL, h->protocol_whitelist) < 0)
goto fail;
s->local_rtpport = ff_udp_get_local_port(s->rtp_hd);
if(s->local_rtpport == 65535) {
build_udp_url(s, buf, sizeof(buf),
hostname, s->rtcp_port, s->local_rtcpport,
sources, block);
- if (ffurl_open(&s->rtcp_hd, buf, flags, &h->interrupt_callback, NULL) < 0) {
+ if (ffurl_open_whitelist(&s->rtcp_hd, buf, flags,
+ &h->interrupt_callback, NULL,
+ h->protocol_whitelist) < 0) {
s->local_rtpport = s->local_rtcpport = -1;
continue;
}
build_udp_url(s, buf, sizeof(buf),
hostname, s->rtcp_port, s->local_rtcpport,
sources, block);
- if (ffurl_open(&s->rtcp_hd, buf, flags, &h->interrupt_callback, NULL) < 0)
+ if (ffurl_open_whitelist(&s->rtcp_hd, buf, flags, &h->interrupt_callback,
+ NULL, h->protocol_whitelist) < 0)
goto fail;
break;
}
"?localport=%d", j);
/* we will use two ports per rtp stream (rtp and rtcp) */
j += 2;
- err = ffurl_open(&rtsp_st->rtp_handle, buf, AVIO_FLAG_READ_WRITE,
- &s->interrupt_callback, &opts);
+ err = ffurl_open_whitelist(&rtsp_st->rtp_handle, buf, AVIO_FLAG_READ_WRITE,
+ &s->interrupt_callback, &opts, s->protocol_whitelist);
av_dict_free(&opts);
namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
port, "%s", optbuf);
- if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
- &s->interrupt_callback, NULL) < 0) {
+ if (ffurl_open_whitelist(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
+ &s->interrupt_callback, NULL, s->protocol_whitelist) < 0) {
err = AVERROR_INVALIDDATA;
goto fail;
}
ff_url_join(tcpname, sizeof(tcpname), lower_rtsp_proto, NULL,
host, port,
"?timeout=%d", rt->stimeout);
- if ((ret = ffurl_open(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,
- &s->interrupt_callback, NULL)) < 0) {
+ if ((ret = ffurl_open_whitelist(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,
+ &s->interrupt_callback, NULL, s->protocol_whitelist)) < 0) {
err = ret;
goto fail;
}
append_source_addrs(url, sizeof(url), "block",
rtsp_st->nb_exclude_source_addrs,
rtsp_st->exclude_source_addrs);
- err = ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
- &s->interrupt_callback, &opts);
+ err = ffurl_open_whitelist(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
+ &s->interrupt_callback, &opts, s->protocol_whitelist);
av_dict_free(&opts);
if (!ff_network_init())
return AVERROR(EIO);
- ret = ffurl_open(&in, s->filename, AVIO_FLAG_READ,
- &s->interrupt_callback, NULL);
+ ret = ffurl_open_whitelist(&in, s->filename, AVIO_FLAG_READ,
+ &s->interrupt_callback, NULL, s->protocol_whitelist);
if (ret)
goto fail;
av_dict_set(&opts, "buffer_size", buf, 0);
ff_url_join(url, sizeof(url), "rtp", NULL, host, localport, NULL);
av_log(s, AV_LOG_TRACE, "Opening: %s", url);
- ret = ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
- &s->interrupt_callback, &opts);
+ ret = ffurl_open_whitelist(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
+ &s->interrupt_callback, &opts,
+ s->protocol_whitelist);
av_dict_free(&opts);
if (ret)
localport += 2;
ff_url_join(tcpname, sizeof(tcpname), lower_proto, NULL, host, port,
"?listen&listen_timeout=%d", rt->initial_timeout * 1000);
- if (ret = ffurl_open(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,
- &s->interrupt_callback, NULL)) {
+ if (ret = ffurl_open_whitelist(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,
+ &s->interrupt_callback, NULL,
+ s->protocol_whitelist)) {
av_log(s, AV_LOG_ERROR, "Unable to open RTSP for listening\n");
return ret;
}
ff_url_join(url, sizeof(url), "udp", NULL, host, port, "?localport=%d",
port);
- ret = ffurl_open(&sap->ann_fd, url, AVIO_FLAG_READ,
- &s->interrupt_callback, NULL);
+ ret = ffurl_open_whitelist(&sap->ann_fd, url, AVIO_FLAG_READ,
+ &s->interrupt_callback, NULL,
+ s->protocol_whitelist);
if (ret)
goto fail;
"?ttl=%d", ttl);
if (!same_port)
base_port += 2;
- ret = ffurl_open(&fd, url, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL);
+ ret = ffurl_open_whitelist(&fd, url, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, NULL,
+ s->protocol_whitelist);
if (ret) {
ret = AVERROR(EIO);
goto fail;
ff_url_join(url, sizeof(url), "udp", NULL, announce_addr, port,
"?ttl=%d&connect=1", ttl);
- ret = ffurl_open(&sap->ann_fd, url, AVIO_FLAG_WRITE,
- &s->interrupt_callback, NULL);
+ ret = ffurl_open_whitelist(&sap->ann_fd, url, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, NULL,
+ s->protocol_whitelist);
if (ret) {
ret = AVERROR(EIO);
goto fail;
#include <time.h>
#include "avformat.h"
+#include "avio_internal.h"
#include "internal.h"
#include "libavutil/avassert.h"
if ((err = set_segment_filename(s)) < 0)
return err;
- if ((err = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
- &s->interrupt_callback, NULL)) < 0) {
+ if ((err = ffio_open_whitelist(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, NULL, s->protocol_whitelist)) < 0) {
av_log(s, AV_LOG_ERROR, "Failed to open segment '%s'\n", oc->filename);
return err;
}
int ret;
snprintf(seg->temp_list_filename, sizeof(seg->temp_list_filename), seg->use_rename ? "%s.tmp" : "%s", seg->list);
- ret = avio_open2(&seg->list_pb, seg->temp_list_filename, AVIO_FLAG_WRITE,
- &s->interrupt_callback, NULL);
+ ret = ffio_open_whitelist(&seg->list_pb, seg->temp_list_filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, NULL, s->protocol_whitelist);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "Failed to open segment list '%s'\n", seg->list);
return ret;
goto fail;
if (seg->write_header_trailer) {
- if ((ret = avio_open2(&oc->pb, seg->header_filename ? seg->header_filename : oc->filename, AVIO_FLAG_WRITE,
- &s->interrupt_callback, NULL)) < 0) {
+ if ((ret = ffio_open_whitelist(&oc->pb, seg->header_filename ? seg->header_filename : oc->filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, NULL, s->protocol_whitelist)) < 0) {
av_log(s, AV_LOG_ERROR, "Failed to open segment '%s'\n", oc->filename);
goto fail;
}
} else {
close_null_ctxp(&oc->pb);
}
- if ((ret = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
- &s->interrupt_callback, NULL)) < 0)
+ if ((ret = ffio_open_whitelist(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, NULL, s->protocol_whitelist)) < 0)
goto fail;
if (!seg->individual_header_trailer)
oc->pb->seekable = 0;
#endif
#include "avformat.h"
+#include "avio_internal.h"
#include "internal.h"
#include "os_support.h"
#include "avc.h"
AVDictionary *opts = NULL;
os->tail_out = os->out;
av_dict_set(&opts, "truncate", "0", 0);
- ret = ffurl_open(&os->out, frag->file, AVIO_FLAG_READ_WRITE, &os->ctx->interrupt_callback, &opts);
+ ret = ffurl_open_whitelist(&os->out, frag->file, AVIO_FLAG_READ_WRITE,
+ &os->ctx->interrupt_callback, &opts, os->ctx->protocol_whitelist);
av_dict_free(&opts);
if (ret < 0) {
os->out = os->tail_out;
return ret;
}
av_dict_set(&opts, "truncate", "0", 0);
- ffurl_open(&os->out2, frag->infofile, AVIO_FLAG_READ_WRITE, &os->ctx->interrupt_callback, &opts);
+ ffurl_open_whitelist(&os->out2, frag->infofile, AVIO_FLAG_READ_WRITE,
+ &os->ctx->interrupt_callback, &opts, os->ctx->protocol_whitelist);
av_dict_free(&opts);
ffurl_seek(os->out, offset - frag->start_pos, SEEK_SET);
if (os->out2)
snprintf(filename, sizeof(filename), "%s/Manifest", s->filename);
snprintf(temp_filename, sizeof(temp_filename), "%s/Manifest.tmp", s->filename);
- ret = avio_open2(&out, temp_filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL);
+ ret = ffio_open_whitelist(&out, temp_filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL, s->protocol_whitelist);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "Unable to open %s for writing\n", temp_filename);
return ret;
}
ctx = avformat_alloc_context();
- if (!ctx) {
+ if (!ctx || ff_copy_whitelists(ctx, s) < 0) {
ret = AVERROR(ENOMEM);
goto fail;
}
AVIOContext *in;
int ret;
uint32_t len;
- if ((ret = avio_open2(&in, filename, AVIO_FLAG_READ, &s->interrupt_callback, NULL)) < 0)
+ if ((ret = ffio_open_whitelist(&in, filename, AVIO_FLAG_READ, &s->interrupt_callback, NULL, s->protocol_whitelist)) < 0)
return ret;
ret = AVERROR(EIO);
*moof_size = avio_rb32(in);
{
AVIOContext *in, *out;
int ret = 0;
- if ((ret = avio_open2(&in, infile, AVIO_FLAG_READ, &s->interrupt_callback, NULL)) < 0)
+ if ((ret = ffio_open_whitelist(&in, infile, AVIO_FLAG_READ, &s->interrupt_callback, NULL, s->protocol_whitelist)) < 0)
return ret;
- if ((ret = avio_open2(&out, outfile, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL)) < 0) {
+ if ((ret = ffio_open_whitelist(&out, outfile, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL, s->protocol_whitelist)) < 0) {
avio_close(in);
return ret;
}
continue;
snprintf(filename, sizeof(filename), "%s/temp", os->dirname);
- ret = ffurl_open(&os->out, filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL);
+ ret = ffurl_open_whitelist(&os->out, filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL, s->protocol_whitelist);
if (ret < 0)
break;
os->cur_start_pos = os->tail_pos;
av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &rtp_port,
path, sizeof(path), uri);
ff_url_join(buf, sizeof(buf), "rtp", NULL, hostname, rtp_port, "%s", path);
- if ((ret = ffurl_open(&s->rtp_hd, buf, flags, &h->interrupt_callback, NULL)) < 0)
+ if ((ret = ffurl_open_whitelist(&s->rtp_hd, buf, flags, &h->interrupt_callback,
+ NULL, h->protocol_whitelist)) < 0)
goto fail;
h->max_packet_size = FFMIN(s->rtp_hd->max_packet_size,
return AVERROR(EINVAL);
}
av_strstart(filename, "subfile:", &filename);
- ret = ffurl_open(&c->h, filename, flags, &h->interrupt_callback, options);
+ ret = ffurl_open_whitelist(&c->h, filename, flags, &h->interrupt_callback,
+ options, h->protocol_whitelist);
if (ret < 0)
return ret;
c->pos = c->start;
.url_close = subfile_close,
.priv_data_size = sizeof(SubfileContext),
.priv_data_class = &subfile_class,
+ .default_whitelist = "file",
};
#include "libavutil/avstring.h"
#include "libavutil/opt.h"
#include "avformat.h"
+#include "avio_internal.h"
#define MAX_SLAVES 16
}
if (!(avf2->oformat->flags & AVFMT_NOFILE)) {
- if ((ret = avio_open(&avf2->pb, filename, AVIO_FLAG_WRITE)) < 0) {
+ if ((ret = ffio_open_whitelist(&avf2->pb, filename, AVIO_FLAG_WRITE,
+ &avf->interrupt_callback, NULL,
+ avf->protocol_whitelist)) < 0) {
av_log(avf, AV_LOG_ERROR, "Slave '%s': error opening: %s\n",
slave, av_err2str(ret));
goto end;
proxy_port, "/%s", dest);
}
- return ffurl_open(&c->tcp, buf, AVIO_FLAG_READ_WRITE,
- &parent->interrupt_callback, options);
+ return ffurl_open_whitelist(&c->tcp, buf, AVIO_FLAG_READ_WRITE,
+ &parent->interrupt_callback, options,
+ parent->protocol_whitelist);
}
goto end;
}
- if ((ret = avio_open2(&s, path, AVIO_FLAG_READ,
- &h->interrupt_callback, NULL)) < 0)
+ if ((ret = ffio_open_whitelist(&s, path, AVIO_FLAG_READ,
+ &h->interrupt_callback, NULL,
+ h->protocol_whitelist)) < 0)
goto end;
if ((ret = avio_size(s)) < 0)
#include "avformat.h"
#include "avio.h"
+#include "avio_internal.h"
#include "internal.h"
#include "libavutil/avassert.h"
ret = get_chunk_filename(s, 1, oc->filename);
if (ret < 0)
return ret;
- ret = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
- &s->interrupt_callback, NULL);
+ ret = ffio_open_whitelist(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, NULL, s->protocol_whitelist);
if (ret < 0)
return ret;
ret = get_chunk_filename(s, 0, filename);
if (ret < 0)
goto fail;
- ret = avio_open2(&pb, filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL);
+ ret = ffio_open_whitelist(&pb, filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, NULL, s->protocol_whitelist);
if (ret < 0)
goto fail;
avio_write(pb, buffer, buffer_size);