lavf: reorganize URLProtocols
[ffmpeg.git] / libavformat / avio.c
1 /*
2  * unbuffered I/O
3  * Copyright (c) 2001 Fabrice Bellard
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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 "os_support.h"
27 #include "avformat.h"
28 #if CONFIG_NETWORK
29 #include "network.h"
30 #endif
31 #include "url.h"
32
33 /** @name Logging context. */
34 /*@{*/
35 static const char *urlcontext_to_name(void *ptr)
36 {
37     URLContext *h = (URLContext *)ptr;
38     if (h->prot)
39         return h->prot->name;
40     else
41         return "NULL";
42 }
43
44 static void *urlcontext_child_next(void *obj, void *prev)
45 {
46     URLContext *h = obj;
47     if (!prev && h->priv_data && h->prot->priv_data_class)
48         return h->priv_data;
49     return NULL;
50 }
51
52 static const AVClass *urlcontext_child_class_next(const AVClass *prev)
53 {
54     int i;
55
56     /* find the protocol that corresponds to prev */
57     for (i = 0; ff_url_protocols[i]; i++) {
58         if (ff_url_protocols[i]->priv_data_class == prev) {
59             i++;
60             break;
61         }
62     }
63
64     /* find next protocol with priv options */
65     for (; ff_url_protocols[i]; i++)
66         if (ff_url_protocols[i]->priv_data_class)
67             return ff_url_protocols[i]->priv_data_class;
68     return NULL;
69 }
70
71 static const AVOption options[] = { { NULL } };
72 const AVClass ffurl_context_class = {
73     .class_name       = "URLContext",
74     .item_name        = urlcontext_to_name,
75     .option           = options,
76     .version          = LIBAVUTIL_VERSION_INT,
77     .child_next       = urlcontext_child_next,
78     .child_class_next = urlcontext_child_class_next,
79 };
80 /*@}*/
81
82 const char *avio_enum_protocols(void **opaque, int output)
83 {
84     const URLProtocol **p = *opaque;
85
86     p = p ? p + 1 : ff_url_protocols;
87     *opaque = p;
88     if (!*p) {
89         *opaque = NULL;
90         return NULL;
91     }
92     if ((output && (*p)->url_write) || (!output && (*p)->url_read))
93         return (*p)->name;
94     return avio_enum_protocols(opaque, output);
95 }
96
97 static int url_alloc_for_protocol(URLContext **puc, const URLProtocol *up,
98                                   const char *filename, int flags,
99                                   const AVIOInterruptCB *int_cb)
100 {
101     URLContext *uc;
102     int err;
103
104 #if CONFIG_NETWORK
105     if (up->flags & URL_PROTOCOL_FLAG_NETWORK && !ff_network_init())
106         return AVERROR(EIO);
107 #endif
108     uc = av_mallocz(sizeof(URLContext) + strlen(filename) + 1);
109     if (!uc) {
110         err = AVERROR(ENOMEM);
111         goto fail;
112     }
113     uc->av_class = &ffurl_context_class;
114     uc->filename = (char *)&uc[1];
115     strcpy(uc->filename, filename);
116     uc->prot            = up;
117     uc->flags           = flags;
118     uc->is_streamed     = 0; /* default = not streamed */
119     uc->max_packet_size = 0; /* default: stream file */
120     if (up->priv_data_size) {
121         uc->priv_data = av_mallocz(up->priv_data_size);
122         if (!uc->priv_data) {
123             err = AVERROR(ENOMEM);
124             goto fail;
125         }
126         if (up->priv_data_class) {
127             *(const AVClass **)uc->priv_data = up->priv_data_class;
128             av_opt_set_defaults(uc->priv_data);
129         }
130     }
131     if (int_cb)
132         uc->interrupt_callback = *int_cb;
133
134     *puc = uc;
135     return 0;
136 fail:
137     *puc = NULL;
138     if (uc)
139         av_freep(&uc->priv_data);
140     av_freep(&uc);
141 #if CONFIG_NETWORK
142     if (up->flags & URL_PROTOCOL_FLAG_NETWORK)
143         ff_network_close();
144 #endif
145     return err;
146 }
147
148 int ffurl_connect(URLContext *uc, AVDictionary **options)
149 {
150     int err =
151         uc->prot->url_open2 ? uc->prot->url_open2(uc,
152                                                   uc->filename,
153                                                   uc->flags,
154                                                   options) :
155         uc->prot->url_open(uc, uc->filename, uc->flags);
156     if (err)
157         return err;
158     uc->is_connected = 1;
159     /* We must be careful here as ffurl_seek() could be slow,
160      * for example for http */
161     if ((uc->flags & AVIO_FLAG_WRITE) || !strcmp(uc->prot->name, "file"))
162         if (!uc->is_streamed && ffurl_seek(uc, 0, SEEK_SET) < 0)
163             uc->is_streamed = 1;
164     return 0;
165 }
166
167 #define URL_SCHEME_CHARS                        \
168     "abcdefghijklmnopqrstuvwxyz"                \
169     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"                \
170     "0123456789+-."
171
172 int ffurl_alloc(URLContext **puc, const char *filename, int flags,
173                 const AVIOInterruptCB *int_cb)
174 {
175     char proto_str[128], proto_nested[128], *ptr;
176     size_t proto_len = strspn(filename, URL_SCHEME_CHARS);
177     int i;
178
179     if (filename[proto_len] != ':' || is_dos_path(filename))
180         strcpy(proto_str, "file");
181     else
182         av_strlcpy(proto_str, filename,
183                    FFMIN(proto_len + 1, sizeof(proto_str)));
184
185     av_strlcpy(proto_nested, proto_str, sizeof(proto_nested));
186     if ((ptr = strchr(proto_nested, '+')))
187         *ptr = '\0';
188
189     for (i = 0; ff_url_protocols[i]; i++) {
190         const URLProtocol *up = ff_url_protocols[i];
191         if (!strcmp(proto_str, up->name))
192             return url_alloc_for_protocol(puc, up, filename, flags, int_cb);
193         if (up->flags & URL_PROTOCOL_FLAG_NESTED_SCHEME &&
194             !strcmp(proto_nested, up->name))
195             return url_alloc_for_protocol(puc, up, filename, flags, int_cb);
196     }
197     *puc = NULL;
198     return AVERROR_PROTOCOL_NOT_FOUND;
199 }
200
201 int ffurl_open(URLContext **puc, const char *filename, int flags,
202                const AVIOInterruptCB *int_cb, AVDictionary **options)
203 {
204     int ret = ffurl_alloc(puc, filename, flags, int_cb);
205     if (ret)
206         return ret;
207     if (options && (*puc)->prot->priv_data_class &&
208         (ret = av_opt_set_dict((*puc)->priv_data, options)) < 0)
209         goto fail;
210     ret = ffurl_connect(*puc, options);
211     if (!ret)
212         return 0;
213 fail:
214     ffurl_close(*puc);
215     *puc = NULL;
216     return ret;
217 }
218
219 static inline int retry_transfer_wrapper(URLContext *h, uint8_t *buf,
220                                          int size, int size_min,
221                                          int (*transfer_func)(URLContext *h,
222                                                               uint8_t *buf,
223                                                               int size))
224 {
225     int ret, len;
226     int fast_retries = 5;
227
228     len = 0;
229     while (len < size_min) {
230         ret = transfer_func(h, buf + len, size - len);
231         if (ret == AVERROR(EINTR))
232             continue;
233         if (h->flags & AVIO_FLAG_NONBLOCK)
234             return ret;
235         if (ret == AVERROR(EAGAIN)) {
236             ret = 0;
237             if (fast_retries)
238                 fast_retries--;
239             else
240                 av_usleep(1000);
241         } else if (ret < 1)
242             return (ret < 0 && ret != AVERROR_EOF) ? ret : len;
243         if (ret)
244             fast_retries = FFMAX(fast_retries, 2);
245         len += ret;
246         if (ff_check_interrupt(&h->interrupt_callback))
247             return AVERROR_EXIT;
248     }
249     return len;
250 }
251
252 int ffurl_read(URLContext *h, unsigned char *buf, int size)
253 {
254     if (!(h->flags & AVIO_FLAG_READ))
255         return AVERROR(EIO);
256     return retry_transfer_wrapper(h, buf, size, 1, h->prot->url_read);
257 }
258
259 int ffurl_read_complete(URLContext *h, unsigned char *buf, int size)
260 {
261     if (!(h->flags & AVIO_FLAG_READ))
262         return AVERROR(EIO);
263     return retry_transfer_wrapper(h, buf, size, size, h->prot->url_read);
264 }
265
266 int ffurl_write(URLContext *h, const unsigned char *buf, int size)
267 {
268     if (!(h->flags & AVIO_FLAG_WRITE))
269         return AVERROR(EIO);
270     /* avoid sending too big packets */
271     if (h->max_packet_size && size > h->max_packet_size)
272         return AVERROR(EIO);
273
274     return retry_transfer_wrapper(h, buf, size, size,
275                                   (int (*)(struct URLContext *, uint8_t *, int))
276                                   h->prot->url_write);
277 }
278
279 int64_t ffurl_seek(URLContext *h, int64_t pos, int whence)
280 {
281     int64_t ret;
282
283     if (!h->prot->url_seek)
284         return AVERROR(ENOSYS);
285     ret = h->prot->url_seek(h, pos, whence & ~AVSEEK_FORCE);
286     return ret;
287 }
288
289 int ffurl_close(URLContext *h)
290 {
291     int ret = 0;
292     if (!h)
293         return 0;     /* can happen when ffurl_open fails */
294
295     if (h->is_connected && h->prot->url_close)
296         ret = h->prot->url_close(h);
297 #if CONFIG_NETWORK
298     if (h->prot->flags & URL_PROTOCOL_FLAG_NETWORK)
299         ff_network_close();
300 #endif
301     if (h->prot->priv_data_size) {
302         if (h->prot->priv_data_class)
303             av_opt_free(h->priv_data);
304         av_free(h->priv_data);
305     }
306     av_free(h);
307     return ret;
308 }
309
310 int avio_check(const char *url, int flags)
311 {
312     URLContext *h;
313     int ret = ffurl_alloc(&h, url, flags, NULL);
314     if (ret)
315         return ret;
316
317     if (h->prot->url_check) {
318         ret = h->prot->url_check(h, flags);
319     } else {
320         ret = ffurl_connect(h, NULL);
321         if (ret >= 0)
322             ret = flags;
323     }
324
325     ffurl_close(h);
326     return ret;
327 }
328
329 int64_t ffurl_size(URLContext *h)
330 {
331     int64_t pos, size;
332
333     size = ffurl_seek(h, 0, AVSEEK_SIZE);
334     if (size < 0) {
335         pos = ffurl_seek(h, 0, SEEK_CUR);
336         if ((size = ffurl_seek(h, -1, SEEK_END)) < 0)
337             return size;
338         size++;
339         ffurl_seek(h, pos, SEEK_SET);
340     }
341     return size;
342 }
343
344 int ffurl_get_file_handle(URLContext *h)
345 {
346     if (!h->prot->url_get_file_handle)
347         return -1;
348     return h->prot->url_get_file_handle(h);
349 }
350
351 int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
352 {
353     if (!h->prot->url_get_multi_file_handle) {
354         if (!h->prot->url_get_file_handle)
355             return AVERROR(ENOSYS);
356         *handles = av_malloc(sizeof(**handles));
357         if (!*handles)
358             return AVERROR(ENOMEM);
359         *numhandles = 1;
360         *handles[0] = h->prot->url_get_file_handle(h);
361         return 0;
362     }
363     return h->prot->url_get_multi_file_handle(h, handles, numhandles);
364 }
365
366 int ffurl_shutdown(URLContext *h, int flags)
367 {
368     if (!h->prot->url_shutdown)
369         return AVERROR(EINVAL);
370     return h->prot->url_shutdown(h, flags);
371 }
372
373 int ff_check_interrupt(AVIOInterruptCB *cb)
374 {
375     int ret;
376     if (cb && cb->callback && (ret = cb->callback(cb->opaque)))
377         return ret;
378     return 0;
379 }