3 * Copyright (c) 2001 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "libavutil/avstring.h"
23 #include "libavutil/dict.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/time.h"
26 #include "libavutil/avassert.h"
27 #include "os_support.h"
34 static URLProtocol *first_protocol = NULL;
36 URLProtocol *ffurl_protocol_next(const URLProtocol *prev)
38 return prev ? prev->next : first_protocol;
41 /** @name Logging context. */
43 static const char *urlcontext_to_name(void *ptr)
45 URLContext *h = (URLContext *)ptr;
52 static void *urlcontext_child_next(void *obj, void *prev)
55 if (!prev && h->priv_data && h->prot->priv_data_class)
60 static const AVClass *urlcontext_child_class_next(const AVClass *prev)
62 URLProtocol *p = NULL;
64 /* find the protocol that corresponds to prev */
65 while (prev && (p = ffurl_protocol_next(p)))
66 if (p->priv_data_class == prev)
69 /* find next protocol with priv options */
70 while (p = ffurl_protocol_next(p))
71 if (p->priv_data_class)
72 return p->priv_data_class;
76 static const AVOption options[] = { { NULL } };
77 const AVClass ffurl_context_class = {
78 .class_name = "URLContext",
79 .item_name = urlcontext_to_name,
81 .version = LIBAVUTIL_VERSION_INT,
82 .child_next = urlcontext_child_next,
83 .child_class_next = urlcontext_child_class_next,
87 const char *avio_enum_protocols(void **opaque, int output)
90 *opaque = ffurl_protocol_next(*opaque);
93 if ((output && p->url_write) || (!output && p->url_read))
95 return avio_enum_protocols(opaque, output);
98 int ffurl_register_protocol(URLProtocol *protocol)
105 protocol->next = NULL;
109 static int url_alloc_for_protocol(URLContext **puc, struct URLProtocol *up,
110 const char *filename, int flags,
111 const AVIOInterruptCB *int_cb)
117 if (up->flags & URL_PROTOCOL_FLAG_NETWORK && !ff_network_init())
120 if ((flags & AVIO_FLAG_READ) && !up->url_read) {
121 av_log(NULL, AV_LOG_ERROR,
122 "Impossible to open the '%s' protocol for reading\n", up->name);
125 if ((flags & AVIO_FLAG_WRITE) && !up->url_write) {
126 av_log(NULL, AV_LOG_ERROR,
127 "Impossible to open the '%s' protocol for writing\n", up->name);
130 uc = av_mallocz(sizeof(URLContext) + strlen(filename) + 1);
132 err = AVERROR(ENOMEM);
135 uc->av_class = &ffurl_context_class;
136 uc->filename = (char *)&uc[1];
137 strcpy(uc->filename, filename);
140 uc->is_streamed = 0; /* default = not streamed */
141 uc->max_packet_size = 0; /* default: stream file */
142 if (up->priv_data_size) {
143 uc->priv_data = av_mallocz(up->priv_data_size);
144 if (!uc->priv_data) {
145 err = AVERROR(ENOMEM);
148 if (up->priv_data_class) {
149 int proto_len= strlen(up->name);
150 char *start = strchr(uc->filename, ',');
151 *(const AVClass **)uc->priv_data = up->priv_data_class;
152 av_opt_set_defaults(uc->priv_data);
153 if(!strncmp(up->name, uc->filename, proto_len) && uc->filename + proto_len == start){
159 while(ret >= 0 && (key= strchr(p, sep)) && p<key && (val = strchr(key+1, sep))){
161 ret= av_opt_set(uc->priv_data, p, key+1, 0);
162 if (ret == AVERROR_OPTION_NOT_FOUND)
163 av_log(uc, AV_LOG_ERROR, "Key '%s' not found.\n", p);
168 av_log(uc, AV_LOG_ERROR, "Error parsing options string %s\n", start);
169 av_freep(&uc->priv_data);
171 err = AVERROR(EINVAL);
174 memmove(start, key+1, strlen(key));
179 uc->interrupt_callback = *int_cb;
186 av_freep(&uc->priv_data);
189 if (up->flags & URL_PROTOCOL_FLAG_NETWORK)
195 int ffurl_connect(URLContext *uc, AVDictionary **options)
198 uc->prot->url_open2 ? uc->prot->url_open2(uc,
202 uc->prot->url_open(uc, uc->filename, uc->flags);
205 uc->is_connected = 1;
206 /* We must be careful here as ffurl_seek() could be slow,
207 * for example for http */
208 if ((uc->flags & AVIO_FLAG_WRITE) || !strcmp(uc->prot->name, "file"))
209 if (!uc->is_streamed && ffurl_seek(uc, 0, SEEK_SET) < 0)
214 int ffurl_accept(URLContext *s, URLContext **c)
217 if (s->prot->url_accept)
218 return s->prot->url_accept(s, c);
219 return AVERROR(EBADF);
222 int ffurl_handshake(URLContext *c)
225 if (c->prot->url_handshake) {
226 ret = c->prot->url_handshake(c);
234 #define URL_SCHEME_CHARS \
235 "abcdefghijklmnopqrstuvwxyz" \
236 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
239 static struct URLProtocol *url_find_protocol(const char *filename)
241 URLProtocol *up = NULL;
242 char proto_str[128], proto_nested[128], *ptr;
243 size_t proto_len = strspn(filename, URL_SCHEME_CHARS);
245 if (filename[proto_len] != ':' &&
246 (filename[proto_len] != ',' || !strchr(filename + proto_len + 1, ':')) ||
247 is_dos_path(filename))
248 strcpy(proto_str, "file");
250 av_strlcpy(proto_str, filename,
251 FFMIN(proto_len + 1, sizeof(proto_str)));
253 if ((ptr = strchr(proto_str, ',')))
255 av_strlcpy(proto_nested, proto_str, sizeof(proto_nested));
256 if ((ptr = strchr(proto_nested, '+')))
259 while (up = ffurl_protocol_next(up)) {
260 if (!strcmp(proto_str, up->name))
262 if (up->flags & URL_PROTOCOL_FLAG_NESTED_SCHEME &&
263 !strcmp(proto_nested, up->name))
270 int ffurl_alloc(URLContext **puc, const char *filename, int flags,
271 const AVIOInterruptCB *int_cb)
273 URLProtocol *p = NULL;
275 if (!first_protocol) {
276 av_log(NULL, AV_LOG_WARNING, "No URL Protocols are registered. "
277 "Missing call to av_register_all()?\n");
280 p = url_find_protocol(filename);
282 return url_alloc_for_protocol(puc, p, filename, flags, int_cb);
285 if (av_strstart(filename, "https:", NULL))
286 av_log(NULL, AV_LOG_WARNING, "https protocol not found, recompile FFmpeg with "
288 "or securetransport enabled.\n");
289 return AVERROR_PROTOCOL_NOT_FOUND;
292 int ffurl_open(URLContext **puc, const char *filename, int flags,
293 const AVIOInterruptCB *int_cb, AVDictionary **options)
295 int ret = ffurl_alloc(puc, filename, flags, int_cb);
298 if (options && (*puc)->prot->priv_data_class &&
299 (ret = av_opt_set_dict((*puc)->priv_data, options)) < 0)
301 if ((ret = av_opt_set_dict(*puc, options)) < 0)
303 ret = ffurl_connect(*puc, options);
312 static inline int retry_transfer_wrapper(URLContext *h, uint8_t *buf,
313 int size, int size_min,
314 int (*transfer_func)(URLContext *h,
319 int fast_retries = 5;
320 int64_t wait_since = 0;
323 while (len < size_min) {
324 if (ff_check_interrupt(&h->interrupt_callback))
326 ret = transfer_func(h, buf + len, size - len);
327 if (ret == AVERROR(EINTR))
329 if (h->flags & AVIO_FLAG_NONBLOCK)
331 if (ret == AVERROR(EAGAIN)) {
338 wait_since = av_gettime_relative();
339 else if (av_gettime_relative() > wait_since + h->rw_timeout)
345 return (ret < 0 && ret != AVERROR_EOF) ? ret : len;
347 fast_retries = FFMAX(fast_retries, 2);
353 int ffurl_read(URLContext *h, unsigned char *buf, int size)
355 if (!(h->flags & AVIO_FLAG_READ))
357 return retry_transfer_wrapper(h, buf, size, 1, h->prot->url_read);
360 int ffurl_read_complete(URLContext *h, unsigned char *buf, int size)
362 if (!(h->flags & AVIO_FLAG_READ))
364 return retry_transfer_wrapper(h, buf, size, size, h->prot->url_read);
367 int ffurl_write(URLContext *h, const unsigned char *buf, int size)
369 if (!(h->flags & AVIO_FLAG_WRITE))
371 /* avoid sending too big packets */
372 if (h->max_packet_size && size > h->max_packet_size)
375 return retry_transfer_wrapper(h, (unsigned char *)buf, size, size,
376 (int (*)(struct URLContext *, uint8_t *, int))
380 int64_t ffurl_seek(URLContext *h, int64_t pos, int whence)
384 if (!h->prot->url_seek)
385 return AVERROR(ENOSYS);
386 ret = h->prot->url_seek(h, pos, whence & ~AVSEEK_FORCE);
390 int ffurl_closep(URLContext **hh)
395 return 0; /* can happen when ffurl_open fails */
397 if (h->is_connected && h->prot->url_close)
398 ret = h->prot->url_close(h);
400 if (h->prot->flags & URL_PROTOCOL_FLAG_NETWORK)
403 if (h->prot->priv_data_size) {
404 if (h->prot->priv_data_class)
405 av_opt_free(h->priv_data);
406 av_freep(&h->priv_data);
412 int ffurl_close(URLContext *h)
414 return ffurl_closep(&h);
418 const char *avio_find_protocol_name(const char *url)
420 URLProtocol *p = url_find_protocol(url);
422 return p ? p->name : NULL;
425 int avio_check(const char *url, int flags)
428 int ret = ffurl_alloc(&h, url, flags, NULL);
432 if (h->prot->url_check) {
433 ret = h->prot->url_check(h, flags);
435 ret = ffurl_connect(h, NULL);
444 int avpriv_io_move(const char *url_src, const char *url_dst)
446 URLContext *h_src, *h_dst;
447 int ret = ffurl_alloc(&h_src, url_src, AVIO_FLAG_READ_WRITE, NULL);
450 ret = ffurl_alloc(&h_dst, url_dst, AVIO_FLAG_WRITE, NULL);
456 if (h_src->prot == h_dst->prot && h_src->prot->url_move)
457 ret = h_src->prot->url_move(h_src, h_dst);
459 ret = AVERROR(ENOSYS);
466 int avpriv_io_delete(const char *url)
469 int ret = ffurl_alloc(&h, url, AVIO_FLAG_WRITE, NULL);
473 if (h->prot->url_delete)
474 ret = h->prot->url_delete(h);
476 ret = AVERROR(ENOSYS);
482 int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options)
484 URLContext *h = NULL;
485 AVIODirContext *ctx = NULL;
489 ctx = av_mallocz(sizeof(*ctx));
491 ret = AVERROR(ENOMEM);
495 if ((ret = ffurl_alloc(&h, url, AVIO_FLAG_READ, NULL)) < 0)
498 if (h->prot->url_open_dir && h->prot->url_read_dir && h->prot->url_close_dir) {
499 if (options && h->prot->priv_data_class &&
500 (ret = av_opt_set_dict(h->priv_data, options)) < 0)
502 ret = h->prot->url_open_dir(h);
504 ret = AVERROR(ENOSYS);
509 ctx->url_context = h;
520 int avio_read_dir(AVIODirContext *s, AVIODirEntry **next)
525 if (!s || !s->url_context)
526 return AVERROR(EINVAL);
528 if ((ret = h->prot->url_read_dir(h, next)) < 0)
529 avio_free_directory_entry(next);
533 int avio_close_dir(AVIODirContext **s)
538 if (!(*s) || !(*s)->url_context)
539 return AVERROR(EINVAL);
540 h = (*s)->url_context;
541 h->prot->url_close_dir(h);
548 void avio_free_directory_entry(AVIODirEntry **entry)
550 if (!entry || !*entry)
552 av_free((*entry)->name);
556 int64_t ffurl_size(URLContext *h)
560 size = ffurl_seek(h, 0, AVSEEK_SIZE);
562 pos = ffurl_seek(h, 0, SEEK_CUR);
563 if ((size = ffurl_seek(h, -1, SEEK_END)) < 0)
566 ffurl_seek(h, pos, SEEK_SET);
571 int ffurl_get_file_handle(URLContext *h)
573 if (!h->prot->url_get_file_handle)
575 return h->prot->url_get_file_handle(h);
578 int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
580 if (!h->prot->url_get_multi_file_handle) {
581 if (!h->prot->url_get_file_handle)
582 return AVERROR(ENOSYS);
583 *handles = av_malloc(sizeof(**handles));
585 return AVERROR(ENOMEM);
587 *handles[0] = h->prot->url_get_file_handle(h);
590 return h->prot->url_get_multi_file_handle(h, handles, numhandles);
593 int ffurl_shutdown(URLContext *h, int flags)
595 if (!h->prot->url_shutdown)
596 return AVERROR(EINVAL);
597 return h->prot->url_shutdown(h, flags);
600 int ff_check_interrupt(AVIOInterruptCB *cb)
603 if (cb && cb->callback && (ret = cb->callback(cb->opaque)))