git.sesse.net Git - ffmpeg/blob - libavformat/network.c

   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
  31 int 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
  46 void 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
  58 int 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
  69 int 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
  78 int 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
  98 int 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
 116 void ff_network_close(void)
 117 {
 118 #if HAVE_WINSOCK2_H
 119     WSACleanup();
 120 #endif
 121 }
 122
 123 #if HAVE_WINSOCK2_H
 124 int 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
 145 int 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
 159 static 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
 183 int 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
 210 int 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
 228 int 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
 246 int 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
 258 int 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
 303 static 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
 334 static 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
 348 struct 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.
 356 static 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
 403 int 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
 527 static 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
 551 int 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
 581 void 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 }