FFmpeg: libavformat/network.c Source File

FFmpeg
Loading...
Searching...
No Matches
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 <string.h>
22
23#include "config.h"
24#include "config_components.h"
25#include "libavutil/attributes.h"
26
27#if CONFIG_TLS_PROTOCOL && CONFIG_OPENSSL
28#include <openssl/opensslv.h>
29#endif
30
31#include <fcntl.h>
32#include "network.h"
33#include "tls.h"
34#include "url.h"
35#include "libavutil/avassert.h"
36#include "libavutil/mem.h"
37#include "libavutil/time.h"
38
39 int ff_tls_init(void)
40{
41#if CONFIG_TLS_PROTOCOL
42#if CONFIG_GNUTLS
44#endif
45#endif
46 return 0;
47}
48
49 void ff_tls_deinit(void)
50{
51#if CONFIG_TLS_PROTOCOL
52#if CONFIG_GNUTLS
54#endif
55#endif
56}
57
58/**
59 * Initialize the network subsystem. On Windows, this calls WSAStartup().
60 *
61 * @return 0 on success, a negative AVERROR code on failure.
62 */
64{
65#if HAVE_WINSOCK2_H
66 WSADATA wsaData;
67
68 if (WSAStartup(MAKEWORD(1,1), &wsaData))
69 return AVERROR(EIO);
70#endif
71 return 0;
72}
73
74 int ff_network_wait_fd(int fd, int write)
75{
76 int ev = write ? POLLOUT : POLLIN;
77 struct pollfd p = { .fd = fd, .events = ev, .revents = 0 };
78 int ret;
79 ret = poll(&p, 1, POLLING_TIME);
80 return ret < 0 ? ff_neterrno() : p.revents & (ev | POLLERR | POLLHUP) ? 0 : AVERROR(EAGAIN);
81}
82
83 int ff_network_wait_fd_timeout(int fd, int write, int64_t timeout, AVIOInterruptCB *int_cb)
84{
85 int ret;
86 int64_t wait_start = 0;
87
88 while (1) {
90 return AVERROR_EXIT;
91 ret = ff_network_wait_fd(fd, write);
92 if (ret != AVERROR(EAGAIN))
93 return ret;
94 if (timeout > 0) {
95 if (!wait_start)
96 wait_start = av_gettime_relative();
97 else if (av_gettime_relative() - wait_start > timeout)
98 return AVERROR(ETIMEDOUT);
99 }
100 }
101}
102
104{
105 int64_t wait_start = av_gettime_relative();
106
107 while (1) {
108 int64_t time_left;
109
111 return AVERROR_EXIT;
112
113 time_left = timeout - (av_gettime_relative() - wait_start);
114 if (time_left <= 0)
115 return AVERROR(ETIMEDOUT);
116
117 av_usleep(FFMIN(time_left, POLLING_TIME * 1000));
118 }
119}
120
122{
123#if HAVE_WINSOCK2_H
124 WSACleanup();
125#endif
126}
127
128#if HAVE_WINSOCK2_H
129int ff_neterrno(void)
130{
131 int err = WSAGetLastError();
132 switch (err) {
133 case WSAEWOULDBLOCK:
134 return AVERROR(EAGAIN);
135 case WSAEINTR:
136 return AVERROR(EINTR);
137 case WSAEPROTONOSUPPORT:
138 return AVERROR(EPROTONOSUPPORT);
139 case WSAETIMEDOUT:
140 return AVERROR(ETIMEDOUT);
141 case WSAECONNREFUSED:
142 return AVERROR(ECONNREFUSED);
143 case WSAEINPROGRESS:
144 return AVERROR(EINPROGRESS);
145 }
146 return -err;
147}
148#endif
149
150 int ff_is_multicast_address(struct sockaddr *addr)
151{
152 if (addr->sa_family == AF_INET) {
153 return IN_MULTICAST(ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr));
154 }
155#if HAVE_STRUCT_SOCKADDR_IN6
156 if (addr->sa_family == AF_INET6) {
157 return IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6 *)addr)->sin6_addr);
158 }
159#endif
160
161 return 0;
162}
163
164 static int ff_poll_interrupt(struct pollfd *p, nfds_t nfds, int timeout,
166{
167 int runs = timeout / POLLING_TIME;
168 int ret = 0;
169
170 do {
172 return AVERROR_EXIT;
173 ret = poll(p, nfds, POLLING_TIME);
174 if (ret != 0) {
175 if (ret < 0)
176 ret = ff_neterrno();
177 if (ret == AVERROR(EINTR))
178 continue;
179 break;
180 }
181 } while (timeout <= 0 || runs-- > 0);
182
183 if (!ret)
184 return AVERROR(ETIMEDOUT);
185 return ret;
186}
187
188 int ff_socket(int af, int type, int proto, void *logctx)
189{
190 int fd;
191
192#ifdef SOCK_CLOEXEC
193 fd = socket(af, type | SOCK_CLOEXEC, proto);
194 if (fd == -1 && errno == EINVAL)
195#endif
196 {
197 fd = socket(af, type, proto);
198#if HAVE_FCNTL
199 if (fd != -1) {
200 if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
201 av_log(logctx, AV_LOG_DEBUG, "Failed to set close on exec\n");
202 }
203#endif
204 }
205#ifdef SO_NOSIGPIPE
206 if (fd != -1) {
207 if (setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &(int){1}, sizeof(int))) {
208 av_log(logctx, AV_LOG_WARNING, "setsockopt(SO_NOSIGPIPE) failed\n");
209 }
210 }
211#endif
212 return fd;
213}
214
215 int ff_listen(int fd, const struct sockaddr *addr,
216 socklen_t addrlen, void *logctx)
217{
218 int ret;
219 int reuse = 1;
220 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse))) {
221 av_log(logctx, AV_LOG_WARNING, "setsockopt(SO_REUSEADDR) failed\n");
222 }
223 ret = bind(fd, addr, addrlen);
224 if (ret)
225 return ff_neterrno();
226
227 ret = listen(fd, 1);
228 if (ret)
229 return ff_neterrno();
230 return ret;
231}
232
233 int ff_accept(int fd, int timeout, URLContext *h)
234{
235 int ret;
236 struct pollfd lp = { fd, POLLIN, 0 };
237
238 ret = ff_poll_interrupt(&lp, 1, timeout, &h->interrupt_callback);
239 if (ret < 0)
240 return ret;
241
242 ret = accept(fd, NULL, NULL);
243 if (ret < 0)
244 return ff_neterrno();
245 if (ff_socket_nonblock(ret, 1) < 0)
246 av_log(h, AV_LOG_DEBUG, "ff_socket_nonblock failed\n");
247
248 return ret;
249}
250
251 int ff_listen_bind(int fd, const struct sockaddr *addr,
252 socklen_t addrlen, int timeout, URLContext *h)
253{
254 int ret;
255 if ((ret = ff_listen(fd, addr, addrlen, h)) < 0)
256 return ret;
257 if ((ret = ff_accept(fd, timeout, h)) < 0)
258 return ret;
259 closesocket(fd);
260 return ret;
261}
262
263 int ff_listen_connect(int fd, const struct sockaddr *addr,
264 socklen_t addrlen, int timeout, URLContext *h,
265 int will_try_next)
266{
267 struct pollfd p = {fd, POLLOUT, 0};
268 int ret;
269 socklen_t optlen;
270
271 if (ff_socket_nonblock(fd, 1) < 0)
272 av_log(h, AV_LOG_DEBUG, "ff_socket_nonblock failed\n");
273
274 while ((ret = connect(fd, addr, addrlen))) {
275 ret = ff_neterrno();
276 switch (ret) {
277 case AVERROR(EINTR):
278 if (ff_check_interrupt(&h->interrupt_callback))
279 return AVERROR_EXIT;
280 continue;
281 case AVERROR(EINPROGRESS):
282 case AVERROR(EAGAIN):
283 ret = ff_poll_interrupt(&p, 1, timeout, &h->interrupt_callback);
284 if (ret < 0)
285 return ret;
286 optlen = sizeof(ret);
287 if (getsockopt (fd, SOL_SOCKET, SO_ERROR, &ret, &optlen))
288 ret = AVUNERROR(ff_neterrno());
289 if (ret != 0) {
290 ret = AVERROR(ret);
291 if (will_try_next)
293 "Connection to %s failed (%s), trying next address\n",
294 h->filename, av_err2str(ret));
295 else
296 av_log(h, AV_LOG_ERROR, "Connection to %s failed: %s\n",
297 h->filename, av_err2str(ret));
298 }
300 default:
301 return ret;
302 }
303 }
304 return ret;
305}
306
307 static void interleave_addrinfo(struct addrinfo *base)
308{
309 struct addrinfo **next = &base->ai_next;
310 while (*next) {
311 struct addrinfo *cur = *next;
312 // Iterate forward until we find an entry of a different family.
313 if (cur->ai_family == base->ai_family) {
314 next = &cur->ai_next;
315 continue;
316 }
317 if (cur == base->ai_next) {
318 // If the first one following base is of a different family, just
319 // move base forward one step and continue.
320 base = cur;
321 next = &base->ai_next;
322 continue;
323 }
324 // Unchain cur from the rest of the list from its current spot.
325 *next = cur->ai_next;
326 // Hook in cur directly after base.
327 cur->ai_next = base->ai_next;
328 base->ai_next = cur;
329 // Restart with a new base. We know that before moving the cur element,
330 // everything between the previous base and cur had the same family,
331 // different from cur->ai_family. Therefore, we can keep next pointing
332 // where it was, and continue from there with base at the one after
333 // cur.
334 base = cur->ai_next;
335 }
336}
337
338 static void print_address_list(void *ctx, const struct addrinfo *addr,
339 const char *title)
340{
341 char hostbuf[100], portbuf[20];
342 av_log(ctx, AV_LOG_DEBUG, "%s:\n", title);
343 while (addr) {
344 getnameinfo(addr->ai_addr, addr->ai_addrlen,
345 hostbuf, sizeof(hostbuf), portbuf, sizeof(portbuf),
347 av_log(ctx, AV_LOG_DEBUG, "Address %s port %s\n", hostbuf, portbuf);
348 addr = addr->ai_next;
349 }
350}
351
357
358// Returns < 0 on error, 0 on successfully started connection attempt,
359// > 0 for a connection that succeeded already.
360 static int start_connect_attempt(struct ConnectionAttempt *attempt,
361 struct addrinfo **ptr, int timeout_ms,
362 URLContext *h,
363 int (*customize_fd)(void *, int, int), void *customize_ctx)
364{
365 struct addrinfo *ai = *ptr;
366 int ret;
367
368 *ptr = ai->ai_next;
369
370 attempt->fd = ff_socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol, h);
371 if (attempt->fd < 0)
372 return ff_neterrno();
373 attempt->deadline_us = av_gettime_relative() + timeout_ms * 1000;
374 attempt->addr = ai;
375
376 ff_socket_nonblock(attempt->fd, 1);
377
378 if (customize_fd) {
379 ret = customize_fd(customize_ctx, attempt->fd, ai->ai_family);
380 if (ret) {
381 closesocket(attempt->fd);
382 attempt->fd = -1;
383 return ret;
384 }
385 }
386
387 while ((ret = connect(attempt->fd, ai->ai_addr, ai->ai_addrlen))) {
388 ret = ff_neterrno();
389 switch (ret) {
390 case AVERROR(EINTR):
391 if (ff_check_interrupt(&h->interrupt_callback)) {
392 closesocket(attempt->fd);
393 attempt->fd = -1;
394 return AVERROR_EXIT;
395 }
396 continue;
397 case AVERROR(EINPROGRESS):
398 case AVERROR(EAGAIN):
399 return 0;
400 default:
401 closesocket(attempt->fd);
402 attempt->fd = -1;
403 return ret;
404 }
405 }
406 return 1;
407}
408
409// Try a new connection to another address after 200 ms, as suggested in
410// RFC 8305 (or sooner if an earlier attempt fails).
411 #define NEXT_ATTEMPT_DELAY_MS 200
412
413 int ff_connect_parallel(struct addrinfo *addrs, int timeout_ms_per_address,
414 int parallel, URLContext *h, int *fd,
415 int (*customize_fd)(void *, int, int), void *customize_ctx)
416{
417 struct ConnectionAttempt attempts[3];
418 struct pollfd pfd[3];
419 int nb_attempts = 0, i, j;
420 int64_t next_attempt_us = av_gettime_relative(), next_deadline_us;
421 int last_err = AVERROR(EIO);
422 socklen_t optlen;
423 char hostbuf[100], portbuf[20];
424
425 if (parallel > FF_ARRAY_ELEMS(attempts))
426 parallel = FF_ARRAY_ELEMS(attempts);
427
428 print_address_list(h, addrs, "Original list of addresses");
429 // This mutates the list, but the head of the list is still the same
430 // element, so the caller, who owns the list, doesn't need to get
431 // an updated pointer.
432 interleave_addrinfo(addrs);
433 print_address_list(h, addrs, "Interleaved list of addresses");
434
435 while (nb_attempts > 0 || addrs) {
436 // Start a new connection attempt, if possible.
437 if (nb_attempts < parallel && addrs) {
438 getnameinfo(addrs->ai_addr, addrs->ai_addrlen,
439 hostbuf, sizeof(hostbuf), portbuf, sizeof(portbuf),
441 av_log(h, AV_LOG_VERBOSE, "Starting connection attempt to %s port %s\n",
442 hostbuf, portbuf);
443 last_err = start_connect_attempt(&attempts[nb_attempts], &addrs,
444 timeout_ms_per_address, h,
445 customize_fd, customize_ctx);
446 if (last_err < 0) {
447 av_log(h, AV_LOG_VERBOSE, "Connected attempt failed: %s\n",
448 av_err2str(last_err));
449 continue;
450 }
451 if (last_err > 0) {
452 for (i = 0; i < nb_attempts; i++)
453 closesocket(attempts[i].fd);
454 *fd = attempts[nb_attempts].fd;
455 return 0;
456 }
457 pfd[nb_attempts].fd = attempts[nb_attempts].fd;
458 pfd[nb_attempts].events = POLLOUT;
459 next_attempt_us = av_gettime_relative() + NEXT_ATTEMPT_DELAY_MS * 1000;
460 nb_attempts++;
461 }
462
463 av_assert0(nb_attempts > 0);
464 // The connection attempts are sorted from oldest to newest, so the
465 // first one will have the earliest deadline.
466 next_deadline_us = attempts[0].deadline_us;
467 // If we can start another attempt in parallel, wait until that time.
468 if (nb_attempts < parallel && addrs)
469 next_deadline_us = FFMIN(next_deadline_us, next_attempt_us);
470 last_err = ff_poll_interrupt(pfd, nb_attempts,
471 (next_deadline_us - av_gettime_relative())/1000,
472 &h->interrupt_callback);
473 if (last_err < 0 && last_err != AVERROR(ETIMEDOUT))
474 break;
475
476 // Check the status from the poll output.
477 for (i = 0; i < nb_attempts; i++) {
478 last_err = 0;
479 if (pfd[i].revents) {
480 // Some sort of action for this socket, check its status (either
481 // a successful connection or an error).
482 optlen = sizeof(last_err);
483 if (getsockopt(attempts[i].fd, SOL_SOCKET, SO_ERROR, &last_err, &optlen))
484 last_err = ff_neterrno();
485 else if (last_err != 0)
486 last_err = AVERROR(last_err);
487 if (last_err == 0) {
488 // Everything is ok, we seem to have a successful
489 // connection. Close other sockets and return this one.
490 for (j = 0; j < nb_attempts; j++)
491 if (j != i)
492 closesocket(attempts[j].fd);
493 *fd = attempts[i].fd;
494 getnameinfo(attempts[i].addr->ai_addr, attempts[i].addr->ai_addrlen,
495 hostbuf, sizeof(hostbuf), portbuf, sizeof(portbuf),
497 av_log(h, AV_LOG_VERBOSE, "Successfully connected to %s port %s\n",
498 hostbuf, portbuf);
499 return 0;
500 }
501 }
502 if (attempts[i].deadline_us < av_gettime_relative() && !last_err)
503 last_err = AVERROR(ETIMEDOUT);
504 if (!last_err)
505 continue;
506 // Error (or timeout) for this socket; close the socket and remove
507 // it from the attempts/pfd arrays, to let a new attempt start
508 // directly.
509 getnameinfo(attempts[i].addr->ai_addr, attempts[i].addr->ai_addrlen,
510 hostbuf, sizeof(hostbuf), portbuf, sizeof(portbuf),
512 av_log(h, AV_LOG_VERBOSE, "Connection attempt to %s port %s "
513 "failed: %s\n", hostbuf, portbuf, av_err2str(last_err));
514 closesocket(attempts[i].fd);
515 memmove(&attempts[i], &attempts[i + 1],
516 (nb_attempts - i - 1) * sizeof(*attempts));
517 memmove(&pfd[i], &pfd[i + 1],
518 (nb_attempts - i - 1) * sizeof(*pfd));
519 i--;
520 nb_attempts--;
521 }
522 }
523 for (i = 0; i < nb_attempts; i++)
524 closesocket(attempts[i].fd);
525 if (last_err >= 0)
526 last_err = AVERROR(ECONNREFUSED);
527 if (last_err != AVERROR_EXIT) {
528 av_log(h, AV_LOG_ERROR, "Connection to %s failed: %s\n",
529 h->filename, av_err2str(last_err));
530 }
531 return last_err;
532}
533
534 static int match_host_pattern(const char *pattern, const char *hostname)
535{
536 int len_p, len_h;
537 if (!strcmp(pattern, "*"))
538 return 1;
539 // Skip a possible *. at the start of the pattern
540 if (pattern[0] == '*')
541 pattern++;
542 if (pattern[0] == '.')
543 pattern++;
544 len_p = strlen(pattern);
545 len_h = strlen(hostname);
546 if (len_p > len_h)
547 return 0;
548 // Simply check if the end of hostname is equal to 'pattern'
549 if (!strcmp(pattern, &hostname[len_h - len_p])) {
550 if (len_h == len_p)
551 return 1; // Exact match
552 if (hostname[len_h - len_p - 1] == '.')
553 return 1; // The matched substring is a domain and not just a substring of a domain
554 }
555 return 0;
556}
557
558 int ff_http_match_no_proxy(const char *no_proxy, const char *hostname)
559{
560 char *buf, *start;
561 int ret = 0;
562 if (!no_proxy)
563 return 0;
564 if (!hostname)
565 return 0;
566 buf = av_strdup(no_proxy);
567 if (!buf)
568 return 0;
569 start = buf;
570 while (start) {
571 char *sep, *next = NULL;
572 start += strspn(start, " ,");
573 sep = start + strcspn(start, " ,");
574 if (*sep) {
575 next = sep + 1;
576 *sep = '0円';
577 }
578 if (match_host_pattern(start, hostname)) {
579 ret = 1;
580 break;
581 }
582 start = next;
583 }
584 av_free(buf);
585 return ret;
586}
587
588 void ff_log_net_error(void *ctx, int level, const char* prefix)
589{
590 av_log(ctx, level, "%s: %s\n", prefix, av_err2str(ff_neterrno()));
591}
static AVFormatContext * ctx
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition avassert.h:42
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
Definition avio.c:922
i
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
#define NULL
Definition coverity.c:32
long long int64_t
Definition coverity.c:34
const AVIOInterruptCB int_cb
Definition ffmpeg.c:322
#define AVUNERROR(e)
Definition error.h:46
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition error.h:58
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition error.h:122
#define AVERROR(e)
Definition error.h:45
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition log.h:231
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition log.h:216
#define AV_LOG_VERBOSE
Detailed information.
Definition log.h:226
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
cl_device_type type
Macro definitions for various function/variable attributes.
#define av_fallthrough
Definition attributes.h:67
#define FFMIN(a, b)
Definition macros.h:49
Memory handling functions.
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:413
int ff_is_multicast_address(struct sockaddr *addr)
Definition network.c:150
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:360
int ff_socket(int af, int type, int proto, void *logctx)
Definition network.c:188
int ff_network_sleep_interruptible(int64_t timeout, AVIOInterruptCB *int_cb)
Waits for up to 'timeout' microseconds.
Definition network.c:103
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:215
void ff_log_net_error(void *ctx, int level, const char *prefix)
Definition network.c:588
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:263
static void print_address_list(void *ctx, const struct addrinfo *addr, const char *title)
Definition network.c:338
static void interleave_addrinfo(struct addrinfo *base)
Definition network.c:307
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:251
static int ff_poll_interrupt(struct pollfd *p, nfds_t nfds, int timeout, AVIOInterruptCB *cb)
Definition network.c:164
int ff_network_wait_fd(int fd, int write)
Definition network.c:74
int ff_network_init(void)
Initialize the network subsystem.
Definition network.c:63
static int match_host_pattern(const char *pattern, const char *hostname)
Definition network.c:534
int ff_tls_init(void)
Definition network.c:39
#define NEXT_ATTEMPT_DELAY_MS
Definition network.c:411
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:83
void ff_network_close(void)
Definition network.c:121
void ff_tls_deinit(void)
Definition network.c:49
int ff_http_match_no_proxy(const char *no_proxy, const char *hostname)
Definition network.c:558
int ff_accept(int fd, int timeout, URLContext *h)
Poll for a single connection on the passed file descriptor.
Definition network.c:233
int ff_socket_nonblock(int socket, int enable)
#define POLLING_TIME
Definition network.h:249
#define NI_NUMERICHOST
Definition network.h:195
#define ff_neterrno()
Definition network.h:68
#define IN_MULTICAST(a)
Definition network.h:241
#define getnameinfo
Definition network.h:219
#define IN6_IS_ADDR_MULTICAST(a)
Definition network.h:244
#define NI_NUMERICSERV
Definition network.h:203
#define av_strdup(s)
Definition ops_static.c:55
#define FF_ARRAY_ELEMS(a)
Callback for checking whether to abort blocking functions.
Definition avio.h:59
int64_t deadline_us
Definition network.c:354
struct addrinfo * addr
Definition network.c:355
Definition url.h:35
struct sockaddr * ai_addr
Definition network.h:143
int ai_socktype
Definition network.h:140
int ai_protocol
Definition network.h:141
int ai_addrlen
Definition network.h:142
struct addrinfo * ai_next
Definition network.h:145
int ai_family
Definition network.h:139
uint8_t level
Definition svq3.c:208
#define av_free(p)
#define av_log(a,...)
static int customize_fd(void *ctx, int fd, int family)
Definition tcp.c:80
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition time.c:93
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition time.c:57
void ff_gnutls_deinit(void)
Definition tls_gnutls.c:359
void ff_gnutls_init(void)
Definition tls_gnutls.c:348
char prefix[8]
unbuffered private I/O API
static double cb(void *priv, double x, double y)
Definition vf_geq.c:247
uint8_t base
Definition vp3data.h:128
h
h
Generated on Sun Sep 6 2026 19:21:08 for FFmpeg by doxygen 1.13.2

AltStyle によって変換されたページ (->オリジナル) /