FFmpeg
network.c
Go to the documentation of this 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 "config_components.h"
22 
23 #include <fcntl.h>
24 #include "network.h"
25 #include "tls.h"
26 #include "url.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
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
51 #endif
52 #if CONFIG_GNUTLS
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) {
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 
99 {
100  int64_t wait_start = av_gettime_relative();
101 
102  while (1) {
103  int64_t time_left;
104 
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 
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,
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, void *logctx)
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(logctx, 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(logctx, 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, void *logctx)
212 {
213  int ret;
214  int reuse = 1;
215  if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse))) {
216  av_log(logctx, 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, h)) < 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))
284  if (ret != 0) {
285  char errbuf[100];
286  ret = AVERROR(ret);
287  av_strerror(ret, errbuf, sizeof(errbuf));
288  if (will_try_next)
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),
343  av_log(ctx, AV_LOG_DEBUG, "Address %s port %s\n", hostbuf, portbuf);
344  addr = addr->ai_next;
345  }
346 }
347 
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  int (*customize_fd)(void *, int, 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, h);
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  ret = customize_fd(customize_ctx, attempt->fd, ai->ai_family);
376  if (ret) {
377  closesocket(attempt->fd);
378  attempt->fd = -1;
379  return ret;
380  }
381  }
382 
383  while ((ret = connect(attempt->fd, ai->ai_addr, ai->ai_addrlen))) {
384  ret = ff_neterrno();
385  switch (ret) {
386  case AVERROR(EINTR):
387  if (ff_check_interrupt(&h->interrupt_callback)) {
388  closesocket(attempt->fd);
389  attempt->fd = -1;
390  return AVERROR_EXIT;
391  }
392  continue;
393  case AVERROR(EINPROGRESS):
394  case AVERROR(EAGAIN):
395  return 0;
396  default:
397  closesocket(attempt->fd);
398  attempt->fd = -1;
399  return ret;
400  }
401  }
402  return 1;
403 }
404 
405 // Try a new connection to another address after 200 ms, as suggested in
406 // RFC 8305 (or sooner if an earlier attempt fails).
407 #define NEXT_ATTEMPT_DELAY_MS 200
408 
409 int ff_connect_parallel(struct addrinfo *addrs, int timeout_ms_per_address,
410  int parallel, URLContext *h, int *fd,
411  int (*customize_fd)(void *, int, int), void *customize_ctx)
412 {
413  struct ConnectionAttempt attempts[3];
414  struct pollfd pfd[3];
415  int nb_attempts = 0, i, j;
416  int64_t next_attempt_us = av_gettime_relative(), next_deadline_us;
417  int last_err = AVERROR(EIO);
418  socklen_t optlen;
419  char errbuf[100], hostbuf[100], portbuf[20];
420 
421  if (parallel > FF_ARRAY_ELEMS(attempts))
422  parallel = FF_ARRAY_ELEMS(attempts);
423 
424  print_address_list(h, addrs, "Original list of addresses");
425  // This mutates the list, but the head of the list is still the same
426  // element, so the caller, who owns the list, doesn't need to get
427  // an updated pointer.
428  interleave_addrinfo(addrs);
429  print_address_list(h, addrs, "Interleaved list of addresses");
430 
431  while (nb_attempts > 0 || addrs) {
432  // Start a new connection attempt, if possible.
433  if (nb_attempts < parallel && addrs) {
434  getnameinfo(addrs->ai_addr, addrs->ai_addrlen,
435  hostbuf, sizeof(hostbuf), portbuf, sizeof(portbuf),
437  av_log(h, AV_LOG_VERBOSE, "Starting connection attempt to %s port %s\n",
438  hostbuf, portbuf);
439  last_err = start_connect_attempt(&attempts[nb_attempts], &addrs,
440  timeout_ms_per_address, h,
441  customize_fd, customize_ctx);
442  if (last_err < 0) {
443  av_strerror(last_err, errbuf, sizeof(errbuf));
444  av_log(h, AV_LOG_VERBOSE, "Connected attempt failed: %s\n",
445  errbuf);
446  continue;
447  }
448  if (last_err > 0) {
449  for (i = 0; i < nb_attempts; i++)
450  closesocket(attempts[i].fd);
451  *fd = attempts[nb_attempts].fd;
452  return 0;
453  }
454  pfd[nb_attempts].fd = attempts[nb_attempts].fd;
455  pfd[nb_attempts].events = POLLOUT;
456  next_attempt_us = av_gettime_relative() + NEXT_ATTEMPT_DELAY_MS * 1000;
457  nb_attempts++;
458  }
459 
460  av_assert0(nb_attempts > 0);
461  // The connection attempts are sorted from oldest to newest, so the
462  // first one will have the earliest deadline.
463  next_deadline_us = attempts[0].deadline_us;
464  // If we can start another attempt in parallel, wait until that time.
465  if (nb_attempts < parallel && addrs)
466  next_deadline_us = FFMIN(next_deadline_us, next_attempt_us);
467  last_err = ff_poll_interrupt(pfd, nb_attempts,
468  (next_deadline_us - av_gettime_relative())/1000,
469  &h->interrupt_callback);
470  if (last_err < 0 && last_err != AVERROR(ETIMEDOUT))
471  break;
472 
473  // Check the status from the poll output.
474  for (i = 0; i < nb_attempts; i++) {
475  last_err = 0;
476  if (pfd[i].revents) {
477  // Some sort of action for this socket, check its status (either
478  // a successful connection or an error).
479  optlen = sizeof(last_err);
480  if (getsockopt(attempts[i].fd, SOL_SOCKET, SO_ERROR, &last_err, &optlen))
481  last_err = ff_neterrno();
482  else if (last_err != 0)
483  last_err = AVERROR(last_err);
484  if (last_err == 0) {
485  // Everything is ok, we seem to have a successful
486  // connection. Close other sockets and return this one.
487  for (j = 0; j < nb_attempts; j++)
488  if (j != i)
489  closesocket(attempts[j].fd);
490  *fd = attempts[i].fd;
491  getnameinfo(attempts[i].addr->ai_addr, attempts[i].addr->ai_addrlen,
492  hostbuf, sizeof(hostbuf), portbuf, sizeof(portbuf),
494  av_log(h, AV_LOG_VERBOSE, "Successfully connected to %s port %s\n",
495  hostbuf, portbuf);
496  return 0;
497  }
498  }
499  if (attempts[i].deadline_us < av_gettime_relative() && !last_err)
500  last_err = AVERROR(ETIMEDOUT);
501  if (!last_err)
502  continue;
503  // Error (or timeout) for this socket; close the socket and remove
504  // it from the attempts/pfd arrays, to let a new attempt start
505  // directly.
506  getnameinfo(attempts[i].addr->ai_addr, attempts[i].addr->ai_addrlen,
507  hostbuf, sizeof(hostbuf), portbuf, sizeof(portbuf),
509  av_strerror(last_err, errbuf, sizeof(errbuf));
510  av_log(h, AV_LOG_VERBOSE, "Connection attempt to %s port %s "
511  "failed: %s\n", hostbuf, portbuf, errbuf);
512  closesocket(attempts[i].fd);
513  memmove(&attempts[i], &attempts[i + 1],
514  (nb_attempts - i - 1) * sizeof(*attempts));
515  memmove(&pfd[i], &pfd[i + 1],
516  (nb_attempts - i - 1) * sizeof(*pfd));
517  i--;
518  nb_attempts--;
519  }
520  }
521  for (i = 0; i < nb_attempts; i++)
522  closesocket(attempts[i].fd);
523  if (last_err >= 0)
524  last_err = AVERROR(ECONNREFUSED);
525  if (last_err != AVERROR_EXIT) {
526  av_strerror(last_err, errbuf, sizeof(errbuf));
527  av_log(h, AV_LOG_ERROR, "Connection to %s failed: %s\n",
528  h->filename, errbuf);
529  }
530  return last_err;
531 }
532 
533 static int match_host_pattern(const char *pattern, const char *hostname)
534 {
535  int len_p, len_h;
536  if (!strcmp(pattern, "*"))
537  return 1;
538  // Skip a possible *. at the start of the pattern
539  if (pattern[0] == '*')
540  pattern++;
541  if (pattern[0] == '.')
542  pattern++;
543  len_p = strlen(pattern);
544  len_h = strlen(hostname);
545  if (len_p > len_h)
546  return 0;
547  // Simply check if the end of hostname is equal to 'pattern'
548  if (!strcmp(pattern, &hostname[len_h - len_p])) {
549  if (len_h == len_p)
550  return 1; // Exact match
551  if (hostname[len_h - len_p - 1] == '.')
552  return 1; // The matched substring is a domain and not just a substring of a domain
553  }
554  return 0;
555 }
556 
557 int ff_http_match_no_proxy(const char *no_proxy, const char *hostname)
558 {
559  char *buf, *start;
560  int ret = 0;
561  if (!no_proxy)
562  return 0;
563  if (!hostname)
564  return 0;
565  buf = av_strdup(no_proxy);
566  if (!buf)
567  return 0;
568  start = buf;
569  while (start) {
570  char *sep, *next = NULL;
571  start += strspn(start, " ,");
572  sep = start + strcspn(start, " ,");
573  if (*sep) {
574  next = sep + 1;
575  *sep = '\0';
576  }
577  if (match_host_pattern(start, hostname)) {
578  ret = 1;
579  break;
580  }
581  start = next;
582  }
583  av_free(buf);
584  return ret;
585 }
586 
587 void ff_log_net_error(void *ctx, int level, const char* prefix)
588 {
589  char errbuf[100];
590  av_strerror(ff_neterrno(), errbuf, sizeof(errbuf));
591  av_log(ctx, level, "%s: %s\n", prefix, errbuf);
592 }
ConnectionAttempt::fd
int fd
Definition: network.c:349
ConnectionAttempt::addr
struct addrinfo * addr
Definition: network.c:351
av_gettime_relative
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
level
uint8_t level
Definition: svq3.c:204
interleave_addrinfo
static void interleave_addrinfo(struct addrinfo *base)
Definition: network.c:303
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:241
NI_NUMERICSERV
#define NI_NUMERICSERV
Definition: network.h:203
ff_poll_interrupt
static int ff_poll_interrupt(struct pollfd *p, nfds_t nfds, int timeout, AVIOInterruptCB *cb)
Definition: network.c:159
ff_gnutls_init
void ff_gnutls_init(void)
Definition: tls_gnutls.c:57
ff_log_net_error
void ff_log_net_error(void *ctx, int level, const char *prefix)
Definition: network.c:587
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
base
uint8_t base
Definition: vp3data.h:128
print_address_list
static void print_address_list(void *ctx, const struct addrinfo *addr, const char *title)
Definition: network.c:334
ff_network_close
void ff_network_close(void)
Definition: network.c:116
ConnectionAttempt::deadline_us
int64_t deadline_us
Definition: network.c:350
IN6_IS_ADDR_MULTICAST
#define IN6_IS_ADDR_MULTICAST(a)
Definition: network.h:244
ff_network_init
int ff_network_init(void)
Definition: network.c:58
ff_tls_init
int ff_tls_init(void)
Definition: network.c:31
AVIOInterruptCB
Callback for checking whether to abort blocking functions.
Definition: avio.h:59
AVUNERROR
#define AVUNERROR(e)
Definition: error.h:46
ff_gnutls_deinit
void ff_gnutls_deinit(void)
Definition: tls_gnutls.c:68
ff_openssl_deinit
void ff_openssl_deinit(void)
Definition: tls_openssl.c:106
av_strerror
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:108
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
ff_check_interrupt
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
Definition: avio.c:667
ff_listen_bind
int ff_listen_bind(int fd, const struct sockaddr *addr, socklen_t addrlen, int timeout, URLContext *h)
Bind to a file descriptor and poll for a connection.
Definition: network.c:246
ff_openssl_init
int ff_openssl_init(void)
Definition: tls_openssl.c:69
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
customize_fd
static int customize_fd(void *ctx, int fd, int family)
Definition: tcp.c:77
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_usleep
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
ff_http_match_no_proxy
int ff_http_match_no_proxy(const char *no_proxy, const char *hostname)
Definition: network.c:557
NULL
#define NULL
Definition: coverity.c:32
ff_is_multicast_address
int ff_is_multicast_address(struct sockaddr *addr)
Definition: network.c:145
ff_listen_connect
int ff_listen_connect(int fd, const struct sockaddr *addr, socklen_t addrlen, int timeout, URLContext *h, int will_try_next)
Connect to a file descriptor and poll for result.
Definition: network.c:258
ff_network_wait_fd_timeout
int ff_network_wait_fd_timeout(int fd, int write, int64_t timeout, AVIOInterruptCB *int_cb)
This works similarly to ff_network_wait_fd, but waits up to 'timeout' microseconds Uses ff_network_wa...
Definition: network.c:78
time.h
ff_neterrno
#define ff_neterrno()
Definition: network.h:68
addrinfo::ai_addr
struct sockaddr * ai_addr
Definition: network.h:143
addrinfo::ai_family
int ai_family
Definition: network.h:139
NI_NUMERICHOST
#define NI_NUMERICHOST
Definition: network.h:195
ff_accept
int ff_accept(int fd, int timeout, URLContext *h)
Poll for a single connection on the passed file descriptor.
Definition: network.c:228
addrinfo::ai_protocol
int ai_protocol
Definition: network.h:141
ff_socket_nonblock
int ff_socket_nonblock(int socket, int enable)
addrinfo::ai_next
struct addrinfo * ai_next
Definition: network.h:145
addrinfo::ai_addrlen
int ai_addrlen
Definition: network.h:142
URLContext
Definition: url.h:37
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
ff_network_sleep_interruptible
int ff_network_sleep_interruptible(int64_t timeout, AVIOInterruptCB *int_cb)
Waits for up to 'timeout' microseconds.
Definition: network.c:98
getnameinfo
#define getnameinfo
Definition: network.h:219
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
url.h
int_cb
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:324
ConnectionAttempt
Definition: network.c:348
ff_connect_parallel
int ff_connect_parallel(struct addrinfo *addrs, int timeout_ms_per_address, int parallel, URLContext *h, int *fd, int(*customize_fd)(void *, int, int), void *customize_ctx)
Connect to any of the given addrinfo addresses, with multiple attempts running in parallel.
Definition: network.c:409
ff_tls_deinit
void ff_tls_deinit(void)
Definition: network.c:46
ret
ret
Definition: filter_design.txt:187
addrinfo::ai_socktype
int ai_socktype
Definition: network.h:140
network.h
ff_listen
int ff_listen(int fd, const struct sockaddr *addr, socklen_t addrlen, void *logctx)
Bind to a file descriptor to an address without accepting connections.
Definition: network.c:210
tls.h
IN_MULTICAST
#define IN_MULTICAST(a)
Definition: network.h:241
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
mem.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
POLLING_TIME
#define POLLING_TIME
Definition: network.h:249
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2038
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
ff_socket
int ff_socket(int af, int type, int proto, void *logctx)
Definition: network.c:183
addrinfo
Definition: network.h:137
NEXT_ATTEMPT_DELAY_MS
#define NEXT_ATTEMPT_DELAY_MS
Definition: network.c:407
int
int
Definition: ffmpeg_filter.c:424
match_host_pattern
static int match_host_pattern(const char *pattern, const char *hostname)
Definition: network.c:533
start_connect_attempt
static int start_connect_attempt(struct ConnectionAttempt *attempt, struct addrinfo **ptr, int timeout_ms, URLContext *h, int(*customize_fd)(void *, int, int), void *customize_ctx)
Definition: network.c:356
ff_network_wait_fd
int ff_network_wait_fd(int fd, int write)
Definition: network.c:69