PageRenderTime 81ms CodeModel.GetById 13ms app.highlight 63ms RepoModel.GetById 1ms app.codeStats 0ms

/libavformat/network.c

http://github.com/FFmpeg/FFmpeg
C | 586 lines | 485 code | 51 blank | 50 comment | 114 complexity | aa1d4ef453e2f6b235efd9c0f3157299 MD5 | raw file
  1/*
  2 * Copyright (c) 2007 The FFmpeg Project
  3 *
  4 * This file is part of FFmpeg.
  5 *
  6 * FFmpeg is free software; you can redistribute it and/or
  7 * modify it under the terms of the GNU Lesser General Public
  8 * License as published by the Free Software Foundation; either
  9 * version 2.1 of the License, or (at your option) any later version.
 10 *
 11 * FFmpeg is distributed in the hope that it will be useful,
 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 14 * Lesser General Public License for more details.
 15 *
 16 * You should have received a copy of the GNU Lesser General Public
 17 * License along with FFmpeg; if not, write to the Free Software
 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 19 */
 20
 21#include <fcntl.h>
 22#include "network.h"
 23#include "tls.h"
 24#include "url.h"
 25#include "libavcodec/internal.h"
 26#include "libavutil/avutil.h"
 27#include "libavutil/avassert.h"
 28#include "libavutil/mem.h"
 29#include "libavutil/time.h"
 30
 31int ff_tls_init(void)
 32{
 33#if CONFIG_TLS_PROTOCOL
 34#if CONFIG_OPENSSL
 35    int ret;
 36    if ((ret = ff_openssl_init()) < 0)
 37        return ret;
 38#endif
 39#if CONFIG_GNUTLS
 40    ff_gnutls_init();
 41#endif
 42#endif
 43    return 0;
 44}
 45
 46void ff_tls_deinit(void)
 47{
 48#if CONFIG_TLS_PROTOCOL
 49#if CONFIG_OPENSSL
 50    ff_openssl_deinit();
 51#endif
 52#if CONFIG_GNUTLS
 53    ff_gnutls_deinit();
 54#endif
 55#endif
 56}
 57
 58int ff_network_init(void)
 59{
 60#if HAVE_WINSOCK2_H
 61    WSADATA wsaData;
 62
 63    if (WSAStartup(MAKEWORD(1,1), &wsaData))
 64        return 0;
 65#endif
 66    return 1;
 67}
 68
 69int ff_network_wait_fd(int fd, int write)
 70{
 71    int ev = write ? POLLOUT : POLLIN;
 72    struct pollfd p = { .fd = fd, .events = ev, .revents = 0 };
 73    int ret;
 74    ret = poll(&p, 1, POLLING_TIME);
 75    return ret < 0 ? ff_neterrno() : p.revents & (ev | POLLERR | POLLHUP) ? 0 : AVERROR(EAGAIN);
 76}
 77
 78int ff_network_wait_fd_timeout(int fd, int write, int64_t timeout, AVIOInterruptCB *int_cb)
 79{
 80    int ret;
 81    int64_t wait_start = 0;
 82
 83    while (1) {
 84        if (ff_check_interrupt(int_cb))
 85            return AVERROR_EXIT;
 86        ret = ff_network_wait_fd(fd, write);
 87        if (ret != AVERROR(EAGAIN))
 88            return ret;
 89        if (timeout > 0) {
 90            if (!wait_start)
 91                wait_start = av_gettime_relative();
 92            else if (av_gettime_relative() - wait_start > timeout)
 93                return AVERROR(ETIMEDOUT);
 94        }
 95    }
 96}
 97
 98int ff_network_sleep_interruptible(int64_t timeout, AVIOInterruptCB *int_cb)
 99{
100    int64_t wait_start = av_gettime_relative();
101
102    while (1) {
103        int64_t time_left;
104
105        if (ff_check_interrupt(int_cb))
106            return AVERROR_EXIT;
107
108        time_left = timeout - (av_gettime_relative() - wait_start);
109        if (time_left <= 0)
110            return AVERROR(ETIMEDOUT);
111
112        av_usleep(FFMIN(time_left, POLLING_TIME * 1000));
113    }
114}
115
116void ff_network_close(void)
117{
118#if HAVE_WINSOCK2_H
119    WSACleanup();
120#endif
121}
122
123#if HAVE_WINSOCK2_H
124int ff_neterrno(void)
125{
126    int err = WSAGetLastError();
127    switch (err) {
128    case WSAEWOULDBLOCK:
129        return AVERROR(EAGAIN);
130    case WSAEINTR:
131        return AVERROR(EINTR);
132    case WSAEPROTONOSUPPORT:
133        return AVERROR(EPROTONOSUPPORT);
134    case WSAETIMEDOUT:
135        return AVERROR(ETIMEDOUT);
136    case WSAECONNREFUSED:
137        return AVERROR(ECONNREFUSED);
138    case WSAEINPROGRESS:
139        return AVERROR(EINPROGRESS);
140    }
141    return -err;
142}
143#endif
144
145int ff_is_multicast_address(struct sockaddr *addr)
146{
147    if (addr->sa_family == AF_INET) {
148        return IN_MULTICAST(ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr));
149    }
150#if HAVE_STRUCT_SOCKADDR_IN6
151    if (addr->sa_family == AF_INET6) {
152        return IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6 *)addr)->sin6_addr);
153    }
154#endif
155
156    return 0;
157}
158
159static int ff_poll_interrupt(struct pollfd *p, nfds_t nfds, int timeout,
160                             AVIOInterruptCB *cb)
161{
162    int runs = timeout / POLLING_TIME;
163    int ret = 0;
164
165    do {
166        if (ff_check_interrupt(cb))
167            return AVERROR_EXIT;
168        ret = poll(p, nfds, POLLING_TIME);
169        if (ret != 0) {
170            if (ret < 0)
171                ret = ff_neterrno();
172            if (ret == AVERROR(EINTR))
173                continue;
174            break;
175        }
176    } while (timeout <= 0 || runs-- > 0);
177
178    if (!ret)
179        return AVERROR(ETIMEDOUT);
180    return ret;
181}
182
183int ff_socket(int af, int type, int proto)
184{
185    int fd;
186
187#ifdef SOCK_CLOEXEC
188    fd = socket(af, type | SOCK_CLOEXEC, proto);
189    if (fd == -1 && errno == EINVAL)
190#endif
191    {
192        fd = socket(af, type, proto);
193#if HAVE_FCNTL
194        if (fd != -1) {
195            if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
196                av_log(NULL, AV_LOG_DEBUG, "Failed to set close on exec\n");
197        }
198#endif
199    }
200#ifdef SO_NOSIGPIPE
201    if (fd != -1) {
202        if (setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &(int){1}, sizeof(int))) {
203             av_log(NULL, AV_LOG_WARNING, "setsockopt(SO_NOSIGPIPE) failed\n");
204        }
205    }
206#endif
207    return fd;
208}
209
210int ff_listen(int fd, const struct sockaddr *addr,
211              socklen_t addrlen)
212{
213    int ret;
214    int reuse = 1;
215    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse))) {
216        av_log(NULL, AV_LOG_WARNING, "setsockopt(SO_REUSEADDR) failed\n");
217    }
218    ret = bind(fd, addr, addrlen);
219    if (ret)
220        return ff_neterrno();
221
222    ret = listen(fd, 1);
223    if (ret)
224        return ff_neterrno();
225    return ret;
226}
227
228int ff_accept(int fd, int timeout, URLContext *h)
229{
230    int ret;
231    struct pollfd lp = { fd, POLLIN, 0 };
232
233    ret = ff_poll_interrupt(&lp, 1, timeout, &h->interrupt_callback);
234    if (ret < 0)
235        return ret;
236
237    ret = accept(fd, NULL, NULL);
238    if (ret < 0)
239        return ff_neterrno();
240    if (ff_socket_nonblock(ret, 1) < 0)
241        av_log(h, AV_LOG_DEBUG, "ff_socket_nonblock failed\n");
242
243    return ret;
244}
245
246int ff_listen_bind(int fd, const struct sockaddr *addr,
247                   socklen_t addrlen, int timeout, URLContext *h)
248{
249    int ret;
250    if ((ret = ff_listen(fd, addr, addrlen)) < 0)
251        return ret;
252    if ((ret = ff_accept(fd, timeout, h)) < 0)
253        return ret;
254    closesocket(fd);
255    return ret;
256}
257
258int ff_listen_connect(int fd, const struct sockaddr *addr,
259                      socklen_t addrlen, int timeout, URLContext *h,
260                      int will_try_next)
261{
262    struct pollfd p = {fd, POLLOUT, 0};
263    int ret;
264    socklen_t optlen;
265
266    if (ff_socket_nonblock(fd, 1) < 0)
267        av_log(h, AV_LOG_DEBUG, "ff_socket_nonblock failed\n");
268
269    while ((ret = connect(fd, addr, addrlen))) {
270        ret = ff_neterrno();
271        switch (ret) {
272        case AVERROR(EINTR):
273            if (ff_check_interrupt(&h->interrupt_callback))
274                return AVERROR_EXIT;
275            continue;
276        case AVERROR(EINPROGRESS):
277        case AVERROR(EAGAIN):
278            ret = ff_poll_interrupt(&p, 1, timeout, &h->interrupt_callback);
279            if (ret < 0)
280                return ret;
281            optlen = sizeof(ret);
282            if (getsockopt (fd, SOL_SOCKET, SO_ERROR, &ret, &optlen))
283                ret = AVUNERROR(ff_neterrno());
284            if (ret != 0) {
285                char errbuf[100];
286                ret = AVERROR(ret);
287                av_strerror(ret, errbuf, sizeof(errbuf));
288                if (will_try_next)
289                    av_log(h, AV_LOG_WARNING,
290                           "Connection to %s failed (%s), trying next address\n",
291                           h->filename, errbuf);
292                else
293                    av_log(h, AV_LOG_ERROR, "Connection to %s failed: %s\n",
294                           h->filename, errbuf);
295            }
296        default:
297            return ret;
298        }
299    }
300    return ret;
301}
302
303static void interleave_addrinfo(struct addrinfo *base)
304{
305    struct addrinfo **next = &base->ai_next;
306    while (*next) {
307        struct addrinfo *cur = *next;
308        // Iterate forward until we find an entry of a different family.
309        if (cur->ai_family == base->ai_family) {
310            next = &cur->ai_next;
311            continue;
312        }
313        if (cur == base->ai_next) {
314            // If the first one following base is of a different family, just
315            // move base forward one step and continue.
316            base = cur;
317            next = &base->ai_next;
318            continue;
319        }
320        // Unchain cur from the rest of the list from its current spot.
321        *next = cur->ai_next;
322        // Hook in cur directly after base.
323        cur->ai_next = base->ai_next;
324        base->ai_next = cur;
325        // Restart with a new base. We know that before moving the cur element,
326        // everything between the previous base and cur had the same family,
327        // different from cur->ai_family. Therefore, we can keep next pointing
328        // where it was, and continue from there with base at the one after
329        // cur.
330        base = cur->ai_next;
331    }
332}
333
334static void print_address_list(void *ctx, const struct addrinfo *addr,
335                               const char *title)
336{
337    char hostbuf[100], portbuf[20];
338    av_log(ctx, AV_LOG_DEBUG, "%s:\n", title);
339    while (addr) {
340        getnameinfo(addr->ai_addr, addr->ai_addrlen,
341                    hostbuf, sizeof(hostbuf), portbuf, sizeof(portbuf),
342                    NI_NUMERICHOST | NI_NUMERICSERV);
343        av_log(ctx, AV_LOG_DEBUG, "Address %s port %s\n", hostbuf, portbuf);
344        addr = addr->ai_next;
345    }
346}
347
348struct ConnectionAttempt {
349    int fd;
350    int64_t deadline_us;
351    struct addrinfo *addr;
352};
353
354// Returns < 0 on error, 0 on successfully started connection attempt,
355// > 0 for a connection that succeeded already.
356static int start_connect_attempt(struct ConnectionAttempt *attempt,
357                                 struct addrinfo **ptr, int timeout_ms,
358                                 URLContext *h,
359                                 void (*customize_fd)(void *, int), void *customize_ctx)
360{
361    struct addrinfo *ai = *ptr;
362    int ret;
363
364    *ptr = ai->ai_next;
365
366    attempt->fd = ff_socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
367    if (attempt->fd < 0)
368        return ff_neterrno();
369    attempt->deadline_us = av_gettime_relative() + timeout_ms * 1000;
370    attempt->addr = ai;
371
372    ff_socket_nonblock(attempt->fd, 1);
373
374    if (customize_fd)
375        customize_fd(customize_ctx, attempt->fd);
376
377    while ((ret = connect(attempt->fd, ai->ai_addr, ai->ai_addrlen))) {
378        ret = ff_neterrno();
379        switch (ret) {
380        case AVERROR(EINTR):
381            if (ff_check_interrupt(&h->interrupt_callback)) {
382                closesocket(attempt->fd);
383                attempt->fd = -1;
384                return AVERROR_EXIT;
385            }
386            continue;
387        case AVERROR(EINPROGRESS):
388        case AVERROR(EAGAIN):
389            return 0;
390        default:
391            closesocket(attempt->fd);
392            attempt->fd = -1;
393            return ret;
394        }
395    }
396    return 1;
397}
398
399// Try a new connection to another address after 200 ms, as suggested in
400// RFC 8305 (or sooner if an earlier attempt fails).
401#define NEXT_ATTEMPT_DELAY_MS 200
402
403int ff_connect_parallel(struct addrinfo *addrs, int timeout_ms_per_address,
404                        int parallel, URLContext *h, int *fd,
405                        void (*customize_fd)(void *, int), void *customize_ctx)
406{
407    struct ConnectionAttempt attempts[3];
408    struct pollfd pfd[3];
409    int nb_attempts = 0, i, j;
410    int64_t next_attempt_us = av_gettime_relative(), next_deadline_us;
411    int last_err = AVERROR(EIO);
412    socklen_t optlen;
413    char errbuf[100], hostbuf[100], portbuf[20];
414
415    if (parallel > FF_ARRAY_ELEMS(attempts))
416        parallel = FF_ARRAY_ELEMS(attempts);
417
418    print_address_list(h, addrs, "Original list of addresses");
419    // This mutates the list, but the head of the list is still the same
420    // element, so the caller, who owns the list, doesn't need to get
421    // an updated pointer.
422    interleave_addrinfo(addrs);
423    print_address_list(h, addrs, "Interleaved list of addresses");
424
425    while (nb_attempts > 0 || addrs) {
426        // Start a new connection attempt, if possible.
427        if (nb_attempts < parallel && addrs) {
428            getnameinfo(addrs->ai_addr, addrs->ai_addrlen,
429                        hostbuf, sizeof(hostbuf), portbuf, sizeof(portbuf),
430                        NI_NUMERICHOST | NI_NUMERICSERV);
431            av_log(h, AV_LOG_VERBOSE, "Starting connection attempt to %s port %s\n",
432                                      hostbuf, portbuf);
433            last_err = start_connect_attempt(&attempts[nb_attempts], &addrs,
434                                             timeout_ms_per_address, h,
435                                             customize_fd, customize_ctx);
436            if (last_err < 0) {
437                av_strerror(last_err, errbuf, sizeof(errbuf));
438                av_log(h, AV_LOG_VERBOSE, "Connected attempt failed: %s\n",
439                                          errbuf);
440                continue;
441            }
442            if (last_err > 0) {
443                for (i = 0; i < nb_attempts; i++)
444                    closesocket(attempts[i].fd);
445                *fd = attempts[nb_attempts].fd;
446                return 0;
447            }
448            pfd[nb_attempts].fd = attempts[nb_attempts].fd;
449            pfd[nb_attempts].events = POLLOUT;
450            next_attempt_us = av_gettime_relative() + NEXT_ATTEMPT_DELAY_MS * 1000;
451            nb_attempts++;
452        }
453
454        av_assert0(nb_attempts > 0);
455        // The connection attempts are sorted from oldest to newest, so the
456        // first one will have the earliest deadline.
457        next_deadline_us = attempts[0].deadline_us;
458        // If we can start another attempt in parallel, wait until that time.
459        if (nb_attempts < parallel && addrs)
460            next_deadline_us = FFMIN(next_deadline_us, next_attempt_us);
461        last_err = ff_poll_interrupt(pfd, nb_attempts,
462                                     (next_deadline_us - av_gettime_relative())/1000,
463                                     &h->interrupt_callback);
464        if (last_err < 0 && last_err != AVERROR(ETIMEDOUT))
465            break;
466
467        // Check the status from the poll output.
468        for (i = 0; i < nb_attempts; i++) {
469            last_err = 0;
470            if (pfd[i].revents) {
471                // Some sort of action for this socket, check its status (either
472                // a successful connection or an error).
473                optlen = sizeof(last_err);
474                if (getsockopt(attempts[i].fd, SOL_SOCKET, SO_ERROR, &last_err, &optlen))
475                    last_err = ff_neterrno();
476                else if (last_err != 0)
477                    last_err = AVERROR(last_err);
478                if (last_err == 0) {
479                    // Everything is ok, we seem to have a successful
480                    // connection. Close other sockets and return this one.
481                    for (j = 0; j < nb_attempts; j++)
482                        if (j != i)
483                            closesocket(attempts[j].fd);
484                    *fd = attempts[i].fd;
485                    getnameinfo(attempts[i].addr->ai_addr, attempts[i].addr->ai_addrlen,
486                                hostbuf, sizeof(hostbuf), portbuf, sizeof(portbuf),
487                                NI_NUMERICHOST | NI_NUMERICSERV);
488                    av_log(h, AV_LOG_VERBOSE, "Successfully connected to %s port %s\n",
489                                              hostbuf, portbuf);
490                    return 0;
491                }
492            }
493            if (attempts[i].deadline_us < av_gettime_relative() && !last_err)
494                last_err = AVERROR(ETIMEDOUT);
495            if (!last_err)
496                continue;
497            // Error (or timeout) for this socket; close the socket and remove
498            // it from the attempts/pfd arrays, to let a new attempt start
499            // directly.
500            getnameinfo(attempts[i].addr->ai_addr, attempts[i].addr->ai_addrlen,
501                        hostbuf, sizeof(hostbuf), portbuf, sizeof(portbuf),
502                        NI_NUMERICHOST | NI_NUMERICSERV);
503            av_strerror(last_err, errbuf, sizeof(errbuf));
504            av_log(h, AV_LOG_VERBOSE, "Connection attempt to %s port %s "
505                                      "failed: %s\n", hostbuf, portbuf, errbuf);
506            closesocket(attempts[i].fd);
507            memmove(&attempts[i], &attempts[i + 1],
508                    (nb_attempts - i - 1) * sizeof(*attempts));
509            memmove(&pfd[i], &pfd[i + 1],
510                    (nb_attempts - i - 1) * sizeof(*pfd));
511            i--;
512            nb_attempts--;
513        }
514    }
515    for (i = 0; i < nb_attempts; i++)
516        closesocket(attempts[i].fd);
517    if (last_err >= 0)
518        last_err = AVERROR(ECONNREFUSED);
519    if (last_err != AVERROR_EXIT) {
520        av_strerror(last_err, errbuf, sizeof(errbuf));
521        av_log(h, AV_LOG_ERROR, "Connection to %s failed: %s\n",
522               h->filename, errbuf);
523    }
524    return last_err;
525}
526
527static int match_host_pattern(const char *pattern, const char *hostname)
528{
529    int len_p, len_h;
530    if (!strcmp(pattern, "*"))
531        return 1;
532    // Skip a possible *. at the start of the pattern
533    if (pattern[0] == '*')
534        pattern++;
535    if (pattern[0] == '.')
536        pattern++;
537    len_p = strlen(pattern);
538    len_h = strlen(hostname);
539    if (len_p > len_h)
540        return 0;
541    // Simply check if the end of hostname is equal to 'pattern'
542    if (!strcmp(pattern, &hostname[len_h - len_p])) {
543        if (len_h == len_p)
544            return 1; // Exact match
545        if (hostname[len_h - len_p - 1] == '.')
546            return 1; // The matched substring is a domain and not just a substring of a domain
547    }
548    return 0;
549}
550
551int ff_http_match_no_proxy(const char *no_proxy, const char *hostname)
552{
553    char *buf, *start;
554    int ret = 0;
555    if (!no_proxy)
556        return 0;
557    if (!hostname)
558        return 0;
559    buf = av_strdup(no_proxy);
560    if (!buf)
561        return 0;
562    start = buf;
563    while (start) {
564        char *sep, *next = NULL;
565        start += strspn(start, " ,");
566        sep = start + strcspn(start, " ,");
567        if (*sep) {
568            next = sep + 1;
569            *sep = '\0';
570        }
571        if (match_host_pattern(start, hostname)) {
572            ret = 1;
573            break;
574        }
575        start = next;
576    }
577    av_free(buf);
578    return ret;
579}
580
581void ff_log_net_error(void *ctx, int level, const char* prefix)
582{
583    char errbuf[100];
584    av_strerror(ff_neterrno(), errbuf, sizeof(errbuf));
585    av_log(ctx, level, "%s: %s\n", prefix, errbuf);
586}