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  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, 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  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),
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),
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),
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 }
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:206
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:239
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:581
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
base
uint8_t base
Definition: vp3data.h:141
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:658
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
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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
start_connect_attempt
static int start_connect_attempt(struct ConnectionAttempt *attempt, struct addrinfo **ptr, int timeout_ms, URLContext *h, void(*customize_fd)(void *, int), void *customize_ctx)
Definition: network.c:356
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:551
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:269
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
ff_connect_parallel
int ff_connect_parallel(struct addrinfo *addrs, int timeout_ms_per_address, int parallel, URLContext *h, int *fd, void(*customize_fd)(void *, int), void *customize_ctx)
Connect to any of the given addrinfo addresses, with multiple attempts running in parallel.
Definition: network.c:403
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
url.h
int_cb
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:512
ConnectionAttempt
Definition: network.c:348
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:280
mem.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
POLLING_TIME
#define POLLING_TIME
Definition: network.h:249
customize_fd
static void customize_fd(void *ctx, int fd)
Definition: tcp.c:73
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:401
int
int
Definition: ffmpeg_filter.c:153
match_host_pattern
static int match_host_pattern(const char *pattern, const char *hostname)
Definition: network.c:527
ff_network_wait_fd
int ff_network_wait_fd(int fd, int write)
Definition: network.c:69