FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
avio.c
Go to the documentation of this file.
1 /*
2  * unbuffered I/O
3  * Copyright (c) 2001 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
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.
11  *
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.
16  *
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
20  */
21 
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"
28 #include "avformat.h"
29 #if CONFIG_NETWORK
30 #include "network.h"
31 #endif
32 #include "url.h"
33 
34 /** @name Logging context. */
35 /*@{*/
36 static const char *urlcontext_to_name(void *ptr)
37 {
38  URLContext *h = (URLContext *)ptr;
39  if (h->prot)
40  return h->prot->name;
41  else
42  return "NULL";
43 }
44 
45 static void *urlcontext_child_next(void *obj, void *prev)
46 {
47  URLContext *h = obj;
48  if (!prev && h->priv_data && h->prot->priv_data_class)
49  return h->priv_data;
50  return NULL;
51 }
52 
53 #define OFFSET(x) offsetof(URLContext,x)
54 #define E AV_OPT_FLAG_ENCODING_PARAM
55 #define D AV_OPT_FLAG_DECODING_PARAM
56 static const AVOption options[] = {
57  {"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 },
58  {"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 },
59  {"rw_timeout", "Timeout for IO operations (in microseconds)", offsetof(URLContext, rw_timeout), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_DECODING_PARAM },
60  { NULL }
61 };
62 
64  .class_name = "URLContext",
65  .item_name = urlcontext_to_name,
66  .option = options,
67  .version = LIBAVUTIL_VERSION_INT,
68  .child_next = urlcontext_child_next,
69  .child_class_next = ff_urlcontext_child_class_next,
70 };
71 /*@}*/
72 
73 static int url_alloc_for_protocol(URLContext **puc, const URLProtocol *up,
74  const char *filename, int flags,
75  const AVIOInterruptCB *int_cb)
76 {
77  URLContext *uc;
78  int err;
79 
80 #if CONFIG_NETWORK
82  return AVERROR(EIO);
83 #endif
84  if ((flags & AVIO_FLAG_READ) && !up->url_read) {
86  "Impossible to open the '%s' protocol for reading\n", up->name);
87  return AVERROR(EIO);
88  }
89  if ((flags & AVIO_FLAG_WRITE) && !up->url_write) {
91  "Impossible to open the '%s' protocol for writing\n", up->name);
92  return AVERROR(EIO);
93  }
94  uc = av_mallocz(sizeof(URLContext) + strlen(filename) + 1);
95  if (!uc) {
96  err = AVERROR(ENOMEM);
97  goto fail;
98  }
100  uc->filename = (char *)&uc[1];
101  strcpy(uc->filename, filename);
102  uc->prot = up;
103  uc->flags = flags;
104  uc->is_streamed = 0; /* default = not streamed */
105  uc->max_packet_size = 0; /* default: stream file */
106  if (up->priv_data_size) {
108  if (!uc->priv_data) {
109  err = AVERROR(ENOMEM);
110  goto fail;
111  }
112  if (up->priv_data_class) {
113  int proto_len= strlen(up->name);
114  char *start = strchr(uc->filename, ',');
115  *(const AVClass **)uc->priv_data = up->priv_data_class;
117  if(!strncmp(up->name, uc->filename, proto_len) && uc->filename + proto_len == start){
118  int ret= 0;
119  char *p= start;
120  char sep= *++p;
121  char *key, *val;
122  p++;
123 
124  if (strcmp(up->name, "subfile"))
125  ret = AVERROR(EINVAL);
126 
127  while(ret >= 0 && (key= strchr(p, sep)) && p<key && (val = strchr(key+1, sep))){
128  *val= *key= 0;
129  if (strcmp(p, "start") && strcmp(p, "end")) {
131  } else
132  ret= av_opt_set(uc->priv_data, p, key+1, 0);
133  if (ret == AVERROR_OPTION_NOT_FOUND)
134  av_log(uc, AV_LOG_ERROR, "Key '%s' not found.\n", p);
135  *val= *key= sep;
136  p= val+1;
137  }
138  if(ret<0 || p!=key){
139  av_log(uc, AV_LOG_ERROR, "Error parsing options string %s\n", start);
140  av_freep(&uc->priv_data);
141  av_freep(&uc);
142  err = AVERROR(EINVAL);
143  goto fail;
144  }
145  memmove(start, key+1, strlen(key));
146  }
147  }
148  }
149  if (int_cb)
150  uc->interrupt_callback = *int_cb;
151 
152  *puc = uc;
153  return 0;
154 fail:
155  *puc = NULL;
156  if (uc)
157  av_freep(&uc->priv_data);
158  av_freep(&uc);
159 #if CONFIG_NETWORK
162 #endif
163  return err;
164 }
165 
167 {
168  int err;
169  AVDictionary *tmp_opts = NULL;
171 
172  if (!options)
173  options = &tmp_opts;
174 
175  // Check that URLContext was initialized correctly and lists are matching if set
176  av_assert0(!(e=av_dict_get(*options, "protocol_whitelist", NULL, 0)) ||
177  (uc->protocol_whitelist && !strcmp(uc->protocol_whitelist, e->value)));
178  av_assert0(!(e=av_dict_get(*options, "protocol_blacklist", NULL, 0)) ||
179  (uc->protocol_blacklist && !strcmp(uc->protocol_blacklist, e->value)));
180 
181  if (uc->protocol_whitelist && av_match_list(uc->prot->name, uc->protocol_whitelist, ',') <= 0) {
182  av_log(uc, AV_LOG_ERROR, "Protocol '%s' not on whitelist '%s'!\n", uc->prot->name, uc->protocol_whitelist);
183  return AVERROR(EINVAL);
184  }
185 
186  if (uc->protocol_blacklist && av_match_list(uc->prot->name, uc->protocol_blacklist, ',') > 0) {
187  av_log(uc, AV_LOG_ERROR, "Protocol '%s' on blacklist '%s'!\n", uc->prot->name, uc->protocol_blacklist);
188  return AVERROR(EINVAL);
189  }
190 
191  if (!uc->protocol_whitelist && uc->prot->default_whitelist) {
192  av_log(uc, AV_LOG_DEBUG, "Setting default whitelist '%s'\n", uc->prot->default_whitelist);
194  if (!uc->protocol_whitelist) {
195  return AVERROR(ENOMEM);
196  }
197  } else if (!uc->protocol_whitelist)
198  av_log(uc, AV_LOG_DEBUG, "No default whitelist set\n"); // This should be an error once all declare a default whitelist
199 
200  if ((err = av_dict_set(options, "protocol_whitelist", uc->protocol_whitelist, 0)) < 0)
201  return err;
202  if ((err = av_dict_set(options, "protocol_blacklist", uc->protocol_blacklist, 0)) < 0)
203  return err;
204 
205  err =
206  uc->prot->url_open2 ? uc->prot->url_open2(uc,
207  uc->filename,
208  uc->flags,
209  options) :
210  uc->prot->url_open(uc, uc->filename, uc->flags);
211 
212  av_dict_set(options, "protocol_whitelist", NULL, 0);
213  av_dict_set(options, "protocol_blacklist", NULL, 0);
214 
215  if (err)
216  return err;
217  uc->is_connected = 1;
218  /* We must be careful here as ffurl_seek() could be slow,
219  * for example for http */
220  if ((uc->flags & AVIO_FLAG_WRITE) || !strcmp(uc->prot->name, "file"))
221  if (!uc->is_streamed && ffurl_seek(uc, 0, SEEK_SET) < 0)
222  uc->is_streamed = 1;
223  return 0;
224 }
225 
227 {
228  av_assert0(!*c);
229  if (s->prot->url_accept)
230  return s->prot->url_accept(s, c);
231  return AVERROR(EBADF);
232 }
233 
235 {
236  int ret;
237  if (c->prot->url_handshake) {
238  ret = c->prot->url_handshake(c);
239  if (ret)
240  return ret;
241  }
242  c->is_connected = 1;
243  return 0;
244 }
245 
246 #define URL_SCHEME_CHARS \
247  "abcdefghijklmnopqrstuvwxyz" \
248  "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
249  "0123456789+-."
250 
251 static const struct URLProtocol *url_find_protocol(const char *filename)
252 {
253  const URLProtocol **protocols;
254  char proto_str[128], proto_nested[128], *ptr;
255  size_t proto_len = strspn(filename, URL_SCHEME_CHARS);
256  int i;
257 
258  if (filename[proto_len] != ':' &&
259  (strncmp(filename, "subfile,", 8) || !strchr(filename + proto_len + 1, ':')) ||
260  is_dos_path(filename))
261  strcpy(proto_str, "file");
262  else
263  av_strlcpy(proto_str, filename,
264  FFMIN(proto_len + 1, sizeof(proto_str)));
265 
266  av_strlcpy(proto_nested, proto_str, sizeof(proto_nested));
267  if ((ptr = strchr(proto_nested, '+')))
268  *ptr = '\0';
269 
270  protocols = ffurl_get_protocols(NULL, NULL);
271  if (!protocols)
272  return NULL;
273  for (i = 0; protocols[i]; i++) {
274  const URLProtocol *up = protocols[i];
275  if (!strcmp(proto_str, up->name)) {
276  av_freep(&protocols);
277  return up;
278  }
280  !strcmp(proto_nested, up->name)) {
281  av_freep(&protocols);
282  return up;
283  }
284  }
285  av_freep(&protocols);
286 
287  return NULL;
288 }
289 
290 int ffurl_alloc(URLContext **puc, const char *filename, int flags,
291  const AVIOInterruptCB *int_cb)
292 {
293  const URLProtocol *p = NULL;
294 
295  p = url_find_protocol(filename);
296  if (p)
297  return url_alloc_for_protocol(puc, p, filename, flags, int_cb);
298 
299  *puc = NULL;
300  if (av_strstart(filename, "https:", NULL))
301  av_log(NULL, AV_LOG_WARNING, "https protocol not found, recompile FFmpeg with "
302  "openssl, gnutls "
303  "or securetransport enabled.\n");
305 }
306 
307 int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags,
308  const AVIOInterruptCB *int_cb, AVDictionary **options,
309  const char *whitelist, const char* blacklist,
310  URLContext *parent)
311 {
312  AVDictionary *tmp_opts = NULL;
314  int ret = ffurl_alloc(puc, filename, flags, int_cb);
315  if (ret < 0)
316  return ret;
317  if (parent)
318  av_opt_copy(*puc, parent);
319  if (options &&
320  (ret = av_opt_set_dict(*puc, options)) < 0)
321  goto fail;
322  if (options && (*puc)->prot->priv_data_class &&
323  (ret = av_opt_set_dict((*puc)->priv_data, options)) < 0)
324  goto fail;
325 
326  if (!options)
327  options = &tmp_opts;
328 
329  av_assert0(!whitelist ||
330  !(e=av_dict_get(*options, "protocol_whitelist", NULL, 0)) ||
331  !strcmp(whitelist, e->value));
332  av_assert0(!blacklist ||
333  !(e=av_dict_get(*options, "protocol_blacklist", NULL, 0)) ||
334  !strcmp(blacklist, e->value));
335 
336  if ((ret = av_dict_set(options, "protocol_whitelist", whitelist, 0)) < 0)
337  goto fail;
338 
339  if ((ret = av_dict_set(options, "protocol_blacklist", blacklist, 0)) < 0)
340  goto fail;
341 
342  if ((ret = av_opt_set_dict(*puc, options)) < 0)
343  goto fail;
344 
345  ret = ffurl_connect(*puc, options);
346 
347  if (!ret)
348  return 0;
349 fail:
350  ffurl_close(*puc);
351  *puc = NULL;
352  return ret;
353 }
354 
355 int ffurl_open(URLContext **puc, const char *filename, int flags,
356  const AVIOInterruptCB *int_cb, AVDictionary **options)
357 {
358  return ffurl_open_whitelist(puc, filename, flags,
359  int_cb, options, NULL, NULL, NULL);
360 }
361 
363  int size, int size_min,
364  int (*transfer_func)(URLContext *h,
365  uint8_t *buf,
366  int size))
367 {
368  int ret, len;
369  int fast_retries = 5;
370  int64_t wait_since = 0;
371 
372  len = 0;
373  while (len < size_min) {
375  return AVERROR_EXIT;
376  ret = transfer_func(h, buf + len, size - len);
377  if (ret == AVERROR(EINTR))
378  continue;
379  if (h->flags & AVIO_FLAG_NONBLOCK)
380  return ret;
381  if (ret == AVERROR(EAGAIN)) {
382  ret = 0;
383  if (fast_retries) {
384  fast_retries--;
385  } else {
386  if (h->rw_timeout) {
387  if (!wait_since)
388  wait_since = av_gettime_relative();
389  else if (av_gettime_relative() > wait_since + h->rw_timeout)
390  return AVERROR(EIO);
391  }
392  av_usleep(1000);
393  }
394  } else if (ret < 1)
395  return (ret < 0 && ret != AVERROR_EOF) ? ret : len;
396  if (ret) {
397  fast_retries = FFMAX(fast_retries, 2);
398  wait_since = 0;
399  }
400  len += ret;
401  }
402  return len;
403 }
404 
405 int ffurl_read(URLContext *h, unsigned char *buf, int size)
406 {
407  if (!(h->flags & AVIO_FLAG_READ))
408  return AVERROR(EIO);
409  return retry_transfer_wrapper(h, buf, size, 1, h->prot->url_read);
410 }
411 
412 int ffurl_read_complete(URLContext *h, unsigned char *buf, int size)
413 {
414  if (!(h->flags & AVIO_FLAG_READ))
415  return AVERROR(EIO);
416  return retry_transfer_wrapper(h, buf, size, size, h->prot->url_read);
417 }
418 
419 int ffurl_write(URLContext *h, const unsigned char *buf, int size)
420 {
421  if (!(h->flags & AVIO_FLAG_WRITE))
422  return AVERROR(EIO);
423  /* avoid sending too big packets */
424  if (h->max_packet_size && size > h->max_packet_size)
425  return AVERROR(EIO);
426 
427  return retry_transfer_wrapper(h, (unsigned char *)buf, size, size,
428  (int (*)(struct URLContext *, uint8_t *, int))
429  h->prot->url_write);
430 }
431 
432 int64_t ffurl_seek(URLContext *h, int64_t pos, int whence)
433 {
434  int64_t ret;
435 
436  if (!h->prot->url_seek)
437  return AVERROR(ENOSYS);
438  ret = h->prot->url_seek(h, pos, whence & ~AVSEEK_FORCE);
439  return ret;
440 }
441 
443 {
444  URLContext *h= *hh;
445  int ret = 0;
446  if (!h)
447  return 0; /* can happen when ffurl_open fails */
448 
449  if (h->is_connected && h->prot->url_close)
450  ret = h->prot->url_close(h);
451 #if CONFIG_NETWORK
454 #endif
455  if (h->prot->priv_data_size) {
456  if (h->prot->priv_data_class)
458  av_freep(&h->priv_data);
459  }
460  av_opt_free(h);
461  av_freep(hh);
462  return ret;
463 }
464 
466 {
467  return ffurl_closep(&h);
468 }
469 
470 
471 const char *avio_find_protocol_name(const char *url)
472 {
473  const URLProtocol *p = url_find_protocol(url);
474 
475  return p ? p->name : NULL;
476 }
477 
478 int avio_check(const char *url, int flags)
479 {
480  URLContext *h;
481  int ret = ffurl_alloc(&h, url, flags, NULL);
482  if (ret < 0)
483  return ret;
484 
485  if (h->prot->url_check) {
486  ret = h->prot->url_check(h, flags);
487  } else {
488  ret = ffurl_connect(h, NULL);
489  if (ret >= 0)
490  ret = flags;
491  }
492 
493  ffurl_close(h);
494  return ret;
495 }
496 
497 int avpriv_io_move(const char *url_src, const char *url_dst)
498 {
499  URLContext *h_src, *h_dst;
500  int ret = ffurl_alloc(&h_src, url_src, AVIO_FLAG_READ_WRITE, NULL);
501  if (ret < 0)
502  return ret;
503  ret = ffurl_alloc(&h_dst, url_dst, AVIO_FLAG_WRITE, NULL);
504  if (ret < 0) {
505  ffurl_close(h_src);
506  return ret;
507  }
508 
509  if (h_src->prot == h_dst->prot && h_src->prot->url_move)
510  ret = h_src->prot->url_move(h_src, h_dst);
511  else
512  ret = AVERROR(ENOSYS);
513 
514  ffurl_close(h_src);
515  ffurl_close(h_dst);
516  return ret;
517 }
518 
519 int avpriv_io_delete(const char *url)
520 {
521  URLContext *h;
522  int ret = ffurl_alloc(&h, url, AVIO_FLAG_WRITE, NULL);
523  if (ret < 0)
524  return ret;
525 
526  if (h->prot->url_delete)
527  ret = h->prot->url_delete(h);
528  else
529  ret = AVERROR(ENOSYS);
530 
531  ffurl_close(h);
532  return ret;
533 }
534 
535 int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options)
536 {
537  URLContext *h = NULL;
539  int ret;
540  av_assert0(s);
541 
542  ctx = av_mallocz(sizeof(*ctx));
543  if (!ctx) {
544  ret = AVERROR(ENOMEM);
545  goto fail;
546  }
547 
548  if ((ret = ffurl_alloc(&h, url, AVIO_FLAG_READ, NULL)) < 0)
549  goto fail;
550 
551  if (h->prot->url_open_dir && h->prot->url_read_dir && h->prot->url_close_dir) {
552  if (options && h->prot->priv_data_class &&
553  (ret = av_opt_set_dict(h->priv_data, options)) < 0)
554  goto fail;
555  ret = h->prot->url_open_dir(h);
556  } else
557  ret = AVERROR(ENOSYS);
558  if (ret < 0)
559  goto fail;
560 
561  h->is_connected = 1;
562  ctx->url_context = h;
563  *s = ctx;
564  return 0;
565 
566  fail:
567  av_free(ctx);
568  *s = NULL;
569  ffurl_close(h);
570  return ret;
571 }
572 
574 {
575  URLContext *h;
576  int ret;
577 
578  if (!s || !s->url_context)
579  return AVERROR(EINVAL);
580  h = s->url_context;
581  if ((ret = h->prot->url_read_dir(h, next)) < 0)
583  return ret;
584 }
585 
587 {
588  URLContext *h;
589 
590  av_assert0(s);
591  if (!(*s) || !(*s)->url_context)
592  return AVERROR(EINVAL);
593  h = (*s)->url_context;
594  h->prot->url_close_dir(h);
595  ffurl_close(h);
596  av_freep(s);
597  *s = NULL;
598  return 0;
599 }
600 
602 {
603  if (!entry || !*entry)
604  return;
605  av_free((*entry)->name);
606  av_freep(entry);
607 }
608 
610 {
611  int64_t pos, size;
612 
613  size = ffurl_seek(h, 0, AVSEEK_SIZE);
614  if (size < 0) {
615  pos = ffurl_seek(h, 0, SEEK_CUR);
616  if ((size = ffurl_seek(h, -1, SEEK_END)) < 0)
617  return size;
618  size++;
619  ffurl_seek(h, pos, SEEK_SET);
620  }
621  return size;
622 }
623 
625 {
626  if (!h->prot->url_get_file_handle)
627  return -1;
628  return h->prot->url_get_file_handle(h);
629 }
630 
631 int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
632 {
633  if (!h->prot->url_get_multi_file_handle) {
634  if (!h->prot->url_get_file_handle)
635  return AVERROR(ENOSYS);
636  *handles = av_malloc(sizeof(**handles));
637  if (!*handles)
638  return AVERROR(ENOMEM);
639  *numhandles = 1;
640  *handles[0] = h->prot->url_get_file_handle(h);
641  return 0;
642  }
643  return h->prot->url_get_multi_file_handle(h, handles, numhandles);
644 }
645 
647 {
648  if (!h->prot->url_get_short_seek)
649  return AVERROR(ENOSYS);
650  return h->prot->url_get_short_seek(h);
651 }
652 
654 {
655  if (!h->prot->url_shutdown)
656  return AVERROR(EINVAL);
657  return h->prot->url_shutdown(h, flags);
658 }
659 
661 {
662  int ret;
663  if (cb && cb->callback && (ret = cb->callback(cb->opaque)))
664  return ret;
665  return 0;
666 }
int(* url_open_dir)(URLContext *h)
Definition: url.h:94
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:771
const char * s
Definition: avisynth_c.h:768
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. ...
Definition: avio.c:307
#define URL_PROTOCOL_FLAG_NETWORK
Definition: url.h:34
int(* url_close_dir)(URLContext *h)
Definition: url.h:96
AVOption.
Definition: opt.h:246
int(* url_check)(URLContext *h, int mask)
Definition: url.h:93
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int flags
Definition: url.h:92
#define LIBAVUTIL_VERSION_INT
Definition: version.h:86
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
Write size bytes from buf to the resource accessed by h.
Definition: avio.c:419
int is_streamed
true if streamed (no seek possible), default = false
Definition: url.h:45
int ffurl_connect(URLContext *uc, AVDictionary **options)
Connect an URLContext that has been allocated by ffurl_alloc.
Definition: avio.c:166
AVIOInterruptCB interrupt_callback
Definition: url.h:47
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1291
Describes single entry of the directory.
Definition: avio.h:86
#define AVIO_FLAG_READ
read-only
Definition: avio.h:643
int64_t rw_timeout
maximum time to wait for (network) read/write operation completion, in mcs
Definition: url.h:48
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:644
void ff_network_close(void)
Definition: network.c:102
int flags
Definition: url.h:43
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:222
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
static void * urlcontext_child_next(void *obj, void *prev)
Definition: avio.c:45
static int url_alloc_for_protocol(URLContext **puc, const URLProtocol *up, const char *filename, int flags, const AVIOInterruptCB *int_cb)
Definition: avio.c:73
int ffurl_shutdown(URLContext *h, int flags)
Signal the URLContext that we are done reading or writing the stream.
Definition: avio.c:653
#define URL_SCHEME_CHARS
Definition: avio.c:246
int avpriv_io_move(const char *url_src, const char *url_dst)
Move or rename a resource.
Definition: avio.c:497
void * opaque
Definition: avio.h:60
const AVClass * priv_data_class
Definition: url.h:91
int avio_check(const char *url, int flags)
Return AVIO_FLAG_* access flags corresponding to the access permissions of the resource in url...
Definition: avio.c:478
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Public dictionary API.
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:106
uint8_t
#define av_malloc(s)
int ff_network_init(void)
Definition: network.c:55
AVOptions.
miscellaneous OS support macros and functions.
int avio_read_dir(AVIODirContext *s, AVIODirEntry **next)
Get next directory entry.
Definition: avio.c:573
#define OFFSET(x)
Definition: avio.c:53
int(* url_get_file_handle)(URLContext *h)
Definition: url.h:85
#define AVERROR_PROTOCOL_NOT_FOUND
Protocol not found.
Definition: error.h:63
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
const AVClass * ff_urlcontext_child_class_next(const AVClass *prev)
Definition: protocols.c:76
int(* url_get_multi_file_handle)(URLContext *h, int **handles, int *numhandles)
Definition: url.h:86
static int flags
Definition: log.c:57
#define AVERROR_EOF
End of file.
Definition: error.h:55
ptrdiff_t size
Definition: opengl_enc.c:101
#define av_log(a,...)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
int(* url_move)(URLContext *h_src, URLContext *h_dst)
Definition: url.h:98
Callback for checking whether to abort blocking functions.
Definition: avio.h:58
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...
Definition: avio.c:290
int(* url_open2)(URLContext *h, const char *url, int flags, AVDictionary **options)
This callback is to be used by protocols which open further nested protocols.
Definition: url.h:62
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
Return the file descriptors associated with this URL.
Definition: avio.c:631
int(* callback)(void *)
Definition: avio.h:59
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:464
const char * protocol_whitelist
Definition: url.h:49
#define AVERROR(e)
Definition: error.h:43
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition: avstring.c:442
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
#define URL_PROTOCOL_FLAG_NESTED_SCHEME
Definition: url.h:33
simple assert() macros that are a bit more flexible than ISO C assert().
int(* url_open)(URLContext *h, const char *url, int flags)
Definition: url.h:56
#define FFMAX(a, b)
Definition: common.h:94
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
#define fail()
Definition: checkasm.h:98
static const char * urlcontext_to_name(void *ptr)
Definition: avio.c:36
void avio_free_directory_entry(AVIODirEntry **entry)
Free entry allocated by avio_read_dir().
Definition: avio.c:601
int(* url_write)(URLContext *h, const unsigned char *buf, int size)
Definition: url.h:79
int(* url_read)(URLContext *h, unsigned char *buf, int size)
Read data from the protocol.
Definition: url.h:78
static const AVOption options[]
Definition: avio.c:56
static int retry_transfer_wrapper(URLContext *h, uint8_t *buf, int size, int size_min, int(*transfer_func)(URLContext *h, uint8_t *buf, int size))
Definition: avio.c:362
int ffurl_get_short_seek(URLContext *h)
Return the current short seek threshold value for this URL.
Definition: avio.c:646
#define FFMIN(a, b)
Definition: common.h:96
AVFormatContext * ctx
Definition: movenc.c:48
int ffurl_handshake(URLContext *c)
Perform one step of the protocol handshake to accept a new client.
Definition: avio.c:234
int64_t(* url_seek)(URLContext *h, int64_t pos, int whence)
Definition: url.h:80
int ffurl_get_file_handle(URLContext *h)
Return the file descriptor associated with this URL.
Definition: avio.c:624
int ffurl_accept(URLContext *s, URLContext **c)
Accept an URLContext c on an URLContext s.
Definition: avio.c:226
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:56
int is_connected
Definition: url.h:46
int ffurl_closep(URLContext **hh)
Close the resource accessed by the URLContext h, and free the memory used by it.
Definition: avio.c:442
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:237
static int is_dos_path(const char *path)
Definition: os_support.h:70
const char * protocol_blacklist
Definition: url.h:50
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
Definition: avio.c:660
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1589
#define AVIO_FLAG_NONBLOCK
Use non-blocking mode.
Definition: avio.h:662
const char * default_whitelist
Definition: url.h:99
int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options)
Open directory for reading.
Definition: avio.c:535
int64_t ffurl_size(URLContext *h)
Return the filesize of the resource accessed by h, AVERROR(ENOSYS) if the operation is not supported ...
Definition: avio.c:609
void * buf
Definition: avisynth_c.h:690
Definition: url.h:38
#define AVIO_FLAG_READ_WRITE
read-write pseudo flag
Definition: avio.h:645
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AVSEEK_FORCE
Passing this flag as the "whence" parameter to a seek function causes it to seek by any means (like r...
Definition: avio.h:530
void * priv_data
Definition: url.h:41
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
int(* url_handshake)(URLContext *c)
Definition: url.h:64
int(* url_read_dir)(URLContext *h, AVIODirEntry **next)
Definition: url.h:95
const char * name
Definition: url.h:55
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
Definition: avio.c:471
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
const AVClass * av_class
information for av_log().
Definition: url.h:39
int ffurl_close(URLContext *h)
Definition: avio.c:465
int(* url_accept)(URLContext *s, URLContext **c)
Definition: url.h:63
const AVClass ffurl_context_class
Definition: avio.c:63
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:34
Main libavformat public API header.
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1544
int64_t ffurl_seek(URLContext *h, int64_t pos, int whence)
Change the position that will be used by the next read/write operation on the resource accessed by h...
Definition: avio.c:432
const struct URLProtocol * prot
Definition: url.h:40
int ffurl_open(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Definition: avio.c:355
int(* url_delete)(URLContext *h)
Definition: url.h:97
static double c[64]
int ffurl_read_complete(URLContext *h, unsigned char *buf, int size)
Read as many bytes as possible (up to size), calling the read function multiple times if necessary...
Definition: avio.c:412
char * filename
specified URL
Definition: url.h:42
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:1702
#define AVSEEK_SIZE
ORing this as the "whence" parameter to a seek function causes it to return the filesize without seek...
Definition: avio.h:522
int avio_close_dir(AVIODirContext **s)
Close directory.
Definition: avio.c:586
#define av_free(p)
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:61
char * value
Definition: dict.h:87
int len
int avpriv_io_delete(const char *url)
Delete a resource.
Definition: avio.c:519
int max_packet_size
if non zero, the stream is packetized with this max packet size
Definition: url.h:44
int(* url_close)(URLContext *h)
Definition: url.h:81
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:690
unbuffered private I/O API
#define D
Definition: avio.c:55
int(* url_get_short_seek)(URLContext *h)
Definition: url.h:88
static const struct URLProtocol * url_find_protocol(const char *filename)
Definition: avio.c:251
int(* url_shutdown)(URLContext *h, int flags)
Definition: url.h:89
struct URLContext * url_context
Definition: avio.h:104
int priv_data_size
Definition: url.h:90
const URLProtocol ** ffurl_get_protocols(const char *whitelist, const char *blacklist)
Construct a list of protocols matching a given whitelist and/or blacklist.
Definition: protocols.c:111
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:449
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...
Definition: avio.c:405