udp: Use AVOptions
[ffmpeg.git] / libavformat / udp.c
1 /*
2  * UDP prototype streaming system
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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 _BSD_SOURCE     /* Needed for using struct ip_mreq with recent glibc */
28
29 #include "avformat.h"
30 #include "avio_internal.h"
31 #include "libavutil/parseutils.h"
32 #include "libavutil/avstring.h"
33 #include "libavutil/opt.h"
34 #include "internal.h"
35 #include "network.h"
36 #include "os_support.h"
37 #include "url.h"
38
39 #ifndef IPV6_ADD_MEMBERSHIP
40 #define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
41 #define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
42 #endif
43
44 typedef struct UDPContext {
45     int udp_fd;
46     int ttl;
47     int buffer_size;
48     int pkt_size;
49     int is_multicast;
50     int local_port;
51     int reuse_socket;
52     struct sockaddr_storage dest_addr;
53     int dest_addr_len;
54     int is_connected;
55     char *localaddr;
56     char *sources;
57     char *block;
58 } UDPContext;
59
60 #define UDP_TX_BUF_SIZE 32768
61 #define UDP_MAX_PKT_SIZE 65536
62
63 #define OFFSET(x) offsetof(UDPContext, x)
64 #define D AV_OPT_FLAG_DECODING_PARAM
65 #define E AV_OPT_FLAG_ENCODING_PARAM
66 static const AVOption options[] = {
67     { "ttl",            "Time to live (in milliseconds, multicast only)",  OFFSET(ttl),            AV_OPT_TYPE_INT,    { .i64 = 16 },     0, INT_MAX, .flags = D|E },
68     { "buffer_size",    "System data size (in bytes)",                     OFFSET(buffer_size),    AV_OPT_TYPE_INT,    { .i64 = -1 },    -1, INT_MAX, .flags = D|E },
69     { "local_port",     "Local port",                                      OFFSET(local_port),     AV_OPT_TYPE_INT,    { .i64 = -1 },    -1, INT_MAX, .flags = D|E },
70     { "reuse_socket",   "Reuse socket",                                    OFFSET(reuse_socket),   AV_OPT_TYPE_INT,    { .i64 = -1 },    -1, 1,       .flags = D|E },
71     { "connect",        "Connect socket",                                  OFFSET(is_connected),   AV_OPT_TYPE_INT,    { .i64 =  0 },     0, 1,       .flags = D|E },
72     { "pkt_size",       "Maximum packet size",                             OFFSET(pkt_size),       AV_OPT_TYPE_INT,    { .i64 = -1 },    -1, INT_MAX, .flags = D|E },
73     { "localaddr",      "Local address",                                   OFFSET(localaddr),      AV_OPT_TYPE_STRING, { .str = NULL },               .flags = D|E },
74     { "sources",        "Source list",                                     OFFSET(sources),        AV_OPT_TYPE_STRING, { .str = NULL },               .flags = D|E },
75     { "block",          "Block list",                                      OFFSET(block),          AV_OPT_TYPE_STRING, { .str = NULL },               .flags = D|E },
76     { NULL }
77 };
78
79 static const AVClass udp_class = {
80     .class_name = "udp",
81     .item_name  = av_default_item_name,
82     .option     = options,
83     .version    = LIBAVUTIL_VERSION_INT,
84 };
85
86 static void log_net_error(void *ctx, int level, const char* prefix)
87 {
88     char errbuf[100];
89     av_strerror(ff_neterrno(), errbuf, sizeof(errbuf));
90     av_log(ctx, level, "%s: %s\n", prefix, errbuf);
91 }
92
93 static int udp_set_multicast_ttl(int sockfd, int mcastTTL,
94                                  struct sockaddr *addr)
95 {
96 #ifdef IP_MULTICAST_TTL
97     if (addr->sa_family == AF_INET) {
98         if (setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_TTL, &mcastTTL, sizeof(mcastTTL)) < 0) {
99             log_net_error(NULL, AV_LOG_ERROR, "setsockopt(IP_MULTICAST_TTL)");
100             return -1;
101         }
102     }
103 #endif
104 #if defined(IPPROTO_IPV6) && defined(IPV6_MULTICAST_HOPS)
105     if (addr->sa_family == AF_INET6) {
106         if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &mcastTTL, sizeof(mcastTTL)) < 0) {
107             log_net_error(NULL, AV_LOG_ERROR, "setsockopt(IPV6_MULTICAST_HOPS)");
108             return -1;
109         }
110     }
111 #endif
112     return 0;
113 }
114
115 static int udp_join_multicast_group(int sockfd, struct sockaddr *addr)
116 {
117 #ifdef IP_ADD_MEMBERSHIP
118     if (addr->sa_family == AF_INET) {
119         struct ip_mreq mreq;
120
121         mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
122         mreq.imr_interface.s_addr= INADDR_ANY;
123         if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {
124             log_net_error(NULL, AV_LOG_ERROR, "setsockopt(IP_ADD_MEMBERSHIP)");
125             return -1;
126         }
127     }
128 #endif
129 #if HAVE_STRUCT_IPV6_MREQ && defined(IPPROTO_IPV6)
130     if (addr->sa_family == AF_INET6) {
131         struct ipv6_mreq mreq6;
132
133         memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
134         mreq6.ipv6mr_interface= 0;
135         if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
136             log_net_error(NULL, AV_LOG_ERROR, "setsockopt(IPV6_ADD_MEMBERSHIP)");
137             return -1;
138         }
139     }
140 #endif
141     return 0;
142 }
143
144 static int udp_leave_multicast_group(int sockfd, struct sockaddr *addr)
145 {
146 #ifdef IP_DROP_MEMBERSHIP
147     if (addr->sa_family == AF_INET) {
148         struct ip_mreq mreq;
149
150         mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
151         mreq.imr_interface.s_addr= INADDR_ANY;
152         if (setsockopt(sockfd, IPPROTO_IP, IP_DROP_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {
153             log_net_error(NULL, AV_LOG_ERROR, "setsockopt(IP_DROP_MEMBERSHIP)");
154             return -1;
155         }
156     }
157 #endif
158 #if HAVE_STRUCT_IPV6_MREQ && defined(IPPROTO_IPV6)
159     if (addr->sa_family == AF_INET6) {
160         struct ipv6_mreq mreq6;
161
162         memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
163         mreq6.ipv6mr_interface= 0;
164         if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
165             log_net_error(NULL, AV_LOG_ERROR, "setsockopt(IPV6_DROP_MEMBERSHIP)");
166             return -1;
167         }
168     }
169 #endif
170     return 0;
171 }
172
173 static struct addrinfo* udp_resolve_host(const char *hostname, int port,
174                                          int type, int family, int flags)
175 {
176     struct addrinfo hints = { 0 }, *res = 0;
177     int error;
178     char sport[16];
179     const char *node = 0, *service = "0";
180
181     if (port > 0) {
182         snprintf(sport, sizeof(sport), "%d", port);
183         service = sport;
184     }
185     if ((hostname) && (hostname[0] != '\0') && (hostname[0] != '?')) {
186         node = hostname;
187     }
188     hints.ai_socktype = type;
189     hints.ai_family   = family;
190     hints.ai_flags = flags;
191     if ((error = getaddrinfo(node, service, &hints, &res))) {
192         res = NULL;
193         av_log(NULL, AV_LOG_ERROR, "udp_resolve_host: %s\n", gai_strerror(error));
194     }
195
196     return res;
197 }
198
199 static int udp_set_multicast_sources(int sockfd, struct sockaddr *addr,
200                                      int addr_len, char **sources,
201                                      int nb_sources, int include)
202 {
203 #if HAVE_STRUCT_GROUP_SOURCE_REQ && defined(MCAST_BLOCK_SOURCE) && !defined(_WIN32)
204     /* These ones are available in the microsoft SDK, but don't seem to work
205      * as on linux, so just prefer the v4-only approach there for now. */
206     int i;
207     for (i = 0; i < nb_sources; i++) {
208         struct group_source_req mreqs;
209         int level = addr->sa_family == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
210         struct addrinfo *sourceaddr = udp_resolve_host(sources[i], 0,
211                                                        SOCK_DGRAM, AF_UNSPEC,
212                                                        0);
213         if (!sourceaddr)
214             return AVERROR(ENOENT);
215
216         mreqs.gsr_interface = 0;
217         memcpy(&mreqs.gsr_group, addr, addr_len);
218         memcpy(&mreqs.gsr_source, sourceaddr->ai_addr, sourceaddr->ai_addrlen);
219         freeaddrinfo(sourceaddr);
220
221         if (setsockopt(sockfd, level,
222                        include ? MCAST_JOIN_SOURCE_GROUP : MCAST_BLOCK_SOURCE,
223                        (const void *)&mreqs, sizeof(mreqs)) < 0) {
224             if (include)
225                 log_net_error(NULL, AV_LOG_ERROR, "setsockopt(MCAST_JOIN_SOURCE_GROUP)");
226             else
227                 log_net_error(NULL, AV_LOG_ERROR, "setsockopt(MCAST_BLOCK_SOURCE)");
228             return ff_neterrno();
229         }
230     }
231 #elif HAVE_STRUCT_IP_MREQ_SOURCE && defined(IP_BLOCK_SOURCE)
232     int i;
233     if (addr->sa_family != AF_INET) {
234         av_log(NULL, AV_LOG_ERROR,
235                "Setting multicast sources only supported for IPv4\n");
236         return AVERROR(EINVAL);
237     }
238     for (i = 0; i < nb_sources; i++) {
239         struct ip_mreq_source mreqs;
240         struct addrinfo *sourceaddr = udp_resolve_host(sources[i], 0,
241                                                        SOCK_DGRAM, AF_UNSPEC,
242                                                        0);
243         if (!sourceaddr)
244             return AVERROR(ENOENT);
245         if (sourceaddr->ai_addr->sa_family != AF_INET) {
246             freeaddrinfo(sourceaddr);
247             av_log(NULL, AV_LOG_ERROR, "%s is of incorrect protocol family\n",
248                    sources[i]);
249             return AVERROR(EINVAL);
250         }
251
252         mreqs.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
253         mreqs.imr_interface.s_addr = INADDR_ANY;
254         mreqs.imr_sourceaddr.s_addr = ((struct sockaddr_in *)sourceaddr->ai_addr)->sin_addr.s_addr;
255         freeaddrinfo(sourceaddr);
256
257         if (setsockopt(sockfd, IPPROTO_IP,
258                        include ? IP_ADD_SOURCE_MEMBERSHIP : IP_BLOCK_SOURCE,
259                        (const void *)&mreqs, sizeof(mreqs)) < 0) {
260             if (include)
261                 log_net_error(NULL, AV_LOG_ERROR, "setsockopt(IP_ADD_SOURCE_MEMBERSHIP)");
262             else
263                 log_net_error(NULL, AV_LOG_ERROR, "setsockopt(IP_BLOCK_SOURCE)");
264             return ff_neterrno();
265         }
266     }
267 #else
268     return AVERROR(ENOSYS);
269 #endif
270     return 0;
271 }
272 static int udp_set_url(struct sockaddr_storage *addr,
273                        const char *hostname, int port)
274 {
275     struct addrinfo *res0;
276     int addr_len;
277
278     res0 = udp_resolve_host(hostname, port, SOCK_DGRAM, AF_UNSPEC, 0);
279     if (res0 == 0) return AVERROR(EIO);
280     memcpy(addr, res0->ai_addr, res0->ai_addrlen);
281     addr_len = res0->ai_addrlen;
282     freeaddrinfo(res0);
283
284     return addr_len;
285 }
286
287 static int udp_socket_create(UDPContext *s, struct sockaddr_storage *addr,
288                              socklen_t *addr_len, const char *localaddr)
289 {
290     int udp_fd = -1;
291     struct addrinfo *res0 = NULL, *res = NULL;
292     int family = AF_UNSPEC;
293
294     if (((struct sockaddr *) &s->dest_addr)->sa_family)
295         family = ((struct sockaddr *) &s->dest_addr)->sa_family;
296     res0 = udp_resolve_host(localaddr[0] ? localaddr : NULL, s->local_port,
297                             SOCK_DGRAM, family, AI_PASSIVE);
298     if (res0 == 0)
299         goto fail;
300     for (res = res0; res; res=res->ai_next) {
301         udp_fd = ff_socket(res->ai_family, SOCK_DGRAM, 0);
302         if (udp_fd != -1) break;
303         log_net_error(NULL, AV_LOG_ERROR, "socket");
304     }
305
306     if (udp_fd < 0)
307         goto fail;
308
309     memcpy(addr, res->ai_addr, res->ai_addrlen);
310     *addr_len = res->ai_addrlen;
311
312     freeaddrinfo(res0);
313
314     return udp_fd;
315
316  fail:
317     if (udp_fd >= 0)
318         closesocket(udp_fd);
319     if(res0)
320         freeaddrinfo(res0);
321     return -1;
322 }
323
324 static int udp_port(struct sockaddr_storage *addr, int addr_len)
325 {
326     char sbuf[sizeof(int)*3+1];
327     int error;
328
329     if ((error = getnameinfo((struct sockaddr *)addr, addr_len, NULL, 0,  sbuf, sizeof(sbuf), NI_NUMERICSERV)) != 0) {
330         av_log(NULL, AV_LOG_ERROR, "getnameinfo: %s\n", gai_strerror(error));
331         return -1;
332     }
333
334     return strtol(sbuf, NULL, 10);
335 }
336
337
338 /**
339  * If no filename is given to av_open_input_file because you want to
340  * get the local port first, then you must call this function to set
341  * the remote server address.
342  *
343  * url syntax: udp://host:port[?option=val...]
344  * option: 'ttl=n'       : set the ttl value (for multicast only)
345  *         'localport=n' : set the local port
346  *         'pkt_size=n'  : set max packet size
347  *         'reuse=1'     : enable reusing the socket
348  *
349  * @param h media file context
350  * @param uri of the remote server
351  * @return zero if no error.
352  */
353 int ff_udp_set_remote_url(URLContext *h, const char *uri)
354 {
355     UDPContext *s = h->priv_data;
356     char hostname[256], buf[10];
357     int port;
358     const char *p;
359
360     av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
361
362     /* set the destination address */
363     s->dest_addr_len = udp_set_url(&s->dest_addr, hostname, port);
364     if (s->dest_addr_len < 0) {
365         return AVERROR(EIO);
366     }
367     s->is_multicast = ff_is_multicast_address((struct sockaddr*) &s->dest_addr);
368     p = strchr(uri, '?');
369     if (p) {
370         if (av_find_info_tag(buf, sizeof(buf), "connect", p)) {
371             int was_connected = s->is_connected;
372             s->is_connected = strtol(buf, NULL, 10);
373             if (s->is_connected && !was_connected) {
374                 if (connect(s->udp_fd, (struct sockaddr *) &s->dest_addr,
375                             s->dest_addr_len)) {
376                     s->is_connected = 0;
377                     log_net_error(h, AV_LOG_ERROR, "connect");
378                     return AVERROR(EIO);
379                 }
380             }
381         }
382     }
383
384     return 0;
385 }
386
387 /**
388  * Return the local port used by the UDP connection
389  * @param h media file context
390  * @return the local port number
391  */
392 int ff_udp_get_local_port(URLContext *h)
393 {
394     UDPContext *s = h->priv_data;
395     return s->local_port;
396 }
397
398 /**
399  * Return the udp file handle for select() usage to wait for several RTP
400  * streams at the same time.
401  * @param h media file context
402  */
403 static int udp_get_file_handle(URLContext *h)
404 {
405     UDPContext *s = h->priv_data;
406     return s->udp_fd;
407 }
408
409 static int parse_source_list(char *buf, char **sources, int *num_sources,
410                              int max_sources)
411 {
412     char *source_start;
413
414     source_start = buf;
415     while (1) {
416         char *next = strchr(source_start, ',');
417         if (next)
418             *next = '\0';
419         sources[*num_sources] = av_strdup(source_start);
420         if (!sources[*num_sources])
421             return AVERROR(ENOMEM);
422         source_start = next + 1;
423         (*num_sources)++;
424         if (*num_sources >= max_sources || !next)
425             break;
426     }
427     return 0;
428 }
429
430 /* put it in UDP context */
431 /* return non zero if error */
432 static int udp_open(URLContext *h, const char *uri, int flags)
433 {
434     char hostname[1024], localaddr[1024] = "";
435     int port, udp_fd = -1, tmp, bind_ret = -1;
436     UDPContext *s = h->priv_data;
437     int is_output;
438     const char *p;
439     char buf[256];
440     struct sockaddr_storage my_addr;
441     socklen_t len;
442     int i, num_include_sources = 0, num_exclude_sources = 0;
443     char *include_sources[32], *exclude_sources[32];
444
445     h->is_streamed = 1;
446     h->max_packet_size = 1472;
447
448     is_output = !(flags & AVIO_FLAG_READ);
449
450     if (s->buffer_size < 0)
451         s->buffer_size = is_output ? UDP_TX_BUF_SIZE : UDP_MAX_PKT_SIZE;
452
453     if (s->sources) {
454         if (parse_source_list(s->sources, include_sources,
455                               &num_include_sources,
456                               FF_ARRAY_ELEMS(include_sources)))
457             goto fail;
458     }
459
460     if (s->block) {
461         if (parse_source_list(s->block, exclude_sources, &num_exclude_sources,
462                               FF_ARRAY_ELEMS(exclude_sources)))
463             goto fail;
464     }
465
466     if (s->pkt_size)
467         h->max_packet_size = s->pkt_size;
468
469     p = strchr(uri, '?');
470     if (p) {
471         if (av_find_info_tag(buf, sizeof(buf), "reuse", p)) {
472             char *endptr = NULL;
473             s->reuse_socket = strtol(buf, &endptr, 10);
474             /* assume if no digits were found it is a request to enable it */
475             if (buf == endptr)
476                 s->reuse_socket = 1;
477         }
478         if (av_find_info_tag(buf, sizeof(buf), "ttl", p)) {
479             s->ttl = strtol(buf, NULL, 10);
480         }
481         if (av_find_info_tag(buf, sizeof(buf), "localport", p)) {
482             s->local_port = strtol(buf, NULL, 10);
483         }
484         if (av_find_info_tag(buf, sizeof(buf), "pkt_size", p)) {
485             h->max_packet_size = strtol(buf, NULL, 10);
486         }
487         if (av_find_info_tag(buf, sizeof(buf), "buffer_size", p)) {
488             s->buffer_size = strtol(buf, NULL, 10);
489         }
490         if (av_find_info_tag(buf, sizeof(buf), "connect", p)) {
491             s->is_connected = strtol(buf, NULL, 10);
492         }
493         if (av_find_info_tag(buf, sizeof(buf), "localaddr", p)) {
494             av_strlcpy(localaddr, buf, sizeof(localaddr));
495         }
496         if (av_find_info_tag(buf, sizeof(buf), "sources", p)) {
497             if (parse_source_list(buf, include_sources, &num_include_sources,
498                                   FF_ARRAY_ELEMS(include_sources)))
499                 goto fail;
500         }
501         if (av_find_info_tag(buf, sizeof(buf), "block", p)) {
502             if (parse_source_list(buf, exclude_sources, &num_exclude_sources,
503                                   FF_ARRAY_ELEMS(exclude_sources)))
504                 goto fail;
505         }
506     }
507
508     /* fill the dest addr */
509     av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
510
511     /* XXX: fix av_url_split */
512     if (hostname[0] == '\0' || hostname[0] == '?') {
513         /* only accepts null hostname if input */
514         if (!(flags & AVIO_FLAG_READ))
515             goto fail;
516     } else {
517         if (ff_udp_set_remote_url(h, uri) < 0)
518             goto fail;
519     }
520
521     if ((s->is_multicast || !s->local_port) && (h->flags & AVIO_FLAG_READ))
522         s->local_port = port;
523
524     if (localaddr[0])
525         udp_fd = udp_socket_create(s, &my_addr, &len, localaddr);
526     else
527         udp_fd = udp_socket_create(s, &my_addr, &len, s->localaddr);
528     if (udp_fd < 0)
529         goto fail;
530
531     /* Follow the requested reuse option, unless it's multicast in which
532      * case enable reuse unless explicitly disabled.
533      */
534     if (s->reuse_socket > 0 || (s->is_multicast && s->reuse_socket < 0)) {
535         s->reuse_socket = 1;
536         if (setsockopt (udp_fd, SOL_SOCKET, SO_REUSEADDR, &(s->reuse_socket), sizeof(s->reuse_socket)) != 0)
537             goto fail;
538     }
539
540     /* If multicast, try binding the multicast address first, to avoid
541      * receiving UDP packets from other sources aimed at the same UDP
542      * port. This fails on windows. This makes sending to the same address
543      * using sendto() fail, so only do it if we're opened in read-only mode. */
544     if (s->is_multicast && !(h->flags & AVIO_FLAG_WRITE)) {
545         bind_ret = bind(udp_fd,(struct sockaddr *)&s->dest_addr, len);
546     }
547     /* bind to the local address if not multicast or if the multicast
548      * bind failed */
549     /* the bind is needed to give a port to the socket now */
550     if (bind_ret < 0 && bind(udp_fd,(struct sockaddr *)&my_addr, len) < 0) {
551         log_net_error(h, AV_LOG_ERROR, "bind failed");
552         goto fail;
553     }
554
555     len = sizeof(my_addr);
556     getsockname(udp_fd, (struct sockaddr *)&my_addr, &len);
557     s->local_port = udp_port(&my_addr, len);
558
559     if (s->is_multicast) {
560         if (h->flags & AVIO_FLAG_WRITE) {
561             /* output */
562             if (udp_set_multicast_ttl(udp_fd, s->ttl, (struct sockaddr *)&s->dest_addr) < 0)
563                 goto fail;
564         }
565         if (h->flags & AVIO_FLAG_READ) {
566             /* input */
567             if (num_include_sources && num_exclude_sources) {
568                 av_log(h, AV_LOG_ERROR, "Simultaneously including and excluding multicast sources is not supported\n");
569                 goto fail;
570             }
571             if (num_include_sources) {
572                 if (udp_set_multicast_sources(udp_fd, (struct sockaddr *)&s->dest_addr, s->dest_addr_len, include_sources, num_include_sources, 1) < 0)
573                     goto fail;
574             } else {
575                 if (udp_join_multicast_group(udp_fd, (struct sockaddr *)&s->dest_addr) < 0)
576                     goto fail;
577             }
578             if (num_exclude_sources) {
579                 if (udp_set_multicast_sources(udp_fd, (struct sockaddr *)&s->dest_addr, s->dest_addr_len, exclude_sources, num_exclude_sources, 0) < 0)
580                     goto fail;
581             }
582         }
583     }
584
585     if (is_output) {
586         /* limit the tx buf size to limit latency */
587         tmp = s->buffer_size;
588         if (setsockopt(udp_fd, SOL_SOCKET, SO_SNDBUF, &tmp, sizeof(tmp)) < 0) {
589             log_net_error(h, AV_LOG_ERROR, "setsockopt(SO_SNDBUF)");
590             goto fail;
591         }
592     } else {
593         /* set udp recv buffer size to the largest possible udp packet size to
594          * avoid losing data on OSes that set this too low by default. */
595         tmp = s->buffer_size;
596         if (setsockopt(udp_fd, SOL_SOCKET, SO_RCVBUF, &tmp, sizeof(tmp)) < 0) {
597             log_net_error(h, AV_LOG_WARNING, "setsockopt(SO_RECVBUF)");
598         }
599         /* make the socket non-blocking */
600         ff_socket_nonblock(udp_fd, 1);
601     }
602     if (s->is_connected) {
603         if (connect(udp_fd, (struct sockaddr *) &s->dest_addr, s->dest_addr_len)) {
604             log_net_error(h, AV_LOG_ERROR, "connect");
605             goto fail;
606         }
607     }
608
609     for (i = 0; i < num_include_sources; i++)
610         av_freep(&include_sources[i]);
611     for (i = 0; i < num_exclude_sources; i++)
612         av_freep(&exclude_sources[i]);
613
614     s->udp_fd = udp_fd;
615     return 0;
616  fail:
617     if (udp_fd >= 0)
618         closesocket(udp_fd);
619     for (i = 0; i < num_include_sources; i++)
620         av_freep(&include_sources[i]);
621     for (i = 0; i < num_exclude_sources; i++)
622         av_freep(&exclude_sources[i]);
623     return AVERROR(EIO);
624 }
625
626 static int udp_read(URLContext *h, uint8_t *buf, int size)
627 {
628     UDPContext *s = h->priv_data;
629     int ret;
630
631     if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
632         ret = ff_network_wait_fd(s->udp_fd, 0);
633         if (ret < 0)
634             return ret;
635     }
636     ret = recv(s->udp_fd, buf, size, 0);
637     return ret < 0 ? ff_neterrno() : ret;
638 }
639
640 static int udp_write(URLContext *h, const uint8_t *buf, int size)
641 {
642     UDPContext *s = h->priv_data;
643     int ret;
644
645     if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
646         ret = ff_network_wait_fd(s->udp_fd, 1);
647         if (ret < 0)
648             return ret;
649     }
650
651     if (!s->is_connected) {
652         ret = sendto (s->udp_fd, buf, size, 0,
653                       (struct sockaddr *) &s->dest_addr,
654                       s->dest_addr_len);
655     } else
656         ret = send(s->udp_fd, buf, size, 0);
657
658     return ret < 0 ? ff_neterrno() : ret;
659 }
660
661 static int udp_close(URLContext *h)
662 {
663     UDPContext *s = h->priv_data;
664
665     if (s->is_multicast && (h->flags & AVIO_FLAG_READ))
666         udp_leave_multicast_group(s->udp_fd, (struct sockaddr *)&s->dest_addr);
667     closesocket(s->udp_fd);
668     return 0;
669 }
670
671 URLProtocol ff_udp_protocol = {
672     .name                = "udp",
673     .url_open            = udp_open,
674     .url_read            = udp_read,
675     .url_write           = udp_write,
676     .url_close           = udp_close,
677     .url_get_file_handle = udp_get_file_handle,
678     .priv_data_size      = sizeof(UDPContext),
679     .flags               = URL_PROTOCOL_FLAG_NETWORK,
680     .priv_data_class     = &udp_class,
681 };