FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavformat/udp.c
Date: 2025-10-10 03:51:19
Exec Total Coverage
Lines: 0 503 0.0%
Functions: 0 19 0.0%
Branches: 0 321 0.0%

Line Branch Exec Source
1 /*
2 * UDP prototype streaming system
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /**
23 * @file
24 * UDP protocol
25 */
26
27 #define _DEFAULT_SOURCE
28 #define _BSD_SOURCE /* Needed for using struct ip_mreq with recent glibc */
29
30 #include "avformat.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/mem.h"
33 #include "libavutil/parseutils.h"
34 #include "libavutil/fifo.h"
35 #include "libavutil/intreadwrite.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/log.h"
38 #include "libavutil/time.h"
39 #include "internal.h"
40 #include "network.h"
41 #include "os_support.h"
42 #include "url.h"
43 #include "ip.h"
44
45 #ifdef __APPLE__
46 #include "TargetConditionals.h"
47 #endif
48
49 #if HAVE_UDPLITE_H
50 #include "udplite.h"
51 #else
52 /* On many Linux systems, udplite.h is missing but the kernel supports UDP-Lite.
53 * So, we provide a fallback here.
54 */
55 #define UDPLITE_SEND_CSCOV 10
56 #define UDPLITE_RECV_CSCOV 11
57 #endif
58
59 #ifndef IPPROTO_UDPLITE
60 #define IPPROTO_UDPLITE 136
61 #endif
62
63 #if HAVE_W32THREADS
64 #undef HAVE_PTHREAD_CANCEL
65 #define HAVE_PTHREAD_CANCEL 1
66 #endif
67
68 #if HAVE_PTHREAD_CANCEL
69 #include "libavutil/thread.h"
70 #endif
71
72 #ifndef IPV6_ADD_MEMBERSHIP
73 #define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
74 #define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
75 #endif
76
77 #define UDP_TX_BUF_SIZE 32768
78 #define UDP_RX_BUF_SIZE 393216
79 #define UDP_MAX_PKT_SIZE 65536
80 #define UDP_HEADER_SIZE 8
81
82 typedef struct UDPQueuedPacketHeader {
83 int pkt_size;
84 struct sockaddr_storage addr;
85 socklen_t addr_len;
86 } UDPQueuedPacketHeader;
87
88 typedef struct UDPContext {
89 const AVClass *class;
90 int udp_fd;
91 int ttl;
92 int udplite_coverage;
93 int buffer_size;
94 int pkt_size;
95 int is_multicast;
96 int is_broadcast;
97 int local_port;
98 int reuse_socket;
99 int overrun_nonfatal;
100 struct sockaddr_storage dest_addr;
101 int dest_addr_len;
102 int is_connected;
103
104 /* Circular Buffer variables for use in UDP receive code */
105 int circular_buffer_size;
106 AVFifo *rx_fifo;
107 AVFifo *tx_fifo;
108 int circular_buffer_error;
109 int64_t bitrate; /* number of bits to send per second */
110 int64_t burst_bits;
111 int close_req;
112 #if HAVE_PTHREAD_CANCEL
113 pthread_t circular_buffer_thread;
114 pthread_mutex_t mutex;
115 pthread_cond_t cond;
116 int thread_started;
117 #endif
118 uint8_t tmp[UDP_MAX_PKT_SIZE + sizeof(UDPQueuedPacketHeader)];
119 int remaining_in_dg;
120 char *localaddr;
121 int timeout;
122 int dscp;
123 struct sockaddr_storage local_addr_storage;
124 char *sources;
125 char *block;
126 IPSourceFilters filters;
127 struct sockaddr_storage last_recv_addr;
128 socklen_t last_recv_addr_len;
129 } UDPContext;
130
131 #define OFFSET(x) offsetof(UDPContext, x)
132 #define D AV_OPT_FLAG_DECODING_PARAM
133 #define E AV_OPT_FLAG_ENCODING_PARAM
134 static const AVOption options[] = {
135 { "buffer_size", "System data size (in bytes)", OFFSET(buffer_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
136 { "bitrate", "Bits to send per second", OFFSET(bitrate), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, .flags = E },
137 { "burst_bits", "Max length of bursts in bits (when using bitrate)", OFFSET(burst_bits), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, .flags = E },
138 { "localport", "Local port", OFFSET(local_port), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, D|E },
139 { "local_port", "Local port", OFFSET(local_port), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
140 { "localaddr", "Local address", OFFSET(localaddr), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },
141 { "udplite_coverage", "choose UDPLite head size which should be validated by checksum", OFFSET(udplite_coverage), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, D|E },
142 { "pkt_size", "Maximum UDP packet size", OFFSET(pkt_size), AV_OPT_TYPE_INT, { .i64 = 1472 }, -1, INT_MAX, .flags = D|E },
143 { "reuse", "explicitly allow reusing UDP sockets", OFFSET(reuse_socket), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, D|E },
144 { "reuse_socket", "explicitly allow reusing UDP sockets", OFFSET(reuse_socket), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, .flags = D|E },
145 { "broadcast", "explicitly allow or disallow broadcast destination", OFFSET(is_broadcast), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
146 { "ttl", "Time to live (multicast only)", OFFSET(ttl), AV_OPT_TYPE_INT, { .i64 = 16 }, 0, 255, E },
147 { "dscp", "DSCP class for outgoing packets", OFFSET(dscp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 63, E },
148 { "connect", "set if connect() should be called on socket", OFFSET(is_connected), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = D|E },
149 { "fifo_size", "set the UDP circular buffer size (in 188-byte packets)", OFFSET(circular_buffer_size), AV_OPT_TYPE_INT, {.i64 = HAVE_PTHREAD_CANCEL ? 7*4096 : 0}, 0, INT_MAX, D },
150 { "overrun_nonfatal", "survive in case of UDP receiving circular buffer overrun", OFFSET(overrun_nonfatal), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, D },
151 { "timeout", "set raise error timeout, in microseconds (only in read mode)",OFFSET(timeout), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, D },
152 { "sources", "Source list", OFFSET(sources), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },
153 { "block", "Block list", OFFSET(block), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },
154 { NULL }
155 };
156
157 static const AVClass udp_class = {
158 .class_name = "udp",
159 .item_name = av_default_item_name,
160 .option = options,
161 .version = LIBAVUTIL_VERSION_INT,
162 };
163
164 static const AVClass udplite_context_class = {
165 .class_name = "udplite",
166 .item_name = av_default_item_name,
167 .option = options,
168 .version = LIBAVUTIL_VERSION_INT,
169 };
170
171 static int udp_set_multicast_ttl(int sockfd, int mcastTTL,
172 struct sockaddr *addr,
173 void *logctx)
174 {
175 int protocol, cmd;
176
177 /* There is some confusion in the world whether IP_MULTICAST_TTL
178 * takes a byte or an int as an argument.
179 * BSD seems to indicate byte so we are going with that and use
180 * int and fall back to byte to be safe */
181 switch (addr->sa_family) {
182 #ifdef IP_MULTICAST_TTL
183 case AF_INET:
184 protocol = IPPROTO_IP;
185 cmd = IP_MULTICAST_TTL;
186 break;
187 #endif
188 #ifdef IPV6_MULTICAST_HOPS
189 case AF_INET6:
190 protocol = IPPROTO_IPV6;
191 cmd = IPV6_MULTICAST_HOPS;
192 break;
193 #endif
194 default:
195 return 0;
196 }
197
198 if (setsockopt(sockfd, protocol, cmd, &mcastTTL, sizeof(mcastTTL)) < 0) {
199 /* BSD compatibility */
200 unsigned char ttl = (unsigned char) mcastTTL;
201
202 ff_log_net_error(logctx, AV_LOG_DEBUG, "setsockopt(IPV4/IPV6 MULTICAST TTL)");
203 if (setsockopt(sockfd, protocol, cmd, &ttl, sizeof(ttl)) < 0) {
204 ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IPV4/IPV6 MULTICAST TTL)");
205 return ff_neterrno();
206 }
207 }
208
209 return 0;
210 }
211
212 static int udp_join_multicast_group(int sockfd, struct sockaddr *addr,
213 struct sockaddr *local_addr, void *logctx)
214 {
215 #ifdef IP_ADD_MEMBERSHIP
216 if (addr->sa_family == AF_INET) {
217 struct ip_mreq mreq;
218
219 mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
220 if (local_addr)
221 mreq.imr_interface= ((struct sockaddr_in *)local_addr)->sin_addr;
222 else
223 mreq.imr_interface.s_addr = INADDR_ANY;
224 if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {
225 ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IP_ADD_MEMBERSHIP)");
226 return ff_neterrno();
227 }
228 }
229 #endif
230 #if HAVE_STRUCT_IPV6_MREQ && defined(IPPROTO_IPV6)
231 if (addr->sa_family == AF_INET6) {
232 struct ipv6_mreq mreq6;
233
234 memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
235 //TODO: Interface index should be looked up from local_addr
236 mreq6.ipv6mr_interface = 0;
237 if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
238 ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IPV6_ADD_MEMBERSHIP)");
239 return ff_neterrno();
240 }
241 }
242 #endif
243 return 0;
244 }
245
246 static int udp_leave_multicast_group(int sockfd, struct sockaddr *addr,
247 struct sockaddr *local_addr, void *logctx)
248 {
249 #ifdef IP_DROP_MEMBERSHIP
250 if (addr->sa_family == AF_INET) {
251 struct ip_mreq mreq;
252
253 mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
254 if (local_addr)
255 mreq.imr_interface = ((struct sockaddr_in *)local_addr)->sin_addr;
256 else
257 mreq.imr_interface.s_addr = INADDR_ANY;
258 if (setsockopt(sockfd, IPPROTO_IP, IP_DROP_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {
259 ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IP_DROP_MEMBERSHIP)");
260 return -1;
261 }
262 }
263 #endif
264 #if HAVE_STRUCT_IPV6_MREQ && defined(IPPROTO_IPV6)
265 if (addr->sa_family == AF_INET6) {
266 struct ipv6_mreq mreq6;
267
268 memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
269 //TODO: Interface index should be looked up from local_addr
270 mreq6.ipv6mr_interface = 0;
271 if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
272 ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IPV6_DROP_MEMBERSHIP)");
273 return -1;
274 }
275 }
276 #endif
277 return 0;
278 }
279
280 static int udp_set_multicast_sources(URLContext *h,
281 int sockfd, struct sockaddr *addr,
282 int addr_len, struct sockaddr_storage *local_addr,
283 struct sockaddr_storage *sources,
284 int nb_sources, int include)
285 {
286 if (addr->sa_family != AF_INET) {
287 #if HAVE_STRUCT_GROUP_SOURCE_REQ && defined(MCAST_BLOCK_SOURCE)
288 /* For IPv4 prefer the old approach, as that alone works reliably on
289 * Windows and it also supports supplying the interface based on its
290 * address. */
291 for (int i = 0; i < nb_sources; i++) {
292 struct group_source_req mreqs;
293 int level = addr->sa_family == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
294
295 //TODO: Interface index should be looked up from local_addr
296 mreqs.gsr_interface = 0;
297 memcpy(&mreqs.gsr_group, addr, addr_len);
298 memcpy(&mreqs.gsr_source, &sources[i], sizeof(*sources));
299
300 if (setsockopt(sockfd, level,
301 include ? MCAST_JOIN_SOURCE_GROUP : MCAST_BLOCK_SOURCE,
302 (const void *)&mreqs, sizeof(mreqs)) < 0) {
303 if (include)
304 ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(MCAST_JOIN_SOURCE_GROUP)");
305 else
306 ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(MCAST_BLOCK_SOURCE)");
307 return ff_neterrno();
308 }
309 }
310 return 0;
311 #else
312 av_log(h, AV_LOG_ERROR,
313 "Setting multicast sources only supported for IPv4\n");
314 return AVERROR(EINVAL);
315 #endif
316 }
317 #if HAVE_STRUCT_IP_MREQ_SOURCE && defined(IP_BLOCK_SOURCE)
318 for (int i = 0; i < nb_sources; i++) {
319 struct ip_mreq_source mreqs;
320 if (sources[i].ss_family != AF_INET) {
321 av_log(h, AV_LOG_ERROR, "Source/block address %d is of incorrect protocol family\n", i + 1);
322 return AVERROR(EINVAL);
323 }
324
325 mreqs.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
326 if (local_addr)
327 mreqs.imr_interface = ((struct sockaddr_in *)local_addr)->sin_addr;
328 else
329 mreqs.imr_interface.s_addr = INADDR_ANY;
330 mreqs.imr_sourceaddr.s_addr = ((struct sockaddr_in *)&sources[i])->sin_addr.s_addr;
331
332 if (setsockopt(sockfd, IPPROTO_IP,
333 include ? IP_ADD_SOURCE_MEMBERSHIP : IP_BLOCK_SOURCE,
334 (const void *)&mreqs, sizeof(mreqs)) < 0) {
335 if (include)
336 ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(IP_ADD_SOURCE_MEMBERSHIP)");
337 else
338 ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(IP_BLOCK_SOURCE)");
339 return ff_neterrno();
340 }
341 }
342 #else
343 return AVERROR(ENOSYS);
344 #endif
345 return 0;
346 }
347 static int udp_set_url(URLContext *h,
348 struct sockaddr_storage *addr,
349 const char *hostname, int port)
350 {
351 struct addrinfo *res0;
352 int addr_len;
353
354 res0 = ff_ip_resolve_host(h, hostname, port, SOCK_DGRAM, AF_UNSPEC, 0);
355 if (!res0) return AVERROR(EIO);
356 memcpy(addr, res0->ai_addr, res0->ai_addrlen);
357 addr_len = res0->ai_addrlen;
358 freeaddrinfo(res0);
359
360 return addr_len;
361 }
362
363 static int udp_socket_create(URLContext *h, struct sockaddr_storage *addr,
364 socklen_t *addr_len, const char *localaddr)
365 {
366 UDPContext *s = h->priv_data;
367 int udp_fd = -1;
368 struct addrinfo *res0, *res;
369 int family = AF_UNSPEC;
370
371 if (((struct sockaddr *) &s->dest_addr)->sa_family)
372 family = ((struct sockaddr *) &s->dest_addr)->sa_family;
373 res0 = ff_ip_resolve_host(h, (localaddr && localaddr[0]) ? localaddr : NULL,
374 s->local_port,
375 SOCK_DGRAM, family, AI_PASSIVE);
376 if (!res0)
377 goto fail;
378 for (res = res0; res; res=res->ai_next) {
379 if (s->udplite_coverage)
380 udp_fd = ff_socket(res->ai_family, SOCK_DGRAM, IPPROTO_UDPLITE, h);
381 else
382 udp_fd = ff_socket(res->ai_family, SOCK_DGRAM, 0, h);
383 if (udp_fd != -1) break;
384 ff_log_net_error(h, AV_LOG_ERROR, "socket");
385 }
386
387 if (udp_fd < 0)
388 goto fail;
389
390 memcpy(addr, res->ai_addr, res->ai_addrlen);
391 *addr_len = res->ai_addrlen;
392
393 freeaddrinfo(res0);
394
395 return udp_fd;
396
397 fail:
398 if (udp_fd >= 0)
399 closesocket(udp_fd);
400 if(res0)
401 freeaddrinfo(res0);
402 return -1;
403 }
404
405 static int udp_port(struct sockaddr_storage *addr, int addr_len)
406 {
407 char sbuf[sizeof(int)*3+1];
408 int error;
409
410 if ((error = getnameinfo((struct sockaddr *)addr, addr_len, NULL, 0, sbuf, sizeof(sbuf), NI_NUMERICSERV)) != 0) {
411 av_log(NULL, AV_LOG_ERROR, "getnameinfo: %s\n", gai_strerror(error));
412 return -1;
413 }
414
415 return strtol(sbuf, NULL, 10);
416 }
417
418
419 /**
420 * If no filename is given to av_open_input_file because you want to
421 * get the local port first, then you must call this function to set
422 * the remote server address.
423 *
424 * url syntax: udp://host:port[?option=val...]
425 * option: 'ttl=n' : set the ttl value (for multicast only)
426 * 'localport=n' : set the local port
427 * 'pkt_size=n' : set max packet size
428 * 'reuse=1' : enable reusing the socket
429 * 'overrun_nonfatal=1': survive in case of circular buffer overrun
430 *
431 * @param h media file context
432 * @param uri of the remote server
433 * @return zero if no error.
434 */
435 int ff_udp_set_remote_url(URLContext *h, const char *uri)
436 {
437 UDPContext *s = h->priv_data;
438 char hostname[256], buf[10];
439 int port;
440 const char *p;
441
442 av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
443
444 /* set the destination address */
445 s->dest_addr_len = udp_set_url(h, &s->dest_addr, hostname, port);
446 if (s->dest_addr_len < 0) {
447 return AVERROR(EIO);
448 }
449 s->is_multicast = ff_is_multicast_address((struct sockaddr*) &s->dest_addr);
450 p = strchr(uri, '?');
451 if (p) {
452 if (av_find_info_tag(buf, sizeof(buf), "connect", p)) {
453 int was_connected = s->is_connected;
454 s->is_connected = strtol(buf, NULL, 10);
455 if (s->is_connected && !was_connected) {
456 if (connect(s->udp_fd, (struct sockaddr *) &s->dest_addr,
457 s->dest_addr_len)) {
458 s->is_connected = 0;
459 ff_log_net_error(h, AV_LOG_ERROR, "connect");
460 return AVERROR(EIO);
461 }
462 }
463 }
464 }
465
466 return 0;
467 }
468
469 /**
470 * This function is identical to ff_udp_set_remote_url, except that it takes a sockaddr directly.
471 */
472 int ff_udp_set_remote_addr(URLContext *h, const struct sockaddr *dest_addr, socklen_t dest_addr_len, int do_connect)
473 {
474 UDPContext *s = h->priv_data;
475
476 /* set the destination address */
477 if ((size_t)dest_addr_len > sizeof(s->dest_addr))
478 return AVERROR(EIO);
479 s->dest_addr_len = dest_addr_len;
480 memcpy(&s->dest_addr, dest_addr, dest_addr_len);
481
482 s->is_multicast = ff_is_multicast_address((struct sockaddr*) &s->dest_addr);
483 if (do_connect >= 0) {
484 int was_connected = s->is_connected;
485 s->is_connected = do_connect;
486 if (s->is_connected && !was_connected) {
487 if (connect(s->udp_fd, (struct sockaddr *) &s->dest_addr,
488 s->dest_addr_len)) {
489 s->is_connected = 0;
490 ff_log_net_error(h, AV_LOG_ERROR, "connect");
491 return AVERROR(EIO);
492 }
493 }
494 }
495
496 return 0;
497 }
498
499 /**
500 * Return the local port used by the UDP connection
501 * @param h media file context
502 * @return the local port number
503 */
504 int ff_udp_get_local_port(URLContext *h)
505 {
506 UDPContext *s = h->priv_data;
507 return s->local_port;
508 }
509
510 void ff_udp_get_last_recv_addr(URLContext *h, struct sockaddr_storage *addr, socklen_t *addr_len)
511 {
512 UDPContext *s = h->priv_data;
513 *addr = s->last_recv_addr;
514 *addr_len = s->last_recv_addr_len;
515 }
516
517 /**
518 * Return the udp file handle for select() usage to wait for several RTP
519 * streams at the same time.
520 * @param h media file context
521 */
522 static int udp_get_file_handle(URLContext *h)
523 {
524 UDPContext *s = h->priv_data;
525 return s->udp_fd;
526 }
527
528 #if HAVE_PTHREAD_CANCEL
529 static void *circular_buffer_task_rx( void *_URLContext)
530 {
531 URLContext *h = _URLContext;
532 UDPContext *s = h->priv_data;
533 int old_cancelstate;
534
535 ff_thread_setname("udp-rx");
536
537 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancelstate);
538 pthread_mutex_lock(&s->mutex);
539 if (ff_socket_nonblock(s->udp_fd, 0) < 0) {
540 av_log(h, AV_LOG_ERROR, "Failed to set blocking mode");
541 s->circular_buffer_error = AVERROR(EIO);
542 goto end;
543 }
544 while(1) {
545 UDPQueuedPacketHeader pkt_header;
546
547 pthread_mutex_unlock(&s->mutex);
548 /* Blocking operations are always cancellation points;
549 see "General Information" / "Thread Cancellation Overview"
550 in Single Unix. */
551 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &old_cancelstate);
552 pkt_header.pkt_size = recvfrom(s->udp_fd, s->tmp + sizeof(pkt_header), sizeof(s->tmp) - sizeof(pkt_header), 0, (struct sockaddr *)&pkt_header.addr, &pkt_header.addr_len);
553 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancelstate);
554 pthread_mutex_lock(&s->mutex);
555 if (pkt_header.pkt_size < 0) {
556 if (ff_neterrno() != AVERROR(EAGAIN) && ff_neterrno() != AVERROR(EINTR)) {
557 s->circular_buffer_error = ff_neterrno();
558 goto end;
559 }
560 continue;
561 }
562 if (ff_ip_check_source_lists(&pkt_header.addr, &s->filters))
563 continue;
564 memcpy(s->tmp, &pkt_header, sizeof(pkt_header));
565
566 if (av_fifo_can_write(s->rx_fifo) < pkt_header.pkt_size + sizeof(pkt_header)) {
567 /* No Space left */
568 if (s->overrun_nonfatal) {
569 av_log(h, AV_LOG_WARNING, "Circular buffer overrun. "
570 "Surviving due to overrun_nonfatal option\n");
571 continue;
572 } else {
573 av_log(h, AV_LOG_ERROR, "Circular buffer overrun. "
574 "To avoid, increase fifo_size URL option. "
575 "To survive in such case, use overrun_nonfatal option\n");
576 s->circular_buffer_error = AVERROR(EIO);
577 goto end;
578 }
579 }
580 av_fifo_write(s->rx_fifo, s->tmp, pkt_header.pkt_size + sizeof(pkt_header));
581 pthread_cond_signal(&s->cond);
582 }
583
584 end:
585 pthread_cond_signal(&s->cond);
586 pthread_mutex_unlock(&s->mutex);
587 return NULL;
588 }
589
590 static void *circular_buffer_task_tx( void *_URLContext)
591 {
592 URLContext *h = _URLContext;
593 UDPContext *s = h->priv_data;
594 int64_t target_timestamp = av_gettime_relative();
595 int64_t start_timestamp = av_gettime_relative();
596 int64_t sent_bits = 0;
597 int64_t burst_interval = s->bitrate ? (s->burst_bits * 1000000 / s->bitrate) : 0;
598 int64_t max_delay = s->bitrate ? ((int64_t)h->max_packet_size * 8 * 1000000 / s->bitrate + 1) : 0;
599
600 ff_thread_setname("udp-tx");
601
602 pthread_mutex_lock(&s->mutex);
603
604 if (ff_socket_nonblock(s->udp_fd, 0) < 0) {
605 av_log(h, AV_LOG_ERROR, "Failed to set blocking mode");
606 s->circular_buffer_error = AVERROR(EIO);
607 goto end;
608 }
609
610 for(;;) {
611 int len;
612 const uint8_t *p;
613 uint8_t tmp[4];
614 int64_t timestamp;
615
616 len = av_fifo_can_read(s->tx_fifo);
617
618 while (len<4) {
619 if (s->close_req)
620 goto end;
621 pthread_cond_wait(&s->cond, &s->mutex);
622 len = av_fifo_can_read(s->tx_fifo);
623 }
624
625 av_fifo_read(s->tx_fifo, tmp, 4);
626 len = AV_RL32(tmp);
627
628 av_assert0(len >= 0);
629 av_assert0(len <= sizeof(s->tmp));
630
631 av_fifo_read(s->tx_fifo, s->tmp, len);
632
633 pthread_mutex_unlock(&s->mutex);
634
635 if (s->bitrate) {
636 timestamp = av_gettime_relative();
637 if (timestamp < target_timestamp) {
638 int64_t delay = target_timestamp - timestamp;
639 if (delay > max_delay) {
640 delay = max_delay;
641 start_timestamp = timestamp + delay;
642 sent_bits = 0;
643 }
644 av_usleep(delay);
645 } else {
646 if (timestamp - burst_interval > target_timestamp) {
647 start_timestamp = timestamp - burst_interval;
648 sent_bits = 0;
649 }
650 }
651 sent_bits += len * 8;
652 target_timestamp = start_timestamp + sent_bits * 1000000 / s->bitrate;
653 }
654
655 p = s->tmp;
656 while (len) {
657 int ret;
658 av_assert0(len > 0);
659 if (!s->is_connected) {
660 ret = sendto (s->udp_fd, p, len, 0,
661 (struct sockaddr *) &s->dest_addr,
662 s->dest_addr_len);
663 } else
664 ret = send(s->udp_fd, p, len, 0);
665 if (ret >= 0) {
666 len -= ret;
667 p += ret;
668 } else {
669 ret = ff_neterrno();
670 if (ret != AVERROR(EAGAIN) && ret != AVERROR(EINTR)) {
671 pthread_mutex_lock(&s->mutex);
672 s->circular_buffer_error = ret;
673 pthread_mutex_unlock(&s->mutex);
674 return NULL;
675 }
676 }
677 }
678
679 pthread_mutex_lock(&s->mutex);
680 }
681
682 end:
683 pthread_mutex_unlock(&s->mutex);
684 return NULL;
685 }
686
687
688 #endif
689
690 /* put it in UDP context */
691 /* return non zero if error */
692 static int udp_open(URLContext *h, const char *uri, int flags)
693 {
694 char hostname[1024];
695 int port, udp_fd = -1, tmp, bind_ret = -1;
696 UDPContext *s = h->priv_data;
697 int is_output;
698 const char *p;
699 struct sockaddr_storage my_addr;
700 socklen_t len;
701 int ret;
702
703 h->is_streamed = 1;
704
705 is_output = !(flags & AVIO_FLAG_READ);
706 if (s->buffer_size < 0)
707 s->buffer_size = is_output ? UDP_TX_BUF_SIZE : UDP_RX_BUF_SIZE;
708
709 p = strchr(uri, '?');
710 if (p) {
711 ret = ff_parse_opts_from_query_string(s, p, 1);
712 if (ret < 0)
713 goto fail;
714 }
715 if (!HAVE_PTHREAD_CANCEL) {
716 int64_t optvals[] = {s->overrun_nonfatal, s->bitrate, s->circular_buffer_size};
717 const char* optnames[] = { "overrun_nonfatal", "bitrate", "fifo_size"};
718 for (unsigned i = 0; i < FF_ARRAY_ELEMS(optvals); i++) {
719 if (optvals[i])
720 av_log(h, AV_LOG_WARNING,
721 "'%s' option was set but it is not supported "
722 "on this build (pthread support is required)\n", optnames[i]);
723 }
724 }
725 if (s->sources) {
726 if ((ret = ff_ip_parse_sources(h, s->sources, &s->filters)) < 0)
727 goto fail;
728 }
729 if (s->block) {
730 if ((ret = ff_ip_parse_blocks(h, s->block, &s->filters)) < 0)
731 goto fail;
732 }
733
734 /* handling needed to support options picking from both AVOption and URL */
735 s->circular_buffer_size *= 188;
736 if (flags & AVIO_FLAG_WRITE) {
737 h->max_packet_size = s->pkt_size;
738 } else {
739 h->max_packet_size = UDP_MAX_PKT_SIZE;
740 }
741 h->rw_timeout = s->timeout;
742
743 /* fill the dest addr */
744 av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
745
746 /* XXX: fix av_url_split */
747 if (hostname[0] == '\0' || hostname[0] == '?') {
748 /* only accepts null hostname if input */
749 if (!(flags & AVIO_FLAG_READ)) {
750 ret = AVERROR(EINVAL);
751 goto fail;
752 }
753 } else {
754 if ((ret = ff_udp_set_remote_url(h, uri)) < 0)
755 goto fail;
756 }
757
758 if ((s->is_multicast || s->local_port < 0) && (h->flags & AVIO_FLAG_READ))
759 s->local_port = port;
760
761 udp_fd = udp_socket_create(h, &my_addr, &len, s->localaddr);
762 if (udp_fd < 0) {
763 ret = AVERROR(EIO);
764 goto fail;
765 }
766
767 s->local_addr_storage=my_addr; //store for future multicast join
768
769 /* Follow the requested reuse option, unless it's multicast in which
770 * case enable reuse unless explicitly disabled.
771 */
772 if (s->reuse_socket > 0 || (s->is_multicast && s->reuse_socket < 0)) {
773 s->reuse_socket = 1;
774 if (setsockopt (udp_fd, SOL_SOCKET, SO_REUSEADDR, &(s->reuse_socket), sizeof(s->reuse_socket)) != 0) {
775 ret = ff_neterrno();
776 goto fail;
777 }
778 }
779
780 if (s->is_broadcast) {
781 #ifdef SO_BROADCAST
782 if (setsockopt (udp_fd, SOL_SOCKET, SO_BROADCAST, &(s->is_broadcast), sizeof(s->is_broadcast)) != 0) {
783 ret = ff_neterrno();
784 goto fail;
785 }
786 #else
787 ret = AVERROR(ENOSYS);
788 goto fail;
789 #endif
790 }
791
792 /* Set the checksum coverage for UDP-Lite (RFC 3828) for sending and receiving.
793 * The receiver coverage has to be less than or equal to the sender coverage.
794 * Otherwise, the receiver will drop all packets.
795 */
796 if (s->udplite_coverage) {
797 if (setsockopt (udp_fd, IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV, &(s->udplite_coverage), sizeof(s->udplite_coverage)) != 0)
798 av_log(h, AV_LOG_WARNING, "socket option UDPLITE_SEND_CSCOV not available");
799
800 if (setsockopt (udp_fd, IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV, &(s->udplite_coverage), sizeof(s->udplite_coverage)) != 0)
801 av_log(h, AV_LOG_WARNING, "socket option UDPLITE_RECV_CSCOV not available");
802 }
803
804 if (s->dscp >= 0) {
805 int dscp = s->dscp << 2;
806 if (setsockopt (udp_fd, IPPROTO_IP, IP_TOS, &dscp, sizeof(dscp)) != 0) {
807 ret = ff_neterrno();
808 goto fail;
809 }
810 }
811
812 /* If multicast, try binding the multicast address first, to avoid
813 * receiving UDP packets from other sources aimed at the same UDP
814 * port. This fails on windows. This makes sending to the same address
815 * using sendto() fail, so only do it if we're opened in read-only mode. */
816 if (s->is_multicast && (h->flags & AVIO_FLAG_READ)) {
817 bind_ret = bind(udp_fd,(struct sockaddr *)&s->dest_addr, len);
818 }
819 /* bind to the local address if not multicast or if the multicast
820 * bind failed */
821 /* the bind is needed to give a port to the socket now */
822 if (bind_ret < 0 && bind(udp_fd,(struct sockaddr *)&my_addr, len) < 0) {
823 ff_log_net_error(h, AV_LOG_ERROR, "bind failed");
824 ret = ff_neterrno();
825 goto fail;
826 }
827
828 len = sizeof(my_addr);
829 getsockname(udp_fd, (struct sockaddr *)&my_addr, &len);
830 s->local_port = udp_port(&my_addr, len);
831
832 if (s->is_multicast) {
833 if (h->flags & AVIO_FLAG_WRITE) {
834 /* output */
835 if ((ret = udp_set_multicast_ttl(udp_fd, s->ttl, (struct sockaddr *)&s->dest_addr, h)) < 0)
836 goto fail;
837 }
838 if (h->flags & AVIO_FLAG_READ) {
839 /* input */
840 if (s->filters.nb_include_addrs) {
841 if ((ret = udp_set_multicast_sources(h, udp_fd,
842 (struct sockaddr *)&s->dest_addr,
843 s->dest_addr_len, &s->local_addr_storage,
844 s->filters.include_addrs,
845 s->filters.nb_include_addrs, 1)) < 0)
846 goto fail;
847 } else {
848 if ((ret = udp_join_multicast_group(udp_fd, (struct sockaddr *)&s->dest_addr,
849 (struct sockaddr *)&s->local_addr_storage, h)) < 0)
850 goto fail;
851 }
852 if (s->filters.nb_exclude_addrs) {
853 if ((ret = udp_set_multicast_sources(h, udp_fd,
854 (struct sockaddr *)&s->dest_addr,
855 s->dest_addr_len, &s->local_addr_storage,
856 s->filters.exclude_addrs,
857 s->filters.nb_exclude_addrs, 0)) < 0)
858 goto fail;
859 }
860 }
861 }
862
863 if (is_output) {
864 /* limit the tx buf size to limit latency */
865 tmp = s->buffer_size;
866 if (setsockopt(udp_fd, SOL_SOCKET, SO_SNDBUF, &tmp, sizeof(tmp)) < 0) {
867 ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(SO_SNDBUF)");
868 ret = ff_neterrno();
869 goto fail;
870 }
871 } else {
872 /* set udp recv buffer size to the requested value (default UDP_RX_BUF_SIZE) */
873 tmp = s->buffer_size;
874 if (setsockopt(udp_fd, SOL_SOCKET, SO_RCVBUF, &tmp, sizeof(tmp)) < 0) {
875 ff_log_net_error(h, AV_LOG_WARNING, "setsockopt(SO_RECVBUF)");
876 }
877 len = sizeof(tmp);
878 if (getsockopt(udp_fd, SOL_SOCKET, SO_RCVBUF, &tmp, &len) < 0) {
879 ff_log_net_error(h, AV_LOG_WARNING, "getsockopt(SO_RCVBUF)");
880 } else {
881 av_log(h, AV_LOG_DEBUG, "end receive buffer size reported is %d\n", tmp);
882 if(tmp < s->buffer_size)
883 av_log(h, AV_LOG_WARNING, "attempted to set receive buffer to size %d but it only ended up set as %d\n", s->buffer_size, tmp);
884 }
885
886 /* make the socket non-blocking */
887 ff_socket_nonblock(udp_fd, 1);
888 }
889 if (s->is_connected) {
890 if (connect(udp_fd, (struct sockaddr *) &s->dest_addr, s->dest_addr_len)) {
891 ff_log_net_error(h, AV_LOG_ERROR, "connect");
892 ret = ff_neterrno();
893 goto fail;
894 }
895 }
896
897 s->udp_fd = udp_fd;
898
899 #if HAVE_PTHREAD_CANCEL
900 /*
901 Create thread in case of:
902 1. Input and circular_buffer_size is set
903 2. Output and bitrate and circular_buffer_size is set
904 */
905
906 if (is_output && s->bitrate && !s->circular_buffer_size) {
907 /* Warn user in case of 'circular_buffer_size' is not set */
908 av_log(h, AV_LOG_WARNING,"'bitrate' option was set but 'circular_buffer_size' is not, but required\n");
909 }
910
911 if ((!is_output && s->circular_buffer_size) || (is_output && s->bitrate && s->circular_buffer_size)) {
912 /* start the task going */
913 AVFifo *fifo = av_fifo_alloc2(s->circular_buffer_size, 1, 0);
914 if (!fifo) {
915 ret = AVERROR(ENOMEM);
916 goto fail;
917 }
918 if (is_output)
919 s->tx_fifo = fifo;
920 else
921 s->rx_fifo = fifo;
922 ret = pthread_mutex_init(&s->mutex, NULL);
923 if (ret != 0) {
924 av_log(h, AV_LOG_ERROR, "pthread_mutex_init failed : %s\n", strerror(ret));
925 ret = AVERROR(ret);
926 goto fail;
927 }
928 ret = pthread_cond_init(&s->cond, NULL);
929 if (ret != 0) {
930 av_log(h, AV_LOG_ERROR, "pthread_cond_init failed : %s\n", strerror(ret));
931 ret = AVERROR(ret);
932 goto cond_fail;
933 }
934 ret = pthread_create(&s->circular_buffer_thread, NULL, is_output?circular_buffer_task_tx:circular_buffer_task_rx, h);
935 if (ret != 0) {
936 av_log(h, AV_LOG_ERROR, "pthread_create failed : %s\n", strerror(ret));
937 ret = AVERROR(ret);
938 goto thread_fail;
939 }
940 s->thread_started = 1;
941 }
942 #endif
943
944 return 0;
945 #if HAVE_PTHREAD_CANCEL
946 thread_fail:
947 pthread_cond_destroy(&s->cond);
948 cond_fail:
949 pthread_mutex_destroy(&s->mutex);
950 #endif
951 fail:
952 if (udp_fd >= 0)
953 closesocket(udp_fd);
954 av_fifo_freep2(&s->rx_fifo);
955 av_fifo_freep2(&s->tx_fifo);
956 ff_ip_reset_filters(&s->filters);
957 return ret;
958 }
959
960 static int udplite_open(URLContext *h, const char *uri, int flags)
961 {
962 UDPContext *s = h->priv_data;
963
964 // set default checksum coverage
965 s->udplite_coverage = UDP_HEADER_SIZE;
966
967 return udp_open(h, uri, flags);
968 }
969
970 static int udp_read(URLContext *h, uint8_t *buf, int size)
971 {
972 UDPContext *s = h->priv_data;
973 int ret;
974 #if HAVE_PTHREAD_CANCEL
975 int avail, nonblock = h->flags & AVIO_FLAG_NONBLOCK;
976
977 if (s->rx_fifo) {
978 pthread_mutex_lock(&s->mutex);
979 do {
980 avail = av_fifo_can_read(s->rx_fifo);
981 if (avail) { // >=size) {
982 UDPQueuedPacketHeader header;
983
984 av_fifo_read(s->rx_fifo, &header, sizeof(header));
985
986 s->last_recv_addr = header.addr;
987 s->last_recv_addr_len = header.addr_len;
988
989 avail = header.pkt_size;
990 if(avail > size){
991 av_log(h, AV_LOG_WARNING, "Part of datagram lost due to insufficient buffer size\n");
992 avail = size;
993 }
994
995 av_fifo_read(s->rx_fifo, buf, avail);
996 av_fifo_drain2(s->rx_fifo, header.pkt_size - avail);
997 pthread_mutex_unlock(&s->mutex);
998 return avail;
999 } else if(s->circular_buffer_error){
1000 int err = s->circular_buffer_error;
1001 pthread_mutex_unlock(&s->mutex);
1002 return err;
1003 } else if(nonblock) {
1004 pthread_mutex_unlock(&s->mutex);
1005 return AVERROR(EAGAIN);
1006 } else {
1007 /* FIXME: using the monotonic clock would be better,
1008 but it does not exist on all supported platforms. */
1009 int64_t t = av_gettime() + 100000;
1010 struct timespec tv = { .tv_sec = t / 1000000,
1011 .tv_nsec = (t % 1000000) * 1000 };
1012 int err = pthread_cond_timedwait(&s->cond, &s->mutex, &tv);
1013 if (err) {
1014 pthread_mutex_unlock(&s->mutex);
1015 return AVERROR(err == ETIMEDOUT ? EAGAIN : err);
1016 }
1017 nonblock = 1;
1018 }
1019 } while(1);
1020 }
1021 #endif
1022
1023 if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
1024 ret = ff_network_wait_fd(s->udp_fd, 0);
1025 if (ret < 0)
1026 return ret;
1027 }
1028 s->last_recv_addr_len = sizeof(s->last_recv_addr);
1029 ret = recvfrom(s->udp_fd, buf, size, 0, (struct sockaddr *)&s->last_recv_addr, &s->last_recv_addr_len);
1030 if (ret < 0)
1031 return ff_neterrno();
1032 if (ff_ip_check_source_lists(&s->last_recv_addr, &s->filters))
1033 return AVERROR(EINTR);
1034 return ret;
1035 }
1036
1037 static int udp_write(URLContext *h, const uint8_t *buf, int size)
1038 {
1039 UDPContext *s = h->priv_data;
1040 int ret;
1041
1042 #if HAVE_PTHREAD_CANCEL
1043 if (s->tx_fifo) {
1044 uint8_t tmp[4];
1045
1046 pthread_mutex_lock(&s->mutex);
1047
1048 /*
1049 Return error if last tx failed.
1050 Here we can't know on which packet error was, but it needs to know that error exists.
1051 */
1052 if (s->circular_buffer_error<0) {
1053 int err = s->circular_buffer_error;
1054 pthread_mutex_unlock(&s->mutex);
1055 return err;
1056 }
1057
1058 if (av_fifo_can_write(s->tx_fifo) < size + 4) {
1059 /* What about a partial packet tx ? */
1060 pthread_mutex_unlock(&s->mutex);
1061 return AVERROR(ENOMEM);
1062 }
1063 AV_WL32(tmp, size);
1064 av_fifo_write(s->tx_fifo, tmp, 4); /* size of packet */
1065 av_fifo_write(s->tx_fifo, buf, size); /* the data */
1066 pthread_cond_signal(&s->cond);
1067 pthread_mutex_unlock(&s->mutex);
1068 return size;
1069 }
1070 #endif
1071 if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
1072 ret = ff_network_wait_fd(s->udp_fd, 1);
1073 if (ret < 0)
1074 return ret;
1075 }
1076
1077 if (!s->is_connected) {
1078 ret = sendto (s->udp_fd, buf, size, 0,
1079 (struct sockaddr *) &s->dest_addr,
1080 s->dest_addr_len);
1081 } else
1082 ret = send(s->udp_fd, buf, size, 0);
1083
1084 return ret < 0 ? ff_neterrno() : ret;
1085 }
1086
1087 static int udp_close(URLContext *h)
1088 {
1089 UDPContext *s = h->priv_data;
1090
1091 #if HAVE_PTHREAD_CANCEL
1092 // Request close once writing is finished
1093 if (s->thread_started && !(h->flags & AVIO_FLAG_READ)) {
1094 pthread_mutex_lock(&s->mutex);
1095 s->close_req = 1;
1096 pthread_cond_signal(&s->cond);
1097 pthread_mutex_unlock(&s->mutex);
1098 }
1099 #endif
1100
1101 if (s->is_multicast && (h->flags & AVIO_FLAG_READ))
1102 udp_leave_multicast_group(s->udp_fd, (struct sockaddr *)&s->dest_addr,
1103 (struct sockaddr *)&s->local_addr_storage, h);
1104 #if HAVE_PTHREAD_CANCEL
1105 if (s->thread_started) {
1106 int ret;
1107 // Cancel only read, as write has been signaled as success to the user
1108 if (h->flags & AVIO_FLAG_READ) {
1109 #ifdef _WIN32
1110 /* recvfrom() is not a cancellation point for win32, so we shutdown
1111 * the socket and abort pending IO, subsequent recvfrom() calls
1112 * will fail with WSAESHUTDOWN causing the thread to exit. */
1113 shutdown(s->udp_fd, SD_RECEIVE);
1114 CancelIoEx((HANDLE)(SOCKET)s->udp_fd, NULL);
1115 #else
1116 pthread_cancel(s->circular_buffer_thread);
1117 #endif
1118 }
1119 ret = pthread_join(s->circular_buffer_thread, NULL);
1120 if (ret != 0)
1121 av_log(h, AV_LOG_ERROR, "pthread_join(): %s\n", strerror(ret));
1122 pthread_mutex_destroy(&s->mutex);
1123 pthread_cond_destroy(&s->cond);
1124 }
1125 #endif
1126 closesocket(s->udp_fd);
1127 av_fifo_freep2(&s->rx_fifo);
1128 av_fifo_freep2(&s->tx_fifo);
1129 ff_ip_reset_filters(&s->filters);
1130 return 0;
1131 }
1132
1133 const URLProtocol ff_udp_protocol = {
1134 .name = "udp",
1135 .url_open = udp_open,
1136 .url_read = udp_read,
1137 .url_write = udp_write,
1138 .url_close = udp_close,
1139 .url_get_file_handle = udp_get_file_handle,
1140 .priv_data_size = sizeof(UDPContext),
1141 .priv_data_class = &udp_class,
1142 .flags = URL_PROTOCOL_FLAG_NETWORK,
1143 };
1144
1145 const URLProtocol ff_udplite_protocol = {
1146 .name = "udplite",
1147 .url_open = udplite_open,
1148 .url_read = udp_read,
1149 .url_write = udp_write,
1150 .url_close = udp_close,
1151 .url_get_file_handle = udp_get_file_handle,
1152 .priv_data_size = sizeof(UDPContext),
1153 .priv_data_class = &udplite_context_class,
1154 .flags = URL_PROTOCOL_FLAG_NETWORK,
1155 };
1156